uymax:\n xmax = (uymax - n)/m\n ymax = m*xmax + n\n else:\n xmax = uxmax\n \n dlo = dso - dsl\n coeff = dsl*dlo*re*dm/(2*pi*dso)\n \n rx = np.linspace(xmin - 5., xmax + 5., 500)\n ry = np.linspace(ymin - 5., ymax + 5., 500)\n uvec = np.meshgrid(rx, ry)\n A, B, C, D, E = causticFreqHelp(uvec, ax, ay, m, n)\n upxvec = np.linspace(xmin, xmax, N)\n freqcaus = []\n for upx in upxvec:\n eq1 = A*upx**2 + B*upx + C\n eq2 = D*upx + E\n evcaus = np.array([eq1, eq2])\n roots = polishedRootsBulk(evcaus, causEqFreq, rx, ry, args = (upx, ax, ay, m, n))\n for root in roots:\n ux, uy = root\n arg = coeff*lensg(ux, uy)[0]/(ux - upx)\n # print(arg)\n if arg > 0:\n freq = c*np.sqrt(arg)/(ax*GHz)\n if freq > 0.01:\n freqcaus.append([upx, freq])\n # print(freqcaus)\n freqcaus = np.asarray(freqcaus).T\n # plt.scatter(freqcaus[0], freqcaus[1], marker = '.', color = 'black', s = 3.)\n # plt.xlim(xmin, xmax)\n # plt.ylim(0., max(freqcaus[1]) + 0.5)\n # plt.xlabel(r\"$u'_x$\", fontsize = 16)\n # plt.ylabel(r'$\\nu$ (GHz)', fontsize = 16)\n # plt.grid()\n # plt.show()\n return freqcaus","def biom_output(self, name='samples.biom'):\n data = self.a.df_abundances\n with open(self.a.out_dir + name, 'w') as handle:\n # Basic #\n sample_ids = data.columns\n sample_md = None\n observation_ids = data.index\n # Observation metadata #\n observation_md = []\n for seq in data.index:\n seq_name = self.a.orig_names_to_renamed[seq]\n counts = self.a.seq_to_counts.get(seq_name)\n if not counts: observation_md.append({})\n else: observation_md.append({'source': counts})\n # Output #\n t = biom.table.Table(data.transpose().as_matrix(), sample_ids, observation_ids, sample_md, observation_md)\n handle.write(t.to_json('seqenv version %s') % seqenv.__version__)","def cossim(corpus):\n files = os.listdir()\n vectorizer = TfidfVectorizer()\n trsfm = vectorizer.fit_transform(corpus)\n columns = vectorizer.get_feature_names()\n df_tfidf = pd.DataFrame(trsfm.toarray(), columns = columns, index = corpus)\n out = cosine_similarity(trsfm)\n df_result = pd.DataFrame(out, columns = files, index = files)\n return df_result","def _snrenv_to_pc(snrenv, k=None, q=None, sigma_s=None, m=None):\n un = norm.ppf(1.0 - 1.0 / m)\n sn = 1.28255 / un\n un += 0.577 / un\n dp = k * snrenv ** q\n return norm.cdf(dp, un, np.sqrt(sigma_s ** 2 + sn ** 2)) * 100","def ca_to_coils_second_df(agent_df):","def idog_conv(sc):\n return math.sqrt(sc*2)","def CL(self):"],"string":"[\n \"def build_mm_df(sralist):\\n\\n def convert_to_codon(nts_array):\\n \\\"\\\"\\\"\\n pysam output is in nucleotides resolution, but scikit_curated_df uses codon resolution.\\n This function converts nucleotide arrays to codon length (nts to codon resolution):\\n \\\"\\\"\\\"\\n \\n nts_array = np.array(nts_array)\\n codon_array = np.sum( np.reshape(A, (int(np.floor(nts_array[1]/3)),3) ), 1)/3.\\n\\n return codon_array\\n\\n\\n def compute_mm(mmdata):\\n \\\"\\\"\\\"\\n get per gene average multi-mapping score\\n \\\"\\\"\\\"\\n\\n mm_df = pd.DataFrame(columns=['ORF', 'MM'])\\n counter = 0\\n\\n for gene in mmdata.keys():\\n current_matrix = mmdata[gene]\\n current_avrg = np.mean( np.sum(current_matrix, 1) / current_matrix.shape[1] )\\n mm_df.loc[counter] = [gene, current_avrg]\\n counter += 1\\n\\n return mm_df\\n\\n\\n mm_mat = {}\\n mm_pct = {}\\n\\n N = len(sralist)\\n\\n for ix, dataset in enumerate(sralist):\\n samfile = pysam.AlignmentFile(TMP_DIR+'/ambiguous_reads/'+dataset+'_STAR_transcriptome_multi_mapped_sorted.bam', 'rb')\\n genes_list = list(samfile.references)\\n print(ix, dataset)\\n\\n for geneID in genes_list:\\n # count the coverage of genomic positions by reads in region.\\n # Returns: four array.arrays of the same length in order A C G T\\n # The coverage is computed per-base [ACGT]\\n cov = samfile.count_coverage(geneID, read_callback='nofilter')\\n # Summ all 4 arrays\\n cov_sum = np.sum(cov, axis=0)\\n #print(geneID, cov_sum)\\n codon_cov = convert_to_codon(cov_sum)\\n codon_bool = np.asarray([1 if i > 0 else 0 for i in codon_cov])\\n \\n M = len(codon_bool)\\n\\n if ix == 0:\\n \\tmm_mat[geneID] = np.zeros((N,M)) * np.nan\\n \\n current_matrix = mm_mat[geneID]\\n current_matrix[ix,:] = np.copy(codon_bool)\\n mm_mat[geneID] = current_matrix\\n\\n\\n mm_avrg = compute_mm(mm_mat)\\n #mm_avrg.to_json('yeast_mm.json')\\n #mm_avrg.to_csv('yeast_mm.txt', header=True, index=False, sep='\\\\t')\\n\\n \\n mm_profile = {}\\n theta_mm = 5\\n for orf in mm_mat.keys():\\n current_mat = mm_mat[orf]\\n current_bool = np.sum(current_mat, 0) <= theta_mm\\n mm_profile[orf] = current_bool\\n\\n with open('../data/processed/mm_consensus.pkl', 'wb') as f_mm:\\n pickle.dump(mm_profile, f_mm)\\n\\n\\n return mm_mat, mm_avrg, mm_profile\",\n \"def df_seqs_concepts(self):\\n # Get the data #\\n df = pandas.DataFrame(self.a.seq_to_counts)\\n df = df.fillna(0)\\n # Rename to original names #\\n df = df.rename(columns=self.a.renamed_to_orig)\\n # Rename envo integers to envo strings #\\n envo_int_to_id = lambda e: \\\"ENVO:%08d\\\" % e\\n df = df.rename(index=envo_int_to_id)\\n # Return\\n return df\",\n \"def matthewscc(self):\\n if not self.total_examples:\\n return 0.\\n\\n true_pos = float(self.true_positives)\\n false_pos = float(self.false_positives)\\n false_neg = float(self.false_negatives)\\n true_neg = float(self.true_negatives)\\n terms = [(true_pos + false_pos),\\n (true_pos + false_neg),\\n (true_neg + false_pos),\\n (true_neg + false_neg)]\\n denom = 1.\\n for t in filter(lambda t: t != 0., terms):\\n denom *= t\\n return ((true_pos * true_neg) - (false_pos * false_neg)) / math.sqrt(denom)\",\n \"def uCSIsUnifiedCanadianAboriginalSyllabics(code):\\n ret = libxml2mod.xmlUCSIsUnifiedCanadianAboriginalSyllabics(code)\\n return ret\",\n \"def get_mod_freq_clf(df, cols, chr_pos, strains, clf, method=\\\"GMM\\\"):\\n results = []\\n for cp in chr_pos:\\n # min-max normalisation\\n _df = df.loc[(df[\\\"chr_pos\\\"]==cp)&(df.Strain.isin(strains)), cols+[\\\"Strain\\\"]]\\n _X = min_max_norm(_df[cols].to_numpy().astype(\\\"float\\\"))\\n # get fit and clusters\\n clusters = clf.fit_predict(_X)\\n # for outlier method, store outliers (-1) as cluster_1 and normal (1) as cluster_0\\n if max(clusters)>1: \\n clusters[clusters!=0] = 1\\n elif -1 in clusters and 1 in clusters: # outlier method\\n clusters[clusters==1] = 0\\n clusters[clusters<0] = 1\\n # get modification freuqency - simply number of 1s over all for each sample\\n freqs = [clusters[_df[\\\"Strain\\\"]==s].mean() for s in strains]\\n results.append((cp, method, *freqs, \\\", \\\".join(map(str, strains[1:]))))\\n return results\",\n \"def _compute_pc(df_embs, npc=1):\\n svd = TruncatedSVD(n_components=npc, n_iter=7, random_state=0)\\n svd.fit(df_embs)\\n return svd.components_\",\n \"def get_cs(self, model=1, limits=None, prev_aa=None, next_aa=None,\\n piqc=False, sigma_n=None, like_ss=True, debug=False):\\n\\n # Validate input.\\n aa = self.correlation.aa\\n if aa not in aminoacids.aa_list:\\n mesg = '{} is not a supported amino-acid!'.format(aa)\\n raise ValueError(mesg)\\n\\n for atom in self.correlation.atoms:\\n if atom not in aminoacids.aa_atoms[aa]:\\n raise ValueError('{} is not an atom in {}'.format(atom, aa))\\n if prev_aa:\\n prev_aa = tuple(set(prev_aa))\\n for prev_aa_i in prev_aa:\\n if prev_aa_i not in aminoacids.aa_list:\\n mesg = '{} is not an amino-acid!'.format(prev_aa_i)\\n raise ValueError(mesg)\\n if next_aa:\\n next_aa = tuple(set(next_aa))\\n for next_aa_i in next_aa:\\n if next_aa_i not in aminoacids.aa_list:\\n mesg = '{} is not an amino-acid!'.format(next_aa_i)\\n raise ValueError(mesg)\\n\\n if piqc and not self.database.table_exist('SEQ_CS_DB'):\\n mesg = 'The PIQC table is not in {}.'.format(self.database)\\n raise ValueError(mesg)\\n\\n ss = self.correlation.ss\\n n = self.dims\\n\\n # Scary sub-query to find unique secondary structure or the most common\\n # secondary structure. I am sorry ...\\n if model == 'all':\\n sub_sql = \\\"\\\"\\\"INNER JOIN(\\n SELECT DISTINCT c.KEY_ID, c.SND_STRC FROM {0}_strc_db as c\\n INNER JOIN (\\n SELECT KEY_ID, COUNT(a.KEY_ID) as count FROM (\\n SELECT DISTINCT KEY_ID, SND_STRC FROM {0}_strc_db\\n GROUP BY KEY_ID, SND_STRC)as a\\n GROUP BY KEY_ID\\n HAVING count = 1\\n ) as b ON c.KEY_ID = b.KEY_ID ) as strc\\n ON cs_0.KEY_ID = strc.KEY_ID\\\"\\\"\\\".format(aa)\\n\\n if model == 'most':\\n sub_sql = \\\"\\\"\\\"INNER JOIN (SELECT KEY_ID,\\n SUBSTRING_INDEX(GROUP_CONCAT(x.SND_STRC\\n ORDER BY x.count DESC SEPARATOR ':::'), ':::', 1) AS snd_strc_mode\\n FROM (SELECT KEY_ID, SND_STRC, COUNT(*) as count FROM {0}_strc_db\\n GROUP BY KEY_ID, SND_STRC) as x\\n GROUP BY x.KEY_ID ) as xx\\n ON cs_0.KEY_ID = xx.KEY_ID\\\"\\\"\\\".format(aa)\\n\\n # Build SQL query\\n # Select Chemical Shifts From Sub Table(s)\\n cs = 'cs_{0}.C_SHIFT as cs{0}'\\n sql = [(\\\"SELECT \\\" + ', '.join([cs.format(x) for x in range(n)])),\\n \\\"FROM {0}_cs_db as cs_0\\\".format(aa)]\\n\\n # Join other sub table for chemical shift.\\n for ni in range(1, n):\\n sql.append(\\\"INNER JOIN {0}_cs_db AS cs_{1} \\\".format(aa, ni))\\n sql.append(\\\"ON cs_0.KEY_ID = cs_{0}.KEY_ID\\\".format(ni))\\n\\n # Join other sub table for structure\\n if ss and ss != 'X':\\n if model in {'all', 'most'}:\\n sql.append(sub_sql)\\n else:\\n sql.append(\\\"INNER JOIN {0}_strc_db AS strc\\\".format(aa))\\n sql.append(\\\"ON cs_0.KEY_ID = strc.KEY_ID\\\")\\n\\n if prev_aa or next_aa:\\n sql.append(\\\"INNER JOIN {0}_db AS info\\\".format(aa))\\n sql.append(\\\"ON cs_0.KEY_ID = info.KEY_ID\\\")\\n\\n if piqc:\\n sql.append(\\\"INNER JOIN SEQ_CS_DB \\\")\\n sql.append(\\\"ON cs_0.FIRSTKEY_ID = SEQ_CS_DB.KEY_ID\\\")\\n\\n # Start of the where statements.\\n # Atoms and Limits for first atom\\n atom_0 = self.correlation.atoms[0]\\n sql.append(\\\"WHERE cs_0.ATOM_NAME = '{0}'\\\".format(atom_0))\\n\\n if prev_aa:\\n if len(prev_aa) == 1:\\n sql.append(\\\"AND info.PREV_X = '{}'\\\".format(prev_aa[0]))\\n else:\\n sql.append(\\\"AND info.PREV_X in {}\\\".format(prev_aa))\\n\\n if next_aa:\\n if len(next_aa) == 1:\\n sql.append(\\\"AND info.NEXT_X = '{}'\\\".format(next_aa[0]))\\n else:\\n sql.append(\\\"AND info.NEXT_X in {}\\\".format(next_aa))\\n\\n if limits:\\n sql.append(\\\"AND cs_0.C_SHIFT\\\")\\n limits_0 = (limits[0][0], limits[0][1])\\n sql.append(\\\"BETWEEN {0} AND {1}\\\".format(limits_0))\\n\\n # Atoms and Limits for rest of the atom\\n for ni in list(range(1, n)):\\n sql.append(\\\"AND cs_{0}.ATOM_NAME = '{1}'\\\".format(\\n ni, self.correlation.atoms[ni]))\\n\\n if limits:\\n sql.append(\\\"AND cs_{0}.C_SHIFT \\\".format(ni))\\n limits_n = (limits[ni][0], limits[ni][1])\\n sql.append(\\\"BETWEEN {0} AND {1}\\\".format(limits_n))\\n\\n # If secondary structure\\n if ss and ss != 'X':\\n try:\\n ss_list = aminoacids.similar_sndstr[ss]\\n except KeyError:\\n raise ValueError('{} is not a valid sndstr'.format(ss))\\n\\n if model == 'all':\\n if like_ss:\\n sql.append(\\\"AND strc.SND_STRC IN {0}\\\".format(ss_list))\\n else:\\n sql.append(\\\"AND strc.SND_STRC = '{}'\\\".format(ss))\\n elif model == 'most':\\n if like_ss:\\n sql.append(\\\"AND xx.snd_strc_mode IN {0}\\\".format(ss_list))\\n else:\\n sql.append(\\\"AND xx.snd_strc_mode = '{0}'\\\".format(ss))\\n else:\\n if like_ss:\\n sql.append(\\\"AND SND_STRC IN {0}\\\".format(ss_list))\\n else:\\n sql.append(\\\"AND SND_STRC = '{0}'\\\".format(ss))\\n sql.append(\\\"AND MODEL_NO={0}\\\".format(model))\\n\\n if piqc:\\n sql.append(\\\"AND ELEMENT='C'\\\")\\n sql.append(\\\"AND PIQC = 1\\\")\\n\\n sql = [x.strip() for x in sql]\\n sql = '\\\\n'.join(sql)\\n\\n if debug:\\n print(sql)\\n\\n cs = self.database.query(sql)\\n\\n if not cs:\\n raise ValueError\\n\\n if sigma_n:\\n avg = np.mean(cs, axis=0)\\n std = np.std(cs, axis=0)\\n ind = np.all(np.abs(cs-avg) <= std*sigma_n, axis=1)\\n cs = np.compress(ind, cs, axis=0)\\n\\n return cs\",\n \"def fit_covid_function(self):\\r\\n return\",\n \"def test_codon_usage_custom(self):\\n # We need a FASTA file of CDS sequences to count the codon usage...\\n dna_fasta_filename = \\\"fasta.tmp\\\"\\n dna_genbank_filename = \\\"GenBank/NC_005816.gb\\\"\\n record = SeqIO.read(dna_genbank_filename, \\\"genbank\\\")\\n records = []\\n for feature in record.features:\\n if feature.type == \\\"CDS\\\" and len(feature.location.parts) == 1:\\n start = feature.location.start.position\\n end = feature.location.end.position\\n table = int(feature.qualifiers[\\\"transl_table\\\"][0])\\n if feature.strand == -1:\\n seq = record.seq[start:end].reverse_complement()\\n else:\\n seq = record.seq[start:end]\\n # Double check we have the CDS sequence expected\\n # TODO - Use any cds_start option if/when added to deal with the met\\n a = \\\"M\\\" + str(seq[3:].translate(table))\\n b = feature.qualifiers[\\\"translation\\\"][0] + \\\"*\\\"\\n self.assertEqual(a, b, \\\"%r vs %r\\\" % (a, b))\\n records.append(SeqRecord(seq, id=feature.qualifiers[\\\"protein_id\\\"][0],\\n description=feature.qualifiers[\\\"product\\\"][0]))\\n\\n with open(dna_fasta_filename, \\\"w\\\") as handle:\\n SeqIO.write(records, handle, \\\"fasta\\\")\\n\\n CAI = CodonAdaptationIndex()\\n # Note - this needs a FASTA file which containing non-ambiguous DNA coding\\n # sequences - which should each be a whole number of codons.\\n CAI.generate_index(dna_fasta_filename)\\n # Now check codon usage index (CAI) using this species\\n self.assertEqual(record.annotations[\\\"source\\\"],\\n \\\"Yersinia pestis biovar Microtus str. 91001\\\")\\n self.assertEqual(\\\"%0.5f\\\" % CAI.cai_for_gene(\\\"ATGCGTATCGATCGCGATACGATTAGGCGGATG\\\"),\\n \\\"0.67213\\\")\\n os.remove(dna_fasta_filename)\",\n \"def pca_2(emb) :\\n pcaer = skd.PCA(n_components=2)\\n pca = pcaer.fit_transform(emb)\\n \\n return pca\",\n \"def cole_coeff(self):\\n return self.diseq_coeff(standardize=True)\",\n \"def n_cs(self):\\n pass\",\n \"def codonfreqs_kmerdf(kmertable): \\n codon_counts_kmer = np.zeros(( len(codons_nonstop) ))\\n for kmer in kmertable['kmer']:\\n current_kmer_codons = [ kmer[(i*3):((i*3)+3)] for i in range(3) ] # ! hard coded for length L=3\\n for codon in current_kmer_codons:\\n current_index = codons_nonstop.index(codon)\\n codon_counts_kmer[current_index] += 1 \\n codon_counts_kmer /= np.sum(codon_counts_kmer)\\n\\n return np.around(codon_counts_kmer, 5)\",\n \"def precip_stats_to_climatology(fili, start_year=1981, end_year=2015):\\n\\n nyear = end_year - start_year + 1\\n \\n ds = xr.open_dataset(fili)\\n\\n year = ds['time'].dt.year\\n #dsMsk = ds.isel( time=( (year >= start_year) & (year <= end_year) ) ).count(dim='time')\\n dsClm = ds.isel( time=( (year >= start_year) & (year <= end_year) ) ).mean(dim='time', skipna=False)\\n #dsClm = dsClm.where(dsMsk == nyear)\\n \\n #dsMsk.to_netcdf('era5.count.nc4')\\n\\n print (dsClm)\\n \\n filo = fili.replace('annual','annual.clm')\\n print (f'Writing climatology to {filo}') \\n dsClm.to_netcdf(filo)\\n\\n return\",\n \"def clus_func(df_all, n_components, feat_subset):\\n\\n df = df_all[featureSet_dic[feat_subset]].copy()\\n\\n X = df.values\\n\\n # # Fit a Gaussian mixture with EM\\n # gmm_model = mixture.GaussianMixture(n_components=n_components,\\n # covariance_type=cv_type,\\n # random_state=1,\\n # n_init=10)\\n # gmm_model = gmm_model.fit(X)\\n\\n model_path = os.path.join(CURR_PATH, 'clustering_model') # create directiry for the current time\\n model_name = os.path.join(model_path, 'gmm.joblib')\\n gmm_model = joblib.load(model_name)\\n\\n # predic labels & probabilities\\n labels = gmm_model.predict(X)\\n labels_prob = gmm_model.predict_proba(X)\\n\\n # adding all droped features (for plotting purposes) of the standardized dataframe\\n added_feat = [feat for feat in data_columns if feat not in df.columns]\\n df[added_feat] = df_all_stand[added_feat].copy()\\n df = df[data_columns]\\n\\n # adding the labels to the dataframe\\n df.insert(0, 'Clus_label', labels)\\n\\n for n in range(n_components):\\n df['Prob_L'+str(n)] = labels_prob[:, n]\\n\\n return gmm_model, df # export all gmm models and a dictionary of all labeled datasets\",\n \"def gain_sequence(det_name, psf_results_file, chiprob_min=0.1, logger=None):\\n warnings.simplefilter('ignore')\\n with fits.open(psf_results_file) as cluster_data:\\n seqnums = sorted(list(set(cluster_data[1].data['SEQNUM'])))\\n all_amps = range(1, cluster_data[0].header['NAMPS'] + 1)\\n det_names, amps, gains, seq_nums = [], [], [], []\\n for seqnum in seqnums:\\n if logger is not None:\\n logger.info(f'{seqnum}')\\n for amp in all_amps:\\n chiprob = cluster_data[amp].data['CHIPROB']\\n index = np.where((chiprob > chiprob_min) &\\n (cluster_data[amp].data['SEQNUM'] == seqnum))\\n dn = cluster_data[amp].data['DN'][index]\\n fitter = Fe55GainFitter(dn)\\n fitter.fit()\\n det_names.append(det_name)\\n amps.append(amp)\\n gains.append(fitter.gain)\\n seq_nums.append(seqnum)\\n return pd.DataFrame({'det_name': det_names, 'amp': amps,\\n 'gain': gains, 'seqnum': seq_nums})\",\n \"def cmu(df, mu, alphamu=0.0, alphacov=2.0):\\r\\n c = alphacov * (alphamu + mu - 2 + 1/mu) / ((N + 2)**2 + alphacov * mu / 2)\\r\\n # c = alphacov * (alphamu + mu - 2 + 1/mu) / (2 * (N + 2)**1.5 + alphacov * mu / 2)\\r\\n # print 'cmu =', c\\r\\n return c\",\n \"def performpca(df, nb_pc=5):\\n # Remove uncomplete series\\n print(df.shape)\\n normalized=(df-df.mean())/df.std()\\n # normalized.plot()\\n # plt.show()\\n pca = PCA(nb_pc)\\n pca.fit(normalized)\\n return pca, normalized\",\n \"def get_all_guides_that_cut_in_cds(self,pam, seq_len_around_cut,\\n min_mut_pos_in_guide, max_mut_pos_in_guide,\\n excluded_seqs, mapping_cmd, sort_by = '5to3'):\\n \\n ordered_lefts = self.cds_lefts\\n ordered_rights = self.cds_rights\\n if (self.is_neg_strand()):\\n ordered_lefts = ordered_lefts[::-1]\\n ordered_rights = ordered_rights[::-1]\\n \\n ######\\n # search positive strand for pam\\n ######\\n cur_cds_nt_start = 0\\n exon_num = 0\\n guides0_chr_pos = np.empty(0,dtype=int)\\n guides_cut_chr_pos = np.empty(0,dtype=int)\\n guides_cut_gene_dna_pos = np.empty(0,dtype=int)\\n guides_exon_num = np.empty(0,dtype=int)\\n\\n for left,right in zip(ordered_lefts,ordered_rights):\\n \\n # cut is to the right of the nucleotide\\n cur_left_for_pam = left + (self.CRISPR_CUT_INDEX + len(pam) - 1) + (1 * self.is_neg_strand()) \\n cur_right_for_pam = right + (self.CRISPR_CUT_INDEX + len(pam) - 1) + (1 * self.is_neg_strand()) \\n \\n\\n \\n seq = self.genome_seq[self.chrom].seq[cur_left_for_pam:cur_right_for_pam]\\n \\n # returns a list of all the positions in that cut in cds\\n cur_pam_dists = np.array([m.start() for m in re.finditer(\\\"(?=\\\"+pam+\\\")\\\", str(seq))])\\n \\n # removing guides that are not entirely in the CDS\\n if ( (not np.isnan(min_mut_pos_in_guide)) and (not np.isnan(max_mut_pos_in_guide)) ):\\n min_mut_pos_in_guide = int(min_mut_pos_in_guide)\\n max_mut_pos_in_guide = int(max_mut_pos_in_guide)\\n \\n cur_pam_dists = cur_pam_dists[cur_pam_dists >= (-min_mut_pos_in_guide) - (self.CRISPR_CUT_INDEX + 1 * self.is_neg_strand() ) ]\\n cur_pam_dists = cur_pam_dists[cur_pam_dists <= (len(seq) - 1 + len(pam) - 1 ) + ( (-max_mut_pos_in_guide) - (self.CRISPR_CUT_INDEX + 1 * self.is_neg_strand()) ) ]\\n \\n \\n cur_guides0_chr_pos = (cur_pam_dists-1) + cur_left_for_pam \\n \\n if (self.is_neg_strand()): # negative\\n cur_guides_cut_gene_dna_pos = (len(seq)-1-cur_pam_dists) + cur_cds_nt_start\\n cur_guides_cut_chr_pos = cur_guides0_chr_pos - (self.CRISPR_CUT_INDEX + 1) # the cut is right of the nt\\n else:\\n cur_guides_cut_gene_dna_pos = cur_pam_dists + cur_cds_nt_start\\n cur_guides_cut_chr_pos = cur_guides0_chr_pos - self.CRISPR_CUT_INDEX # the cut is left of the nt\\n \\n \\n cur_guides_exon_num = np.full_like(cur_guides_cut_gene_dna_pos,exon_num)\\n \\n \\n guides0_chr_pos = np.concatenate((guides0_chr_pos,cur_guides0_chr_pos))\\n guides_cut_chr_pos = np.concatenate((guides_cut_chr_pos,cur_guides_cut_chr_pos))\\n guides_cut_gene_dna_pos = np.concatenate((guides_cut_gene_dna_pos,cur_guides_cut_gene_dna_pos))\\n guides_exon_num = np.concatenate((guides_exon_num,cur_guides_exon_num))\\n \\n \\n cur_cds_nt_start = cur_cds_nt_start + (right - left)\\n exon_num = exon_num + 1\\n \\n \\n pos_strand_guides_df = self.__guide_positions_to_df(pam, False, seq_len_around_cut, excluded_seqs, \\\\\\n guides0_chr_pos, guides_cut_chr_pos, guides_cut_gene_dna_pos, guides_exon_num) \\n \\n ######\\n # search negative strand for pam\\n ######\\n cur_cds_nt_start = 0\\n exon_num = 0\\n guides0_chr_pos = np.empty(0,dtype=int)\\n guides_cut_chr_pos = np.empty(0,dtype=int)\\n guides0_gene_dna_pos = np.empty(0,dtype=int)\\n guides_cut_gene_dna_pos = np.empty(0,dtype=int)\\n guides_exon_num = np.empty(0,dtype=int)\\n \\n for left,right in zip(ordered_lefts,ordered_rights):\\n \\n \\n cur_left_for_pam = int(left) - (self.CRISPR_CUT_INDEX + len(pam)+1) + (1 * self.is_neg_strand())\\n cur_right_for_pam = int(right) - (self.CRISPR_CUT_INDEX + len(pam)+1) + (1 * self.is_neg_strand())\\n \\n seq = self.genome_seq[self.chrom].seq[cur_left_for_pam:cur_right_for_pam]\\n \\n revcomp_pam = Seq(pam,generic_dna).reverse_complement()\\n \\n # returns a list of all the positions in that cut in cds\\n cur_pam_dists = np.array([m.start() for m in re.finditer(\\\"(?=\\\"+str(revcomp_pam)+\\\")\\\", str(seq))])\\n \\n \\n if ( (not np.isnan(min_mut_pos_in_guide)) and (not np.isnan(max_mut_pos_in_guide)) ):\\n min_mut_pos_in_guide = int(min_mut_pos_in_guide)\\n max_mut_pos_in_guide = int(max_mut_pos_in_guide)\\n \\n cur_pam_dists = cur_pam_dists[cur_pam_dists >= (-min_mut_pos_in_guide) - (self.CRISPR_CUT_INDEX + 1 * self.is_neg_strand() ) ]\\n cur_pam_dists = cur_pam_dists[cur_pam_dists <= (len(seq) - 1 + len(pam) - 1 ) + ( (-max_mut_pos_in_guide) - (self.CRISPR_CUT_INDEX + 1 * self.is_neg_strand()) ) ]\\n \\n \\n \\n cur_guides0_chr_pos = (cur_pam_dists+2) + cur_left_for_pam\\n \\n if (self.is_neg_strand()): # negative \\n cur_guides_cut_gene_dna_pos = (len(seq)-1-cur_pam_dists) + cur_cds_nt_start\\n cur_guides_cut_chr_pos = cur_guides0_chr_pos + self.CRISPR_CUT_INDEX # the cut is right of the nt\\n else: # positive\\n cur_guides_cut_gene_dna_pos = cur_pam_dists + cur_cds_nt_start\\n cur_guides_cut_chr_pos = cur_guides0_chr_pos + self.CRISPR_CUT_INDEX + 1 # the cut is leftot the nt\\n \\n \\n cur_guides_exon_num = np.full_like(cur_guides_cut_gene_dna_pos,exon_num)\\n \\n \\n guides0_chr_pos = np.concatenate((guides0_chr_pos,cur_guides0_chr_pos))\\n guides_cut_chr_pos = np.concatenate((guides_cut_chr_pos,cur_guides_cut_chr_pos))\\n guides_cut_gene_dna_pos = np.concatenate((guides_cut_gene_dna_pos,cur_guides_cut_gene_dna_pos))\\n guides_exon_num = np.concatenate((guides_exon_num,cur_guides_exon_num))\\n \\n cur_cds_nt_start = cur_cds_nt_start + (right - left)\\n exon_num = exon_num + 1\\n \\n \\n neg_strand_guides_df = self.__guide_positions_to_df(pam, True, seq_len_around_cut, excluded_seqs, \\\\\\n guides0_chr_pos, guides_cut_chr_pos, guides_cut_gene_dna_pos, guides_exon_num)\\n \\n \\n # concating the positive and negative strands guides\\n guides_df = pd.concat([pos_strand_guides_df, neg_strand_guides_df])\\n \\n # adding for each guide its location in the gene (5' -> 3'; fraction)\\n guides_df[\\\"guide_cut_gene_pos_frac\\\"] = guides_df[\\\"guide_cut_gene_nt_pos\\\"] / guides_df[\\\"CDS_len_nts\\\"]\\n\\n \\n # if the 'sort' method is onlyStopCodon then leave only guide that cut the stop codon\\n if sort_by == 'onlyStopCodon':\\n guides_df = guides_df.ix[( ( (guides_df['CDS_len_nts']).values / 3) == ( (guides_df['guide_cut_gene_aa_pos']).values + 1) ) ,:]\\n \\n # calculating Azimuth score\\n #print \\\"Calculating Azimuth score\\\"\\n guides_df = cal_azimuth_score(guides_df, output_filename_GUIDE_withScores = \\\"\\\", guides_PAMm4p3_col_name=\\\"guide_PAM_m4p3\\\")\\n \\n # calculating off targets\\n #print \\\"Testing off targets\\\"\\n guides_df = eval_guides_off_targets(guides_df, self.genome_seq, 'guide_id', 'guide_noPAM', pam, mapping_cmd)\\n \\n \\n return (guides_df)\",\n \"def df_sample_concepts(self):\\n return self.abundance_mat_mult(False)\",\n \"def calculate_piN_piS(codonseqs, method, codon_table, het=False):\\n analysis = {\\\"seqname\\\": \\\"\\\", \\\"piN\\\": -1, \\\"piS\\\": -1, \\\"piNpiS\\\": -1, \\\"pi\\\": -1, \\\"method\\\":method}\\n x = seqfreqs(codonseqs)\\n #if 'piNpiS' in options.debug:\\n # print(\\\"freqs are: {}\\\".format(x))\\n # print(\\\"len codonseqs is: \\\", len(codonseqs))\\n piN = 0\\n piS = 0\\n for i in range(len(codonseqs)):\\n for j in range(i+1, len(codonseqs)):\\n #print(codonseqs[i], codonseqs[j])\\n if not het:\\n dN, dS = cal_dn_ds(codonseqs[i], codonseqs[j], codon_table=codon_table, method=method)\\n piN = piN + (x[i] * x[j] * dN)\\n piS = piS + (x[i] * x[j] * dS)\\n #if 'piNpiS' in options.debug:\\n # print(\\\"{0} dN{1}{2}={3} dS{1}{2}={4}\\\".format(method, i, j, dN, dS))\\n else:\\n try:\\n dN, dS = cal_dn_ds(codonseqs[i], codonseqs[j], codon_table=codon_table, method=method)\\n piN = piN + (x[i] * x[j] * dN)\\n piS = piS + (x[i] * x[j] * dS)\\n except:\\n pass\\n\\n analysis['piN'] = piN\\n analysis['piS'] = piS\\n try:\\n analysis['piNpiS'] = piN/piS\\n except:\\n analysis['piNpiS'] = 0\\n #if 'piNpiS' in options.debug:\\n # print (\\\"{0} dN={1:.3f} dS={2:.3f} piN/piS = {3:.3f}\\\".format(\\n # method, analysis['piN'], analysis['piS'], analysis['piNpiS']))\\n\\n return analysis\",\n \"def get_gbif_occs(self):\\n\\n # Create a file to store occurrence data.\\n self.occfile = os.path.join(self.outdir, self.params['spname'].replace(\\\" \\\", \\\"_\\\") + \\\".csv\\\")\\n\\n # Get the usageKey for species of interest.\\n self.key = species.name_backbone(name = self.params['spname'], rank = 'species')['usageKey']\\n\\n # Create latitude/longitude lists.\\n self.lats = []\\n self.lons = []\\n\\n # Run a while-loop to go through all observations.\\n curr_offset = 0\\n end_records = False\\n while not end_records:\\n occ_records = occ.search(taxonKey = self.key, hasCoordinate = True, \\n decimalLatitude = ','.join([str(self.params['ymin']), str(self.params['ymax'])]),\\n decimalLongitude = ','.join([str(self.params['xmin']), str(self.params['xmax'])]),\\n offset = curr_offset\\n )\\n end_records = occ_records['endOfRecords']\\n curr_offset += occ_records['limit']\\n\\n # Add latitude/longitude results to lists.\\n self.lats.extend([i['decimalLatitude'] for i in occ_records['results']])\\n self.lons.extend([i['decimalLongitude'] for i in occ_records['results']])\\n\\n # Print a dot on each cycle to show progress.\\n print(\\\".\\\", end = \\\"\\\")\\n\\n # When end of data is reached: build pandas dataframe from lists and remove duplicate data points.\\n if occ_records['endOfRecords']:\\n df = pd.DataFrame({'Latitude': self.lats, 'Longitude': self.lons})\\n df = df.drop_duplicates().reset_index()\\n df = df.drop('index', axis = 1)\\n\\n # Reform the lists by subsetting the dataframe.\\n self.lats = list(df['Latitude'])\\n self.lons = list(df['Longitude'])\\n\\n # Print final number of records.\\n print(f' Found {len(self.lats)} records.')\\n\\n # Build array to write to CSV file. np.vstack layers arrays vertically, where each layer is species-lat-lon. \\n # np.repeat copies the species names as many times as there are entries. It also combines with zip() to put\\n # a newline char at the end of each layer.\\n csvarr = np.vstack([np.repeat(self.params['spname'].replace(\\\" \\\", \\\"_\\\"), len(self.lats)), self.lats,\\n [\\\"{}{}\\\".format(a_, b_) for a_, b_ in zip(self.lons, np.repeat('\\\\n', len(self.lats)))]]\\n ).T\\n\\n # Write array to CSV file.\\n with open(self.occfile, 'w') as f:\\n f.write('Species,Latitude,Longitude\\\\n')\\n for line in csvarr:\\n f.write(\\\",\\\".join(line))\\n\\n # Transform lists to arrays for downstream application.\\n self.lats = np.array(self.lats)\\n self.lons = np.array(self.lons)\",\n \"def codon_bgfreq(codon_seqs, data_mm):\\n codon_counts = np.zeros(( len(codons_nonstop) ))\\n list_orfs = list( data_mm.keys() )\\n\\n for ix, orf in enumerate(list_orfs):\\n current_seq = codon_seqs[orf]\\n current_mm = data_mm[orf]\\n\\n for pos in range( len(current_mm) ):\\n if current_mm[pos] and current_seq[pos] in codons_nonstop:\\n current_index = codons_nonstop.index(current_seq[pos])\\n codon_counts[current_index] += 1\\n codon_counts = np.around( codon_counts / np.sum(codon_counts), 5)\\n\\n return codon_counts\",\n \"def generate_2d_cs_plot(data, atom1=\\\"CA\\\", atom2=\\\"CB\\\", resid_li=\\\"\\\", from_frame='all', to_frame='all', soluplots=False):\\n\\n #Generate an empty dataframe and pop out the mean and the deviation from the CS/frame pickle\\n result = pd.DataFrame()\\n data.set_index(['resSeq','name'], inplace=True)\\n data.drop(data.columns[len(data.columns)-1], axis=1, inplace=True)\\n data.drop(data.columns[len(data.columns)-1], axis=1, inplace=True)\\n\\n # If frames were selected, drop also all columns were\\n if from_frame != 'all':\\n frames = ['resname', 'resname_s']+[ str(f) for f in range(int(from_frame), int(to_frame)+1)]\\n data = data.filter(frames, axis=1)\\n\\n # Take all residues if none were submitted\\n if not resid_li:\\n resid_li = {index[0] for index in data.index.values}\\n\\n # Sort residue ids numerically\\n resid_li = [ str(i) for i in sorted([int(x) for x in resid_li]) ]\\n\\n #loop over the residues selcted by the user\\n for item in resid_li:\\n try: \\n df1 = data.loc[int(item),atom1] #select atom 1 the row from the dataframe which matches the inputs from the user\\n df2 = data.loc[int(item),atom2] #select atom 2 the row from the dataframe which matches the inputs from the user\\n resname = data.loc[[int(item),'CA'], 'resname'].unique()[0]\\n # Option to make \\\"Solution NMR predictions\\\": make a distribution out of average and variance of our cs values, and plot it\\n if soluplots:\\n np1=np.array(df1[2:])\\n np2=np.array(df2[2:])\\n dist1 = np.random.normal(np1.mean(), np1.std()/10, len(np1))\\n dist2 = np.random.normal(np2.mean(), np2.std()/10, len(np2))\\n df_e1 = pd.DataFrame(data=dist1, columns=[atom1]) #Build the plotting dataframe\\n df_e2 = pd.DataFrame(data=dist2, columns=[atom2])\\n else:\\n df_e1=df1.to_frame(name=atom1)\\n df_e2=df2.to_frame(name=atom2)\\n except Exception as e:\\n continue\\n temp_df = pd.concat([df_e1,df_e2], axis=1, join=\\\"inner\\\") #concatenate all the residues dataframe into a bigger one\\n temp_df[\\\"IDs\\\"]=str(item)+' '+resname #give them different ids to have differnete colors in the plot\\n result = result.append(temp_df) #build the final DF\\n\\n # Put atoms in avail_res_atoms dictionary (which I dont remember exactly what does but seems important)\\n avail_res_atoms = {\\n \\\"%s.%s\\\"%(item,atom1) : {\\\"display\\\":False,\\\"color\\\":\\\"#FF0000\\\"},\\n \\\"%s.%s\\\"%(item,atom2) : {\\\"display\\\":False,\\\"color\\\":\\\"#FF0000\\\"},\\n }\\n\\n # If there are no atoms matching this selection\\n if result.empty: \\n return('', ['error'])\\n\\n #plot\\n fig = px.density_contour(result, x=atom1, y=atom2, color=\\\"IDs\\\", labels={\\n atom1 : \\\"Chemical shift for \\\"+str(atom1)+\\\" (ppm)\\\",\\n atom2 : \\\"Chemical shift for \\\"+str(atom2)+\\\" (ppm)\\\",\\n \\\"IDs\\\": \\\"Residue ID\\\"},\\n color_discrete_sequence=px.colors.qualitative.Dark24)\\n # Reverse axis\\n fig['layout']['yaxis']['autorange'] = \\\"reversed\\\"\\n fig['layout']['xaxis']['autorange'] = \\\"reversed\\\"\\n\\n\\n fig.update_layout(legend=dict(\\n itemsizing='constant',\\n itemclick='toggleothers',\\n itemdoubleclick='toggle',\\n ))\\n\\n #Skip hover info when scrolling through the plot\\n fig.update_traces(hoverinfo='skip', hovertemplate=None)\\n\\n # Return plot\\n p = pt.offline.plot(fig, include_plotlyjs=False, output_type='div')\\n return(p,avail_res_atoms)\",\n \"def get_cd_samples(self):\\n \\n if \\\"PCD\\\" in self.algorithm:\\n \\n input_vars = []\\n \\n given_vars = []\\n \\n else:\\n \\n input_vars = [self.minibatch_set]\\n \\n given_vars = {self.x_gibbs: self.train_inputs[self.minibatch_set,:]} \\n \\n get_samples = theano.function(inputs = input_vars,\\n outputs = [self.p_xi_given_x_[-1], \\n self.gibbs_samples[-1]\\n ], \\n givens = given_vars,\\n #start the chain at the data distribution\\n updates = self.gibbs_updates)\\n \\n return get_samples\",\n \"def fetch_compas_df(preprocess=False):\\n (train_X, train_y), (test_X, test_y) = lale.datasets.openml.fetch(\\n \\\"compas\\\", \\\"classification\\\", astype=\\\"pandas\\\", preprocess=False\\n )\\n orig_X = pd.concat([train_X, test_X]).sort_index().astype(np.float64)\\n orig_y = pd.concat([train_y, test_y]).sort_index().astype(np.float64)\\n if preprocess:\\n race = pd.Series(orig_X[\\\"race_caucasian\\\"] == 1, dtype=np.float64)\\n dropped_X = orig_X.drop(\\n labels=[\\\"race_african-american\\\", \\\"race_caucasian\\\"], axis=1\\n )\\n encoded_X = dropped_X.assign(race=race)\\n fairness_info = {\\n \\\"favorable_labels\\\": [1],\\n \\\"protected_attributes\\\": [\\n {\\\"feature\\\": \\\"sex\\\", \\\"reference_group\\\": [1]},\\n {\\\"feature\\\": \\\"race\\\", \\\"reference_group\\\": [1]},\\n ],\\n }\\n return encoded_X, orig_y, fairness_info\\n else:\\n fairness_info = {\\n \\\"favorable_labels\\\": [1],\\n \\\"protected_attributes\\\": [\\n {\\\"feature\\\": \\\"sex\\\", \\\"reference_group\\\": [1]},\\n {\\\"feature\\\": \\\"race_caucasian\\\", \\\"reference_group\\\": [1]},\\n ],\\n }\\n return orig_X, orig_y, fairness_info\",\n \"def covar_samp(self):\\n if self.count <= 1:\\n return None\\n return self.Ck / (self.count - 1)\",\n \"def pseudo_seurat(adata, arg_minpct, arg_mindiffpct, arg_logfcdiff):\\n # define cells\\n cluster_cells_ind = which_ind(adata.obs[\\\"idents\\\"] == \\\"1\\\")\\n other_cells_ind = which_ind(adata.obs[\\\"idents\\\"] == \\\"0\\\")\\n\\n # compute perecentage expressed\\n # from normnalised but not scaled data\\n # remember cells are rows and genes are columns\\n\\n # note: I don't know why norm_counts[cluster_cell_ind:, col_ind] deosn\\\"t work, but it doesn't\\n cluster_pct = (adata.X[cluster_cells_ind, :] > 0).sum(axis=0) / len(cluster_cells_ind)\\n other_pct = (adata.X[other_cells_ind, :] > 0).sum(axis=0) / len(other_cells_ind)\\n\\n pcts = pd.DataFrame(np.vstack((cluster_pct, other_pct)).transpose())\\n max_pct = pcts.max(axis=1)\\n min_pct = pcts.min(axis=1)\\n diff_pct = max_pct - min_pct\\n take_diff_pct = diff_pct > arg_mindiffpct\\n\\n # remove genes that are not expressed higher than 0.1 in one of the groups\\n take_min_pct = max_pct > arg_minpct\\n\\n\\n # KEEP IN CASE NP.ARRAY METHOD USES TOO MUCH MEMORY\\n # import time\\n # this has the potential to be very slow. Transposeing it speeds it up a bit.\\n # I need to understand sparse matrices better to make it work\\n # start = time.time()\\n # nct = adata.X.T[:,cluster_cells_ind]\\n # cluster_mean0 = [exp_mean_sparse(nct[x,:]) for x in range(0,nct.shape[0])]\\n # end = time.time()\\n # print(end - start)\\n #\\n # start = time.time()\\n # nct = adata.X.T[:, other_cells_ind]\\n # other_mean0 = [exp_mean_sparse(nct[x,:]) for x in range(0, nct.shape[0])]\\n # end = time.time()\\n # print(end - start)\\n\\n # extract the counts for cluster cells and calculate exp means on each row\\n nct = adata.X.T[:, cluster_cells_ind]\\n cluster_mean = np.apply_along_axis(exp_mean_dense, 1, nct.todense())\\n\\n # likewise for non-cluster cells\\n nct = adata.X.T[:, other_cells_ind]\\n other_mean = np.apply_along_axis(exp_mean_dense, 1, nct.todense())\\n diff_mean = abs(cluster_mean - other_mean)\\n\\n # remove genes with less than threshold difference\\n take_thresh = diff_mean > arg_logfcdiff\\n # take = if a cell passes all the tests then it is to be kept.\\n take = [a and b and c for a, b, c in zip(take_thresh, take_min_pct, take_diff_pct)]\\n print(\\\"saving universe for fisher test\\\")\\n stats_df = pd.DataFrame(np.vstack((adata.var_names, cluster_mean, other_mean, diff_mean,\\n cluster_pct, other_pct, max_pct, min_pct, diff_pct, take)).transpose(),\\n columns=[\\\"gene\\\", \\\"cluster_mean\\\", \\\"other_mean\\\", \\\"diff_mean\\\",\\n \\\"cluster_pct\\\", \\\"other_pct\\\",\\n \\\"max_pct\\\", \\\"min_pct\\\", \\\"diff_pct\\\", \\\"background\\\"])\\n return stats_df\",\n \"def get_sequence(self):\\n\\n search_params = [\\n '|',\\n ('active', '=', True),\\n ('year', '=', self.year),\\n ('cod_gestion.name', '!=', 'Z8_01_dl15')\\n ]\\n codis_gestio = self.connection.model('cir8.2021.d2').search(search_params)\\n\\n return codis_gestio\",\n \"def test_pmt_pos_nt():\\r\\n pandas.DataFrame(straxen.pmt_positions(False))\",\n \"def pcd(dw, qpts=50):\\n w = w0+dw\\n pcm.set_qpts(qpts)\\n sml = pcm.sml_w(w)\\n avgchi = pcm.avgchi\\n pcm.set_qpts(0)\\n sml2 = pcm.sml_w(w)\\n print sml, log(sml) - pcm.offset, avgchi\\n print sml2, log(sml2) - pcm.offset, pcm.avgchi\",\n \"def recommend_cosim():\\n pass\",\n \"def get_covid_term() -> pd.DataFrame:\\n return NOTICE_GETTER.term\",\n \"def get_pca():\\n from sklearn.decomposition import PCA\\n return PCA()\",\n \"def df_to_cdm(cdm, cdmd, out_dir, dataset, dic_obstab_attributes, fn): \\n \\n #station_id_fails = open('station_id_fail.log' , 'a') \\n #station_id_ok = open('station_id_correct.log' , 'a')\\n \\n t=time.time()\\n if not False: \\n # era5 analysis feedback is read from compressed netcdf files era5.conv._?????.nc.gz in $RSCRATCH/era5/odbs/1\\n \\\"\\\"\\\" Reading the odb and convert to xarray \\\"\\\"\\\" \\n if 'bufr' in dataset :\\n df, stations_id= bufr_to_dataframe(fn) # fdbs: the xarray converted from the pandas dataframe \\n \\n elif 'ncar' in dataset:\\n df, stations_id = uadb_ascii_to_dataframe(fn)\\n \\n elif 'igra2' in dataset:\\n df, stations_id = igra2_ascii_to_dataframe(fn)\\n \\n else:\\n #print('Unidentified file is: ', fn)\\n raise ValueError('Cannot identify the type of file to be analized!!! ')\\n \\n station_configuration_retrieved = get_station_configuration_f( stations_id, cdm['station_configuration'] ) \\n #primary_id = station_configuration_retrieved['primary_id'].values[0].decode('utf-8') \\n try:\\n primary_id = station_configuration_retrieved['primary_id'].values[0].decode('utf-8')\\n except:\\n #print('CANT FIND STATION PRIMARY ID ')\\n out =open(dataset + \\\"_wrong_ids.txt\\\" , 'a+')\\n out.write(fn + '\\\\n')\\n \\n primary_id = '-1'\\n \\n fno, source_file = initialize_output(fn, output_dir, primary_id, dataset) \\n #if primary_id == 'uknown_primary':\\n # return \\n \\n \\\"\\\"\\\" Casting the original variable types to appropriate numpy types \\\"\\\"\\\" \\n #df = convert_variable_type(df) # ->think this is overly complicated. \\n df = convert_variable_type_n(df)\\n #df = df.replace( -2147483648 , np.nan ) \\n \\n \\n \\\"\\\"\\\" Extract the unique indices of each date observation, one for only dates, one for date_time (i.e. record index). \\n Converts the time variables in seconds since 1900-01-01 00:00:00 \\\"\\\"\\\" \\n di=xr.Dataset() \\n \\n \\n if 'igra2' in dataset:\\n releasetime_toseconds = datetime_toseconds( df['report_timestamp'] ) \\n df['report_timestamp'] = releasetime_toseconds # will fill the header_table TODO see if it improves by replacing values with dictionaries in pandas \\n \\n record_timestamp_seconds = datetime_toseconds( df['record_timestamp'] ) # will fill the header_table TODO see if it improves by replacing values with dictionaries in pandas \\n df['record_timestamp'] = record_timestamp_seconds # replacing with seconds from 1900-01-01 00:00:00 \\n\\n indices, day, counts = make_datetime_indices( df['iday'].values ) #only date information\\n di['dateindex'] = ( { 'dateindex' : day.shape } , indices ) \\n \\n indices, date_times , counts = make_datetime_indices( df['record_timestamp'].values ) #date_time plus indices \\n di['recordindex'] = ( {'recordindex' : indices.shape }, indices )\\n di['recordtimestamp'] = ( {'recordtimestamp' : date_times.shape }, date_times )\\n\\n di['recordtimestamp'].attrs['units']='seconds since 1900-01-01 00:00:00'\\n\\n di.to_netcdf( fno, format='netCDF4', engine='h5netcdf', mode='w' )\\n \\n \\n \\n \\\"\\\"\\\" Storing the variable encodings \\\"\\\"\\\"\\n fbencodings={}\\n for d,v in df.items(): \\n if v.dtype==numpy.dtype('float64'):\\n fbencodings[d]={'dtype':numpy.dtype('float32'), 'compression': 'gzip'} \\n \\n elif v.dtype==numpy.dtype('float32'):\\n fbencodings[d]={'dtype':numpy.dtype('float32'), 'compression': 'gzip'} \\n \\n elif v.dtype==numpy.dtype('int32'):\\n fbencodings[d]={'dtype':numpy.dtype('int32'), 'compression': 'gzip'} \\n \\n elif v.dtype==numpy.dtype('int64'):\\n fbencodings[d]={'dtype':numpy.dtype('int64'), 'compression': 'gzip'} \\n \\n elif type(v.values[0])==bytes:\\n fbencodings[d]={'compression': 'gzip', 'chunksizes': ( min( [10000,v.shape[0] ] ), 10 ) }#,'chunksizes':(10000,10)\\n else:\\n fbencodings[d]={'compression': 'gzip'}\\n fbencodings['index']={'compression': 'gzip'}\\n \\n \\n #write_dict_h5(fno, df, 'era5fb', fbencodings, var_selection=[],mode='a')\\n dcols=[]\\n for d in df.columns:\\n if d not in ['date@hdr','time@hdr','statid@hdr','vertco_reference_1@body','varno@body', 'lon@hdr','lat@hdr','seqno@hdr',\\n 'obsvalue@body','fg_depar@body','an_depar@body','biascorr@body','sonde_type@conv', 'record_timestamp' , 'report_timestamp',\\n 'observation_id', 'report_id' , 'units' , 'vertco_type@body' ] :\\n \\n dcols.append(d)\\n df.drop(columns=dcols,inplace=True)\\n \\n groups={}\\n groupencodings={}\\n for k in cdmd.keys(): # loop over all the table definitions \\n if k in ('observations_table'):\\n pass #groups[k]=pd.DataFrame()\\n else:\\n groups[k]=xr.Dataset() # create an xarray\\n groupencodings[k]={} # create a dict of group econding\\n \\n for i in range(len(cdmd[k])):\\n d=cdmd[k].iloc[i] \\n \\n \\\"\\\"\\\" Filling the observations_table \\\"\\\"\\\"\\n if k in ('observations_table'):\\n groups[k]=pd.DataFrame() # creating dataframes that will be written to netcdf via h5py methods by the write_dict_h5() method \\n \\n try: \\n groups[k][d.element_name]= fromfb_l(df, di._variables, cdmfb_noodb[d.element_name], ttrans(d.kind,kinds=okinds)) \\n except KeyError:\\n x=numpy.zeros( df['record_timestamp'].shape[0], dtype=numpy.dtype(ttrans(d.kind,kinds=okinds) ) )\\n x.fill(numpy.nan)\\n groups[k][d.element_name]=x\\n\\n \\n elif k in ('header_table'):\\n if d.element_name == 'report_timestamp':\\n groups[k][d.element_name]= ( {'hdrlen':di['recordindex'].shape[0]} , np.take(df[d.element_name], di['recordindex'] ) )\\n groups[k][d.element_name].attrs['units'] = 'seconds since 1900-01-01 00:00:00'\\n elif d.element_name == 'record_timestamp':\\n groups[k][d.element_name]= ( {'hdrlen':di['recordindex'].shape[0]} , np.take(df[d.element_name], di['recordindex'] ) )\\n groups[k][d.element_name].attrs['units'] = 'seconds since 1900-01-01 00:00:00' \\n else:\\n try:\\n \\n if d.element_name not in station_configuration_retrieved.columns: # variables might be from the df (input file) or from the retrieved station configuration \\n \\n try: \\n # groups[k][d.element_name] = ({'hdrlen':di['recordindex'].shape[0]}, hdrfromfb(df,di._variables, cdmfb[d.element_name],ttrans(d.kind,kinds=gkinds) ) )\\n groups[k][d.element_name]= (di['recordindex'].shape[0], hdrfromfb(df, di._variables, cdmfb_noodb[d.element_name], ttrans(d.kind,kinds=gkinds) ) )\\n except: \\n x=numpy.zeros(di['recordindex'].shape[0], dtype=numpy.dtype(ttrans(d.kind,kinds=gkinds)))\\n x.fill(numpy.nan)\\n groups[k][d.element_name]=({'hdrlen':di['recordindex'].shape[0]},x) \\n \\n else: \\n x=numpy.zeros(di['recordindex'].shape[0], dtype=numpy.dtype(ttrans(d.kind,kinds=gkinds)))\\n x.fill( station_configuration_retrieved[d.element_name].values[0] )\\n groups[k][d.element_name]= ({'hdrlen':di['recordindex'].shape[0]},x) \\n except: # in case I cannot retrieve the station configuration file \\n try: \\n groups[k][d.element_name]=(di['recordindex'].shape[0], hdrfromfb(df, di._variables, cdmfb_noodb[d.element_name], ttrans(d.kind,kinds=gkinds) ) )\\n except: \\n x=numpy.zeros(di['recordindex'].shape[0], dtype=numpy.dtype(ttrans(d.kind,kinds=gkinds)))\\n x.fill(numpy.nan)\\n groups[k][d.element_name]=({'hdrlen':di['recordindex'].shape[0]},x) \\n \\n elif k in ('station_configuration'): # station_configurationt contains info of all the stations, so this extracts only the one line for the wanted station with the numpy.where\\n try: # case when the station+conf cannot be retrieved \\n if d.element_name in station_configuration_retrieved.columns: \\n groups[k][d.element_name]=({'hdrlen': 1}, np.full( 1 , station_configuration_retrieved[d.element_name].values[0] ) )\\n except:\\n pass\\n \\n elif k in ('source_configuration'): # storing the source configuration info, e.g. original file name, \\n if d.element_name=='source_file':\\n # groups[k][d.element_name] = ( {'hdrlen':fbds.variables['date@hdr'].shape[0] } , np.full( fbds.variables['date@hdr'].shape[0] , source_file ) ) \\n groups[k][d.element_name] = ( {'hdrlen': 1 }, np.full( 1 , source_file) )\\n else:\\n try: \\n groups[k][d.element_name] = ( {'hdrlen': 1 }, np.full( 1 , np.nan) ) # element_name is the netcdf variable name, which is the column name of the cdm table k \\n except KeyError:\\n pass\\n\\n else : # this is the case where the cdm tables DO exist\\n try: \\n groups[k][d.element_name]=({k+'_len':len(cdm[k])}, cdm[k][d.element_name].values) # element_name is the netcdf variable name, which is the column name of the cdm table k \\n except KeyError:\\n pass\\n \\n \\n \\\"\\\"\\\" Tryin to add attributes, e.g. description and external tables \\\"\\\"\\\" \\n try:\\n groups[k][d.element_name].attrs['external_table']=d.external_table # defining variable attributes that point to other tables (3rd and 4th columns)\\n groups[k][d.element_name].attrs['description']=d.description # it faisl when trying with the observations_table \\n except:\\n pass\\n \\n try: \\n if type(groups[k][d.element_name].values[0])==str:\\n s=groups[k][d.element_name].values.shape\\n groupencodings[k][d.element_name]={'dtype':numpy.dtype('S80'),'compression': 'gzip','chunksizes':(min(100000,s[0]),80)}\\n else:\\n groupencodings[k][d.element_name]={'compression': 'gzip'}\\n \\n if k in ('observations_table'):\\n write_dict_h5(fno, groups[k], k, groupencodings[k], var_selection=[],mode='a', attrs= dic_obstab_attributes )\\n \\n except:\\n #print('bad:',k,d.element_name)\\n pass\\n \\n for k in groups.keys(): \\n if k not in ('observations_table') : \\n groups[k].to_netcdf(fno,format='netCDF4',engine='h5netcdf',encoding=groupencodings[k],group=k,mode='a') #\\n \\n del df\\n \\n return 0\",\n \"def test_pmt_pos_1t():\\r\\n pandas.DataFrame(straxen.pmt_positions(True))\",\n \"def get_dysbiosis_metrics(diseases, datasets, df, pthresh, samplesizes,\\n overall=None):\\n\\n # Keep only OTUs which were signficant in at least one study\\n # if x is zero, this returns zero (i.e. if there is no effect, it\\n # doesn't count as significant so don't worry)\\n sigmap = lambda x: np.sign(x) if abs(x) < pthresh else 0\\n # This one is for the score-based metric\\n simplesigmap = lambda x: np.sign(x) if abs(x) < pthresh else 0.5*np.sign(x)\\n\\n results = [[],[],[],[]]\\n\\n for dis in diseases:\\n print(dis)\\n ## Prepare subset df\\n keep_datasets = [i for i in datasets if i.startswith(dis + '_')]\\n disdf = df[keep_datasets]\\n # Keep only genera which are significant in at least one study\\n disdf = disdf.loc[disdf.applymap(sigmap).apply(abs).sum(axis=1) != 0]\\n\\n if disdf.empty:\\n print('\\\\tempty, everything is zero')\\n metrics = ['rep_score', 'rep_twostudies', 'rep_twostudies_norm',\\n 'rep_stouffer', 'rep_stouffer_norm', 'n_sig', 'balance',\\n 'rep_dataset', 'rep_dataset_norm']\\n for metric in metrics:\\n val = 0\\n if metric == \\\"balance\\\" or metric == 'rep_dataset':\\n val = np.nan\\n if metric in ['rep_score']:\\n # No genera are significant, therefore none are scored...\\n pass\\n elif metric in ['n_sig', 'balance', 'rep_dataset',\\n 'rep_dataset_norm']:\\n # Dataset-wise results, each disdf column gets its own label\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=[val]*disdf.shape[1],\\n newvariables=disdf.columns.tolist(),\\n newmetric_label=metric,\\n newdisease_label=dis)\\n elif metric in ['rep_twostudies', 'rep_twostudies_norm',\\n 'rep_stouffer', 'rep_stouffer_norm']:\\n # Disease-wise results, each disease gets just one result\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=[val],\\n newvariables=[dis],\\n newmetric_label=metric,\\n newdisease_label=dis)\\n\\n else:\\n ## Reproducibility score: +1/-1 if significant,\\n # +/- 0.5 if not significant - don't weight by sample size\\n # Metric is the row sum divided by number of columns\\n # (i.e. sum across datasets / number of datasets), and is\\n # genus-wise\\n df_simple_rep = disdf.applymap(simplesigmap)\\n reproducibility = list(\\n df_simple_rep.sum(axis=1)/float(df_simple_rep.shape[1]))\\n\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=reproducibility,\\n newvariables=disdf.index.tolist(),\\n newmetric_label='rep_score',\\n newdisease_label=dis)\\n\\n ## Reproducibility co-occurence: genus is 'reproducibly significant'\\n # if it's sig in at least 2 studies\\n # Metric returns one number per disease)\\n dfcooccur = disdf.applymap(sigmap)\\n # Genus is reproducible if it is significant in the same\\n # direction in at least net 2 studies\\n reproducibility = sum(dfcooccur.sum(axis=1).apply(abs) > 1)\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=[reproducibility],\\n newvariables=[dis],\\n newmetric_label='rep_twostudies',\\n newdisease_label=dis)\\n\\n ## Normalize co-occurence: same as above, but value is normalized by total number of sig OTUs in that disease (one number per disease)\\n reproducibility = reproducibility/float(dfcooccur.shape[0])\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=[reproducibility],\\n newvariables=[dis],\\n newmetric_label='rep_twostudies_norm',\\n newdisease_label=dis)\\n\\n ## Fisher's method: number of 'reproducible' genera, i.e. genera\\n # with combine p-value < pthresh\\n # This returns one number per disease\\n reproducibility = \\\\\\n reproducibility_from_fisher(disdf, samplesizes, pthresh)\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=[reproducibility],\\n newvariables=[dis],\\n newmetric_label='rep_stouffer',\\n newdisease_label=dis)\\n\\n ## Normalized Fisher's method: same as above, but normalized\\n # by total number of datasets in that disease\\n reproducibility = reproducibility/float(disdf.shape[0])\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=[reproducibility],\\n newvariables=[dis],\\n newmetric_label='rep_stouffer_norm',\\n newdisease_label=dis)\\n\\n ## Total number of significant OTUs\\n n_otus = disdf.applymap(sigmap)\\\\\\n .applymap(lambda x: 1 if x == 1 or x == -1 else 0)\\\\\\n .sum()\\n # index of this Series is the datasets (i.e. columns of disdf)\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=list(n_otus),\\n newvariables=list(n_otus.index),\\n newmetric_label='n_sig',\\n newdisease_label=dis)\\n\\n ## Balance metric is number of significant disease-associated\\n # (i.e. positive q-value) genera divided by total number of\\n # significant genera\\n n_pos = (disdf.applymap(sigmap) == 1).sum().astype(float)\\n # If there are no significant OTUs, this needs to return nan,\\n # otherwise the zero makes it look the same as \\\"all significant\\n # genera are health-associated\\\"\\n n_otus = n_otus.replace(0, np.nan)\\n balance = n_pos/n_otus\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=list(balance),\\n newvariables=list(balance.index),\\n newmetric_label='balance',\\n newdisease_label=dis)\\n\\n ## Reproducibility per dataset. For each dataset, count the\\n # number of significant genera which are significant (in same dir)\\n # in at least one other dataset of that disease\\n for dataset in disdf:\\n # Keep just the genera which are significant in the one study\\n coldf = disdf[dataset].apply(sigmap)\\n coldf = coldf[coldf != 0]\\n # If there's at least one significant bug in that study\\n if coldf.shape[0] > 0:\\n coldf = disdf.loc[coldf.index].applymap(sigmap)\\n # Count how many genera are significant in at least\\n # two studies\\n reproducibility = (coldf.sum(axis=1).apply(abs) >= 2).sum()\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=[reproducibility],\\n newvariables=[dataset],\\n newmetric_label='rep_dataset',\\n newdisease_label=dis)\\n\\n # Normalize by the total number of significant bugs in\\n # that dataset\\n reproducibility = reproducibility/float(coldf.shape[0])\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=[reproducibility],\\n newvariables=[dataset],\\n newmetric_label='rep_dataset_norm',\\n newdisease_label=dis)\\n else:\\n reproducibility = np.nan\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=[reproducibility],\\n newvariables=[dataset],\\n newmetric_label='rep_dataset',\\n newdisease_label=dis)\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=[reproducibility],\\n newvariables=[dataset],\\n newmetric_label='rep_dataset_norm',\\n newdisease_label=dis)\\n\\n ## Also, if overall is given, calculate the specificity\\n # (i.e. how much overlap with the \\\"core\\\" response each dataset has)\\n if overall is not None:\\n # Note: overall can be a pandas series or one-column dataframe\\n overall_healthy = overall[(overall == -1).values].index\\n overall_disease = overall[(overall == 1).values].index\\n # Note: not looking at overall_mixed bc these *would* be\\n # interesting disease-specific bugs! :)\\n\\n for dataset in disdf:\\n # Keep just the genera which are significant in the study\\n coldf = disdf[dataset].apply(sigmap)\\n coldf = coldf[coldf != 0]\\n # If there's at least one significant bug in that study\\n if coldf.shape[0] > 0:\\n\\n healthy = coldf[coldf == -1].index\\n disease = coldf[coldf == 1].index\\n\\n healthy_overlap = \\\\\\n len([i for i in healthy if i in overall_healthy])\\n disease_overlap = \\\\\\n len([i for i in disease if i in overall_disease])\\n total_overlap = healthy_overlap + disease_overlap\\n total_sig = len(healthy) + len(disease)\\n total_nonoverlap = total_sig - total_overlap\\n\\n # I don't think I should ever get this error...\\n try:\\n perc_overlap = total_overlap / float(total_sig)\\n perc_nonoverlap = 1.0 - perc_overlap\\n except ZeroDivisionError:\\n perc_overlap = np.nan\\n perc_nonoverlap = np.nan\\n\\n # If nothing was significant, all of these metrics are NaN\\n else:\\n total_overlap = np.nan\\n total_nonoverlap = np.nan\\n total_sig = np.nan\\n perc_overlap = np.nan\\n perc_nonoverlap = np.nan\\n\\n # Update the big results with these new metrics\\n all_overlaps = [total_overlap, total_nonoverlap,\\n total_sig, perc_overlap,\\n perc_nonoverlap]\\n all_labels = ['total_overlap', 'total_nonoverlap',\\n 'total_sig', 'perc_overlap',\\n 'perc_nonoverlap']\\n for newvalue, newlabel in zip(all_overlaps, all_labels):\\n results = update_reproducibility_df_lists(\\n *results,\\n newvalues=[newvalue],\\n newvariables=[dataset],\\n newmetric_label=newlabel,\\n newdisease_label=dis)\\n\\n df_results = pd.DataFrame(data=np.column_stack(results),\\n columns=['value', 'label', 'metric', 'disease'])\\n return df_results\",\n \"def test_codon_usage_ecoli(self):\\n CAI = CodonAdaptationIndex()\\n self.assertEqual(\\\"%0.5f\\\" % CAI.cai_for_gene(\\\"ATGCGTATCGATCGCGATACGATTAGGCGGATG\\\"),\\n \\\"0.09978\\\")\",\n \"def get_cod_freq(gene):\\r\\n header = gene.iloc[:,0].values[0].split(' ')\\r\\n geneID=header[0][1:]\\r\\n\\r\\n\\r\\n #get coding sequence\\r\\n cds = gene.iloc[:,1].values[0].upper().replace('T','U')\\r\\n codon_count=dict() \\r\\n \\r\\n #build dictionary to accumulate codon counts; ignore with stop codons\\r\\n for codon in list(codon_aa.keys()):\\r\\n if codon not in [ \\\"UAA\\\",\\\"UAG\\\", \\\"UGA\\\" ]:\\r\\n codon_count[codon]=0\\r\\n \\r\\n ##count codons in cds\\r\\n codons = []\\r\\n for c in range(0,len(cds),3): #O(len cds)\\r\\n cod=cds[c:c+3]\\r\\n try:\\r\\n codon_count[cod]+=1\\r\\n except KeyError:\\r\\n continue\\r\\n \\r\\n #store the fractional freq of each codon in the codon dictionary\\r\\n total_cod=len(cds)/3 #total number of codons in the cds\\r\\n for c in list(codon_count.keys()): #O(len codondict)\\r\\n codon_count[c]/=total_cod\\r\\n \\r\\n df_codcnt=pd.DataFrame(list(codon_count.items()) )\\r\\n df_codcnt.columns=['Codon', 'Fractional_Freq']\\r\\n df_codcnt=df_codcnt.set_index('Codon').T.reset_index(drop=True)\\r\\n \\r\\n df_codcnt['GeneID']=geneID\\r\\n\\t#reorder columns\\r\\n cols2=[df_codcnt.columns[-1]]+sorted(df_codcnt.columns[:61])\\r\\n df_codcnt=df_codcnt[cols2]\\r\\n return df_codcnt\",\n \"def samsemPlots41and42(samsem_data,path,dict):\\n coldef_type = dict['coldef_type']\\n print(\\\"Starting SAMSEM_RES#41+42: Computing of Chi2 for simulation methods of \\\" + str(settings.id2ColDefLong[coldef_type])+\\\".\\\")\\n \\n if 'subfolder' in dict:\\n subfolder = dict['subfolder']\\n path_res = os.path.join(path,subfolder)\\n if not os.path.exists(path_res): os.makedirs(path_res)\\n \\n # Ignore dummy algorithm\\n #whatArr_tmp = [['sim_id',operator.ne,99]];howArr_tmp=[]\\n #samsem_data = organizeArray(samsem_data,whatArr_tmp,howArr_tmp)\\n \\n corrArr = []; uncorrArr = []; data = {}; sim_names = []; chi2_pandas = {}\\n \\n sim_ids = sorted(set(samsem_data['sim_id'].values.astype(int)))\\n for sim_id in sim_ids:\\n sim_name_tmp = settings.id2Sim[sim_id]\\n sim_names.append(sim_name_tmp)\\n if (sim_id !=3) and (sim_id != 99):\\n whatArr_tmp = [['coldef_type',operator.eq,coldef_type],['observer_coldef_type',operator.eq,coldef_type],['sim_id',operator.eq,sim_id]];howArr_tmp=[]\\n else:\\n whatArr_tmp = [['observer_coldef_type',operator.eq,coldef_type],['sim_id',operator.eq,sim_id]]\\n alg_data_tmp = organizeArray(samsem_data,whatArr_tmp)\\n \\n #pandas_dict\\n chi2_pandas.update({sim_name_tmp: alg_data_tmp})\\n \\n # Make Chi2 contingency test\\n obs_array, obs_pandas = preparePandas4Chi2(chi2_pandas,{0: 'vienot', 1: 'vienot-adjusted', 2: 'kotera', 3: 'brettel', 4: 'dummy'})\\n \\n start = 0; end = 4\\n obs_adj = obs_array[:,start:end]\\n chi2, p, dof, ex = stats.chi2_contingency(obs_adj) # Compare only simulation methods\\n \\n res_str = \\\"\\\"\\n res_str = res_str + \\\"Simulation methods and observations:\\\\n\\\" + str(obs_pandas)\\n res_str = res_str + \\\"\\\\n\\\\nSimulation methods included in test:\\\\n\\\" + str(sim_names[start:end])\\n res_str = res_str + \\\"\\\\nChi2: %f, p-value: %E, dof: %i, expect: \\\" % (chi2, p, dof) + \\\"\\\\n\\\"+str(ex)\\n text_file = open(os.path.join(path_res,settings.id2ColDefLong[coldef_type]+\\\"-methods-ACC_pearson-chi2-contingency-test_p-value.txt\\\"), \\\"w+\\\")\\n text_file.write(res_str)\\n text_file.close()\\n \\n writePandastoLatex(obs_pandas, os.path.join(path_res,settings.id2ColDefLong[coldef_type]+\\\"-methods-ACC_observations.tex\\\"))\\n \\n # Make Chi2 contingency 2x2 test matrix\\n dict.update({'filename': dict['filename']+'-ACC'})\\n makePearsonChi2Contingency2x2Test(obs_array, path_res, sim_names, dict)\",\n \"def annotate_ISM(data_df, REFERENCE, position_list, reference_genbank_name=\\\"data/covid-19-genbank.gb\\\"):\\n seq_list = data_df['sequence'].values.tolist()\\n \\n seq_index = []\\n index = 0\\n for base in REFERENCE[1]:\\n if base == '-':\\n seq_index.append(index)\\n else:\\n index += 1\\n seq_index.append(index)\\n reference_local_index_map = np.array(seq_index)\\n mapped_reference_index = []\\n for index, entropy in position_list:\\n mapped_reference_index.append((index, reference_local_index_map[index], entropy))\\n REFERENCE_ISM = ''.join([REFERENCE[1][item[0]] for item in position_list])\\n logging.info('Reference ISM: {}.'.format(REFERENCE_ISM))\\n \\n gene_dict = load_gene_dict(reference_genbank_name)\\n reference_raw = REFERENCE[1].replace('-', '')\\n res = OrderedDict()\\n res['Ref position'] = []\\n res['Entropy'] = []\\n res['Gene'] = []\\n res['Is silent'] = []\\n res['AA position'] = []\\n for align_index, ref_index, entropy in mapped_reference_index:\\n codon, codon_idx, name, codon_pos = find_SNP(ref_index, gene_dict, reference_raw)\\n base_freq = Counter([item[align_index] for item in seq_list]).most_common()\\n for alt_base, count in base_freq:\\n if alt_base != reference_raw[ref_index-1]:\\n break\\n if codon is None:\\n if_silence = True\\n else:\\n alt_codon = list(codon)\\n alt_codon[codon_idx] = alt_base\\n alt_codon = ''.join(alt_codon)\\n ref_aa = translate(codon)\\n ism_aa = translate(alt_codon)\\n if ref_aa == ism_aa:\\n if_silence = True\\n else:\\n if_silence = False\\n res['Ref position'].append(ref_index)\\n res['Entropy'].append(entropy)\\n if name is None:\\n name = 'Non-coding'\\n res['Gene'].append(name)\\n res['Is silent'].append(if_silence)\\n if codon_pos is None:\\n res['AA position'].append('NaN')\\n else:\\n res['AA position'].append('{}{}{}'.format(ref_aa, codon_pos, ism_aa))\\n annotation_df = pd.DataFrame.from_dict(res)\\n return annotation_df\",\n \"def main(n_pairs, cutoff, resDir, matFile, msa_name=None):\\n dca_df = run_analysis(msa_name, n_pairs, cutoff, resDir, matFile, fni=False, plot=False)\\n return dca_df\",\n \"def crs(self):\\n return self.dataframe.crs\",\n \"def make_prog(self):\\r\\n\\r\\n self.cnv.clear()\\r\\n cdf = self.df[self.df.L != 0]\\r\\n c0 = cdf['C0'].value_counts().idxmax()\\r\\n c1 = cdf['C1'].value_counts().idxmax()\\r\\n c2 = cdf['C2'].value_counts().idxmax()\\r\\n c3 = cdf['C3'].value_counts().idxmax()\\r\\n self.cnv.extend([c0, c1, c2, c3])\",\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 get_mod_freq_two_step(df, cols, chr_pos, strains, method=\\\"GMM+eIF\\\", clf_name=\\\"GMM\\\", \\n clf=GaussianMixture(n_components=4, random_state=0), \\n clf2_name=\\\"eIF\\\", clf2=iso_new.iForest(random_state=0), \\n OFFSET=None):\\n results = []\\n for cp in chr_pos:\\n _df = df.loc[(df[\\\"chr_pos\\\"]==cp)&(df.Strain.isin(strains)), cols+[\\\"Strain\\\"]]\\n _X = min_max_norm(_df[cols].to_numpy().astype(\\\"float\\\"))\\n # get clusters from GMM using only SIGNAL INTENSITY\\n clusters = clf.fit_predict(_X) #[:,:3]\\n c2i = Counter(clusters)#; print(c2i)\\n # get outliers using every cluster as training sset\\n mod_freqs = np.zeros((len(c2i), len(strains)))\\n mod_freqs1 = np.zeros_like(mod_freqs)\\n for cl in list(c2i.keys())[:3]:\\n Xtrain = _X[clusters==cl]\\n if len(Xtrain)<3: continue # this is arbitrary value\\n scores = clf2.fit(Xtrain).score_samples(_X)\\n offset = (max(scores)-min(scores))/2 if not OFFSET else OFFSET\\n y_pred = scores>offset\\n # get mod_freq from outlier score cut-off\\n mod_freqs1[cl] = [y_pred[_df[\\\"Strain\\\"]==s].mean() for s in strains]\\n # and using quantile method\\n mod_freqs[cl] = get_modfreq_from_quantiles_many_samples([scores[_df[\\\"Strain\\\"]==s] for s in strains])\\n\\n # pick cluster that gave the largest difference in mod_freq between any two samples\\n extremes = np.vstack([np.nanmin(mod_freqs, axis=1), np.nanmax(mod_freqs, axis=1)])\\n mod_freq_idx = np.abs(np.diff(extremes, axis=0)).argmax()#; print(mod_freq_idx)\\n # and report\\n #results.append((cp, \\\"%s+%s_c\\\"%(clf_name, clf2_name), *mod_freqs1[mod_freq_idx], \\n # \\\", \\\".join(map(str, strains[1:]))))\\n results.append((cp, method, *mod_freqs[mod_freq_idx], \\\", \\\".join(map(str, strains[1:]))))\\n return results\",\n \"def proc_dataset_v2(write=False):\\n \\n path = load_config()\\n M = pd.read_csv(path['metadata_file'])\\n T = pd.read_csv(path['rna_file'])\\n mCH = pd.read_csv(path['mCH_file'])\\n CH = pd.read_csv(path['CH_file'])\\n\\n def format_df(df):\\n \\\"\\\"\\\"The inputs are genes x cells. Transpose data and rename columns\\\"\\\"\\\"\\n df = df.transpose()\\n df.rename(columns=df.iloc[0], inplace=True)\\n df.drop('gene', inplace=True)\\n df.index.rename('sample_id', inplace=True)\\n return df\\n\\n T = format_df(T)\\n mCH = format_df(mCH)\\n CH = format_df(CH)\\n\\n #Update metadata\\n M = pd.read_csv(path['metadata_file'])\\n M.rename(columns={'Unnamed: 0': 'sample_id'}, inplace=True)\\n M.set_index(keys='sample_id', drop=True, inplace=True)\\n\\n #Sort cells by metadata\\n sorted_index = M.sort_values(by='SubClusterAnno').index\\n M = M.loc[sorted_index]\\n T = T.loc[sorted_index]\\n mCH = mCH.loc[sorted_index]\\n CH = CH.loc[sorted_index]\\n\\n assert np.array_equal(CH.columns, mCH.columns), \\\"Genes are not in the same order\\\"\\n assert np.array_equal(T.columns, mCH.columns), \\\"Genes are not in the same order\\\"\\n assert M.index.equals(T.index), \\\"Cells are not in the same order\\\"\\n assert M.index.equals(CH.index), \\\"Cells are not in the same order\\\"\\n assert M.index.equals(mCH.index), \\\"Cells are not in the same order\\\"\\n\\n # CPM-normalize counts\\n X = T.values.astype(np.float32)\\n X = (X/np.sum(X, axis=1, keepdims=True))*1e6\\n X = np.log1p(X)\\n T = pd.DataFrame(data=X, index=T.index, columns=T.columns)\\n print('Completed T processing')\\n\\n # For methylation data\\n X = CH.values.astype(float)\\n Y = mCH.values.astype(float)\\n Z = np.divide(Y,X+1e-10)\\n E = pd.DataFrame(data=Z, index=mCH.index, columns=mCH.columns)\\n print('Completed E processing')\\n\\n # select genes based on variance in log normalized CPM values in T\\n def calc_highvar_genes(df):\\n vars = np.var(df.values, axis=0)\\n order_vars = np.argsort(-vars) # descending order\\n sorted_highvar_genes = df.columns.values[order_vars]\\n return sorted_highvar_genes\\n\\n data = {'sorted_highvar_T_genes': calc_highvar_genes(T),\\n 'sorted_highvar_E_genes': calc_highvar_genes(E)}\\n print('Completed finding high variance features')\\n\\n if write:\\n feather.write_dataframe(T, path['data_dir'] / 'T_dat_v2.feather')\\n feather.write_dataframe(E, path['data_dir'] / 'E_dat_v2.feather')\\n feather.write_dataframe(M, path['data_dir'] / 'Meta_v2.feather')\\n sio.savemat(path['data_dir'] / 'highvar_genes_v2.mat', data)\\n return T, E, M, data\",\n \"def get_ccdf(degseq):\\n uniques, counts = np.unique(degseq, return_counts=True)\\n cumprob = np.cumsum(counts).astype(np.double) / (degseq.size)\\n return uniques[::-1], (1. - cumprob)[::-1]\",\n \"def extract_scc(data, N_max):\\n\\n # copy scalar coupling constants\\n scc = data[['molecule_name', 'scalar_coupling_constant']].copy()\\n\\n # write all scc of a molecule into one line\\n scc = scc.groupby('molecule_name').apply(lambda x: x.values.reshape(-1))\\n\\n # pad with zeros\\n scc_list = []\\n for i in range(len(scc)):\\n n = N_max*2 - len(scc[i])\\n scc_list.append(np.pad(scc[i], (0, n), 'constant',\\n constant_values=(0, np.nan)))\\n\\n # build np array and remove molecule names\\n scc = np.vstack(scc_list)\\n del scc_list\\n scc = np.delete(scc, [2*i for i in range(N_max)], 1)\\n\\n # convert to array and return\\n return scc.astype(float)\",\n \"def tocsc(self):\\n return self.tocsr().tocsc()\",\n \"def proc_dataset_v1(write=False):\\n \\n path = load_config()\\n M = pd.read_csv(path['metadata_file'])\\n T = pd.read_csv(path['rna_file'])\\n mCH = pd.read_csv(path['mCH_file'])\\n CH = pd.read_csv(path['CH_file'])\\n\\n def format_df(df):\\n \\\"\\\"\\\"The inputs are genes x cells. Transpose data and rename columns\\\"\\\"\\\"\\n df = df.transpose()\\n df.rename(columns=df.iloc[0], inplace=True)\\n df.drop('gene', inplace=True)\\n df.index.rename('sample_id', inplace=True)\\n return df\\n\\n T = format_df(T)\\n mCH = format_df(mCH)\\n CH = format_df(CH)\\n\\n #Update metadata\\n M = pd.read_csv(path['metadata_file'])\\n M.rename(columns={'Unnamed: 0': 'sample_id'}, inplace=True)\\n M.set_index(keys='sample_id', drop=True, inplace=True)\\n\\n #Sort cells by metadata\\n sorted_index = M.sort_values(by='SubClusterAnno').index\\n M = M.loc[sorted_index]\\n T = T.loc[sorted_index]\\n mCH = mCH.loc[sorted_index]\\n CH = CH.loc[sorted_index]\\n\\n assert np.array_equal(CH.columns, mCH.columns), \\\"Genes are not in the same order\\\"\\n assert np.array_equal(T.columns, mCH.columns), \\\"Genes are not in the same order\\\"\\n assert M.index.equals(T.index), \\\"Cells are not in the same order\\\"\\n assert M.index.equals(CH.index), \\\"Cells are not in the same order\\\"\\n assert M.index.equals(mCH.index), \\\"Cells are not in the same order\\\"\\n\\n # CPM-normalize counts\\n X = T.values.astype(np.float32)\\n X = (X/np.sum(X, axis=1, keepdims=True))*1e6\\n X = np.log1p(X)\\n T = pd.DataFrame(data=X, index=T.index, columns=T.columns)\\n print('Completed T processing')\\n\\n # For methylation data\\n X = CH.values.astype(float)\\n Y = mCH.values.astype(float)\\n Z = np.log1p(Y) - np.log1p(X)\\n E = pd.DataFrame(data=Z, index=mCH.index, columns=mCH.columns)\\n print('Completed E processing')\\n\\n # select genes based on variance in log normalized CPM values in T\\n def calc_highvar_genes(df):\\n vars = np.var(df.values, axis=0)\\n order_vars = np.argsort(-vars) # descending order\\n sorted_highvar_genes = df.columns.values[order_vars]\\n return sorted_highvar_genes\\n\\n data = {'sorted_highvar_T_genes': calc_highvar_genes(T),\\n 'sorted_highvar_E_genes': calc_highvar_genes(E)}\\n print('Completed finding high variance features')\\n\\n if write:\\n feather.write_dataframe(T, path['data_dir'] / 'T_dat.feather')\\n feather.write_dataframe(E, path['data_dir'] / 'E_dat.feather')\\n feather.write_dataframe(M, path['data_dir'] / 'Meta.feather')\\n sio.savemat(path['data_dir'] / 'highvar_genes.mat', data)\\n return T, E, M, data\",\n \"def get_covariates_df(dataset_name: str) -> pd.DataFrame:\\n path = Path(dataset_name) / COVARIATES_FILE\\n return get_dataframe(path)\",\n \"def pca_pubdev_4167_OOM():\\n h2o.remove_all()\\n transform_types = [\\\"NONE\\\", \\\"STANDARDIZE\\\", \\\"NORMALIZE\\\", \\\"DEMEAN\\\", \\\"DESCALE\\\"] # make sure we check all tranforms\\n transformN = transform_types[randint(0, len(transform_types)-1)]\\n print(\\\"transform used on dataset is {0}.\\\\n\\\".format(transformN))\\n\\n training_data = h2o.import_file(path=pyunit_utils.locate(\\\"/Users/wendycwong/gitBackup/SDatasets/pubdev_4167_Avkash/m120K.tar\\\")) # Nidhi: import may not work\\n\\n gramSVDPCA = H2OPCA(k=training_data.ncols, transform=transformN)\\n gramSVDPCA.train(x=list(range(0, training_data.ncols)), training_frame=training_data)\\n\\n powerSVDPCA = H2OPCA(k=training_data.ncols, transform=transformN, pca_method=\\\"Power\\\")\\n powerSVDPCA.train(x=list(range(0, training_data.ncols)), training_frame=training_data)\\n\\n # compare singular values and stuff between power and GramSVD methods\\n print(\\\"@@@@@@ Comparing eigenvalues between GramSVD and Power...\\\\n\\\")\\n pyunit_utils.assert_H2OTwoDimTable_equal(gramSVDPCA._model_json[\\\"output\\\"][\\\"importance\\\"],\\n powerSVDPCA._model_json[\\\"output\\\"][\\\"importance\\\"],\\n [\\\"Standard deviation\\\", \\\"Cumulative Proportion\\\", \\\"Cumulative Proportion\\\"],\\n tolerance=1e-5, check_all=False)\\n print(\\\"@@@@@@ Comparing eigenvectors between GramSVD and Power...\\\\n\\\")\\n # compare singular vectors\\n pyunit_utils.assert_H2OTwoDimTable_equal(gramSVDPCA._model_json[\\\"output\\\"][\\\"eigenvectors\\\"],\\n powerSVDPCA._model_json[\\\"output\\\"][\\\"eigenvectors\\\"],\\n powerSVDPCA._model_json[\\\"output\\\"][\\\"names\\\"], tolerance=1e-1,\\n check_sign=True)\",\n \"def _find_cusps(self):\\n N = self.level()\\n s = []\\n\\n for d in arith.divisors(N):\\n w = arith.gcd(d, N//d)\\n if w == 1:\\n if d == 1:\\n s.append(Cusp(1,0))\\n elif d == N:\\n s.append(Cusp(0,1))\\n else:\\n s.append(Cusp(1,d))\\n else:\\n for a in range(1, w):\\n if arith.gcd(a, w) == 1:\\n while arith.gcd(a, d//w) != 1:\\n a += w\\n s.append(Cusp(a,d))\\n return sorted(s)\",\n \"def run_sampler(query, nc_lcs=1000, store_path='../data/lc_output/'):\\n\\n # Unpack & load cadences\\n sim_table = generator.simulation.load_table() #complete simulation table\\n sim_table_pointing = generator.fetch_cadence_info(sim_table, query['coordinates'][0], query['coordinates'][1], filter_band=query['sample_bands'])\\n\\n for i in tqdm(range(nc_lcs)):\\n sim_table_gen = generator.simple_mjd_sampler(sim_table_pointing, time_separation=query['survey_duration'], mode='random') # should have all the epochs of observation withiin that time frame\\n #phase = sim_table_gen['mjd'] - sim_table_gen['mjd'][0] # starting from the first detection\\n\\n return calc_lc_band(sim_table_gen)\\n #Select each filter?\\n\\n\\n\\n\\n # TODO: Clean\\n #model_M = np.zeros(shape=(5000,6))\\n #lim_5s = np.zeros(shape=(5000,6)) # no more than >1000 pointings per field (set to 5k to be safe); mark as nan the empty ones\\n #snr = np.zeros(shape=(5000,6))\\n #sigma_band = np.zeros(shape=(5000,6))\\n #for index, filter in tqdm(enumerate(lsst_bands)):\\n # model_M[0:len(phase[sim_table_gen['filter']==filter]), index] = models.photometricmodel(phase[sim_table_gen['filter']==filter]).fourier_cos(*query['model_theta'][index])\\n # model_M[:,index][model_M[:,index]==0] = np.inf # mask as infinity TODO -- numpy mask instead\",\n \"def get_unit_comp(nsys):\\n num_species = nsys.natm_per_species()\\n gcd = np.gcd.reduce(num_species)\\n unum_sp = [ n/gcd for n in num_species ]\\n return gcd,unum_sp\",\n \"def main():\\n\\tdb, cursor = connect()\\n\\t#chroms = ['1','22']\\n\\t#chroms = ['2','21']\\n\\t#chroms = ['3','20']\\n\\t#chroms = ['4','19']\\n\\t#chroms = ['5','18']\\n\\t#chroms = ['6','17']\\n\\t#chroms = ['7','16']\\n\\t#chroms = ['8','15']\\n\\t#chroms = ['9','14']\\n\\t#chroms = ['10','13']\\n\\tchroms = ['11','12']\\n\\t#chroms = [str(i) for i in range(10,23)]\\n\\t#chroms = ['X','Y']\\n\\tchroms.reverse()\\n\\tfor chrom in chroms:\\n\\t\\tt0 = time()\\n\\t\\ttable = \\\"gnomad_freqs_chr_\\\" + chrom\\n\\t\\tprint\\n\\t\\tprint \\\"*\\\"*20\\n\\t\\tprint table\\n\\t\\tprint \\\"number of variants:\\\", search_db(cursor, \\\"select count(1) from %s\\\" % table)[0][0]\\n\\t\\tqry = \\\"select count(1) from %s \\\" % table\\n\\t\\tqry += \\\"where char_length(reference)=1 and char_length(variant)=1\\\"\\n\\t\\tprint \\\"simple SNPs\\\", search_db(cursor, qry)[0][0]\\n\\n\\t\\tcandidates, long_vars_ct = find_complex_variants(cursor, table)\\n\\t\\tprint\\n\\t\\tprint \\\"Complex variants with reference<30:\\\", len(candidates),\\n\\t\\tprint \\\" long variants: \\\", long_vars_ct\\n\\n\\t\\tclusters = find_clusters_of_candidates(candidates)\\n\\t\\tprint\\n\\t\\tprint \\\"Done clustering. Max pos:\\\", max([cluster[0][0] for cluster in clusters])\\n\\t\\tprint \\\"Number of hotspot regions:\\\", len(clusters)\\n\\n\\n\\t\\tnumber_of_vars_in_clusters = 0\\n\\t\\tnumber_of_clusters_with_periodic_motifs = 0\\n\\t\\tfor cluster in clusters:\\n\\t\\t\\t# no varaints: cluster is just the number of positions here, not the number of\\n\\t\\t\\t# vars repoted for each\\n\\t\\t\\t[start,end, number_of_variants] = characterize_region(cluster)\\n\\t\\t\\tif number_of_variants<2: continue\\n\\t\\t\\tnumber_of_vars_in_clusters += number_of_variants\\n\\t\\t\\tfixed_fields = {'chrom':chrom, 'start':start, 'end':end}\\n\\t\\t\\tstore_without_checking(cursor, 'gnomad_hotspots', fixed_fields)\\n\\t\\tprint\\n\\t\\tprint \\\"Number of variants with clusters:\\\", number_of_vars_in_clusters\\n\\t\\tprint \\\"Number of clusters with periodic motifs:\\\", number_of_clusters_with_periodic_motifs\\n\\t\\tprint\\n\\t\\tprint \\\"time taken %.2f min\\\" % ((time() - t0) / 60.0)\\n\\t\\tprint\\n\\tcursor.close()\\n\\tdb.close()\\n\\n\\treturn\",\n \"def plot_bias(clf_list = ['test_small','rt_small','test2_small'],return_df = False,XKCD = False):\\n if XKCD = True:\\n plt.xkcd()\\n print('damn')\\n df = load_all_dfs(clf_list)\\n df = df.swaplevel(0,1)\\n del df['std']\\n df.hist()\\n plt.figure()\\n\\n for clf in clf_list:\\n df.ix[clf].mean().plot(label = clf,figsize=(16, 4))\\n plt.legend(loc='upper right')\\n plt.title('mean')\\n plt.figure()\\n \\n # c = df.columns\\n for clf in clf_list:\\n #df[c[1:]].ix[clf].max().plot(label = clf,figsize=(16, 4))\\n df.ix[clf].max().plot(label = clf,figsize=(16, 4))\\n plt.legend(loc='upper right')\\n plt.title('max')\\n \\n plt.figure()\\n for clf in clf_list:\\n df.ix[clf].std().plot(label = clf,figsize=(16, 4))\\n\\n \\n plt.legend(loc='upper right')\\n plt.title('std')\\n plt.figure()\\n used_list = []\\n for clf in clf_list:\\n for clf2 in clf_list:\\n if (clf != clf2) and ({clf,clf2} not in used_list):\\n diff = ((df.ix[clf] - df.ix[clf2])**2)**(1/2)\\n diff.mean().plot(label = clf+' - ' +clf2,figsize=(16, 4))\\n used_list.append({clf,clf2})\\n \\n \\n \\n \\n \\n plt.legend(loc='upper right')\\n plt.title('difference')\\n print('damnover')\\n if return_df == True:\\n return df\",\n \"def df_sample_names(self):\\n return self.abundance_mat_mult(True)\",\n \"def create_geneIDsDF():\\n datas=data.plfam_to_matrix()\\n datas.run()\\n print('***Dataframe created***')\",\n \"def getCodonSeqs(self):\\r\\n combinations = list(self.codonTable[aa] for aa in self.peptide) # creates a list of possible codons based on AA\\r\\n self.allPepSeqs = list(''.join(codon) for codon in itertools.product(*combinations)) # creates list of peptides\\r\\n return\",\n \"def plot_qc_reads(qc_df):\\n # Record NA values as 0\\n qc_df = qc_df.fillna(0)#.set_index(\\\"sample\\\")\\n cols = [\\\"sample\\\",\\n \\\"num_reads\\\",\\n \\\"num_mapped\\\",\\n \\\"num_unique_mapped\\\",\\n \\\"num_junctions\\\"]\\n qc_df = qc_df[cols]\\n melted_qc = pandas.melt(qc_df, id_vars=[\\\"sample\\\"])\\n qc_r = conversion_pydataframe(melted_qc)\\n labels = tuple([\\\"num_reads\\\",\\n \\\"num_mapped\\\",\\n \\\"num_unique_mapped\\\",\\n \\\"num_junctions\\\"])\\n labels = robj.StrVector(labels)\\n variable_i = qc_r.names.index('variable')\\n qc_r[variable_i] = robj.FactorVector(qc_r[variable_i],\\n levels = labels)\\n ggplot2.theme_set(ggplot2.theme_bw(12))\\n scales = importr(\\\"scales\\\")\\n r_opts = r.options(scipen=4)\\n p = ggplot2.ggplot(qc_r) + \\\\\\n ggplot2.geom_point(aes_string(x=\\\"sample\\\", y=\\\"value\\\")) + \\\\\\n ggplot2.scale_y_continuous(trans=scales.log10_trans(),\\n breaks=scales.trans_breaks(\\\"log10\\\",\\n robj.r('function(x) 10^x')),\\n labels=scales.trans_format(\\\"log10\\\",\\n robj.r('math_format(10^.x)'))) + \\\\\\n r.xlab(\\\"CLIP-Seq samples\\\") + \\\\\\n r.ylab(\\\"No. reads\\\") + \\\\\\n ggplot2.coord_flip() + \\\\\\n ggplot2.facet_wrap(Formula(\\\"~ variable\\\"), ncol=1) + \\\\\\n theme(**{\\\"panel.grid.major.x\\\": element_blank(),\\n \\\"panel.grid.minor.x\\\": element_blank(),\\n \\\"panel.grid.major.y\\\": theme_line(size=0.5,colour=\\\"grey66\\\",linetype=3)})\\n p.plot()\\n\\n return\\n r.par(mfrow=np.array([1,2]))\\n num_samples = len(qc_df.num_reads)\\n r.par(bty=\\\"n\\\", lwd=1.7, lty=2)\\n r_opts = r.options(scipen=4)\\n r.options(r_opts)\\n r.dotchart(convert_to_r_matrix(qc_df[[\\\"num_reads\\\",\\n \\\"num_mapped\\\",\\n \\\"num_unique_mapped\\\"]]),\\n xlab=\\\"No. reads\\\",\\n lcolor=\\\"black\\\",\\n pch=19,\\n gcolor=\\\"darkblue\\\",\\n cex=0.8)\\n r.par(bty=\\\"n\\\")\\n r.dotchart(convert_to_r_matrix(qc_df[[\\\"num_ribosub_mapped\\\",\\n \\\"num_ribo\\\",\\n \\\"num_junctions\\\"]]),\\n xlab=\\\"No. reads\\\",\\n lcolor=\\\"black\\\",\\n pch=19,\\n gcolor=\\\"darkblue\\\",\\n cex=0.8)\",\n \"def convertToSpectroGram(self):\",\n \"def uCSIsCypriotSyllabary(code):\\n ret = libxml2mod.xmlUCSIsCypriotSyllabary(code)\\n return ret\",\n \"def notebook_01():\\n\\n freq_list, volt_list = las.load_freq_volt()\\n\\n n_steps, n_det, n_f, _ = np.shape(volt_list)\\n\\n #y_sym_mat_o = ds.by_sym_mat(volt_list, det_ind=0)\\n #y_sym_mat_i = ds.by_sym_mat(volt_list, det_ind=1)\\n\\n # print(np.shape(y_sym_mat_o))\\n # print(np.shape(y_sym_mat_i))\\n # (mu_o, sigma_o) = stats.norm.fit(y_sym_mat_o[:,0])\\n # (mu_i, sigma_i) = stats.norm.fit(y_sym_mat_i[:,0])\\n # print(mu_o, sigma_o)\\n # print(mu_i, sigma_i)\\n # print(mu_o*89000, mu_i*89000.0, -mu_i*89000.0, -mu_o*89000.0)\\n\\n volt_list_sym = ds.volt_list_sym_calc(volt_list)\\n\\n fit_params_mat = fp.fit_params(ff.f_b_field, volt_list_sym)\\n\\n fit_params_mat_s = fp.fit_params(ff.f_b_field_off, volt_list_sym)\\n\\n # pbd.plot_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\\n\\n # pfp.plot_fit_sym_comp(volt_list_sym, fit_params_mat, fit_params_mat_s, freq_list)\\n\\n\\n # pfp.plot_fit_sym_comp_2(volt_list_sym, fit_params_mat_s, freq_list)\\n\\n #pfp.plot_symmetry_along_z(volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\\n\\n fp.fit_params_FH_data(ff.f_b_field)\\n\\n # pbd.plot_rel_diff_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\",\n \"def coded_output(database_df, output_loc='coded_output.xlsx'):\\n\\n LE = LabelEncoder()\\n output_df = pd.DataFrame()\\n labels_ser = pd.Series()\\n\\n # ID no coding\\n output_df[\\\"ID\\\"] = database_df[\\\"ID\\\"]\\n labels_ser[\\\"ID\\\"] = \\\"no coding\\\"\\n\\n # Age no coding\\n output_df[\\\"Age\\\"] = database_df['Age']\\n labels_ser[\\\"Age\\\"] = \\\"no coding\\\"\\n\\n # Sex coded\\n LE.fit(database_df['Sex'])\\n labels_ser['Sex'] = create_key_string(list(LE.classes_))\\n output_df['Sex'] = LE.transform(database_df['Sex'])\\n\\n # Race coded\\n LE.fit(database_df['Race'])\\n labels_ser['Race'] = create_key_string(list(LE.classes_))\\n output_df['Race'] = LE.transform(database_df['Race'])\\n\\n # Smoking coded\\n LE.fit(database_df['Smoking'])\\n labels_ser['Smoking'] = create_key_string(list(LE.classes_))\\n output_df['Smoking'] = LE.transform(database_df['Smoking'])\\n\\n # BMI no coding\\n output_df[\\\"BMI\\\"] = database_df[\\\"BMI\\\"]\\n labels_ser[\\\"BMI\\\"] = \\\"no coding\\\"\\n\\n # Comorbs broken into:\\n # - HTN T / F\\n output_df[\\\"has_htn\\\"] = database_df['Comorb'].apply(dz_is_in, args=(\\\"htn\\\",))\\n labels_ser[\\\"has_htn\\\"] = \\\"0 = no HTN, 1 = has HTN\\\"\\n\\n # - DM\\n output_df[\\\"has_dm\\\"] = database_df['Comorb'].apply(dz_is_in, args=(\\\"dm\\\",))\\n labels_ser[\\\"has_dm\\\"] = \\\"0 = no DM, 1 = has DM\\\"\\n\\n # - Psych\\n output_df[\\\"has_psych\\\"] = database_df['Comorb'].apply(dz_is_in, args=(\\\"psych\\\",))\\n labels_ser[\\\"has_psych\\\"] = \\\"0 = no psych, 1 = has psych\\\"\\n\\n # - Renal\\n output_df[\\\"has_ckd\\\"] = database_df['Comorb'].apply(dz_is_in, args=(\\\"ckd\\\",))\\n labels_ser[\\\"has_ckd\\\"] = \\\"0 = no CKD, 1 = has CKD\\\"\\n\\n # - Heart?\\n #output_df[\\\"has_cv\\\"] = database_df[\\\"Heart\\\"].apply(is_dz_free)\\n #labels_ser[\\\"has_cv\\\"] = \\\"0 = no CV disease, 1 = has some CV disease\\\"\\n\\n output_df[\\\"has_cv\\\"] = database_df['PostDx'].apply(dz_is_in, args=(\\\"Cardiac\\\",))\\n labels_ser[\\\"has_cv\\\"] = \\\"0 = no CV disease, 1 = has some CV disease\\\"\\n\\n # - CNS\\n #output_df[\\\"has_cns\\\"] = database_df[\\\"CNS\\\"].apply(is_dz_free)\\n #labels_ser[\\\"has_cns\\\"] = \\\"0 = no CNS disease, 1 = has some CNS disease\\\"\\n\\n output_df[\\\"has_cns\\\"] = database_df['PostDx'].apply(dz_is_in, args=(\\\"Neurologic\\\",))\\n labels_ser[\\\"has_cns\\\"] = \\\"0 = no CNS disease, 1 = has some CNS disease\\\"\\n\\n # - Opiate\\n output_df[\\\"has_opiate\\\"] = database_df['PostDx'].apply(dz_is_in, args=(\\\"Medication\\\",))\\n labels_ser[\\\"has_opiate\\\"] = \\\"0 = no opiate, 1 = on opiates\\\"\\n\\n # AHI no coding\\n output_df[\\\"AHI\\\"] = database_df[\\\"AHI\\\"]\\n labels_ser[\\\"AHI\\\"] = \\\"no coding\\\"\\n\\n # HFrEF y/n\\n output_df[\\\"has_hfref\\\"] = database_df[\\\"Heart\\\"].apply(dz_is_in, args=(\\\"hfref\\\",))\\n labels_ser[\\\"has_hfref\\\"] = \\\"0 = no hfref, 1 = has hfref\\\"\\n\\n #TODO: HfpEF y/n? Afib y/n?\\n\\n # HFpEF and AF\\n output_df[\\\"has_hfpef_and_af\\\"] = database_df[\\\"Heart\\\"].apply(dzs_are_in, args=(\\\"hfpef\\\", \\\"afib\\\",))\\n labels_ser[\\\"has_hfpef_and_af\\\"] = \\\"0 = no hfpef or no afib, 1 = has both hfpef and af\\\"\\n\\n # HFrEF and AF y/n\\n output_df[\\\"has_hfref_and_af\\\"] = database_df[\\\"Heart\\\"].apply(dzs_are_in, args=(\\\"hfref\\\", \\\"afib\\\",))\\n labels_ser[\\\"has_hfref_and_af\\\"] = \\\"0 = no hfref or no afib, 1 = has both hfref and af\\\"\\n\\n # Stroke y/n\\n output_df[\\\"has_cva\\\"] = database_df[\\\"CNS\\\"].apply(dz_is_in, args=(\\\"cva\\\",))\\n labels_ser[\\\"has_cva\\\"] = \\\"0 = no cva, 1 = has had a cva\\\"\\n\\n # Dementia or neurodegen\\n\\n # output_df[\\\"has_dementia\\\"] = database_df[\\\"CNS\\\"].apply(dz_is_in, args=(\\\"dementia\\\",))\\n # labels_ser[\\\"has_dementia\\\"] = \\\"0 = no dementia, 1 = has dementia\\\"\\n # output_df[\\\"has_neurodegen\\\"] = database_df[\\\"CNS\\\"].apply(dz_is_in, args=(\\\"neurodegenerative\\\",))\\n # labels_ser[\\\"has_neurodegen\\\"] = \\\"0 = no neurodegenerative disorder, 1 = has neurodegenerative disorder\\\"\\n\\n # then add those two together, then round 2 (= has both) back to 1 (= has any)\\n output_df[\\\"has_dem_or_neurodegen\\\"] = (database_df[\\\"CNS\\\"].apply(dz_is_in, args=(\\\"dementia\\\",)) + \\\\\\n database_df[\\\"CNS\\\"].apply(dz_is_in, args=(\\\"neurodegenerative\\\",))).replace(2, 1)\\n labels_ser[\\\"has_dem_or_neurodegen\\\"] = \\\"0 = no dementia or neurodegen, 1 = has dementia or neurodegen\\\"\\n\\n # Dementia and (stroke or neurodegen)\\n\\n output_df[\\\"has_neurodegen_and_cva\\\"] = database_df[\\\"CNS\\\"].apply(dzs_are_in, args=(\\\"neurodegenerative\\\", \\\"cva\\\",))\\n labels_ser[\\\"has_neurodegen_and_cva\\\"] = \\\"0 = no cva or no neurodegen, 1 = has both cva and neurodegen\\\"\\n output_df[\\\"has_dem_and_cva\\\"] = database_df[\\\"CNS\\\"].apply(dzs_are_in, args=(\\\"dementia\\\", \\\"cva\\\",))\\n labels_ser[\\\"has_dem_and_cva\\\"] = \\\"0 = no cva or no dementia, 1 = has both cva and dementia\\\"\\n\\n # then add those two together, then round 2 (= has both) back to 1 (= has any)\\n output_df[\\\"has_dem_and_cva_or_degen\\\"] = (database_df[\\\"CNS\\\"].apply(dzs_are_in, args=(\\\"neurodegenerative\\\", \\\"cva\\\",)) + \\\\\\n database_df[\\\"CNS\\\"].apply(dzs_are_in, args=(\\\"dementia\\\", \\\"cva\\\",))).replace(2,1)\\n labels_ser[\\\"has_dem_and_cva_or_degen\\\"] = \\\"1 = has (dem and cva) or (neurodegen and cva), 0 = doesn't have those combos\\\"\\n\\n # Final Treatment\\n\\n # #Similarly do the same for ASV (group 0) vs. CPAP and BPAP together.\\n database_df['FinalTx_coll'] = database_df.apply(collapse_final_treatment, axis=1)\\n\\n LE.fit(database_df['FinalTx_coll'])\\n class_for_swap = list(LE.classes_) # swapped the order of the labels to be more intuitive\\n class_for_swap[0], class_for_swap[1] = class_for_swap[1], class_for_swap[0]\\n labels_ser['FinalTx_coll'] = create_key_string(class_for_swap) # switch labels for PAP to be 0 (not 1) and ASV to be 1 (not 0)\\n\\n output_df['FinalTx_coll'] = LE.transform(database_df['FinalTx_coll'])\\n output_df['FinalTx_coll'] = output_df['FinalTx_coll'].apply(swap_value) #so that the labels are correct order\\n\\n # Collapse: percOSA/CSA as 0 and 1 (0 being >50% OSA –combine 0 and 1 groups and 1 being >50% CSA –combine the 3 and 4).\\n\\n database_df['PercOSA'] = database_df.apply(collapse_base_dx, axis=1)\\n\\n # Category of OSA\\n LE.fit(database_df['PercOSA'])\\n class_for_swap = list(LE.classes_) # swapped the order of the labels to be more intuitive\\n labels_ser['PercOSA'] = create_key_string(class_for_swap[1:] + [class_for_swap[0]]) # Perc(entage) OSA: more descriptive term for BaseDx\\n output_df['PercOSA'] = LE.transform(database_df['PercOSA'])\\n output_df['PercOSA'] = output_df['PercOSA'].apply(swap_value) #so that the labels are correct order\\n\\n # Dx Study\\n LE.fit(database_df['StudyType'])\\n labels_ser['StudyType'] = create_key_string(list(LE.classes_))\\n output_df['StudyType'] = LE.transform(database_df['StudyType'])\\n\\n output_df.to_excel(output_loc)\\n labels_ser.to_excel(\\\"keys_\\\"+output_loc)\\n return\",\n \"def parse_dataframes(genome_gtf, sralist):\\n\\n def gather_strand_by_geneID_dict(genome_gtf):\\n \\\"\\\"\\\"\\n Returns dictionary with strand orientation as values and geneIDs as Keys/\\n e.g.: {'YAL012W': '+',\\n 'YAL069W': '+',\\n 'YAL068W-A': '+',\\n \\\"\\\"\\\"\\n strand_by_geneID_dict = {}\\n with open(genome_gtf) as f: \\n for line in f: \\n current_line = line.split('\\\\t')\\n if current_line[2] == \\\"CDS\\\":\\n current_orf = current_line[8].split(';')[2].split()[1].strip('\\\\\\\"')\\n current_strand = current_line[6]\\n strand_by_geneID_dict[current_orf] = current_strand\\n return strand_by_geneID_dict\\n\\n\\n def import_scikit_data(sralist):\\n \\\"\\\"\\\"\\n Import results from scikit pipeline for all datasets contained in datsets_names.\\n \\\"\\\"\\\"\\n scikit_data_dict = {}\\n for dataset in sralist:\\n with open(TMP_DIR+'scikit_'+dataset+'/ALL_genes_profile_dict.json', 'r') as scikit_data:\\n scikit_data_dict[dataset] = [json.load(scikit_data)]\\n return scikit_data_dict\\n\\n\\n def build_mat_scikit_strandOriented(sralist, scikit_data):\\n \\\"\\\"\\\"\\n Building of scikit_df based on the output of plot_ribo_density_dict.py script.\\n\\n C/-/reverse/complementary strand are taken into account and the profile values\\n (\\\"codon_density_profile\\\", \\\"codon_triplet\\\", \\\"codon_AA\\\") are reversed. This is\\n performed by adding [::-1] to C strands profile ends.\\n\\n Same profile values are also have their extremities trimmed out of 8 codons.\\n (This is because the scikit-ribo pipeline considers 8 extra codons on each end,\\n but here we are only interested in the coding sequence). This is performed by\\n adding [8:-8] to profile lists ends.\\n \\\"\\\"\\\"\\n\\n scikit_mat = {}\\n seq_codons = {}\\n seq_aa = {}\\n\\n for geneID in scikit_data[sralist[0]][0].keys():\\n for ix, dataset in enumerate(sralist):\\n\\n if geneID in scikit_data[dataset][0].keys():\\n current_profile = scikit_data[dataset][0].get(geneID, np.nan)\\n current_ribo = current_profile[0]\\n current_ribo = current_ribo[8:-8]\\n N = len(sralist)\\n M = len(current_ribo)\\n print(geneID, M)\\n\\n if ix == 0:\\n current_matrix = np.zeros((N,M)) * np.nan\\n\\n current_seq_codons = current_profile[1]\\n current_seq_codons = current_seq_codons[8:-8]\\n\\n current_seq_aa = current_profile[2]\\n current_seq_aa = current_seq_aa[8:-8]\\n\\n if strand_by_geneID_dict.get(geneID, \\\"NA\\\") == \\\"+\\\":\\n seq_codons[geneID] = current_seq_codons\\n seq_aa[geneID] = current_seq_aa\\n\\n elif strand_by_geneID_dict.get(geneID, \\\"NA\\\") == \\\"-\\\":\\n seq_codons[geneID] = current_seq_codons[::-1]\\n seq_aa[geneID] = current_seq_aa[::-1]\\n \\n \\n if strand_by_geneID_dict.get(geneID, \\\"NA\\\") == \\\"+\\\":\\n current_matrix[ix,:] = current_ribo\\n\\n elif strand_by_geneID_dict.get(geneID, \\\"NA\\\") == \\\"-\\\":\\n current_matrix[ix,:] = current_ribo[::-1]\\n \\n if np.sum(current_matrix) > 0: \\n scikit_mat[geneID] = current_matrix\\n\\n# scikit_df = pd.DataFrame(values_list, columns=columns_list)\\n\\n return scikit_mat, seq_codons, seq_aa\\n\\n\\n def mean_norm(row):\\n codon_dens_prof = row.codon_density_profile\\n profile_average = np.average(codon_dens_prof)\\n\\n return [x/profile_average for x in codon_dens_prof]\\n \\n #scikit_data_df[\\\"mean_norm_codon_density_profile\\\"] = scikit_data_df.apply(mean_norm, axis=1)\\n #scikit_data_df[\\\"mean_norm_codon_density_profile\\\"] = scikit_data_df['mean_norm_codon_density_profile'].apply(lambda x: x[8:-8])\\n\\n strand_by_geneID_dict = gather_strand_by_geneID_dict(genome_gtf)\\n scikit_data_dict = import_scikit_data(sralist)\\n scikit_data_mat, seq_codons_dict, seq_aa_dict = build_mat_scikit_strandOriented(sralist, scikit_data_dict)\\n\\n with open('../data/processed/scikit_mat.pkl', 'wb') as f:\\n \\tpickle.dump(scikit_data_mat, f)\\n\\n with open('../data/processed/scikit_codonseq.pkl', 'wb') as f_seq:\\n pickle.dump(seq_codons_dict, f_seq)\\n \\n\\n return scikit_data_mat\",\n \"def ncusps(self):\\n n = self.level()\\n return sum([arith.euler_phi(arith.gcd(d,n//d)) for d in n.divisors()])\",\n \"def Ncen(self, m):\\n pass\",\n \"def snparamdf(self):\\n if self._snparamdf is None:\\n self.salt2params.paramSamples.set_index('snid', inplace=True)\\n self.catsimpos.galdf.set_index('snid', inplace=True)\\n self._snparamdf = self.salt2params.paramSamples.join(self.catsimpos.galdf)\\n return self._snparamdf\",\n \"def _qsd_l2_cx_count(self, n):\\n return 9 / 16 * 4**n - 3 / 2 * 2**n\",\n \"def ADM_SM_QCD(nf):\\n\\n adm_qqp_qqp = np.array([[0, 0, 0, 0, 0, 12, 0, 0],\\n [0, 0, 0, 0, 12, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 12],\\n [0, 0, 0, 0, 0, 0, 12, 0],\\n [0, 8/3, 0, 0, - 19/3, 5, 0, 0],\\n [8/3, 0, 0, 0, 5, - 9, 0, 0],\\n [0, 0, 0, 8/3, 0, 0, - 23/3, 5],\\n [0, 0, 8/3, 0, 0, 0, 5, - 23/3]])\\n\\n adm_qqp_qqpp = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 4/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 4/3, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0]])\\n\\n adm_qpq_qppq = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 4/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 4/3]])\\n\\n adm_qqp_qppq = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 4/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 4/3],\\n [0, 0, 0, 0, 0, 0, 0, 0]])\\n\\n adm_qpq_qqpp = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 4/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 4/3, 0]])\\n\\n adm_q_q = np.array([[4, 4, 0, - 28/3],\\n [0, 0, 0, 44/3],\\n [0, 0, 44/9, 0],\\n [5/3, 13/3, 0, - 106/9]])\\n\\n adm_qqp_q = np.array([[0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 4/3],\\n [0, 0, 0, 0],\\n [0, 0, 4/9, 0],\\n [0, 0, 0, 0]])\\n\\n\\n adm_qpq_q = np.array([[0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 4/3],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 4/9, 0]])\\n\\n adm_q_qqp = np.array([[0, 0, 0, 0, 8/3, 0, 0, 0],\\n [0, 0, 0, 0, 8/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 8/3, 0],\\n [0, 0, 0, 0, 20/9, 0, 0, 0]])\\n\\n adm_q_qpq = np.array([[0, 0, 0, 0, 8/3, 0, 0, 0],\\n [0, 0, 0, 0, 8/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 8/3],\\n [0, 0, 0, 0, 20/9, 0, 0, 0]])\\n\\n adm_ud = np.hstack((adm_qqp_qqp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qpq_qqpp, adm_qpq_qqpp,\\\\\\n adm_qpq_qqpp, np.zeros((8, 24)), adm_qqp_q, adm_qpq_q, np.zeros((8,12))))\\n\\n adm_us = np.hstack((adm_qqp_qqpp, adm_qqp_qqp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qpq_qppq, np.zeros((8,16)),\\\\\\n adm_qpq_qqpp, adm_qpq_qqpp, np.zeros((8, 8)), adm_qqp_q, np.zeros((8,4)), adm_qpq_q, np.zeros((8,8))))\\n\\n adm_uc = np.hstack((adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqp, adm_qqp_qqpp, np.zeros((8,8)), adm_qpq_qppq,\\\\\\n np.zeros((8,8)), adm_qpq_qppq, np.zeros((8, 8)), adm_qpq_qqpp, adm_qqp_q, np.zeros((8,8)), adm_qpq_q, np.zeros((8,4))))\\n\\n adm_ub = np.hstack((adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqp, np.zeros((8,16)), adm_qpq_qppq,\\\\\\n np.zeros((8,8)), adm_qpq_qppq, adm_qpq_qppq, adm_qqp_q, np.zeros((8,12)), adm_qpq_q))\\n\\n adm_ds = np.hstack((adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,16)), adm_qqp_qqp, adm_qqp_qqpp, adm_qqp_qqpp,\\\\\\n adm_qpq_qqpp, adm_qpq_qqpp, np.zeros((8,8)), np.zeros((8,4)), adm_qqp_q, adm_qpq_q, np.zeros((8,8))))\\n\\n adm_dc = np.hstack((adm_qqp_qppq, np.zeros((8,8)), adm_qpq_qppq, np.zeros((8,8)), adm_qqp_qqpp, adm_qqp_qqp, adm_qqp_qqpp,\\\\\\n adm_qpq_qppq, np.zeros((8,8)), adm_qpq_qqpp, np.zeros((8,4)), adm_qqp_q, np.zeros((8,4)), adm_qpq_q, np.zeros((8,4))))\\n\\n adm_db = np.hstack((adm_qqp_qppq, np.zeros((8,16)), adm_qpq_qppq, adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqp,\\\\\\n np.zeros((8,8)), adm_qpq_qppq, adm_qpq_qppq, np.zeros((8,4)), adm_qqp_q, np.zeros((8,8)), adm_qpq_q))\\n\\n adm_sc = np.hstack((np.zeros((8,8)), adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,8)), adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,8)),\\\\\\n adm_qqp_qqp, adm_qqp_qqpp, adm_qpq_qqpp, np.zeros((8,8)), adm_qqp_q, adm_qpq_q, np.zeros((8,4))))\\n\\n adm_sb = np.hstack((np.zeros((8,8)), adm_qqp_qppq, np.zeros((8,8)), adm_qpq_qppq, adm_qqp_qppq, np.zeros((8,8)), adm_qpq_qppq,\\\\\\n adm_qqp_qqpp, adm_qqp_qqp, adm_qpq_qppq, np.zeros((8,8)), adm_qqp_q, np.zeros((8,4)), adm_qpq_q))\\n\\n adm_cb = np.hstack((np.zeros((8,16)), adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,8)), adm_qqp_qppq, adm_qpq_qppq,\\\\\\n adm_qqp_qppq, adm_qpq_qppq, adm_qqp_qqp, np.zeros((8,12)), adm_qqp_q, adm_qpq_q))\\n\\n adm_u = np.hstack((adm_q_qqp, adm_q_qqp, adm_q_qqp, adm_q_qqp, np.zeros((4,48)), adm_q_q, np.zeros((4,16))))\\n\\n adm_d = np.hstack((adm_q_qpq, np.zeros((4,24)), adm_q_qqp, adm_q_qqp, adm_q_qqp, np.zeros((4,24)), np.zeros((4,4)), adm_q_q, np.zeros((4,12))))\\n\\n adm_s = np.hstack((np.zeros((4,8)), adm_q_qpq, np.zeros((4,16)), adm_q_qpq, np.zeros((4,16)), adm_q_qqp, adm_q_qqp, np.zeros((4,8)),\\\\\\n np.zeros((4,8)), adm_q_q, np.zeros((4,8))))\\n\\n adm_c = np.hstack((np.zeros((4,16)), adm_q_qpq, np.zeros((4,16)), adm_q_qpq, np.zeros((4,8)), adm_q_qpq, np.zeros((4,8)), adm_q_qqp,\\\\\\n np.zeros((4,12)), adm_q_q, np.zeros((4,4))))\\n\\n adm_b = np.hstack((np.zeros((4,24)), adm_q_qpq, np.zeros((4,16)), adm_q_qpq, np.zeros((4,8)), adm_q_qpq, adm_q_qpq, np.zeros((4,16)), adm_q_q))\\n\\n\\n adm = np.vstack((adm_ud, adm_us, adm_uc, adm_ub, adm_ds, adm_dc, adm_db, adm_sc, adm_sb, adm_cb, adm_u, adm_d, adm_s, adm_c, adm_b))\\n\\n if nf == 5:\\n return adm\\n elif nf == 4:\\n return np.delete(np.delete(adm, np.r_[np.s_[24:32], np.s_[48:56], np.s_[64:80], np.s_[96:100]], 0),\\\\\\n np.r_[np.s_[24:32], np.s_[48:56], np.s_[64:80], np.s_[96:100]], 1)\\n else:\\n raise Exception(\\\"nf has to be 4 or 5\\\")\",\n \"def csi(self):\\n return self.table[0, 0] / (self.table[0, 0] + self.table[0, 1] + self.table[1, 0])\",\n \"def get_codon_arr(chromosome: Chromosome) -> np.ndarray:\\n\\n seq_len = len(chromosome.sequence)\\n arr = np.zeros((seq_len - 2,), dtype=np.int)\\n\\n for f in chromosome.features:\\n\\n if f.type != 'CDS':\\n continue\\n if f.strand == '-':\\n continue\\n\\n protein_len = (f.end - f.start) // 3\\n for aa in range(protein_len):\\n pos = f.start + (aa * 3) - 1 # -1 to 0-based\\n arr[pos] = 1\\n\\n return arr\",\n \"def from_mypackage(mycosmo):\\n # Cosmology provides a nice method \\\"mapping\\\", so all that needs to\\n # be done here is create a dictionary of the parameters\\n mapping = {}\\n mapping[\\\"H0\\\"] = mycosmo.hubble_parameter\\n mapping[\\\"Om0\\\"] = mycosmo.Omega_matter_initial\\n ... # keep building mapping\\n\\n return Cosmology.from_format(\\n mapping, format=\\\"mapping\\\", move_to_meta=True\\n ) # extra info -> meta\",\n \"def constellaqc(denovo_groups, annotated_groups):\\n known_feat = np.unique(annotated_groups.loc[:, 'group'])\\n pred_group = np.unique(denovo_groups.loc[:, 'group'])\\n\\n scores = []\\n\\n for anno in known_feat:\\n # anno_bool_index = annotated_groups.loc[:, 'group'] == anno\\n anno_group_calls = denovo_groups.loc[annotated_groups.loc[:, 'group'] == anno, 'group'].values\\n # print(anno, 'count: ', np.sum(anno_bool_index))\\n score_row = []\\n for denovo in pred_group:\\n score_row.append(np.sum(anno_group_calls == denovo))\\n scores.append(score_row)\\n\\n scores = pd.DataFrame(scores, index=known_feat, columns=pred_group)\\n\\n if params.debug is not None:\\n print('Known Feature-Predicted Group Scoring Matrix:\\\\n')\\n print(scores)\\n\\n anno_sum = []\\n anno_no = []\\n anno_error = []\\n ni = []\\n\\n for anno in known_feat:\\n anno_sum.append(np.sum(scores.loc[anno, :].values))\\n anno_no.append(np.sum(scores.loc[anno, :].values != 0))\\n anno_error.append(np.sum(scores.loc[anno, :].values != 0) - 1)\\n ni.append(1)\\n pred_sum = []\\n pred_no = []\\n pred_error = []\\n nj = []\\n\\n for denovo in pred_group:\\n pred_sum.append(np.sum(scores.loc[:, denovo].values))\\n pred_no.append(np.sum(scores.loc[:, denovo].values != 0))\\n pred_error.append(np.sum(scores.loc[:, denovo].values != 0) - 1)\\n nj.append(1)\\n\\n anno_valid = np.array(anno_sum) - ni - np.array(anno_error)\\n # pred_valid = np.array(pred_sum) - nj - np.array(pred_error)\\n\\n v_sum = np.sum(anno_valid)\\n s_sum = np.sum(anno_error)\\n c_sum = np.sum(pred_error)\\n total = v_sum + s_sum + c_sum\\n\\n print('\\\\n\\\\nValid Call Rate: ', round(100 * (v_sum / total), 2), '%')\\n print('Splitting Call Rate: ', round(100 * (s_sum / total), 2), '%')\\n print('Clumping Call Rate: ', round(100 * (c_sum / total), 2), '%')\",\n \"def load_ChEMBL_kd():\\n affinity = pd.read_csv('./dataset/regression/ChEMBL/Chem_Kd_nM.txt', header=None)\\n target = pd.read_csv('./dataset/regression/ChEMBL/ChEMBL_Target_Sequence.txt', header=None)\\n drug = pd.read_csv('./dataset/regression/ChEMBL/Chem_SMILES_only.txt', header=None)\\n \\n SMILES=[]\\n Target=[]\\n y=[]\\n drugcnt=[]\\n \\n for i in range(len(target)):\\n Target.append(target[0][i])\\n y.append(affinity[0][i])\\n SMILES.append(drug[0][i])\\n\\n aff=[]\\n total=[]\\n for i in range(len(target)):\\n aff.insert(i, y[i].split(\\\" \\\"))\\n for i in aff:\\n total += i\\n for i in range(len(SMILES)):\\n drugcnt.insert(i, len(SMILES[i].split()))\\n\\n smile = []\\n for segments in SMILES:\\n for x in segments.split():\\n smile.extend(x)\\n #smile = [x for segments in SMILES for x in segments.split()]\\n smiles_res=[]\\n y_tmp=[]\\n target_res=[]\\n tmp=[]\\n\\n for i in range(len(drugcnt)):\\n tmp.extend(repeat(Target[i], drugcnt[i]))\\n for i in range(len(total)):\\n if total[i] != '-1':\\n y_tmp.append(total[i])\\n smiles_res.append(smile[i])\\n target_res.append(tmp[i])\\n\\n y_res = [float(i) for i in y_tmp]\\n y_res = convert_y_unit(np.array(y_res), 'nM', 'p')\\n return np.array(smiles_res), np.array(target_res), np.array(y_res)\",\n \"def set_lookup_qn(diagram, p_cm, p_max, gammas, skip=True, verbose=0):\\n\\n lookup_p = set_lookup_p(p_max, p_cm, diagram, skip)\\n lookup_g = set_lookup_g(gammas, diagram)\\n\\n # TODO: A more elegant solution for combining lookup_p and lookup_g is welcome\\n # maybe Multiindex.from_product()\\n tmp = it.product(lookup_p, lookup_g)\\n lookup_qn = []\\n for t in tmp:\\n lookup_qn.append(t[0]+t[1])\\n lookup_qn = DataFrame(lookup_qn, columns=['p_{so}', 'p_{si}', '\\\\gamma_{so}', '\\\\gamma_{si}'])\\n# lookup_qn['p_{so}'] = qn['p_{so}'].apply(np.array)\\n# lookup_qn['p_{si}'] = qn['p_{si}'].apply(np.array)\\n \\n return lookup_qn\",\n \"def get_mod_freq_clf_train_test(df, cols, chr_pos, strains, train_samples, \\n clf=KNeighborsClassifier(), method=\\\"KNN\\\"):\\n results = []\\n for cp in chr_pos:\\n # train classifier using train sampels: unmod and mod\\n _df = df.loc[(df[\\\"chr_pos\\\"]==cp)&(df.Strain.isin(train_samples)), cols+[\\\"Strain\\\"]]\\n X_train = min_max_norm(_df[cols].to_numpy().astype(\\\"float\\\"))\\n y_train = _df.Strain==train_samples[-1]\\n clf.fit(X_train, y_train)\\n # min-max normalisation\\n _df = df.loc[(df[\\\"chr_pos\\\"]==cp)&(df.Strain.isin(strains)), cols+[\\\"Strain\\\"]]\\n _X = min_max_norm(_df[cols].to_numpy().astype(\\\"float\\\"))\\n # get fit and clusters\\n clusters = clf.predict(_X) # this will return 0 (unmodified) and 1 (modified)\\n # get modification freuqency - simply number of 1s over all for each sample\\n freqs = [clusters[_df[\\\"Strain\\\"]==s].mean() for s in strains]\\n results.append((cp, method, *freqs, \\\", \\\".join(map(str, strains[1:]))))\\n return results\",\n \"def base_composition(reads, base):\\n assert base.upper() in set(\\\"ACGT\\\")\\n\\n \\\"\\\"\\\" Reports nucelotide frequencies at each position in the\\n sam sequences\\n \\\"\\\"\\\"\\n # DNA_Alphabet=[\\\"A\\\",\\\"C\\\",\\\"T\\\",\\\"G\\\",\\\"N\\\"]\\n all_nucs = []\\n for read in reads:\\n nucs = {} # Dictionary to store nucleotide data.\\n seq = read[9]\\n for i in range(0, len(seq)):\\n nucs[str(i + 1)] = seq[i]\\n all_nucs.append(nucs)\\n all_items = []\\n counts = []\\n for dicts in all_nucs:\\n for item in dicts.items():\\n all_items.append(item)\\n all_items.sort(key=operator.itemgetter(0))\\n groups = [map(operator.itemgetter(1), list(group))\\n for key, group in itertools.groupby(\\n all_items, operator.itemgetter(0))]\\n for group in groups:\\n counts.append(group.count(base))\\n\\n pos = range(1, len(seq) + 1)\\n\\n # Create plot.\\n plt.figure(1, figsize=(8, 8))\\n plt.axes([0.1, 0.1, 0.8, 0.8])\\n plt.bar(pos, counts, facecolor='g')\\n plt.xlabel(\\\"Position\\\")\\n plt.ylabel(\\\"number of mapped reads\\\")\\n plt.title(base)\\n plt.show()\",\n \"def seq_gc(seq, mapped_only=True):\\n if not isinstance(seq, str):\\n raise ValueError(\\\"reformat input sequence as a str\\\")\\n g = seq.count(\\\"G\\\")\\n g += seq.count(\\\"g\\\")\\n c = seq.count(\\\"C\\\")\\n c += seq.count(\\\"c\\\")\\n nbases = len(seq)\\n if mapped_only:\\n n = seq.count(\\\"N\\\")\\n n += seq.count(\\\"n\\\")\\n nbases -= n\\n return (g + c) / nbases if nbases > 0 else np.nan\",\n \"def raw_features_extractor(database='./red_cod.db.pkl', sites=-1, elements = -1, maxatoms= -1,\\r\\n dictionary='diccionario', features='datosrahm.csv'):\\r\\n \\r\\n df=create_collection(database=database,sites=sites, elements=elements, maxatoms=maxatoms, \\r\\n dictionary=dictionary)\\r\\n \\r\\n start=time.time()\\r\\n \\r\\n datos=pd.read_csv(features)\\r\\n datos=datos.fillna(-1)\\r\\n\\r\\n dicc=dict(datos[['Symbol','Z']].values)\\r\\n\\r\\n dicc['D']=1\\r\\n dicc['Bk']=97\\r\\n dicc['Cf']=98\\r\\n dicc['Es']=99\\r\\n dicc['Fm']=100\\r\\n dicc['Md']=101\\r\\n dicc['No']=102\\r\\n dicc['Lr']=103\\r\\n \\r\\n max_sitios = max(df['sitios'].values)\\r\\n\\r\\n df=df[df['sitios'] <= max_sitios].reset_index(drop=True)\\r\\n \\r\\n X=np.zeros((len(df),max_sitios,104))\\r\\n y=np.zeros((len(df),1))\\r\\n mult=np.zeros((len(df),max_sitios))\\r\\n wyckmul=np.load('support/WyckoffSG_dict.npy').item()['wyckmul']\\r\\n \\r\\n for row in range(len(df)):\\r\\n \\r\\n item=df['WyckOcc'][row]\\r\\n sitios=list(item.values()) \\r\\n sitocc=np.zeros((len(sitios),104))\\r\\n spacegroup = str(df['sgnum'][row]).zfill(3)\\r\\n \\r\\n try:\\r\\n \\r\\n s=[int(wyckmul[spacegroup][i]) for j in [list(item.keys()) for item in \\\\\\r\\n sitios] for i in j]\\r\\n \\r\\n except:\\r\\n print('There exists an error concerning with the space group of CIF ', df['cif'][row],'\\\\n')\\r\\n print('Please check in www.crystallography.net to provide the correct space group number of that CIF',\\r\\n '\\\\n','\\\\n')\\r\\n spacegroup=input('Give me the correct spacegroup:'+'\\\\n'+'\\\\n')\\r\\n s=[int(wyckmul[spacegroup][i]) for j in [list(item.keys()) for item in \\\\\\r\\n list(df['WyckOcc'][row].values())] for i in j]\\r\\n \\r\\n occs=[]\\r\\n for i in range(len(sitios)):\\r\\n\\r\\n for j in list(sitios[i].values()):\\r\\n \\r\\n ocupacion=np.array(list(j.values()))\\r\\n llaves=[llave.replace('+','').replace('-','').replace('1',\\r\\n '').replace('2','').replace('3','').replace('4',\\r\\n '') for llave in np.array(list(j.keys()))]\\r\\n llaves=[llave.replace('.','') for llave in llaves]\\r\\n llaves=[llave.replace('5','').replace('6','').replace('7',\\r\\n '').replace('8','').replace('9','').replace('0',\\r\\n '') for llave in llaves]\\r\\n vector=np.zeros((1,104))\\r\\n occs=[sum(ocupacion)]+occs\\r\\n \\r\\n try:\\r\\n \\r\\n idx=[dicc[k] for k in llaves]\\r\\n \\r\\n except:\\r\\n \\r\\n print(' ELEMENTO NO IDENTIFICADO EN LA LISTA ',llaves,'\\\\n',\\r\\n 'REVISA EL SIGUIENTE CIF PARA HACER LA CORRECCION:','\\\\t',df['cif'][row])\\r\\n \\r\\n former = input('Elemento Incorrecto: ')\\r\\n current = input('Elemento Correcto: ')\\r\\n \\r\\n llaves=[current if x == former else x for x in llaves]\\r\\n idx=[dicc[k] for k in llaves]\\r\\n \\r\\n \\r\\n for k in idx:\\r\\n vector[0][k-1] = ocupacion[idx.index(k)]\\r\\n \\r\\n \\r\\n sitocc[i]=vector\\r\\n \\r\\n while sitocc.shape[0] != max_sitios:\\r\\n sitocc=np.concatenate((np.zeros((1,104)),sitocc))\\r\\n s=[0]+s\\r\\n \\r\\n X[row,:,:]=sitocc\\r\\n y[row]=df['target'][row]\\r\\n mult[row]=s\\r\\n \\r\\n S = np.expand_dims(mult,axis=2)\\r\\n features=datos.iloc[:,2:].values\\r\\n x=X[:,:,:96]\\r\\n \\r\\n fracsum = np.expand_dims(np.sum(x,axis=2), axis=2)\\r\\n \\r\\n x=np.dot(x,features) \\r\\n\\r\\n print('Atomic radii and electronegativities for each Wyckoff site extracted in',\\r\\n round(time.time()-start,2),' s') \\r\\n \\r\\n np.save('raw_features', x)\\r\\n np.save('output_values', y)\\r\\n np.save('multiplicities', S)\\r\\n np.save('occupation_fractions', fracsum)\\r\\n \\r\\n return x, y, S, fracsum, df\",\n \"def galactic_to_MS():\\n return MS_MATRIX\",\n \"def get_transcript_sgrnas(target_region_seq_df, context_len, pam_start, pam_len,\\n sgrna_start, sgrna_len, pams, sg_positions):\\n sgrna_df_list = []\\n meta_columns = ['object_type', 'strand', 'transcript_id', 'seq_region_name', 'region_id', 'start', 'end']\\n for i, row in target_region_seq_df.iterrows():\\n seq_start = row['expanded_start']\\n seq_end = row['expanded_end']\\n sequence = row['seq']\\n # Sequences on the positive strand\\n pos_sgrna_df = tile.build_sgrna_df(sequence, context_len=context_len, pam_start=pam_start,\\n pam_len=pam_len, sgrna_start=sgrna_start,\\n sgrna_len=sgrna_len, pams=pams)\\n pos_sgrna_df = get_sgrna_global_indices(pos_sgrna_df, seq_start, seq_end, 1, sg_positions)\\n # assuming the target_region_seq_df is oriented on the positive sgRNA strand\\n pos_sgrna_df['sgrna_strand'] = 1\\n # Sequences on the negative strand\\n rev_comp_seq = reverse_compliment(sequence)\\n neg_sgrna_df = tile.build_sgrna_df(rev_comp_seq, context_len=context_len, pam_start=pam_start,\\n pam_len=pam_len, sgrna_start=sgrna_start,\\n sgrna_len=sgrna_len, pams=pams)\\n neg_sgrna_df = get_sgrna_global_indices(neg_sgrna_df, seq_start, seq_end, -1, sg_positions)\\n neg_sgrna_df['sgrna_strand'] = -1\\n # Combine and filter sgrna_dfs\\n sgrna_df = pd.concat([pos_sgrna_df, neg_sgrna_df])\\n for col in meta_columns:\\n sgrna_df[col] = row[col]\\n sgrna_df_list.append(sgrna_df)\\n concatenated_sgrna_dfs = (pd.concat(sgrna_df_list)\\n .rename({'strand': 'transcript_strand',\\n 'start': 'region_start',\\n 'end': 'region_end',\\n 'seq_region_name': 'chromosome'}, axis=1))\\n return concatenated_sgrna_dfs\",\n \"def Jsc_integrated(self):\\n fname = 'scalar_reduce_genRate.npy'\\n base = self.sims[0].conf['General']['results_dir']\\n self.log.info('Computing integrated Jsc for group at %s', base)\\n path = os.path.join(base, fname)\\n try:\\n genRate = np.load(path)\\n except FileNotFoundError:\\n self.scalar_reduce('genRate')\\n genRate = np.load(path)\\n # Gen rate in cm^-3. Gotta convert lengths here from um to cm\\n z_vals = self.sims[0].Z\\n x_vals = self.sims[0].X\\n y_vals = self.sims[0].Y\\n z_integral = intg.trapz(genRate, x=z_vals, axis=0)\\n x_integral = intg.trapz(z_integral, x=x_vals, axis=0)\\n y_integral = intg.trapz(x_integral, x=y_vals, axis=0)\\n # z_integral = intg.simps(genRate, x=z_vals, axis=0)\\n # x_integral = intg.simps(z_integral, x=x_vals, axis=0)\\n # y_integral = intg.simps(x_integral, x=y_vals, axis=0)\\n # Convert period to cm and current to mA\\n Jsc = 1000*(consts.e/(self.sims[0].period*1e-4)**2)*y_integral\\n outf = os.path.join(base, 'jsc_integrated.dat')\\n with open(outf, 'w') as out:\\n out.write('%f\\\\n' % Jsc)\\n self.log.info('Jsc_integrated = %f', Jsc)\\n return Jsc\",\n \"def ceQTL(counts, dos, cov_mat, rsid):\\n acov_mat = cov_mat.copy(deep=True)\\n acov_mat['soi'] = dos.ix[rsid, acov_mat.index]\\n res = sm.OLS(counts, acov_mat).fit()\\n return(res)\",\n \"def get_predictions_coverage(self):\\n\\n latest_tag_frequency_file = self.get_latest_output_file_name(configurations.TAG_FREQUENCY_STREAMS, next=False)[1]\\n latest_tag_frequency_file_location = os.path.join(configurations.OUTPUT_FILES_DIRECTORY, latest_tag_frequency_file)\\n tag_frequency_file_df = pd.read_csv(latest_tag_frequency_file_location, header=0, index_col=0)\\n all_streams = tag_frequency_file_df.index.values\\n\\n\\n output_file_name = self.get_latest_output_file_name(configurations.SIMILAR_STREAMS_GENRATED_FILE_NAME, next=False)[1]\\n output_file_location = os.path.join(configurations.OUTPUT_FILES_DIRECTORY, output_file_name)\\n output_df = pd.read_csv(output_file_location, header=0, index_col=0)\\n all_streams_set = set(all_streams)\\n\\n recommended_stream_counter = Counter()\\n for idx, row in output_df.iterrows():\\n for val in row:\\n if not math.isnan(val):\\n val_int = int(val)\\n recommended_stream_counter[val_int] += 1\\n\\n recommended_streams_set = set(recommended_stream_counter.keys())\\n\\n print(\\\"Most common {0} recommendations...\\\".format(str(configurations.NUM_MOST_COMMON_STREAMS)))\\n print(recommended_stream_counter.most_common(configurations.NUM_MOST_COMMON_STREAMS))\\n coverage = len(recommended_streams_set)/len(all_streams_set)\\n print(\\\"Coverage = {0}\\\".format(str(coverage)))\\n\\n non_recommended_streams = all_streams_set - recommended_streams_set\\n if non_recommended_streams:\\n print(\\\"These streams were not recommended at all: \\\")\\n print(non_recommended_streams)\\n else:\\n print(\\\"All streams were recommended at least once\\\")\",\n \"def run_phaseg(locus_file, gam_file, vg_file, canu_alignments, true_haps):\\n\\trecombrate=1.26\\n\\tmax_coverage = 15\\n\\tall_heterozygous = False\\n\\tdistrust_genotypes = True\\n\\twith ExitStack() as stack:\\n\\t\\tnode_seq_list, edge_connections = vg_graph_reader(vg_file)\\n\\t\\tall_reads, alleles_per_pos, locus_branch_mapping = vg_reader(locus_file, gam_file, canu_alignments)\\n\\t\\tall_positions = sorted(all_reads.get_positions())\\n\\t\\tall_components = find_components(all_positions, all_reads)\\n\\t\\tblocks = defaultdict(list)\\n\\t\\tprint(\\\"all_components\\\")\\n\\t\\tfor position, block_id in all_components.items():\\n\\t\\t\\tblocks[block_id].append(locus_branch_mapping[position][0][0][0])\\n\\t\\tfor k,v in blocks.items():\\n\\t\\t\\tprint(k,v)\\n\\t\\tprint(\\\"all_components\\\")\\n\\t\\t\\n\\n\\t\\t#print(all_reads)\\n\\t\\tselected_indices = readselection(all_reads, max_coverage)\\n\\t\\tselected_reads = all_reads.subset(selected_indices)\\n\\n\\t\\t#selected_reads = slice_reads(all_reads, max_coverage)\\n\\t\\t#print('positions from all reads')\\n\\t\\t#print(len(all_reads.get_positions()))\\n\\t\\tprint(\\\"reads after read-selection\\\")\\n\\t\\tprint(len(selected_reads))\\n\\t\\tprint(\\\"positions covered by atleast one read after read selection\\\")\\n\\t\\tprint(len(selected_reads.get_positions()))\\n\\n\\t\\taccessible_positions = sorted(selected_reads.get_positions())\\n\\t\\t\\n\\t\\tprint(\\\"readset after read_selection\\\")\\n\\t\\t#for read in selected_reads:\\n\\t\\t\\t#print(read.name)\\n\\t\\tpedigree = Pedigree(NumericSampleIds())\\n\\t\\t# compute the number of alleles at each position.\\n\\t\\talleles_per_accessible_pos =[]\\n\\t\\tgenotype_likelihoods = []\\n\\t\\tfor pos in accessible_positions:\\n\\t\\t\\tif pos in alleles_per_pos:\\n\\t\\t\\t\\tn_alleles = alleles_per_pos[pos] \\n\\t\\t\\t\\tpossible_genotypes = n_alleles + ncr(n_alleles, 2)\\n\\t\\t\\t\\tgenotype_likelihoods.append(None if all_heterozygous else PhredGenotypeLikelihoods([0]* possible_genotypes))\\n\\t\\t# random input of genotypes, since distrust_genotypes is always ON.\\n\\t\\tpedigree.add_individual('individual0', [0]* len(accessible_positions), genotype_likelihoods)\\n\\t\\trecombination_costs = uniform_recombination_map(recombrate, accessible_positions)\\n\\t\\t# Finally, run phasing algorithm\\n\\t\\t#print(selected_reads)\\n\\t\\tdp_table = PedigreeDPTable(selected_reads, recombination_costs, pedigree, distrust_genotypes, accessible_positions)\\n\\t\\tsuperreads_list, transmission_vector = dp_table.get_super_reads()\\n\\n\\t\\tcost = dp_table.get_optimal_cost()\\n\\t\\tprint(superreads_list[0])\\n\\t\\t#print(cost)\\n\\t\\tread_partitions = dp_table.get_optimal_partitioning()\\n\\t\\t#print(read_partitions)\\n\\t\\t\\n\\t\\t## To generate the connected components and corresponding haplotypes.\\n\\t\\tprint(\\\"in components\\\")\\n\\t\\tf = open('whole_genome' + '.predicted_read_partionting.pred', 'w')\\n\\t\\toverall_components = find_components(accessible_positions, selected_reads)\\n\\t\\t\\n\\t\\tread_partitions_dict ={}\\n\\t\\tfor read, haplotype in zip(selected_reads, read_partitions):\\n\\t\\t\\tphaseset = overall_components[read[0].position] + 1\\n\\t\\t\\tprint(read.name, phaseset, haplotype, file=f)\\n\\t\\t\\tread_partitions_dict[read.name] = haplotype\\n\\t\\t#phaset is blockid\\n\\n\\t\\tn_phased_blocks = len(set(overall_components.values()))\\n\\t\\tall_phased_blocks = len(set(all_components.values()))\\n\\t\\tprint('No. of phased blocks: %d', n_phased_blocks)\\n\\t\\tlargest_component = find_largest_component(overall_components)\\n\\t\\tprint('No. of blocks from all the reads: %d', all_phased_blocks)\\n\\t\\tlargest_component_all_reads = find_largest_component(all_components)\\n\\t\\tif len(largest_component) > 0:\\n\\t\\t\\tprint('Largest component contains %d variants',len(largest_component))\\n\\t\\tif len(largest_component_all_reads) > 0:\\n\\t\\t\\tprint('Largest component contains %d variants',len(largest_component_all_reads))\\n\\t\\t\\n\\t\\t\\n\\t\\t### To generate contig sequences\\n\\t\\tsample = 0\\n\\t\\tsuperreads, components = dict(), dict()\\n\\t\\tsuperreads[sample] = superreads_list[0]\\n\\t\\tcomponents[sample] = overall_components\\n\\t\\t#generate_hap_contigs_based_on_canu(superreads_list[0], components[sample], node_seq_list, locus_branch_mapping, edge_connections, canu_alignments, vg_file)\\n\\t\\t#generate_hap_contigs(superreads_list[0], overall_components, node_seq_list, locus_branch_mapping, edge_connections)\\n\\t\\t\\n\\t\\tnodes_in_bubbles =[]\\n\\t\\twith stream.open(str(locus_file), \\\"rb\\\") as istream:\\n\\t\\t\\tfor data in istream:\\n\\t\\t\\t\\tl = vg_pb2.SnarlTraversal()\\n\\t\\t\\t\\tl.ParseFromString(data)\\n\\t\\t\\t\\tfor i in range(0,len(l.visits)):\\n\\t\\t\\t\\t\\tnodes_in_bubbles.append(l.visits[i].node_id)\\n\\t\\t\\t\\t#nodes_in_bubbles.append(l.snarl.end.node_id)\\n\\t\\t\\t\\t#nodes_in_bubbles.append(l.snarl.start.node_id)\\n\\t\\tedge_connections_tmp = defaultdict(list)\\n\\t\\twith stream.open(str(vg_file), \\\"rb\\\") as istream:\\n\\t\\t\\tfor data in istream:\\n\\t\\t\\t\\tl = vg_pb2.Graph()\\n\\t\\t\\t\\tl.ParseFromString(data)\\n\\t\\t\\t\\tfor j in range(len(l.edge)):\\n\\t\\t\\t\\t\\tfrom_edge = getattr(l.edge[j], \\\"from\\\")\\n\\t\\t\\t\\t\\t#if from_edge not in nodes_in_bubbles and l.edge[j].to not in nodes_in_bubbles:\\n\\t\\t\\t\\t\\tedge_connections_tmp[str(from_edge)].append(str(l.edge[j].to))\\n\\t\\t\\t\\t\\tedge_connections_tmp[str(l.edge[j].to)].append(str(from_edge))\\n\\n\\n\\t\\t#generate_hap_contigs_based_on_canu(superreads, components, node_seq_list, locus_branch_mapping, edge_connections, canu_alignments, vg_file)\\n\\t\\t#generate_hap_contigs_avgRL(superreads, components, node_seq_list, locus_branch_mapping, edge_connections, edge_connections_tmp, gam_file, read_partitions_dict, nodes_in_bubbles)\\n\\t\\t\\n\\t\\t# evaluation partition all the reads based on one iteration\\n\\t\\t#print('partition all the reads based on haplotypes from one iteration')\\n\\t\\t# Check here if you wanna do all reads or selected reads only\\n\\t\\t#haplotag(superreads_list[0], selected_reads, overall_components, 1)\\n\\t\\t\\n\\t\\t#compute_read_partitioning_accuracy(\\\"true_partioning\\\")\\n\\n\\n\\n\\t\\t##generate_hap_contigs(superreads, components, node_seq_list, locus_branch_mapping, edge_connections)\\n\\t\\t\\n\\t\\t##For phasing accuracy, read true haps and generate corresponding superreads\\n\\t\\t#all_reads_true, alleles_per_pos_true, locus_branch_mapping_true = vg_reader(locus_file, true_haps)\\n\\t\\t# Finally, run phasing algorithm for true haplotypes\\n\\t\\t#dp_table_true = PedigreeDPTable(all_reads_true, recombination_costs, pedigree, distrust_genotypes, accessible_positions)\\n\\t\\t#superreads_list_true, transmission_vector_true = dp_table_true.get_super_reads()\\n\\t\\t# to compute the phasing accuracy\\n\\t\\t#true_haps = ReadSet()\\n\\t\\t#for read in all_reads_true:\\n\\t\\t\\t#tmp_read = Read(read.name, 0, 0, 0)\\n\\t\\t\\t#for variant in read:\\n\\t\\t\\t\\t#if variant.position in accessible_positions:\\n\\t\\t\\t\\t\\t#tmp_read.add_variant(variant.position, variant.allele, [10])\\n\\t\\t\\t#true_haps.add(tmp_read)\\n\\t\\t#compare(superreads_list[0], true_haps, overall_components)\\n\\t\\t## To perform iterative whatshap phasing\\n\\t\\t#remaining_reads =[]\\n\\t\\t#for read in all_reads:\\n\\t\\t\\t#remaining_reads.append(read.name)\\n\\t\\t#prev_superreads = superreads_list[0]\\n\\t\\t#for read in selected_reads:\\n\\t\\t\\t#remaining_reads.remove(read.name)\\n\\t\\t#while len(remaining_reads)>0:\\n\\t\\t\\t#print('iteration')\\n\\t\\t\\t#iterative_reaset = ReadSet()\\n\\t\\t\\t#for read in all_reads:\\n\\t\\t\\t\\t#if read.name in remaining_reads:\\n\\t\\t\\t\\t\\t#iterative_reaset.add(read)\\n\\n\\t\\t\\t\\t\\n\\t\\t\\t#selected_indices = readselection(iterative_reaset, max_coverage)\\n\\t\\t\\t#selected_reads = iterative_reaset.subset(selected_indices)\\n\\t\\t\\t#for read in prev_superreads:\\n\\t\\t\\t\\t#selected_reads.add(read)\\n\\t\\t\\t\\t#remaining_reads.append(read.name)\\n\\t\\t\\t#accessible_positions = sorted(selected_reads.get_positions())\\n\\t\\t\\t#selected_reads.sort()\\n\\t\\t\\t#pedigree = Pedigree(NumericSampleIds())\\n\\t\\t\\t## compute the number of alleles at each position.\\n\\t\\t\\t#alleles_per_accessible_pos =[]\\n\\t\\t\\t#genotype_likelihoods = []\\n\\t\\t\\t#for pos in accessible_positions:\\n\\t\\t\\t\\t#if pos in alleles_per_pos:\\n\\t\\t\\t\\t\\t#n_alleles = alleles_per_pos[pos] \\n\\t\\t\\t\\t\\t#possible_genotypes = n_alleles + ncr(n_alleles, 2)\\n\\t\\t\\t\\t\\t#genotype_likelihoods.append(None if all_heterozygous else PhredGenotypeLikelihoods([0]* possible_genotypes))\\n\\t\\t\\t## random input of genotypes, since distrust_genotypes is always ON.\\n\\t\\t\\t#pedigree.add_individual('individual0', [0]* len(accessible_positions), genotype_likelihoods)\\n\\t\\t\\t#recombination_costs = uniform_recombination_map(recombrate, accessible_positions)\\n\\t\\t\\t## Finally, run phasing algorithm\\n\\t\\t\\t##print(selected_reads)\\n\\t\\t\\t#dp_table = PedigreeDPTable(selected_reads, recombination_costs, pedigree, distrust_genotypes, accessible_positions)\\n\\t\\t\\t#superreads_list, transmission_vector = dp_table.get_super_reads()\\n\\t\\t\\t#for read in selected_reads:\\n\\t\\t\\t\\t#remaining_reads.remove(read.name)\\n\\t\\t\\t#prev_superreads = superreads_list[0]\\n\\t\\t\\t\\n\\t\\t#print('I am final')\\n\\t\\t#accessible_positions = sorted(all_reads.get_positions())\\n\\t\\t#overall_components = find_components(accessible_positions, all_reads)\\n\\t\\t#haplotag(superreads_list[0], all_reads, overall_components, \\\"all_iter\\\")\\n\\t\\t#compare(superreads_list[0], superreads_list_true[0], overall_components)\\n\\t\\t#print(superreads_list[0])\\n\\t\\t\\n\\t\\t#iterative whatshap for sparse matrices where we fix the phasing for variants at each iteration that reach max coverage.\",\n \"def load_ChEMBL_pkd():\\n affinity = pd.read_csv('./dataset/regression/ChEMBL/Chem_Affinity.txt', header=None)\\n affinity = affinity.fillna(-1)\\n target = pd.read_csv('./dataset/regression/ChEMBL/ChEMBL_Target_Sequence.txt', header=None)\\n drug = pd.read_csv('./dataset/regression/ChEMBL/Chem_SMILES_only.txt', header=None)\\n \\n SMILES=[]\\n Target=[]\\n y=[]\\n drugcnt=[]\\n \\n for i in range(len(target)):\\n Target.append(target[0][i])\\n y.append(affinity[0][i])\\n SMILES.append(drug[0][i])\\n\\n aff=[]\\n total=[]\\n for i in range(len(target)):\\n aff.insert(i, y[i].split(\\\" \\\"))\\n for i in aff:\\n total += i\\n for i in range(len(SMILES)):\\n drugcnt.insert(i, len(SMILES[i].split()))\\n \\n smile = []\\n for segments in SMILES:\\n for x in segments.split():\\n smile.extend(x)\\n #smile = [x for segments in SMILES for x in segments.split()]\\n smiles_res=[]\\n y_tmp=[]\\n target_res=[]\\n tmp=[]\\n \\n for i in range(len(drugcnt)):\\n tmp.extend(repeat(Target[i], drugcnt[i]))\\n for i in range(len(total)):\\n if total[i] != '-1':\\n y_tmp.append(total[i])\\n smiles_res.append(smile[i])\\n target_res.append(tmp[i])\\n\\n y_res = [float(i) for i in y_tmp]\\n return np.array(smiles_res), np.array(target_res), np.array(y_res)\",\n \"def do_qc(fn, df, year):\\n (lon, lat) = fn2lonlat(fn)\\n stage4 = compute_stage4(lon, lat, year)\\n # Does the frame appear to have all dates?\\n if len(df.index) != len(df.resample(\\\"D\\\").mean().index):\\n print(\\\"ERROR: Appears to be missing dates!\\\")\\n\\n if open(fn).read()[-1] != \\\"\\\\n\\\":\\n print(\\\"ERROR: File does not end with \\\\\\\\n\\\")\\n\\n print(\\\"--------- Summary stats from the .cli file\\\")\\n print(\\\"YEAR | RAIN | MAXRATE | MAXACC | #DAYS | #>1RT | RAD/D\\\")\\n print(\\\" --- | --- | --- | --- | --- | --- | ---\\\")\\n for _year, gdf in df.groupby(by=df.index.year):\\n print(\\n (\\\"%s | %6.2f | %7.2f | %7.2f | %6i | %6i | %6.0f\\\")\\n % (\\n _year,\\n mm2inch(gdf[\\\"pcpn\\\"].sum()),\\n mm2inch(gdf[\\\"maxr\\\"].max()),\\n mm2inch(gdf[\\\"pcpn\\\"].max()),\\n len(gdf[gdf[\\\"pcpn\\\"] > 0].index),\\n len(gdf[gdf[\\\"maxr\\\"] > 25.4].index),\\n gdf[\\\"rad\\\"].mean(),\\n )\\n )\\n\\n print(\\\"---- Months with < 0.05 precipitation ----\\\")\\n gdf = df.groupby(by=[df.index.year, df.index.month])[\\\"pcpn\\\"].sum()\\n print(gdf[gdf < 1.0])\\n\\n print(\\\"----- Average high temperature -----\\\")\\n print(\\\"YEAR | Avg High F | Avg Low F | Days > 100F\\\")\\n print(\\\" --- | --- | --- | ---\\\")\\n for _year, gdf in df.groupby(by=df.index.year):\\n print(\\n (\\\"%s | %6.2f | %6.2f | %3i\\\")\\n % (\\n _year,\\n c2f(gdf[\\\"tmax\\\"].mean()),\\n c2f(gdf[\\\"tmin\\\"].mean()),\\n len(gdf[gdf[\\\"tmax\\\"] > 37.7].index),\\n )\\n )\\n\\n monthly = df[df.index.year == year][\\\"pcpn\\\"].resample(\\\"M\\\").sum().copy()\\n monthly = pd.DataFrame(\\n {\\\"dep\\\": mm2inch(monthly.values)}, index=range(1, 13)\\n )\\n\\n # Get prism, for a bulk comparison\\n prism = requests.get(\\n (\\n \\\"http://mesonet.agron.iastate.edu/json/prism/\\\"\\n \\\"%.2f/%.2f/%s0101-%s1231\\\"\\n )\\n % (lon, lat, year, year)\\n ).json()\\n rows = []\\n for entry in prism[\\\"data\\\"]:\\n rows.append(\\n {\\n \\\"date\\\": datetime.datetime.strptime(\\n entry[\\\"valid\\\"][:10], \\\"%Y-%m-%d\\\"\\n ),\\n \\\"precip\\\": entry[\\\"precip_in\\\"],\\n }\\n )\\n prismdf = pd.DataFrame(rows)\\n prismdf = prismdf.set_index(\\\"date\\\")\\n monthly[\\\"prism\\\"] = prismdf[\\\"precip\\\"].resample(\\\"M\\\").sum().copy().values\\n\\n # Compare daily values\\n iemjson = requests.get(\\n (\\n \\\"http://mesonet.agron.iastate.edu/iemre/multiday/\\\"\\n \\\"%s-01-01/%s-12-31/%s/%s/json\\\"\\n )\\n % (year, year, lat, lon)\\n ).json()\\n rows = []\\n for entry in iemjson[\\\"data\\\"]:\\n rows.append(\\n {\\n \\\"date\\\": datetime.datetime.strptime(entry[\\\"date\\\"], \\\"%Y-%m-%d\\\"),\\n \\\"precip\\\": entry[\\\"daily_precip_in\\\"],\\n }\\n )\\n iemdf = pd.DataFrame(rows)\\n iemdf = iemdf.set_index(\\\"date\\\")\\n print(\\\"PRISM %s precip is: %.2f\\\" % (year, prismdf[\\\"precip\\\"].sum()))\\n print(\\\"IEMRE sum precip is: %.2f\\\" % (iemdf[\\\"precip\\\"].sum(),))\\n print(\\\"StageIV sum precip is: %.2f\\\" % (stage4[\\\"precip\\\"].sum(),))\\n monthly[\\\"stage4\\\"] = stage4[\\\"precip\\\"].resample(\\\"M\\\").sum().copy().values\\n monthly[\\\"iemre\\\"] = iemdf[\\\"precip\\\"].resample(\\\"M\\\").sum().copy().values\\n monthly[\\\"prism-dep\\\"] = monthly[\\\"prism\\\"] - monthly[\\\"dep\\\"]\\n monthly[\\\"iemre-dep\\\"] = monthly[\\\"iemre\\\"] - monthly[\\\"dep\\\"]\\n\\n print(\\\" --------- %s Monthly Totals --------\\\" % (year,))\\n print(monthly)\\n df.at[\\n slice(datetime.date(year, 1, 1), datetime.date(year, 12, 31)),\\n \\\"stage4_precip\\\",\\n ] = stage4[\\\"precip\\\"].values\\n df[\\\"iemre_precip\\\"] = iemdf[\\\"precip\\\"]\\n df[\\\"diff_precip\\\"] = df[\\\"pcpn_in\\\"] - df[\\\"iemre_precip\\\"]\\n df[\\\"diff_stage4\\\"] = df[\\\"pcpn_in\\\"] - df[\\\"stage4_precip\\\"]\\n print(\\\" --- Top 5 Largest DEP > IEMRE ----\\\")\\n print(\\n df[\\n [\\n \\\"diff_precip\\\",\\n \\\"pcpn_in\\\",\\n \\\"iemre_precip\\\",\\n \\\"stage4_precip\\\",\\n \\\"diff_stage4\\\",\\n ]\\n ]\\n .sort_values(by=\\\"diff_precip\\\", ascending=False)\\n .head()\\n )\\n print(\\\" --- Top 5 Largest IEMRE > DEP ----\\\")\\n print(\\n df[\\n [\\n \\\"diff_precip\\\",\\n \\\"pcpn_in\\\",\\n \\\"iemre_precip\\\",\\n \\\"stage4_precip\\\",\\n \\\"diff_stage4\\\",\\n ]\\n ]\\n .sort_values(by=\\\"diff_precip\\\", ascending=True)\\n .head()\\n )\\n\\n print(\\\" --- Top 10 Largest Stage4 > DEP ----\\\")\\n print(\\n df[\\n [\\n \\\"diff_precip\\\",\\n \\\"pcpn_in\\\",\\n \\\"iemre_precip\\\",\\n \\\"stage4_precip\\\",\\n \\\"diff_stage4\\\",\\n ]\\n ]\\n .sort_values(by=\\\"diff_stage4\\\", ascending=True)\\n .head(10)\\n )\\n print(\\\" vvv job listing based on the above vvv\\\")\\n for dt in df.sort_values(by=\\\"diff_stage4\\\", ascending=True).head(10).index:\\n print(\\n \\\"python daily_clifile_editor.py 0 %s %s %s\\\"\\n % (dt.year, dt.month, dt.day)\\n )\\n df2 = df.loc[slice(datetime.date(year, 1, 1), datetime.date(year, 1, 31))][\\n [\\\"diff_precip\\\", \\\"pcpn_in\\\", \\\"iemre_precip\\\", \\\"stage4_precip\\\"]\\n ].sort_values(by=\\\"diff_precip\\\")\\n print(\\\" --- Daily values for month \\\" \\\"\\\")\\n print(df2)\",\n \"def test_gclda_symmetric(testdata_laird):\\n counts_df = annotate.text.generate_counts(\\n testdata_laird.texts,\\n text_column=\\\"abstract\\\",\\n tfidf=False,\\n min_df=1,\\n max_df=1.0,\\n )\\n\\n with pytest.raises(ValueError):\\n annotate.gclda.GCLDAModel(\\n counts_df,\\n testdata_laird.coordinates,\\n mask=testdata_laird.masker.mask_img,\\n n_regions=3,\\n symmetric=True,\\n )\\n\\n model = annotate.gclda.GCLDAModel(\\n counts_df,\\n testdata_laird.coordinates,\\n mask=testdata_laird.masker.mask_img,\\n n_regions=2,\\n symmetric=True,\\n )\\n model.fit(n_iters=5, loglikely_freq=5)\\n\\n # Create ROI to decode\\n arr = np.zeros(testdata_laird.masker.mask_img.shape, np.int32)\\n arr[40:44, 45:49, 40:44] = 1\\n mask_img = nib.Nifti1Image(arr, testdata_laird.masker.mask_img.affine)\\n decoded_df, _ = decode.discrete.gclda_decode_roi(model, mask_img)\\n assert isinstance(decoded_df, pd.DataFrame)\\n\\n # Decode the ROI as a continuous map\\n decoded_df, _ = decode.continuous.gclda_decode_map(model, mask_img)\\n assert isinstance(decoded_df, pd.DataFrame)\\n\\n # Encode text\\n encoded_img, _ = decode.encode.gclda_encode(model, \\\"fmri activation\\\")\\n assert isinstance(encoded_img, nib.Nifti1Image)\",\n \"def test_pcca_1():\\n n = 1000 #number of data points\\n kk = 3 #number of points where data accumulates\\n k = 10 #number of cluster_centers\\n factor = 0.1 #how much is the data perturbed\\n data = np.zeros((n,1))\\n for i in range(0,n):\\n data[i] = i % kk + factor * np.random.rand() * math.pow(-1,int(2*np.random.rand()))\\n #plt.scatter(data[:,0],np.zeros((n,1)))\\n \\n clustering = cl.KMeans(data,k)\\n cluster_centers = clustering.cluster_centers\\n cluster_labels = clustering.cluster_labels\\n \\n #plt.scatter(cluster_centers[:],np.zeros((k,1)),c='r')\\n \\n estimator = est.Estimator(cluster_labels, 1, 1)\\n matrix = estimator.reversible_transition_matrix\\n msm = ana.MarkovStateModel(matrix)\\n \\n n_pcca_states = 4;\\n #fig, ax = plt.subplots(figsize=(6.5, 5))\\n pcca_labels = msm.metastable_set_assignments(n_pcca_states)\\n #im = ax.scatter(cluster_centers[:, 0], np.zeros((k,1)), c=pcca_labels, s=200)\\n #cbar = fig.colorbar(im, ax=ax)\\n error = 0;\\n for j in range(0,kk):\\n for i in range(0,k):\\n if (round(cluster_centers[i,0]) == j):\\n test = i\\n for i in range(0,k):\\n if (np.abs(cluster_centers[i,0] - cluster_centers[test,0]) < 2*factor):\\n if (not pcca_labels[i] == pcca_labels[test]):\\n error = 1\\n print(error)\\n assert_true(error == 0)\",\n \"def context_study_stats(frame_path=METRICS_DIR+'/merge.csv'):\\n frame = pd.read_csv(frame_path)\\n print(frame['LOC_prod'].mean())\\n print(frame['LOC_prod'].sum())\\n print(frame['LOC_test'].sum())\\n print(frame['no_mutations'].sum())\\n print(frame.shape[0])\\n\\n sizes = frame.groupby('project').size()\\n prod = frame.groupby('project')['LOC_prod'].sum( )\\n test = frame.groupby('project')['LOC_test'].sum()\\n mutants = frame.groupby('project')['no_mutations'].sum()\\n\\n result = pd.DataFrame({'project': list(sizes.index),\\n 'size': list(sizes),\\n 'prod': list(prod),\\n 'test': list(test),\\n 'mutants': list(mutants)},\\n columns=['project', 'size', 'prod', 'test', 'mutants'])\\n print(result.to_latex())\",\n \"def runcircos(self):\\n pd.read_csv(self.cns, sep=\\\"\\\\t\\\")[\\n [\\\"chromosome\\\", \\\"start\\\", \\\"end\\\", \\\"tcn\\\"]\\n ].rename({\\\"chromosome\\\": \\\"chrm\\\", \\\"tcn\\\": \\\"cns\\\"}, axis=1).to_csv(\\n self.segs, index=None\\n )\\n\\n passed_svs = [\\n sv\\n for sv in self.svs.values()\\n ]\\n circos_sv_file = os.path.join(\\n self.out_dir, \\\"circos_svs.tsv\\\"\\n )\\n circos_df = pd.DataFrame(\\n [\\n (\\\"chr\\\" + sv.chr1, sv.pos1, sv.pos1, \\\"chr\\\" + sv.chr2, sv.pos2, sv.pos2)\\n for sv in passed_svs\\n ],\\n columns=[\\n \\\"Chromosome\\\",\\n \\\"chromStart\\\",\\n \\\"chromEnd\\\",\\n \\\"Chromosome.1\\\",\\n \\\"chromStart.1\\\",\\n \\\"chromEnd.1\\\",\\n ],\\n )\\n circos_df.to_csv(circos_sv_file, index=None)\",\n \"def causDspectra(uxmax, uymax, ax, ay, dso, dsl, dm, m, n, N):\\n \\n ymin = -m*uxmax + n\\n ymax = m*uxmax + n\\n if ymin < -uymax:\\n xmin = (-uymax - n)/m\\n ymin = m*xmin + n\\n else:\\n xmin = -uxmax\\n if ymax > uymax:\\n xmax = (uymax - n)/m\\n ymax = m*xmax + n\\n else:\\n xmax = uxmax\\n \\n dlo = dso - dsl\\n coeff = dsl*dlo*re*dm/(2*pi*dso)\\n \\n rx = np.linspace(xmin - 5., xmax + 5., 500)\\n ry = np.linspace(ymin - 5., ymax + 5., 500)\\n uvec = np.meshgrid(rx, ry)\\n A, B, C, D, E = causticFreqHelp(uvec, ax, ay, m, n)\\n upxvec = np.linspace(xmin, xmax, N)\\n freqcaus = []\\n for upx in upxvec:\\n eq1 = A*upx**2 + B*upx + C\\n eq2 = D*upx + E\\n evcaus = np.array([eq1, eq2])\\n roots = polishedRootsBulk(evcaus, causEqFreq, rx, ry, args = (upx, ax, ay, m, n))\\n for root in roots:\\n ux, uy = root\\n arg = coeff*lensg(ux, uy)[0]/(ux - upx)\\n # print(arg)\\n if arg > 0:\\n freq = c*np.sqrt(arg)/(ax*GHz)\\n if freq > 0.01:\\n freqcaus.append([upx, freq])\\n # print(freqcaus)\\n freqcaus = np.asarray(freqcaus).T\\n # plt.scatter(freqcaus[0], freqcaus[1], marker = '.', color = 'black', s = 3.)\\n # plt.xlim(xmin, xmax)\\n # plt.ylim(0., max(freqcaus[1]) + 0.5)\\n # plt.xlabel(r\\\"$u'_x$\\\", fontsize = 16)\\n # plt.ylabel(r'$\\\\nu$ (GHz)', fontsize = 16)\\n # plt.grid()\\n # plt.show()\\n return freqcaus\",\n \"def biom_output(self, name='samples.biom'):\\n data = self.a.df_abundances\\n with open(self.a.out_dir + name, 'w') as handle:\\n # Basic #\\n sample_ids = data.columns\\n sample_md = None\\n observation_ids = data.index\\n # Observation metadata #\\n observation_md = []\\n for seq in data.index:\\n seq_name = self.a.orig_names_to_renamed[seq]\\n counts = self.a.seq_to_counts.get(seq_name)\\n if not counts: observation_md.append({})\\n else: observation_md.append({'source': counts})\\n # Output #\\n t = biom.table.Table(data.transpose().as_matrix(), sample_ids, observation_ids, sample_md, observation_md)\\n handle.write(t.to_json('seqenv version %s') % seqenv.__version__)\",\n \"def cossim(corpus):\\n files = os.listdir()\\n vectorizer = TfidfVectorizer()\\n trsfm = vectorizer.fit_transform(corpus)\\n columns = vectorizer.get_feature_names()\\n df_tfidf = pd.DataFrame(trsfm.toarray(), columns = columns, index = corpus)\\n out = cosine_similarity(trsfm)\\n df_result = pd.DataFrame(out, columns = files, index = files)\\n return df_result\",\n \"def _snrenv_to_pc(snrenv, k=None, q=None, sigma_s=None, m=None):\\n un = norm.ppf(1.0 - 1.0 / m)\\n sn = 1.28255 / un\\n un += 0.577 / un\\n dp = k * snrenv ** q\\n return norm.cdf(dp, un, np.sqrt(sigma_s ** 2 + sn ** 2)) * 100\",\n \"def ca_to_coils_second_df(agent_df):\",\n \"def idog_conv(sc):\\n return math.sqrt(sc*2)\",\n \"def CL(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.55647254","0.49846494","0.48036072","0.4783149","0.47653148","0.47555912","0.47205758","0.47141117","0.46780866","0.4677644","0.46744534","0.4664888","0.46561313","0.4651731","0.46359685","0.46011293","0.4596688","0.45749894","0.45679227","0.45530605","0.45446667","0.44948655","0.44901535","0.44893095","0.44892","0.44848907","0.4481873","0.44788462","0.4470406","0.4462831","0.4458076","0.44571707","0.4454197","0.44517976","0.4438931","0.4433001","0.4431192","0.44251838","0.44233868","0.44175956","0.4416754","0.4412691","0.44021207","0.43999204","0.43995002","0.4396869","0.4393578","0.43896374","0.438897","0.4387073","0.43855423","0.4385297","0.43822673","0.4369672","0.4362151","0.4350303","0.43490425","0.43482807","0.43363294","0.43304652","0.43265373","0.43239537","0.43226263","0.43196616","0.4318778","0.4315391","0.43149322","0.4312836","0.4310891","0.43015847","0.42963052","0.42957127","0.42927808","0.42926088","0.42910093","0.4287684","0.42849046","0.42797852","0.42736104","0.42720097","0.4263917","0.4262528","0.42611164","0.4259174","0.42540082","0.42518172","0.4246931","0.42464507","0.4245288","0.42425808","0.42423633","0.42418763","0.42389682","0.42364264","0.42341292","0.4232769","0.42291176","0.42273268","0.42260915","0.42250156","0.42245346"],"string":"[\n \"0.55647254\",\n \"0.49846494\",\n \"0.48036072\",\n \"0.4783149\",\n \"0.47653148\",\n \"0.47555912\",\n \"0.47205758\",\n \"0.47141117\",\n \"0.46780866\",\n \"0.4677644\",\n \"0.46744534\",\n \"0.4664888\",\n \"0.46561313\",\n \"0.4651731\",\n \"0.46359685\",\n \"0.46011293\",\n \"0.4596688\",\n \"0.45749894\",\n \"0.45679227\",\n \"0.45530605\",\n \"0.45446667\",\n \"0.44948655\",\n \"0.44901535\",\n \"0.44893095\",\n \"0.44892\",\n \"0.44848907\",\n \"0.4481873\",\n \"0.44788462\",\n \"0.4470406\",\n \"0.4462831\",\n \"0.4458076\",\n \"0.44571707\",\n \"0.4454197\",\n \"0.44517976\",\n \"0.4438931\",\n \"0.4433001\",\n \"0.4431192\",\n \"0.44251838\",\n \"0.44233868\",\n \"0.44175956\",\n \"0.4416754\",\n \"0.4412691\",\n \"0.44021207\",\n \"0.43999204\",\n \"0.43995002\",\n \"0.4396869\",\n \"0.4393578\",\n \"0.43896374\",\n \"0.438897\",\n \"0.4387073\",\n \"0.43855423\",\n \"0.4385297\",\n \"0.43822673\",\n \"0.4369672\",\n \"0.4362151\",\n \"0.4350303\",\n \"0.43490425\",\n \"0.43482807\",\n \"0.43363294\",\n \"0.43304652\",\n \"0.43265373\",\n \"0.43239537\",\n \"0.43226263\",\n \"0.43196616\",\n \"0.4318778\",\n \"0.4315391\",\n \"0.43149322\",\n \"0.4312836\",\n \"0.4310891\",\n \"0.43015847\",\n \"0.42963052\",\n \"0.42957127\",\n \"0.42927808\",\n \"0.42926088\",\n \"0.42910093\",\n \"0.4287684\",\n \"0.42849046\",\n \"0.42797852\",\n \"0.42736104\",\n \"0.42720097\",\n \"0.4263917\",\n \"0.4262528\",\n \"0.42611164\",\n \"0.4259174\",\n \"0.42540082\",\n \"0.42518172\",\n \"0.4246931\",\n \"0.42464507\",\n \"0.4245288\",\n \"0.42425808\",\n \"0.42423633\",\n \"0.42418763\",\n \"0.42389682\",\n \"0.42364264\",\n \"0.42341292\",\n \"0.4232769\",\n \"0.42291176\",\n \"0.42273268\",\n \"0.42260915\",\n \"0.42250156\",\n \"0.42245346\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":171,"cells":{"query":{"kind":"string","value":"get per gene average multimapping score"},"document":{"kind":"string","value":"def compute_mm(mmdata):\n\n mm_df = pd.DataFrame(columns=['ORF', 'MM'])\n counter = 0\n\n for gene in mmdata.keys():\n current_matrix = mmdata[gene]\n current_avrg = np.mean( np.sum(current_matrix, 1) / current_matrix.shape[1] )\n mm_df.loc[counter] = [gene, current_avrg]\n counter += 1\n\n return mm_df"},"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_avg_score(df, score):\n avg_score = (df.groupby(['condition', 'gene_a', 'gene_b'])\n .agg({score: 'mean'})\n .reset_index())\n return avg_score","def compute_ave_score_w_sample(genes, samples):\n\n scores = np.zeros(len(genes), dtype=np.uint32)\n\n for i, v in enumerate(genes):\n for j in samples:\n score, _ = run_duel(v, j)\n scores[i] += score\n continue\n continue\n\n return scores / len(samples)","def avg_e_score(self, entity):\n return float(entity['es']) / float(entity['count'])","def _gsea_score(self, gene_list, correl_vector, gene_set, weighted_score_type=1, \n single=False, scale=False):\n N = len(gene_list)\n tag_indicator = np.in1d(gene_list, gene_set, assume_unique=True).astype(int)\n\n if weighted_score_type == 0 :\n correl_vector = np.repeat(1, N)\n else:\n correl_vector = np.abs(correl_vector)**weighted_score_type\n\n # GSEA Enrichment Score\n Nhint = tag_indicator.sum()\n sum_correl_tag = np.sum(correl_vector*tag_indicator)\n\n no_tag_indicator = 1 - tag_indicator\n Nmiss = N - Nhint\n norm_tag = 1.0/sum_correl_tag\n norm_no_tag = 1.0/Nmiss\n RES = np.cumsum(tag_indicator * correl_vector * norm_tag - no_tag_indicator * norm_no_tag)\n\n if scale: RES = RES / N\n if single: # ssGSEA\n es = RES.sum()\n else:\n max_ES, min_ES = RES.max(), RES.min()\n es = max_ES if np.abs(max_ES) > np.abs(min_ES) else min_ES \n # extract values\n return es","def average_population_grade(population):\r\n total = 0\r\n for individual in population :\r\n total += get_individual_fitness(individual)\r\n return total/POPULATION_COUNT","def _get_average(self):\n norm = 1.0\n for pos, idx in enumerate(self.idx):\n norm *= (self.high[pos] - self.low[pos])\n return 1.0/norm","def calculate_score_persona(self, edge_list):\n score_list = []\n if self.proximity_function == \"dot\":\n for src, tag in edge_list:\n src_personas = self.node_to_persona[src]\n tag_personas = self.node_to_persona[tag]\n max_sim = self.aggregate_function(\n [\n np.dot(self.emb[src_persona], self.emb[tag_persona])\n for src_persona in src_personas\n for tag_persona in tag_personas\n ]\n )\n score_list.append(max_sim)\n elif self.proximity_function == \"cos\":\n for src, tag in edge_list:\n src_embs = [self.emb[persona] for persona in self.node_to_persona[src]]\n tag_embs = [self.emb[persona] for persona in self.node_to_persona[tag]]\n max_sim = np.amax(cosine_similarity(src_embs, tag_embs))\n score_list.append(max_sim)\n return score_list\n\n return score_list","def mean_ensembler(self):\n models_name = self._get_models_name(self.data_dir)\n if type(models_name) != list:\n models_name = [models_name]\n\n get_test_y = self._get_model_val(models_name, self.data_dir, 'test')\n # Calculate the average\n average = pd.DataFrame()\n for add in list(get_test_y.keys()):\n if average.empty:\n average[self.TAGS] = get_test_y[add][self.TAGS]\n else:\n average[self.TAGS] += get_test_y[add][self.TAGS]\n\n average = average/len(list(get_test_y.keys()))\n average.insert(loc=0, column='id', value=self.test_id.values)\n doc_name = self.data_dir + '/' + 'submission_average_ensembler.csv'\n average.to_csv(doc_name, index=False)\n print('submission file saved at {}'.format(doc_name))\n return average","def get_mean_score(rating_scores):\n return sum(rating_scores) / len(rating_scores)","def calculate_avg_score(state_score,state_count):\n\tfor state in state_score.keys():\n\t\tstate_score[state] = 1.*state_score[state]/state_count[state]\n\treturn state_score","def get_average(self, s_freq, e_freq):\n s_ind = self.get_bin(s_freq)\n e_ind = self.get_bin(e_freq)\n lst = self.mags[s_ind:e_ind+1]\n try:\n avg = sum(lst)/len(lst)\n except:\n print(s_ind, e_ind)\n print('werid stuff')\n avg = 0\n return avg","def grade(population, target_sum, target_mult):\r\n summed = reduce(add, (fitness(x, target_sum, target_mult) for x in population), 0)\r\n return summed / len(population)","def get_mean_of_all_genres(df, merged):\n all_genres = get_all_genres_from_df(df)\n mean_genres = {}\n for genres in all_genres:\n mean_genres[genres] = df['rating'][df[genres] == 1].mean()\n\n\n change_nan(mean_genres) # change Nan value\n\n\n for genres in all_genres:\n merged.loc[merged.genre == genres, 'rating'] = merged.loc[merged.genre == genres, 'rating'].map(lambda x : x - mean_genres[genres])\n\n return mean_genres","def algo(GENE_VALUES_MATRIX):\n\n\tA = GENE_VALUES_MATRIX\n\n\tAA = np.zeros_like(A)\n\n\tI = np.argsort(A,axis=0)\n\n\tAA[I,np.arange(A.shape[1])] = np.mean(A[I,np.arange(A.shape[1])],axis=1)[:,np.newaxis]\n\n\treturn AA","def record_em_score(record_examples: List[RecordNestedExample]):\n if not record_examples:\n return 0.\n em_scores = []\n for example in record_examples:\n example_ems = []\n for answer in example.answers:\n example_ems.append(string_f1_score(example.prediction, answer))\n if example_ems:\n em_scores.append(max(example_ems))\n return np.mean(em_scores) if em_scores else -1","def mean_avg_precision(top_k_results, relevance):\n map_score = 0.0\n for j, scores in relevance.items():\n precision, _ = calculate_precision_recall(top_k_results[j - 1], scores)\n relevant = set()\n for x in scores:\n relevant.add(x[0])\n \n precision_score, cnt = 0.0, 0\n for i in range(len(top_k_results[j - 1])):\n if top_k_results[j - 1][i] in relevant:\n precision_score += precision[i]\n cnt += 1\n \n map_score += precision_score if cnt == 0 else precision_score / cnt\n \n map_score /= len(relevance)\n \n return map_score","def compute_GS(GMtcs):\n\n GS = np.mean(GMtcs,axis=0) #average over voxels\n\n return GS","def genre_average(genre_vectors):\n array = [vector for vector in genre_vectors]\n return np.average(array, axis=0)","def get_base_score(df, ctl_genes):\n base_score = (df[df.target_gene.isin(ctl_genes)]\n .groupby(['anchor_guide', 'condition'])\n .agg({'lfc': 'median'})\n .reset_index())\n return base_score","def class_average_withali(images,ptcl_info,xform,ref,averager=(\"mean\",{}),normproc=(\"normalize.edgemean\",{}),setsfref=0,verbose=0):\n\n\tif isinstance(images[0],EMData) : nimg=len(images)\n\telif isinstance(images[0],str) and isinstance(images[1],int) : nimg=len(images)-1\n\telse : raise Exception,\"Bad images list\"\n\n\tincl=[]\n\texcl=[]\n#\txforms=[]\n\tavgr=Averagers.get(averager[0], averager[1])\n\tfor i in range(nimg):\n\t\timg=get_image(images,i,normproc)\n\t\tptcl_info[i]=(ptcl_info[i][0],xform*ptcl_info[i][1],ptcl_info[i][2])\t\t# apply the new Transform to the existing one\n#\t\tptcl_info[i]=(ptcl_info[i][0],ptcl_info[i][1]*xform,ptcl_info[i][2])\t\t# apply the new Transform to the existing one\n\t\timg.process_inplace(\"xform\",{\"transform\":ptcl_info[i][1]})\n\t\ttry: use=ptcl_info[i][2]\n\t\texcept: use=1\n\t\tif use :\n\t\t\tavgr.add_image(img)\t\t\t\t# only include the particle if we've tagged it as good\n\t\t\tif img.has_attr(\"source_n\") : incl.append(img[\"source_n\"])\n#\t\t\txforms.append(ptcl_info[i][1])\n\t\telif img.has_attr(\"source_n\") : excl.append(img[\"source_n\"])\n\n\tavg=avgr.finish()\n\n\t# normalize to the reference, this should make make3dpar work better as we can skip the normalization step\n\tif ref!=None :\n\t\tif setsfref:\n\t\t\tavg.process_inplace(\"filter.matchto\",{\"to\":ref,\"interpolate\":0,\"keephires\":1})\n\t\t\tavg-=avg.get_edge_mean()\n\t\telse : avg.process_inplace(\"normalize.toimage\",{\"to\":ref})\n\n\t\tavg[\"class_qual\"]=avg.cmp(\"ccc\",ref)\n\n\t# set some useful attributes\n\tif len(incl)>0 or len(excl)>0 :\n\t\tif len(incl)>0 : avg[\"class_ptcl_idxs\"]=incl\n\t\tif len(excl)>0 : avg[\"exc_class_ptcl_idxs\"]=excl\n#\t\tif len(xforms)>0: avg[\"class_ptcl_xforms\"]=xforms\n\t\tavg[\"class_ptcl_src\"]=img[\"source_path\"]\n\n\treturn avg","def average_ndcg(self, r):\n scores = []\n score = []\n for rank_max in range(1, len(r[0]) + 1):\n score = []\n for data in r:\n score.append(self.ndcg_at_k(data[:rank_max], rank_max, method = 0))\n scores.append(reduce(lambda x, y: x + y, score) / len(score))\n return scores","def average_scores(self, scores, education, count):\n\n for key in scores.keys():\n for k in scores[key].keys():\n scores[key][k] = round(scores[key][k] / count[key][k], 1)\n education[key][k] = round(education[key][k] / count[key][k], 1)\n\n return scores, education","def average_fitness(individuals):\n fitness_num = 0\n for individual in individuals:\n fitness = individual.get_fitness()\n fitness_num += fitness\n return fitness_num / len(individuals)","def average(array):\n unique_vals = set(array)\n return sum(unique_vals) / len(unique_vals)\n\n \n # your code goes here","def clusterAlgorithm(values):\n clusterMap = dict()\n for value in values:\n if value[2] not in clusterMap.keys():\n clusterMap[value[2]] = []\n clusterMap[value[2]].append(value)\n frequency = [float(len(clusterMap[value[2]])) for value in values]\n total = sum(frequency)\n weightValues = [freq / total for freq in frequency]\n print sum(weightValues)\n lightValues = [value[1] for value in values]\n return np.average(lightValues, weights = weightValues)","def sim_avg(sim_mats):\n return np.array(sim_mats).mean(axis=0)","def get_average(self):\n self.avg = math.floor((self.maths + self.phy + self.che) / 3, )\n self.assign_grade()\n return self.avg\n # End of method get_average","def get_score(self, summ_tids, gold_list):\n k = len(summ_tids)\n f_list = []\n for gold in gold_list:\n if len(gold) !=k:\n print('gold-k:',len(gold), k)\n assert len(gold)==k # for ESBM\n corr = len([t for t in summ_tids if t in gold])\n precision = corr/k\n recall = corr/len(gold)\n f_score = 2*((precision*recall)/(precision+recall)) if corr!=0 else 0\n f_list.append(f_score)\n favg = np.mean(f_list)\n return favg","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def azmap (scores, compare, dimension=0):\r\n mns = amean(compare,dimension)\r\n sstd = asamplestdev(compare,0)\r\n return (scores - mns) / sstd","def get_map(self):\n average_precisions = []\n \n for query, answer in tqdm(zip(self.test_queries, self.results)):\n correct_set = self.correct_answers[query]\n average_precision = 0\n n_relevant = 0\n for i, candidate in enumerate(answer):\n if candidate in correct_set:\n n_relevant += 1\n average_precision += (n_relevant / (i + 1))\n average_precision /= len(correct_set)\n average_precisions.append(average_precision)\n \n return np.mean(average_precisions)","def class_average(images,ref=None,niter=1,normproc=(\"normalize.edgemean\",{}),prefilt=0,align=(\"rotate_translate_flip\",{}),\n\t\taligncmp=(\"ccc\",{}),ralign=None,raligncmp=None,averager=(\"mean\",{}),scmp=(\"ccc\",{}),keep=1.5,keepsig=1,automask=0,saveali=0,verbose=0,callback=None,center=\"xform.center\"):\n\n\tif verbose>2 : print \"class_average(\",images,ref,niter,normproc,prefilt,align,aligncmp,ralign,raligncmp,averager,scmp,keep,keepsig,automask,verbose,callback,\")\"\n\n\t# nimg is the number of particles we have to align/average\n\tif isinstance(images[0],EMData) : nimg=len(images)\n\telif isinstance(images[0],str) and isinstance(images[1],int) : nimg=len(images)-1\n\telse : raise Exception,\"Bad images list (%s)\"%str(images)\n\n\tif verbose>2 : print \"Average %d images\"%nimg\n\n\t# If one image and no reference, just return it\n\tif nimg==1 and ref==None : return (get_image(images,0,normproc),[(0,Transform(),1)])\n\n\t# If one particle and reference, align and return\n\tif nimg==1:\n\t\tif averager[0]!=\"mean\" : raise Exception,\"Cannot perform correct average of single particle\"\n\t\tali=align_one(get_image(images,0,normproc),ref,prefilt,align,aligncmp,ralign,raligncmp)\n\t\ttry: ali[\"model_id\"]=ref[\"model_id\"]\n\t\texcept: pass\n\t\tsim=ali.cmp(scmp[0],ref,scmp[1])\t\t\t# compare similarity to reference (may use a different cmp() than the aligner)\n\t\treturn (ali,[(sim,ali[\"xform.align2d\"],1)])\n\n\t# If we don't have a reference image, we need to make one\n\tif ref==None :\n\t\tif verbose : print \"Generating reference\"\n#\t\tsigs=[(get_image(i)[\"sigma\"],i) for i in range(nimg)]\t\t# sigma for each input image, inefficient\n#\t\tref=get_image(images,max(sigs)[1])\n\t\tref=get_image(images,0,normproc)\t\t\t\t\t\t\t\t\t\t# just start with the first, as EMAN1\n\n\t\t# now align and average the set to the gradually improving average\n\t\tfor i in range(1,nimg):\n\t\t\tif verbose>1 :\n\t\t\t\tprint \".\",\n\t\t\t\tsys.stdout.flush()\n\t\t\tali=align_one(get_image(images,i,normproc),ref,prefilt,align,aligncmp,ralign,raligncmp)\n\t\t\tref.add(ali)\n\n\t\t# A little masking and centering\n\t\ttry:\n\t\t\tgmw=max(5,ref[\"nx\"]/16)\t\t# gaussian mask width\n\t\t\t#ref.process_inplace(\"filter.highpass.gauss\",{\"cutoff_pixels\":min(ref[\"nx\"]/10,5)})\t# highpass to reduce gradient issues\n\t\t\t#ref.process_inplace(\"normalize.circlemean\")\n\t\t\t#ref2=ref.process(\"mask.gaussian\",{\"inner_radius\":ref[\"nx\"]/2-gmw,\"outer_radius\":gmw/1.3})\n\t\t\t#ref2.process_inplace(\"filter.lowpass.gauss\",{\"cutoff_abs\":0.07})\t# highpass to reduce gradient issues\n\t\t\t#ref2.process_inplace(\"normalize.circlemean\")\n\t\t\t#ref2.process_inplace(\"threshold.binary\",{\"value\":ref[\"mean\"]+ref[\"sigma\"]*1.5})\n\t\t\t#ref2.process_inplace(\"xform.centerofmass\",{\"threshold\":0.5})\t\t\t\t\t\t# TODO: should probably check how well this works\n\t\t\t#fxf=ref2[\"xform.align2d\"]\n\t\t\t#ref.translate(fxf.get_trans())\n\t\t\t\n\t\t\tif center:\t#jesus\n\t\t\t\tref.process_inplace(center)\n\t\t\tref.process_inplace(\"normalize.circlemean\",{\"radius\":ref[\"nx\"]/2-gmw})\n\t\t\tref.process_inplace(\"mask.gaussian\",{\"inner_radius\":ref[\"nx\"]/2-gmw,\"outer_radius\":gmw/1.3})\n\t\t\tref_orient=None\n\t\texcept:\n\t\t\ttraceback.print_exc()\n\telse:\n\t\ttry: ref_orient=ref[\"xform.projection\"]\n\t\texcept: ref_orient=None\n\n\t\ttry: ref_model=ref[\"model_id\"]\n\t\texcept: ref_model=0\n\n\tif verbose>1 : print \"\"\n\n\tinit_ref=ref.copy()\n\n\t# Iterative alignment\n\tptcl_info=[None]*nimg\t\t# empty list of particle info\n\n\t# This is really niter+1 1/2 iterations. It gets terminated 1/2 way through the final loop\n\tfor it in range(niter+2):\n\t\tif verbose : print \"Starting iteration %d\"%it\n\t\tif callback!=None : callback(int(it*100/(niter+2)))\n\n\t\tmean,sigma=0.0,1.0\t\t# defaults for when similarity isn't computed\n\n\t\t# Evaluate quality from last iteration, and set a threshold for keeping particles\n\t\tif it>0:\n\t\t\t# measure statistics of quality values\n\t\t\tmean,sigma=0,0\n\t\t\tfor sim,xf,use in ptcl_info:\n\t\t\t\tmean+=sim\n\t\t\t\tsigma+=sim**2\n\t\t\tmean/=len(ptcl_info)\n\t\t\tsigma=sqrt(sigma/len(ptcl_info)-mean**2)\n\n\t\t\t# set a threshold based on statistics and options\n\t\t\tif keepsig:\t\t\t\t\t# keep a relative fraction based on the standard deviation of the similarity values\n\t\t\t\tthresh=mean+sigma*keep\n\t\t\t\tif verbose>1 : print \"mean = %f\\tsigma = %f\\tthresh=%f\"%(mean,sigma,thresh)\n\t\t\telse:\t\t\t\t\t\t# keep an absolute fraction of the total\n\t\t\t\tl=[i[0] for i in ptcl_info]\n\t\t\t\tl.sort()\n\t\t\t\ttry: thresh=l[int(len(l)*keep)]\n\t\t\t\texcept:\n\t\t\t\t\tif verbose: print \"Keeping all particles\"\n\t\t\t\t\tthresh=l[-1]+1.0\n\n\t\t\tif verbose:\n\t\t\t\tprint \"Threshold = %1.4f Quality: min=%f max=%f mean=%f sigma=%f\"%(thresh,min(ptcl_info)[0],max(ptcl_info)[0],mean,sigma)\n\n\t\t\t# mark the particles to keep and exclude\n\t\t\tnex=0\n\t\t\tfor i,pi in enumerate(ptcl_info):\n\t\t\t\tif pi[0]>thresh :\n\t\t\t\t\tnex+=1\n\t\t\t\t\tptcl_info[i]=(pi[0],pi[1],0)\n\t\t\t\telif pi[2]==0:\n\t\t\t\t\tptcl_info[i]=(pi[0],pi[1],1)\n\n\t\t\tif verbose : print \"%d/%d particles excluded\"%(nex,len(ptcl_info))\n\n\t\t\t# if all of the particles were thrown out for some reason, we keep the best one\n\t\t\tif nex==len(ptcl_info) :\n\t\t\t\tbest=ptcl_info.index(min(ptcl_info))\n\t\t\t\tptcl_info[best]=(ptcl_info[best][0],ptcl_info[best][1],1)\n\t\t\t\tif verbose : print \"Best particle reinstated\"\n\n\t\tif it==niter+1 : break\t\t# This is where the loop actually terminates. This makes sure that inclusion/exclusion is updated at the end\n\n\t\t# Now align and average\n\t\tavgr=Averagers.get(averager[0], averager[1])\n\t\tfor i in range(nimg):\n\t\t\tif callback!=None and nimg%10==9 : callback(int((it+i/float(nimg))*100/(niter+2.0)))\n\t\t\tptcl=get_image(images,i,normproc)\t\t\t\t\t# get the particle to align\n\t\t\tali=align_one(ptcl,ref,prefilt,align,aligncmp,ralign,raligncmp) # align to reference\n\t\t\tsim=ali.cmp(scmp[0],ref,scmp[1])\t\t\t# compare similarity to reference (may use a different cmp() than the aligner)\n\t\t\tif saveali and it==niter : ali.write_image(\"aligned.hdf\",-1)\n\n\t\t\ttry: use=ptcl_info[i][2]\n\t\t\texcept: use=1\n\t\t\tif use :\n\t\t\t\tavgr.add_image(ali)\t\t\t\t# only include the particle if we've tagged it as good\n\t\t\t\tif verbose>1 :\n\t\t\t\t\tsys.stdout.write(\".\")\n\t\t\t\t\tsys.stdout.flush()\n\t\t\telif verbose>1:\n\t\t\t\tsys.stdout.write(\"X\")\n\t\t\t\tsys.stdout.flush()\n\t\t\tptcl_info[i]=(sim,ali[\"xform.align2d\"],use)\n\n\t\tif verbose>1 : print \"\"\n\n\t\tref=avgr.finish()\n\t\tref[\"class_ptcl_qual\"]=mean\n\t\tref[\"class_ptcl_qual_sigma\"]=sigma\n\n\t\t# A little masking before the next iteration\n\t\tgmw=max(5,ref[\"nx\"]/12)\t\t# gaussian mask width\n\t\tref.process_inplace(\"normalize.circlemean\",{\"radius\":ref[\"nx\"]/2-gmw})\n\t\tif automask :\n\t\t\tref.process_inplace(\"mask.auto2d\",{\"nmaxseed\":10,\"nshells\":gmw-2,\"nshellsgauss\":gmw,\"sigma\":0.2})\n\t\telse :\n\t\t\tref.process_inplace(\"mask.gaussian\",{\"inner_radius\":ref[\"nx\"]/2-gmw,\"outer_radius\":gmw/1.3})\n\n\tif ref_orient!=None :\n\t\tref[\"xform.projection\"]=ref_orient\n\t\tref[\"model_id\"]=ref_model\n\treturn [ref,ptcl_info]","def similarityMetric(Est, GT, options):\n\n if options == None:\n options = {}\n if not 'metric' in options:\n options['metric'] = 'basic'\n\n#########################################################\n## YOU MUST REMOVE THE REST OF THE CODE OF THIS FUNCTION\n## AND CHANGE FOR YOUR OWN CODE\n#########################################################\n comptador = 0\n if options['metric'].lower() == 'basic':\n for i in Est:\n if i in GT[1]:\n comptador = comptador + 1\n return comptador / len(Est)\n\n else:\n return 0","def enrichment_score(query_genes, term_genes, background_genes):\n n11 = np.intersect1d(query_genes, term_genes).size\n n12 = query_genes.size - n11\n n21 = term_genes.size - n11\n n22 = background_genes.size - (n11 + n12 + n21)\n contmatrix = np.array([[n11, n12], [n21, n22]])\n odds_ratio, p_values = stats.fisher_exact(contmatrix, alternative='greater')\n return odds_ratio, p_values","def getAverage(self):\n return sum(self.scores) / len(self.scores)","def average_strain_data(features, metadata, groups_column='gene_name'):\n\n meta_cols = metadata.columns.to_list() \n data = pd.concat([metadata[groups_column], features], axis=1)\n mean_data = data.groupby(groups_column).mean()\n df = metadata.merge(mean_data, how='right', on=groups_column)\n df = df.groupby(groups_column).first().reset_index()\n \n feat = df[[c for c in df.columns if c not in meta_cols]]\n meta = df[meta_cols]\n \n return feat, meta","def computeOverallScore(self,m):\n \n def _computeOverallScore(scalars):\n \"\"\"Given a netCDF4 group of scalars, blend them into an overall score\"\"\"\n scores = {}\n variables = [v for v in scalars.variables.keys() if \"Score\" in v and \"Overall\" not in v]\n for region in self.regions:\n overall_score = 0.\n sum_of_weights = 0.\n for v in variables:\n if region not in v: continue\n score = v.replace(region,\"\").strip()\n weight = 1.\n if self.weight.has_key(score): weight = self.weight[score]\n overall_score += weight*scalars.variables[v][...]\n sum_of_weights += weight\n overall_score /= max(sum_of_weights,1e-12)\n scores[\"Overall Score %s\" % region] = overall_score\n return scores\n\n fname = os.path.join(self.output_path,\"%s_%s.nc\" % (self.name,m.name))\n if not os.path.isfile(fname): return\n with Dataset(fname,mode=\"r+\") as dataset:\n datasets = [dataset.groups[grp] for grp in dataset.groups if \"scalars\" not in grp]\n groups = [grp for grp in dataset.groups if \"scalars\" not in grp]\n datasets.append(dataset)\n groups .append(None)\n for dset,grp in zip(datasets,groups):\n if \"scalars\" in dset.groups:\n scalars = dset.groups[\"scalars\"]\n score = _computeOverallScore(scalars)\n for key in score.keys():\n if key in scalars.variables:\n scalars.variables[key][0] = score[key]\n else:\n Variable(data=score[key],name=key,unit=\"1\").toNetCDF4(dataset,group=grp)","def gavg(idata):\n\t\n\twgt1=np.cos(np.deg2rad(idata.lat))*(idata*0+1)\n\tga=(wgt1*idata).sum(dim=['lat','lon'])/wgt1.sum(dim=['lat','lon'])\n\n\treturn ga","def global_average_scores(self):\n\n return np.mean(self.average_scores_all_subjects(), axis=0)","def aver_score(datalist):\n scores_per_position = []\n \n for tupl in datalist:\n count = 0\n sum_of_position = 0\n for element in tupl[3]:\n sum_of_position += element\n count +=1\n aver_pos = sum_of_position/ count\n scores_per_position += [aver_pos]\n \n return scores_per_position","def find_avg(centroids, short_cut=False, sim_scores=None):\n \n total_sim = 0.0\n total_comparisons = 0\n \n if short_cut:\n total_comparisons = len(sim_scores)\n \n for score in sim_scores:\n total_sim += score\n \n return (total_sim / total_comparisons)\n\n length = len(centroids)\n\n for i in xrange(0, length):\n for j in xrange(i + 1, length):\n total_sim += similarity(centroids[i], centroids[j])\n total_comparisons += 1\n\n return (total_sim / total_comparisons)","def cal_hit_gbratio(self):\n full, top_k = self._subjects, self._top_k\n top_k = full[full['rank']<=top_k]\n #print({d['user'].iloc[0]:d['ratings'].to_list() for i,d in top_k.groupby('user')})\n score = 0.0\n # golden items hit in the top_K items\n score_1 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)]) for i,d in top_k.groupby('user')}\n score_2 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)]) for i,d in top_k.groupby('user')} \n score_ratio = [(score_1[d]-score_2[d]/self._test_ratings[d]) if self._test_ratings[d]!=0 else 0 for d in self._test_ratings.keys()]\n\n #print(np.mean(score_ratio))\n #print(score_1)\n #score = score_1 + score_2\n return np.mean(score_ratio)","def print_avg():","def avg_rows(rows):\n if len(rows) == 1:\n return rows[0]\n\n agg_vals = {k: [rows[j][k] for j in range(len(rows))] for k in rows[0].keys()}\n return {k: (reduce(np.add, v) / len(v)) for k, v in agg_vals.items()}","def get_average_MAE(true_pred_df): \n age_group = true_pred_df.groupby('y_true')\n \n mae_average = []\n for age, age_data in age_group:\n mae_average.append(np.mean(age_data.mae))\n \n return mae_average","def lof_sig_scores(table, samples, verbose=True):\n mut_probdam = 'Missense:Probably'\n mut_syn = 'Synonymous'\n mut_trunc = ['Nonsense', 'Frameshift', 'Splice-site']\n mut_other = ['Missense:Benign', 'Missense:Possibly', 'MissenseNA', 'Indel']\n mut_all = [mut_probdam, mut_syn] + mut_trunc + mut_other\n\n # Calculate the global nonsynonymous:synonymous ratio ---------------------\n # Within each mutation category, sum counts (across all genes)\n tot_count_probdam = sum(table[mut_probdam])\n tot_count_syn = sum(table[mut_syn])\n tot_count_trunc = sum(itertools.chain(*(list(table[col])\n for col in mut_trunc)))\n tot_count_other = sum(itertools.chain(*(list(table[col])\n for col in mut_other)))\n\n # Global mutation count across all categories and genes (= 3504)\n tot_count_all = sum((tot_count_probdam, tot_count_syn, tot_count_trunc,\n tot_count_other))\n if verbose:\n print(\"Counted\", tot_count_all, \"mutations across\", len(table), \"genes\",\n \"and\", len(samples), \"samples\", file=sys.stderr)\n\n # Fraction of global mutations in each category of interest\n tot_frac_probdam = tot_count_probdam / tot_count_all\n tot_frac_syn = tot_count_syn / tot_count_all\n tot_frac_trunc = tot_count_trunc / tot_count_all\n\n # Global nonsynonymous:synonymous ratio = (1-syn)/syn (= 2.13697)\n tot_ns_s_ratio = (1 - tot_frac_syn) / tot_frac_syn\n\n # Calculate each gene's mutation score ------------------------------------\n for _idx, row in table.iterrows():\n gene_count_all = sum([row[col] for col in mut_all])\n if not gene_count_all:\n # Gene is not mutated at all --> zero score\n yield (row['Gene'], 0.0)\n continue\n\n # Initial score is the sum the 'Normalized' values across all samples\n raw_score = sum(row[sid] for sid in samples)\n\n # Adjust for NS:S ratio\n gene_count_syn = row[mut_syn]\n syn_factor = max(1 - tot_ns_s_ratio * gene_count_syn / gene_count_all,\n 0)\n new_score = raw_score * syn_factor\n\n # Adjust for \"probably damaging\" missense and truncating mutations\n gene_frac_probdam = row[mut_probdam] / gene_count_all\n probdam_factor = 1 + gene_frac_probdam - tot_frac_probdam\n gene_frac_trunc = sum([row[col] for col in mut_trunc]) / gene_count_all\n trunc_factor = gene_frac_trunc / tot_frac_trunc\n final_score = new_score * probdam_factor * trunc_factor\n yield (row['Gene'], final_score)","def average(grade1, grade2, grade3):\n return (grade1 + grade2 + grade3) / 3","def score_game(game_core):\n \n att_counter = [] \n np.random.seed(1) # fix RANDOM SEED so the experiment is reproducible \n random_array = np.random.randint(1,101, size=(1000))\n for number in random_array:\n att_counter.append(game_core(number))\n score = int(np.mean(att_counter))\n print(f\"Your algorithm guesses on average the number in {score} attempts.\")\n return(score)","def get_metrics(cfg, model, X_anchor, y_anchor, X_gal, y_gal, annoy_index, vec_dim):\n rank10_acc = 0\n rank5_acc = 0\n rank1_acc = 0\n avg_acc = 0\n vote_res = 0\n\n l2 = []\n for anchor in range(0, len(X_anchor)):\n res = get_result(get_image_features(cfg, model, X_anchor[anchor]), annoy_index)\n vote = defaultdict(int)\n # Accuracy\n correct = 0\n for i in res[:10]:\n vote[y_gal[i]] += 1\n\n max_key = max(vote, key=vote.get)\n if max_key == y_anchor[anchor]:\n vote_res += 1\n \n\n for recomm in res[:10]:\n if y_gal[recomm] == y_anchor[anchor]:\n correct += 1 \n\n avg_acc += correct/len(res)\n\n # Mean Average Precision\n l1 = []\n for recomm in res[:10]:\n if y_gal[recomm] == y_anchor[anchor]:\n correct += 1\n l1.append(1)\n else:\n l1.append(0)\n l2.append(l1) \n\n # Rank10 Accuracy\n for each_val in res[:10]:\n if y_gal[each_val] == y_anchor[anchor]:\n rank10_acc += 1\n break\n \n # Rank5 Accuracy\n for each_val in res[:5]:\n if y_gal[each_val] == y_anchor[anchor]:\n rank5_acc += 1\n break\n\n # Rank1 Accuracy\n for each_val in res[:1]:\n if y_gal[each_val] == y_anchor[anchor]:\n rank1_acc += 1\n break\n\n print(\"Avg acc is :: {avg_acc}\".format(avg_acc = avg_acc/len(X_anchor)))\n print(\"Rank 10 acc is :: {rank10_acc}\".format(rank10_acc = rank10_acc/len(X_anchor)))\n print(\"Rank 5 acc is :: {rank5_acc}\".format(rank5_acc = rank5_acc/len(X_anchor)))\n print(\"Rank 1 acc is :: {rank1_acc}\".format(rank1_acc = rank1_acc/len(X_anchor)))\n print(\"Mean Avg Precision is :: {mAP}\".format(mAP=mean_average_precision(l2)))\n print(\"Vote res :: \", vote_res/len(X_anchor))\n\n return rank1_acc/len(X_anchor), mean_average_precision(l2)","def average_match(e, l, ignore_self=False):\n # filter out ourself as this will give us a nice 1.0 value\n # the problem with this is if we are a list of 1, anything will have a better value!\n if ignore_self:\n l = [x for x in l if x != e]\n if len(l) == 0:\n return 0\n values = [pairwise[e][x] for x in l]\n return 1.0*sum(values)/len(values)","def summaries(e_dict, m_dict):\n for key, value in m_dict.items():\n e_dict[key].append(np.mean(value))\n return e_dict","def average_grade(lst):\r\n res = []\r\n for stdnt in lst:\r\n name, avg = stdnt[0], mean(conv_to_num(stdnt[1:]))\r\n res.append([name, avg])\r\n\r\n\r\n return(res)","def calculate_metric(self, distance_matrix):\n ap_scores = []\n for node_id in range(len(distance_matrix)):\n sorted_nodes = np.argsort(distance_matrix[node_id]).tolist()\n neighs = self.neighbors[node_id]\n n_correct = 0.0\n precisions = []\n for i in range(1, len(sorted_nodes)):\n if sorted_nodes[i] in neighs:\n n_correct += 1\n precisions.append(n_correct / i)\n if n_correct == len(neighs):\n break\n\n ap_scores.append(np.mean(precisions))\n\n return np.mean(ap_scores)","def average_kappa_for_group(db, groupId):\n documents = db.documents.find({'groupId': groupId})\n kappas = []\n for document in documents:\n if document_has_annotations(db, document['_id']) and document_has_numbers(db, document['_id']):\n kappas.append(get_kappa_for_document(db, document['_id']))\n return sum(kappas)/float(len(kappas))","def getAvg(self):\r\n\t\tdata = self.pair.data\r\n\t\tif data['avg'] == None:\r\n\t\t\treturn None\r\n\t\treturn 1. / self.pair.data['avg']","def score_all_genes(self):\n scores = pd.DataFrame(self.clf.predict_proba(self.dataset), index=self.dataset.index)[1]\n scores = pd.DataFrame(scores).sort_values(1, ascending=False)\n scores['known'] = [int(g in list(self.M.befree_genes + self.M.curated_genes + self.M.sven_genes)) for g in scores.index]\n scores.columns = ['score', 'known']\n scores.to_csv(self.save_path + '/all_gene_scores.csv')\n\n predictions = pd.DataFrame(self.clf.predict(self.dataset), index=self.dataset.index)\n predictions['known'] = [int(g in list(self.M.befree_genes + self.M.curated_genes + self.M.sven_genes)) for g in predictions.index]\n predictions.to_csv(self.save_path + '/predictions.csv')","def get_gpa(scores):\n subjects_gpas = []\n for score in scores:\n subjects_gpas.append(calculate_gpa(score))\n gpa = get_average(subjects_gpas)\n return gpa","def get_averages(self):\t\n\t\t\n\t\taverages = {}\n\t\tfor subject in self.grades.iterkeys():\n\t\t\taverages[subject] = float(sum(self.grades[subject])) / len(self.grades[subject])\n\t\treturn averages","def average_grades(grades):\r\n\r\n\tfor key, value in grades.items(): # iterate through the dictionary for key and value\r\n\t\tgrades[key] = sum(value)/len(value) # average of the value\r\n\r\n\treturn (grades) #return grades\r","def avg_by_elem(p):\n p, num = p\n avg = map(lambda x:x/num, p)\n return tuple(avg)","def get_mean(self):\r\n for i in range(1,len(self.data[0])):\r\n self.prom.append(np.mean(self.data[:,i]))","def average(X, ebunch):\n edge_embeds = np.zeros((len(ebunch), len(X[list(X.keys())[0]])))\n i = 0\n for edge in ebunch:\n edge_embeds[i] = (X[str(edge[0])] + X[str(edge[1])]) / 2.0\n i += 1\n return edge_embeds","def compute_evidence_weighted_aggregated_veracity_score(\n gold: Dict[Tuple[int, str], Dict],\n pred: Dict[Tuple[int, str], Dict],\n elementwise_evidence_f1: Dict[Tuple[int, str], float],\n elementwise_evidence_f1_corrected: Dict[Tuple[int, str], float],\n) -> Dict:\n\n accuracies_passages: List[float] = []\n f1_scores_evidence: List[float] = []\n f1_scores_corrected_evidence: List[float] = []\n\n keys: List[Any] = list(gold.keys())\n\n for key in keys:\n gold_sample: Dict = gold[key]\n pred_sample: Dict = pred[key]\n\n gold_passage_label: str = gold_sample['labels']['passage']\n predicted_passage_label: str = pred_sample['predicted']\n\n accuracies_passages.append(get_instance_accuracy(gold_passage_label, predicted_passage_label))\n f1_scores_evidence.append(elementwise_evidence_f1[key])\n f1_scores_corrected_evidence.append(elementwise_evidence_f1_corrected[key])\n\n return {\n 'ev_weighted_accuracy': np.mean(np.array(accuracies_passages) * np.array(f1_scores_evidence)),\n 'ev_weighted_accuracy_corrected': np.mean(\n np.array(accuracies_passages) * np.array(f1_scores_corrected_evidence)\n )\n }","def compute_metrics(self):\n overall_ret = OrderedDict()\n for ap_iou_thresh in self.ap_iou_thresh:\n ret_dict = OrderedDict()\n rec, prec, ap = eval_det_multiprocessing(self.pred_map_cls, self.gt_map_cls, ovthresh=ap_iou_thresh)\n for key in sorted(ap.keys()):\n clsname = self.class2type_map[key] if self.class2type_map else str(key)\n ret_dict[\"%s Average Precision\" % (clsname)] = ap[key]\n ap_vals = np.array(list(ap.values()), dtype=np.float32)\n ap_vals[np.isnan(ap_vals)] = 0\n ret_dict[\"mAP\"] = ap_vals.mean()\n rec_list = []\n for key in sorted(ap.keys()):\n clsname = self.class2type_map[key] if self.class2type_map else str(key)\n try:\n ret_dict[\"%s Recall\" % (clsname)] = rec[key][-1]\n rec_list.append(rec[key][-1])\n except:\n ret_dict[\"%s Recall\" % (clsname)] = 0\n rec_list.append(0)\n ret_dict[\"AR\"] = np.mean(rec_list)\n overall_ret[ap_iou_thresh] = ret_dict\n return overall_ret","def grade(population, targetSum, targetProduct):\n summed = reduce (add,(fitness(x, targetSum, targetProduct) for x in population), 0 )\n return summed / len(population)","def geo_mean(num_list):\n np_array = np.array(num_list)\n return np_array.prod() ** (1.0 / len(np_array))","def mean_average_position():\n pass","def _score_for_model(meta):\n mean_acc = list()\n pipes = meta[\"pipeline\"]\n acc = meta[\"accuracy\"]\n if \"tagger\" in pipes:\n mean_acc.append(acc[\"tags_acc\"])\n if \"morphologizer\" in pipes:\n mean_acc.append((acc[\"morphs_acc\"] + acc[\"pos_acc\"]) / 2)\n if \"parser\" in pipes:\n mean_acc.append((acc[\"uas\"] + acc[\"las\"]) / 2)\n if \"ner\" in pipes:\n mean_acc.append((acc[\"ents_p\"] + acc[\"ents_r\"] + acc[\"ents_f\"]) / 3)\n if \"textcat\" in pipes:\n mean_acc.append(acc[\"textcat_score\"])\n if \"senter\" in pipes:\n mean_acc.append((acc[\"sent_p\"] + acc[\"sent_r\"] + acc[\"sent_f\"]) / 3)\n return sum(mean_acc) / len(mean_acc)","def ensemble_mean(self):\n return self.mean(dim='mem')","def calculate_score(self, edge_list):\n embs = np.array(\n [[self.emb[source], self.emb[target]] for source, target in edge_list]\n )\n\n if self.proximity_function == \"dot\":\n score_list = [\n np.dot(source_emb, target_emb) for source_emb, target_emb in embs\n ]\n elif self.proximity_function == \"cos\":\n score_list = cosine_similarity(embs[:, 0], embs[:, 1])\n\n return score_list","def calculate_transformation_score(self, aggregated, measure):\n original_data_count = self.data_dict[measure][\"distinct_enum\"]\n aggregated_data_count = len(aggregated)\n score = 1 - aggregated_data_count/original_data_count\n return score","def get_score(location, grid, shape):","def compute_each_score(word_embeddings, each_id_pair): # without weighting scheme\n emb1 = word_embeddings[each_id_pair[0], :]\n emb2 = word_embeddings[each_id_pair[1], :]\n inn = np.inner(emb1, emb2)\n # print('inner product is {}'.format(inn))\n emb1norm = np.sqrt(np.inner(emb1, emb1))\n # print('emb1norm is {}'.format(emb1norm))\n emb2norm = np.sqrt(np.inner(emb2, emb2))\n # print('emb2norm is {}'.format(emb2norm))\n each_pair_score = inn / emb1norm / emb2norm\n # print('each score is {}\\n'.format(each_pair_score))\n return each_pair_score","def compute_ensemble(fopen_list, var_list, range_list, indicesOnCluster, maxIndices, indicesToParticle): #{{{\n\n rlzn_ensmbl = compute_rlzn_ensemble(fopen_list, var_list, range_list)\n\n # average is over 2nd dimension (if it exists), since first is time\n #ensmbl = compute_cluster_ensemble(rlzn_ensmbl, indicesOnCluster, maxIndices, indicesToParticle)\n\n ensmbl = rlzn_ensmbl\n\n return ensmbl #}}}","def compute_average_separability_score(self) -> Dict:\n avg_sep_score = {}\n for class_pair_key, class_pair_val in self.separability_scores.items():\n avg_sep_score[class_pair_key] = np.mean(np.array([val for _, val in class_pair_val.items()]))\n avg_sep_score['agg_with_risk'] = sum(\n np.array([val for _, val in avg_sep_score.items()]) *\n RISK\n ) \n avg_sep_score['agg'] = sum([val for key, val in avg_sep_score.items() if type(key)==int]) \n return avg_sep_score","def load_average(self):\n return _favg(self.load_samples)","def store_overall_means(src_file: H5File) -> None:\n perp_sum = 0\n par_sum = 0\n ref_sum = 0\n counts = 0\n for path in rawnav.pump_group_paths(src_file):\n perp_path = path + '/perp'\n par_path = path + '/par'\n ref_path = path + '/ref'\n perp_sum += src_file[perp_path].attrs['mean']\n par_sum += src_file[par_path].attrs['mean']\n ref_sum += src_file[ref_path].attrs['mean']\n counts += 1\n src_file.attrs['perp_mean'] = perp_sum / counts\n src_file.attrs['par_mean'] = par_sum / counts\n src_file.attrs['ref_mean'] = ref_sum / counts\n return","def _rouge_score_compute(sentence_results: Dict[str, List[Tensor]]) ->Dict[str, Tensor]:\n results: Dict[str, Tensor] = {}\n if sentence_results == {}:\n return results\n for rouge_key, scores in sentence_results.items():\n results[rouge_key] = torch.tensor(scores).mean()\n return results","def average(data):\n return np.average(data)","def top_1_avg(model_topic_labels):\n blog_model_sum = 0\n book_model_sum = 0\n news_model_sum = 0\n pubmed_model_sum = 0\n blog_gold_sum = 0\n book_gold_sum = 0\n news_gold_sum = 0\n pubmed_gold_sum = 0\n\n for topic_id, labels in model_topic_labels.items():\n top_model_label = labels[0]\n model_score = gold_topic_labels[topic_id][top_model_label]\n gold_score = max(gold_topic_labels[topic_id].values())\n if topic_id < N_blogs:\n blog_model_sum += model_score\n blog_gold_sum += gold_score\n elif topic_id < N_blogs + N_books:\n book_model_sum += model_score\n book_gold_sum += gold_score\n elif topic_id < N_blogs + N_books + N_news:\n news_model_sum += model_score\n news_gold_sum += gold_score\n else:\n pubmed_model_sum += model_score\n pubmed_gold_sum += gold_score\n\n top1avg_blogs, upper_bound_blogs = blog_model_sum / N_blogs, blog_gold_sum / N_blogs\n top1avg_books, upper_bound_books = book_model_sum / N_books, book_gold_sum / N_books\n top1avg_news, upper_bound_news = news_model_sum / N_news, news_gold_sum / N_news\n top1avg_pubmed, upper_bound_pubmed = pubmed_model_sum / N_pubmed, pubmed_gold_sum / N_pubmed\n\n return (top1avg_blogs, upper_bound_blogs, top1avg_books, upper_bound_books, \\\n top1avg_news, upper_bound_news, top1avg_pubmed, upper_bound_pubmed)","def residue_pair_energy(self, res1, res2, pose, sf, emap):\n\t\tpose = pose\n\t\temv = EMapVector()\n\t\tsf_pair.eval_ci_2b(res1,res2,pose,emv)\n\t\tweighted_score = -1*(emv[pair]*sec_struct_weight[pose.secstruct()[res1.seqpos()-1]]*sec_struct_weight[pose.secstruct()[res2.seqpos()-1]])\n\t\temap.set(self.scoreType, weighted_score)","def _get_mean(self):\n return (0.485, 0.456, 0.406)","def calculate_all_cycle_gan_metrics(nat_a, nat_b, gen_a, gen_b, cyc_a, cyc_b, combined_results=True):\n score1 = calculate_single_cycle_gan_metrics(gen_a, nat_a) # space A: generated vs. true data\n score2 = calculate_single_cycle_gan_metrics(gen_b, nat_b) # space B: generated vs. true data\n score3 = calculate_single_cycle_gan_metrics(cyc_a, nat_a) # space A: cyclic generated vs. true data\n score4 = calculate_single_cycle_gan_metrics(cyc_b, nat_b) # space B: cyclic generated vs. true data\n if not combined_results:\n print(score1)\n print(score2)\n print(score3)\n print(score4)\n return [score1, score2, score3, score4]\n # mean_score = [(w + x + y + z) / 4 for w, x, y, z in zip(score1, score2, score3, score4)]\n mean_score = [(x + y) / 2 for x, y in zip(score1, score2)]\n return mean_score","def average(self):\n return self.summation() / self.count()","def mape(x, y):\n return statistics.mean(ape(x, y))","def avg():\n\n # call sum method to add up the values in the collection & div by the num of items\n # call len method to compute the # of vals in collection which is divided by sum total \n mean = sum(inlist) / len(inlist)\n return mean \n\n # alternate method would be calling the reduce method with lamda \n # return reduce(lambda a, b: a + b, inlist) / len(inlist)","def avgmu(self):\n if self._dataframe is DataframeEnum.SkimmedNtuple:\n return self._event.averageIntPerXing\n elif self._dataframe is DataframeEnum.PhysVal:\n return self._event.avgmu\n else:\n self._logger.warning(\"Impossible to retrieve the value of avgmu. Unknow dataframe.\")","def mean(xs):\n ave = 0\n for xs_split in xs:\n num = float(xs_split)\n print(xs_split)\n ave = ave+num\n average = ave/len(xs)\n return average","def aver_and_var(self):\n # assert not self.is_empty\n\n for axis in range(3):\n c1, c2 = self.bounds[axis]\n w = self.n_pix_partial[axis]\n aver = np.average(np.arange(c1, c2), weights=w)\n var = np.average(np.arange(c1, c2)**2, weights=w) - aver ** 2 # D = E(X^2) - (EX)^2\n yield aver, var","def ensembleMethod(tool_list, score_dict, dir, args):\n\n chr_list = score_dict[score_dict.keys()[0]].keys()\n peaks = []\n scores = []\n\n print len(tool_list)\n for chr in chr_list:\n print dir\n print args\n print chr_list\n print score_dict\n #print tool\n add_peak, add_score = stacking_peaks(dir, args, tool_list, score_dict, chr=chr)\n\n for peak in add_peak:\n peaks.append(peak)\n\n for score in add_score:\n scores.append(score)\n ensemble.ensembler(peaks, scores, len(tool_list))\n peaks = []\n score = []\n print peaks, scores\n\n print len(peaks), len(scores)","def _compute_cluster_averages(self, key=\"_scvi_labels\"):\n # find cell label column\n label_col = self.adata.uns[\"_scvi\"][\"categorical_mappings\"][key][\"original_key\"]\n\n # find data slot\n x_dict = self.adata.uns[\"_scvi\"][\"data_registry\"][\"X\"]\n if x_dict[\"attr_name\"] == \"X\":\n use_raw = False\n else:\n use_raw = True\n if x_dict[\"attr_name\"] == \"layers\":\n layer = x_dict[\"attr_key\"]\n else:\n layer = None\n\n # compute mean expression of each gene in each cluster/batch\n aver = compute_cluster_averages(self.adata, labels=label_col, use_raw=use_raw, layer=layer)\n\n return aver","def get_average_grade_of_students(students):\n total_grade = 0\n for row in students:\n total_grade += int(row[5])\n return total_grade/len(students)","def _compute_mean(index, M, R, rake):\r\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\r\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\r\n\r\n return mean","def _compute_mean(index, M, R, rake):\r\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\r\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\r\n\r\n return mean","def test_avg_grade(self):\n\t\ts = Student_Analytics()\n\t\tself.assertEqual(s.classify_grade(s.avg_grade(3)),\"B\")","def _compute_mean(self, C, mag, rjb, rake):\n mean = (C['a1'] +\n self._compute_linear_magnitude_term(C, mag) +\n self._compute_quadratic_magnitude_term(C, mag) +\n self._compute_logarithmic_distance_term(C, mag, rjb) +\n self._compute_faulting_style_term(C, rake))\n\n return mean","def score_samples(self, X):\n ..."],"string":"[\n \"def get_avg_score(df, score):\\n avg_score = (df.groupby(['condition', 'gene_a', 'gene_b'])\\n .agg({score: 'mean'})\\n .reset_index())\\n return avg_score\",\n \"def compute_ave_score_w_sample(genes, samples):\\n\\n scores = np.zeros(len(genes), dtype=np.uint32)\\n\\n for i, v in enumerate(genes):\\n for j in samples:\\n score, _ = run_duel(v, j)\\n scores[i] += score\\n continue\\n continue\\n\\n return scores / len(samples)\",\n \"def avg_e_score(self, entity):\\n return float(entity['es']) / float(entity['count'])\",\n \"def _gsea_score(self, gene_list, correl_vector, gene_set, weighted_score_type=1, \\n single=False, scale=False):\\n N = len(gene_list)\\n tag_indicator = np.in1d(gene_list, gene_set, assume_unique=True).astype(int)\\n\\n if weighted_score_type == 0 :\\n correl_vector = np.repeat(1, N)\\n else:\\n correl_vector = np.abs(correl_vector)**weighted_score_type\\n\\n # GSEA Enrichment Score\\n Nhint = tag_indicator.sum()\\n sum_correl_tag = np.sum(correl_vector*tag_indicator)\\n\\n no_tag_indicator = 1 - tag_indicator\\n Nmiss = N - Nhint\\n norm_tag = 1.0/sum_correl_tag\\n norm_no_tag = 1.0/Nmiss\\n RES = np.cumsum(tag_indicator * correl_vector * norm_tag - no_tag_indicator * norm_no_tag)\\n\\n if scale: RES = RES / N\\n if single: # ssGSEA\\n es = RES.sum()\\n else:\\n max_ES, min_ES = RES.max(), RES.min()\\n es = max_ES if np.abs(max_ES) > np.abs(min_ES) else min_ES \\n # extract values\\n return es\",\n \"def average_population_grade(population):\\r\\n total = 0\\r\\n for individual in population :\\r\\n total += get_individual_fitness(individual)\\r\\n return total/POPULATION_COUNT\",\n \"def _get_average(self):\\n norm = 1.0\\n for pos, idx in enumerate(self.idx):\\n norm *= (self.high[pos] - self.low[pos])\\n return 1.0/norm\",\n \"def calculate_score_persona(self, edge_list):\\n score_list = []\\n if self.proximity_function == \\\"dot\\\":\\n for src, tag in edge_list:\\n src_personas = self.node_to_persona[src]\\n tag_personas = self.node_to_persona[tag]\\n max_sim = self.aggregate_function(\\n [\\n np.dot(self.emb[src_persona], self.emb[tag_persona])\\n for src_persona in src_personas\\n for tag_persona in tag_personas\\n ]\\n )\\n score_list.append(max_sim)\\n elif self.proximity_function == \\\"cos\\\":\\n for src, tag in edge_list:\\n src_embs = [self.emb[persona] for persona in self.node_to_persona[src]]\\n tag_embs = [self.emb[persona] for persona in self.node_to_persona[tag]]\\n max_sim = np.amax(cosine_similarity(src_embs, tag_embs))\\n score_list.append(max_sim)\\n return score_list\\n\\n return score_list\",\n \"def mean_ensembler(self):\\n models_name = self._get_models_name(self.data_dir)\\n if type(models_name) != list:\\n models_name = [models_name]\\n\\n get_test_y = self._get_model_val(models_name, self.data_dir, 'test')\\n # Calculate the average\\n average = pd.DataFrame()\\n for add in list(get_test_y.keys()):\\n if average.empty:\\n average[self.TAGS] = get_test_y[add][self.TAGS]\\n else:\\n average[self.TAGS] += get_test_y[add][self.TAGS]\\n\\n average = average/len(list(get_test_y.keys()))\\n average.insert(loc=0, column='id', value=self.test_id.values)\\n doc_name = self.data_dir + '/' + 'submission_average_ensembler.csv'\\n average.to_csv(doc_name, index=False)\\n print('submission file saved at {}'.format(doc_name))\\n return average\",\n \"def get_mean_score(rating_scores):\\n return sum(rating_scores) / len(rating_scores)\",\n \"def calculate_avg_score(state_score,state_count):\\n\\tfor state in state_score.keys():\\n\\t\\tstate_score[state] = 1.*state_score[state]/state_count[state]\\n\\treturn state_score\",\n \"def get_average(self, s_freq, e_freq):\\n s_ind = self.get_bin(s_freq)\\n e_ind = self.get_bin(e_freq)\\n lst = self.mags[s_ind:e_ind+1]\\n try:\\n avg = sum(lst)/len(lst)\\n except:\\n print(s_ind, e_ind)\\n print('werid stuff')\\n avg = 0\\n return avg\",\n \"def grade(population, target_sum, target_mult):\\r\\n summed = reduce(add, (fitness(x, target_sum, target_mult) for x in population), 0)\\r\\n return summed / len(population)\",\n \"def get_mean_of_all_genres(df, merged):\\n all_genres = get_all_genres_from_df(df)\\n mean_genres = {}\\n for genres in all_genres:\\n mean_genres[genres] = df['rating'][df[genres] == 1].mean()\\n\\n\\n change_nan(mean_genres) # change Nan value\\n\\n\\n for genres in all_genres:\\n merged.loc[merged.genre == genres, 'rating'] = merged.loc[merged.genre == genres, 'rating'].map(lambda x : x - mean_genres[genres])\\n\\n return mean_genres\",\n \"def algo(GENE_VALUES_MATRIX):\\n\\n\\tA = GENE_VALUES_MATRIX\\n\\n\\tAA = np.zeros_like(A)\\n\\n\\tI = np.argsort(A,axis=0)\\n\\n\\tAA[I,np.arange(A.shape[1])] = np.mean(A[I,np.arange(A.shape[1])],axis=1)[:,np.newaxis]\\n\\n\\treturn AA\",\n \"def record_em_score(record_examples: List[RecordNestedExample]):\\n if not record_examples:\\n return 0.\\n em_scores = []\\n for example in record_examples:\\n example_ems = []\\n for answer in example.answers:\\n example_ems.append(string_f1_score(example.prediction, answer))\\n if example_ems:\\n em_scores.append(max(example_ems))\\n return np.mean(em_scores) if em_scores else -1\",\n \"def mean_avg_precision(top_k_results, relevance):\\n map_score = 0.0\\n for j, scores in relevance.items():\\n precision, _ = calculate_precision_recall(top_k_results[j - 1], scores)\\n relevant = set()\\n for x in scores:\\n relevant.add(x[0])\\n \\n precision_score, cnt = 0.0, 0\\n for i in range(len(top_k_results[j - 1])):\\n if top_k_results[j - 1][i] in relevant:\\n precision_score += precision[i]\\n cnt += 1\\n \\n map_score += precision_score if cnt == 0 else precision_score / cnt\\n \\n map_score /= len(relevance)\\n \\n return map_score\",\n \"def compute_GS(GMtcs):\\n\\n GS = np.mean(GMtcs,axis=0) #average over voxels\\n\\n return GS\",\n \"def genre_average(genre_vectors):\\n array = [vector for vector in genre_vectors]\\n return np.average(array, axis=0)\",\n \"def get_base_score(df, ctl_genes):\\n base_score = (df[df.target_gene.isin(ctl_genes)]\\n .groupby(['anchor_guide', 'condition'])\\n .agg({'lfc': 'median'})\\n .reset_index())\\n return base_score\",\n \"def class_average_withali(images,ptcl_info,xform,ref,averager=(\\\"mean\\\",{}),normproc=(\\\"normalize.edgemean\\\",{}),setsfref=0,verbose=0):\\n\\n\\tif isinstance(images[0],EMData) : nimg=len(images)\\n\\telif isinstance(images[0],str) and isinstance(images[1],int) : nimg=len(images)-1\\n\\telse : raise Exception,\\\"Bad images list\\\"\\n\\n\\tincl=[]\\n\\texcl=[]\\n#\\txforms=[]\\n\\tavgr=Averagers.get(averager[0], averager[1])\\n\\tfor i in range(nimg):\\n\\t\\timg=get_image(images,i,normproc)\\n\\t\\tptcl_info[i]=(ptcl_info[i][0],xform*ptcl_info[i][1],ptcl_info[i][2])\\t\\t# apply the new Transform to the existing one\\n#\\t\\tptcl_info[i]=(ptcl_info[i][0],ptcl_info[i][1]*xform,ptcl_info[i][2])\\t\\t# apply the new Transform to the existing one\\n\\t\\timg.process_inplace(\\\"xform\\\",{\\\"transform\\\":ptcl_info[i][1]})\\n\\t\\ttry: use=ptcl_info[i][2]\\n\\t\\texcept: use=1\\n\\t\\tif use :\\n\\t\\t\\tavgr.add_image(img)\\t\\t\\t\\t# only include the particle if we've tagged it as good\\n\\t\\t\\tif img.has_attr(\\\"source_n\\\") : incl.append(img[\\\"source_n\\\"])\\n#\\t\\t\\txforms.append(ptcl_info[i][1])\\n\\t\\telif img.has_attr(\\\"source_n\\\") : excl.append(img[\\\"source_n\\\"])\\n\\n\\tavg=avgr.finish()\\n\\n\\t# normalize to the reference, this should make make3dpar work better as we can skip the normalization step\\n\\tif ref!=None :\\n\\t\\tif setsfref:\\n\\t\\t\\tavg.process_inplace(\\\"filter.matchto\\\",{\\\"to\\\":ref,\\\"interpolate\\\":0,\\\"keephires\\\":1})\\n\\t\\t\\tavg-=avg.get_edge_mean()\\n\\t\\telse : avg.process_inplace(\\\"normalize.toimage\\\",{\\\"to\\\":ref})\\n\\n\\t\\tavg[\\\"class_qual\\\"]=avg.cmp(\\\"ccc\\\",ref)\\n\\n\\t# set some useful attributes\\n\\tif len(incl)>0 or len(excl)>0 :\\n\\t\\tif len(incl)>0 : avg[\\\"class_ptcl_idxs\\\"]=incl\\n\\t\\tif len(excl)>0 : avg[\\\"exc_class_ptcl_idxs\\\"]=excl\\n#\\t\\tif len(xforms)>0: avg[\\\"class_ptcl_xforms\\\"]=xforms\\n\\t\\tavg[\\\"class_ptcl_src\\\"]=img[\\\"source_path\\\"]\\n\\n\\treturn avg\",\n \"def average_ndcg(self, r):\\n scores = []\\n score = []\\n for rank_max in range(1, len(r[0]) + 1):\\n score = []\\n for data in r:\\n score.append(self.ndcg_at_k(data[:rank_max], rank_max, method = 0))\\n scores.append(reduce(lambda x, y: x + y, score) / len(score))\\n return scores\",\n \"def average_scores(self, scores, education, count):\\n\\n for key in scores.keys():\\n for k in scores[key].keys():\\n scores[key][k] = round(scores[key][k] / count[key][k], 1)\\n education[key][k] = round(education[key][k] / count[key][k], 1)\\n\\n return scores, education\",\n \"def average_fitness(individuals):\\n fitness_num = 0\\n for individual in individuals:\\n fitness = individual.get_fitness()\\n fitness_num += fitness\\n return fitness_num / len(individuals)\",\n \"def average(array):\\n unique_vals = set(array)\\n return sum(unique_vals) / len(unique_vals)\\n\\n \\n # your code goes here\",\n \"def clusterAlgorithm(values):\\n clusterMap = dict()\\n for value in values:\\n if value[2] not in clusterMap.keys():\\n clusterMap[value[2]] = []\\n clusterMap[value[2]].append(value)\\n frequency = [float(len(clusterMap[value[2]])) for value in values]\\n total = sum(frequency)\\n weightValues = [freq / total for freq in frequency]\\n print sum(weightValues)\\n lightValues = [value[1] for value in values]\\n return np.average(lightValues, weights = weightValues)\",\n \"def sim_avg(sim_mats):\\n return np.array(sim_mats).mean(axis=0)\",\n \"def get_average(self):\\n self.avg = math.floor((self.maths + self.phy + self.che) / 3, )\\n self.assign_grade()\\n return self.avg\\n # End of method get_average\",\n \"def get_score(self, summ_tids, gold_list):\\n k = len(summ_tids)\\n f_list = []\\n for gold in gold_list:\\n if len(gold) !=k:\\n print('gold-k:',len(gold), k)\\n assert len(gold)==k # for ESBM\\n corr = len([t for t in summ_tids if t in gold])\\n precision = corr/k\\n recall = corr/len(gold)\\n f_score = 2*((precision*recall)/(precision+recall)) if corr!=0 else 0\\n f_list.append(f_score)\\n favg = np.mean(f_list)\\n return favg\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def azmap (scores, compare, dimension=0):\\r\\n mns = amean(compare,dimension)\\r\\n sstd = asamplestdev(compare,0)\\r\\n return (scores - mns) / sstd\",\n \"def get_map(self):\\n average_precisions = []\\n \\n for query, answer in tqdm(zip(self.test_queries, self.results)):\\n correct_set = self.correct_answers[query]\\n average_precision = 0\\n n_relevant = 0\\n for i, candidate in enumerate(answer):\\n if candidate in correct_set:\\n n_relevant += 1\\n average_precision += (n_relevant / (i + 1))\\n average_precision /= len(correct_set)\\n average_precisions.append(average_precision)\\n \\n return np.mean(average_precisions)\",\n \"def class_average(images,ref=None,niter=1,normproc=(\\\"normalize.edgemean\\\",{}),prefilt=0,align=(\\\"rotate_translate_flip\\\",{}),\\n\\t\\taligncmp=(\\\"ccc\\\",{}),ralign=None,raligncmp=None,averager=(\\\"mean\\\",{}),scmp=(\\\"ccc\\\",{}),keep=1.5,keepsig=1,automask=0,saveali=0,verbose=0,callback=None,center=\\\"xform.center\\\"):\\n\\n\\tif verbose>2 : print \\\"class_average(\\\",images,ref,niter,normproc,prefilt,align,aligncmp,ralign,raligncmp,averager,scmp,keep,keepsig,automask,verbose,callback,\\\")\\\"\\n\\n\\t# nimg is the number of particles we have to align/average\\n\\tif isinstance(images[0],EMData) : nimg=len(images)\\n\\telif isinstance(images[0],str) and isinstance(images[1],int) : nimg=len(images)-1\\n\\telse : raise Exception,\\\"Bad images list (%s)\\\"%str(images)\\n\\n\\tif verbose>2 : print \\\"Average %d images\\\"%nimg\\n\\n\\t# If one image and no reference, just return it\\n\\tif nimg==1 and ref==None : return (get_image(images,0,normproc),[(0,Transform(),1)])\\n\\n\\t# If one particle and reference, align and return\\n\\tif nimg==1:\\n\\t\\tif averager[0]!=\\\"mean\\\" : raise Exception,\\\"Cannot perform correct average of single particle\\\"\\n\\t\\tali=align_one(get_image(images,0,normproc),ref,prefilt,align,aligncmp,ralign,raligncmp)\\n\\t\\ttry: ali[\\\"model_id\\\"]=ref[\\\"model_id\\\"]\\n\\t\\texcept: pass\\n\\t\\tsim=ali.cmp(scmp[0],ref,scmp[1])\\t\\t\\t# compare similarity to reference (may use a different cmp() than the aligner)\\n\\t\\treturn (ali,[(sim,ali[\\\"xform.align2d\\\"],1)])\\n\\n\\t# If we don't have a reference image, we need to make one\\n\\tif ref==None :\\n\\t\\tif verbose : print \\\"Generating reference\\\"\\n#\\t\\tsigs=[(get_image(i)[\\\"sigma\\\"],i) for i in range(nimg)]\\t\\t# sigma for each input image, inefficient\\n#\\t\\tref=get_image(images,max(sigs)[1])\\n\\t\\tref=get_image(images,0,normproc)\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# just start with the first, as EMAN1\\n\\n\\t\\t# now align and average the set to the gradually improving average\\n\\t\\tfor i in range(1,nimg):\\n\\t\\t\\tif verbose>1 :\\n\\t\\t\\t\\tprint \\\".\\\",\\n\\t\\t\\t\\tsys.stdout.flush()\\n\\t\\t\\tali=align_one(get_image(images,i,normproc),ref,prefilt,align,aligncmp,ralign,raligncmp)\\n\\t\\t\\tref.add(ali)\\n\\n\\t\\t# A little masking and centering\\n\\t\\ttry:\\n\\t\\t\\tgmw=max(5,ref[\\\"nx\\\"]/16)\\t\\t# gaussian mask width\\n\\t\\t\\t#ref.process_inplace(\\\"filter.highpass.gauss\\\",{\\\"cutoff_pixels\\\":min(ref[\\\"nx\\\"]/10,5)})\\t# highpass to reduce gradient issues\\n\\t\\t\\t#ref.process_inplace(\\\"normalize.circlemean\\\")\\n\\t\\t\\t#ref2=ref.process(\\\"mask.gaussian\\\",{\\\"inner_radius\\\":ref[\\\"nx\\\"]/2-gmw,\\\"outer_radius\\\":gmw/1.3})\\n\\t\\t\\t#ref2.process_inplace(\\\"filter.lowpass.gauss\\\",{\\\"cutoff_abs\\\":0.07})\\t# highpass to reduce gradient issues\\n\\t\\t\\t#ref2.process_inplace(\\\"normalize.circlemean\\\")\\n\\t\\t\\t#ref2.process_inplace(\\\"threshold.binary\\\",{\\\"value\\\":ref[\\\"mean\\\"]+ref[\\\"sigma\\\"]*1.5})\\n\\t\\t\\t#ref2.process_inplace(\\\"xform.centerofmass\\\",{\\\"threshold\\\":0.5})\\t\\t\\t\\t\\t\\t# TODO: should probably check how well this works\\n\\t\\t\\t#fxf=ref2[\\\"xform.align2d\\\"]\\n\\t\\t\\t#ref.translate(fxf.get_trans())\\n\\t\\t\\t\\n\\t\\t\\tif center:\\t#jesus\\n\\t\\t\\t\\tref.process_inplace(center)\\n\\t\\t\\tref.process_inplace(\\\"normalize.circlemean\\\",{\\\"radius\\\":ref[\\\"nx\\\"]/2-gmw})\\n\\t\\t\\tref.process_inplace(\\\"mask.gaussian\\\",{\\\"inner_radius\\\":ref[\\\"nx\\\"]/2-gmw,\\\"outer_radius\\\":gmw/1.3})\\n\\t\\t\\tref_orient=None\\n\\t\\texcept:\\n\\t\\t\\ttraceback.print_exc()\\n\\telse:\\n\\t\\ttry: ref_orient=ref[\\\"xform.projection\\\"]\\n\\t\\texcept: ref_orient=None\\n\\n\\t\\ttry: ref_model=ref[\\\"model_id\\\"]\\n\\t\\texcept: ref_model=0\\n\\n\\tif verbose>1 : print \\\"\\\"\\n\\n\\tinit_ref=ref.copy()\\n\\n\\t# Iterative alignment\\n\\tptcl_info=[None]*nimg\\t\\t# empty list of particle info\\n\\n\\t# This is really niter+1 1/2 iterations. It gets terminated 1/2 way through the final loop\\n\\tfor it in range(niter+2):\\n\\t\\tif verbose : print \\\"Starting iteration %d\\\"%it\\n\\t\\tif callback!=None : callback(int(it*100/(niter+2)))\\n\\n\\t\\tmean,sigma=0.0,1.0\\t\\t# defaults for when similarity isn't computed\\n\\n\\t\\t# Evaluate quality from last iteration, and set a threshold for keeping particles\\n\\t\\tif it>0:\\n\\t\\t\\t# measure statistics of quality values\\n\\t\\t\\tmean,sigma=0,0\\n\\t\\t\\tfor sim,xf,use in ptcl_info:\\n\\t\\t\\t\\tmean+=sim\\n\\t\\t\\t\\tsigma+=sim**2\\n\\t\\t\\tmean/=len(ptcl_info)\\n\\t\\t\\tsigma=sqrt(sigma/len(ptcl_info)-mean**2)\\n\\n\\t\\t\\t# set a threshold based on statistics and options\\n\\t\\t\\tif keepsig:\\t\\t\\t\\t\\t# keep a relative fraction based on the standard deviation of the similarity values\\n\\t\\t\\t\\tthresh=mean+sigma*keep\\n\\t\\t\\t\\tif verbose>1 : print \\\"mean = %f\\\\tsigma = %f\\\\tthresh=%f\\\"%(mean,sigma,thresh)\\n\\t\\t\\telse:\\t\\t\\t\\t\\t\\t# keep an absolute fraction of the total\\n\\t\\t\\t\\tl=[i[0] for i in ptcl_info]\\n\\t\\t\\t\\tl.sort()\\n\\t\\t\\t\\ttry: thresh=l[int(len(l)*keep)]\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\tif verbose: print \\\"Keeping all particles\\\"\\n\\t\\t\\t\\t\\tthresh=l[-1]+1.0\\n\\n\\t\\t\\tif verbose:\\n\\t\\t\\t\\tprint \\\"Threshold = %1.4f Quality: min=%f max=%f mean=%f sigma=%f\\\"%(thresh,min(ptcl_info)[0],max(ptcl_info)[0],mean,sigma)\\n\\n\\t\\t\\t# mark the particles to keep and exclude\\n\\t\\t\\tnex=0\\n\\t\\t\\tfor i,pi in enumerate(ptcl_info):\\n\\t\\t\\t\\tif pi[0]>thresh :\\n\\t\\t\\t\\t\\tnex+=1\\n\\t\\t\\t\\t\\tptcl_info[i]=(pi[0],pi[1],0)\\n\\t\\t\\t\\telif pi[2]==0:\\n\\t\\t\\t\\t\\tptcl_info[i]=(pi[0],pi[1],1)\\n\\n\\t\\t\\tif verbose : print \\\"%d/%d particles excluded\\\"%(nex,len(ptcl_info))\\n\\n\\t\\t\\t# if all of the particles were thrown out for some reason, we keep the best one\\n\\t\\t\\tif nex==len(ptcl_info) :\\n\\t\\t\\t\\tbest=ptcl_info.index(min(ptcl_info))\\n\\t\\t\\t\\tptcl_info[best]=(ptcl_info[best][0],ptcl_info[best][1],1)\\n\\t\\t\\t\\tif verbose : print \\\"Best particle reinstated\\\"\\n\\n\\t\\tif it==niter+1 : break\\t\\t# This is where the loop actually terminates. This makes sure that inclusion/exclusion is updated at the end\\n\\n\\t\\t# Now align and average\\n\\t\\tavgr=Averagers.get(averager[0], averager[1])\\n\\t\\tfor i in range(nimg):\\n\\t\\t\\tif callback!=None and nimg%10==9 : callback(int((it+i/float(nimg))*100/(niter+2.0)))\\n\\t\\t\\tptcl=get_image(images,i,normproc)\\t\\t\\t\\t\\t# get the particle to align\\n\\t\\t\\tali=align_one(ptcl,ref,prefilt,align,aligncmp,ralign,raligncmp) # align to reference\\n\\t\\t\\tsim=ali.cmp(scmp[0],ref,scmp[1])\\t\\t\\t# compare similarity to reference (may use a different cmp() than the aligner)\\n\\t\\t\\tif saveali and it==niter : ali.write_image(\\\"aligned.hdf\\\",-1)\\n\\n\\t\\t\\ttry: use=ptcl_info[i][2]\\n\\t\\t\\texcept: use=1\\n\\t\\t\\tif use :\\n\\t\\t\\t\\tavgr.add_image(ali)\\t\\t\\t\\t# only include the particle if we've tagged it as good\\n\\t\\t\\t\\tif verbose>1 :\\n\\t\\t\\t\\t\\tsys.stdout.write(\\\".\\\")\\n\\t\\t\\t\\t\\tsys.stdout.flush()\\n\\t\\t\\telif verbose>1:\\n\\t\\t\\t\\tsys.stdout.write(\\\"X\\\")\\n\\t\\t\\t\\tsys.stdout.flush()\\n\\t\\t\\tptcl_info[i]=(sim,ali[\\\"xform.align2d\\\"],use)\\n\\n\\t\\tif verbose>1 : print \\\"\\\"\\n\\n\\t\\tref=avgr.finish()\\n\\t\\tref[\\\"class_ptcl_qual\\\"]=mean\\n\\t\\tref[\\\"class_ptcl_qual_sigma\\\"]=sigma\\n\\n\\t\\t# A little masking before the next iteration\\n\\t\\tgmw=max(5,ref[\\\"nx\\\"]/12)\\t\\t# gaussian mask width\\n\\t\\tref.process_inplace(\\\"normalize.circlemean\\\",{\\\"radius\\\":ref[\\\"nx\\\"]/2-gmw})\\n\\t\\tif automask :\\n\\t\\t\\tref.process_inplace(\\\"mask.auto2d\\\",{\\\"nmaxseed\\\":10,\\\"nshells\\\":gmw-2,\\\"nshellsgauss\\\":gmw,\\\"sigma\\\":0.2})\\n\\t\\telse :\\n\\t\\t\\tref.process_inplace(\\\"mask.gaussian\\\",{\\\"inner_radius\\\":ref[\\\"nx\\\"]/2-gmw,\\\"outer_radius\\\":gmw/1.3})\\n\\n\\tif ref_orient!=None :\\n\\t\\tref[\\\"xform.projection\\\"]=ref_orient\\n\\t\\tref[\\\"model_id\\\"]=ref_model\\n\\treturn [ref,ptcl_info]\",\n \"def similarityMetric(Est, GT, options):\\n\\n if options == None:\\n options = {}\\n if not 'metric' in options:\\n options['metric'] = 'basic'\\n\\n#########################################################\\n## YOU MUST REMOVE THE REST OF THE CODE OF THIS FUNCTION\\n## AND CHANGE FOR YOUR OWN CODE\\n#########################################################\\n comptador = 0\\n if options['metric'].lower() == 'basic':\\n for i in Est:\\n if i in GT[1]:\\n comptador = comptador + 1\\n return comptador / len(Est)\\n\\n else:\\n return 0\",\n \"def enrichment_score(query_genes, term_genes, background_genes):\\n n11 = np.intersect1d(query_genes, term_genes).size\\n n12 = query_genes.size - n11\\n n21 = term_genes.size - n11\\n n22 = background_genes.size - (n11 + n12 + n21)\\n contmatrix = np.array([[n11, n12], [n21, n22]])\\n odds_ratio, p_values = stats.fisher_exact(contmatrix, alternative='greater')\\n return odds_ratio, p_values\",\n \"def getAverage(self):\\n return sum(self.scores) / len(self.scores)\",\n \"def average_strain_data(features, metadata, groups_column='gene_name'):\\n\\n meta_cols = metadata.columns.to_list() \\n data = pd.concat([metadata[groups_column], features], axis=1)\\n mean_data = data.groupby(groups_column).mean()\\n df = metadata.merge(mean_data, how='right', on=groups_column)\\n df = df.groupby(groups_column).first().reset_index()\\n \\n feat = df[[c for c in df.columns if c not in meta_cols]]\\n meta = df[meta_cols]\\n \\n return feat, meta\",\n \"def computeOverallScore(self,m):\\n \\n def _computeOverallScore(scalars):\\n \\\"\\\"\\\"Given a netCDF4 group of scalars, blend them into an overall score\\\"\\\"\\\"\\n scores = {}\\n variables = [v for v in scalars.variables.keys() if \\\"Score\\\" in v and \\\"Overall\\\" not in v]\\n for region in self.regions:\\n overall_score = 0.\\n sum_of_weights = 0.\\n for v in variables:\\n if region not in v: continue\\n score = v.replace(region,\\\"\\\").strip()\\n weight = 1.\\n if self.weight.has_key(score): weight = self.weight[score]\\n overall_score += weight*scalars.variables[v][...]\\n sum_of_weights += weight\\n overall_score /= max(sum_of_weights,1e-12)\\n scores[\\\"Overall Score %s\\\" % region] = overall_score\\n return scores\\n\\n fname = os.path.join(self.output_path,\\\"%s_%s.nc\\\" % (self.name,m.name))\\n if not os.path.isfile(fname): return\\n with Dataset(fname,mode=\\\"r+\\\") as dataset:\\n datasets = [dataset.groups[grp] for grp in dataset.groups if \\\"scalars\\\" not in grp]\\n groups = [grp for grp in dataset.groups if \\\"scalars\\\" not in grp]\\n datasets.append(dataset)\\n groups .append(None)\\n for dset,grp in zip(datasets,groups):\\n if \\\"scalars\\\" in dset.groups:\\n scalars = dset.groups[\\\"scalars\\\"]\\n score = _computeOverallScore(scalars)\\n for key in score.keys():\\n if key in scalars.variables:\\n scalars.variables[key][0] = score[key]\\n else:\\n Variable(data=score[key],name=key,unit=\\\"1\\\").toNetCDF4(dataset,group=grp)\",\n \"def gavg(idata):\\n\\t\\n\\twgt1=np.cos(np.deg2rad(idata.lat))*(idata*0+1)\\n\\tga=(wgt1*idata).sum(dim=['lat','lon'])/wgt1.sum(dim=['lat','lon'])\\n\\n\\treturn ga\",\n \"def global_average_scores(self):\\n\\n return np.mean(self.average_scores_all_subjects(), axis=0)\",\n \"def aver_score(datalist):\\n scores_per_position = []\\n \\n for tupl in datalist:\\n count = 0\\n sum_of_position = 0\\n for element in tupl[3]:\\n sum_of_position += element\\n count +=1\\n aver_pos = sum_of_position/ count\\n scores_per_position += [aver_pos]\\n \\n return scores_per_position\",\n \"def find_avg(centroids, short_cut=False, sim_scores=None):\\n \\n total_sim = 0.0\\n total_comparisons = 0\\n \\n if short_cut:\\n total_comparisons = len(sim_scores)\\n \\n for score in sim_scores:\\n total_sim += score\\n \\n return (total_sim / total_comparisons)\\n\\n length = len(centroids)\\n\\n for i in xrange(0, length):\\n for j in xrange(i + 1, length):\\n total_sim += similarity(centroids[i], centroids[j])\\n total_comparisons += 1\\n\\n return (total_sim / total_comparisons)\",\n \"def cal_hit_gbratio(self):\\n full, top_k = self._subjects, self._top_k\\n top_k = full[full['rank']<=top_k]\\n #print({d['user'].iloc[0]:d['ratings'].to_list() for i,d in top_k.groupby('user')})\\n score = 0.0\\n # golden items hit in the top_K items\\n score_1 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)]) for i,d in top_k.groupby('user')}\\n score_2 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)]) for i,d in top_k.groupby('user')} \\n score_ratio = [(score_1[d]-score_2[d]/self._test_ratings[d]) if self._test_ratings[d]!=0 else 0 for d in self._test_ratings.keys()]\\n\\n #print(np.mean(score_ratio))\\n #print(score_1)\\n #score = score_1 + score_2\\n return np.mean(score_ratio)\",\n \"def print_avg():\",\n \"def avg_rows(rows):\\n if len(rows) == 1:\\n return rows[0]\\n\\n agg_vals = {k: [rows[j][k] for j in range(len(rows))] for k in rows[0].keys()}\\n return {k: (reduce(np.add, v) / len(v)) for k, v in agg_vals.items()}\",\n \"def get_average_MAE(true_pred_df): \\n age_group = true_pred_df.groupby('y_true')\\n \\n mae_average = []\\n for age, age_data in age_group:\\n mae_average.append(np.mean(age_data.mae))\\n \\n return mae_average\",\n \"def lof_sig_scores(table, samples, verbose=True):\\n mut_probdam = 'Missense:Probably'\\n mut_syn = 'Synonymous'\\n mut_trunc = ['Nonsense', 'Frameshift', 'Splice-site']\\n mut_other = ['Missense:Benign', 'Missense:Possibly', 'MissenseNA', 'Indel']\\n mut_all = [mut_probdam, mut_syn] + mut_trunc + mut_other\\n\\n # Calculate the global nonsynonymous:synonymous ratio ---------------------\\n # Within each mutation category, sum counts (across all genes)\\n tot_count_probdam = sum(table[mut_probdam])\\n tot_count_syn = sum(table[mut_syn])\\n tot_count_trunc = sum(itertools.chain(*(list(table[col])\\n for col in mut_trunc)))\\n tot_count_other = sum(itertools.chain(*(list(table[col])\\n for col in mut_other)))\\n\\n # Global mutation count across all categories and genes (= 3504)\\n tot_count_all = sum((tot_count_probdam, tot_count_syn, tot_count_trunc,\\n tot_count_other))\\n if verbose:\\n print(\\\"Counted\\\", tot_count_all, \\\"mutations across\\\", len(table), \\\"genes\\\",\\n \\\"and\\\", len(samples), \\\"samples\\\", file=sys.stderr)\\n\\n # Fraction of global mutations in each category of interest\\n tot_frac_probdam = tot_count_probdam / tot_count_all\\n tot_frac_syn = tot_count_syn / tot_count_all\\n tot_frac_trunc = tot_count_trunc / tot_count_all\\n\\n # Global nonsynonymous:synonymous ratio = (1-syn)/syn (= 2.13697)\\n tot_ns_s_ratio = (1 - tot_frac_syn) / tot_frac_syn\\n\\n # Calculate each gene's mutation score ------------------------------------\\n for _idx, row in table.iterrows():\\n gene_count_all = sum([row[col] for col in mut_all])\\n if not gene_count_all:\\n # Gene is not mutated at all --> zero score\\n yield (row['Gene'], 0.0)\\n continue\\n\\n # Initial score is the sum the 'Normalized' values across all samples\\n raw_score = sum(row[sid] for sid in samples)\\n\\n # Adjust for NS:S ratio\\n gene_count_syn = row[mut_syn]\\n syn_factor = max(1 - tot_ns_s_ratio * gene_count_syn / gene_count_all,\\n 0)\\n new_score = raw_score * syn_factor\\n\\n # Adjust for \\\"probably damaging\\\" missense and truncating mutations\\n gene_frac_probdam = row[mut_probdam] / gene_count_all\\n probdam_factor = 1 + gene_frac_probdam - tot_frac_probdam\\n gene_frac_trunc = sum([row[col] for col in mut_trunc]) / gene_count_all\\n trunc_factor = gene_frac_trunc / tot_frac_trunc\\n final_score = new_score * probdam_factor * trunc_factor\\n yield (row['Gene'], final_score)\",\n \"def average(grade1, grade2, grade3):\\n return (grade1 + grade2 + grade3) / 3\",\n \"def score_game(game_core):\\n \\n att_counter = [] \\n np.random.seed(1) # fix RANDOM SEED so the experiment is reproducible \\n random_array = np.random.randint(1,101, size=(1000))\\n for number in random_array:\\n att_counter.append(game_core(number))\\n score = int(np.mean(att_counter))\\n print(f\\\"Your algorithm guesses on average the number in {score} attempts.\\\")\\n return(score)\",\n \"def get_metrics(cfg, model, X_anchor, y_anchor, X_gal, y_gal, annoy_index, vec_dim):\\n rank10_acc = 0\\n rank5_acc = 0\\n rank1_acc = 0\\n avg_acc = 0\\n vote_res = 0\\n\\n l2 = []\\n for anchor in range(0, len(X_anchor)):\\n res = get_result(get_image_features(cfg, model, X_anchor[anchor]), annoy_index)\\n vote = defaultdict(int)\\n # Accuracy\\n correct = 0\\n for i in res[:10]:\\n vote[y_gal[i]] += 1\\n\\n max_key = max(vote, key=vote.get)\\n if max_key == y_anchor[anchor]:\\n vote_res += 1\\n \\n\\n for recomm in res[:10]:\\n if y_gal[recomm] == y_anchor[anchor]:\\n correct += 1 \\n\\n avg_acc += correct/len(res)\\n\\n # Mean Average Precision\\n l1 = []\\n for recomm in res[:10]:\\n if y_gal[recomm] == y_anchor[anchor]:\\n correct += 1\\n l1.append(1)\\n else:\\n l1.append(0)\\n l2.append(l1) \\n\\n # Rank10 Accuracy\\n for each_val in res[:10]:\\n if y_gal[each_val] == y_anchor[anchor]:\\n rank10_acc += 1\\n break\\n \\n # Rank5 Accuracy\\n for each_val in res[:5]:\\n if y_gal[each_val] == y_anchor[anchor]:\\n rank5_acc += 1\\n break\\n\\n # Rank1 Accuracy\\n for each_val in res[:1]:\\n if y_gal[each_val] == y_anchor[anchor]:\\n rank1_acc += 1\\n break\\n\\n print(\\\"Avg acc is :: {avg_acc}\\\".format(avg_acc = avg_acc/len(X_anchor)))\\n print(\\\"Rank 10 acc is :: {rank10_acc}\\\".format(rank10_acc = rank10_acc/len(X_anchor)))\\n print(\\\"Rank 5 acc is :: {rank5_acc}\\\".format(rank5_acc = rank5_acc/len(X_anchor)))\\n print(\\\"Rank 1 acc is :: {rank1_acc}\\\".format(rank1_acc = rank1_acc/len(X_anchor)))\\n print(\\\"Mean Avg Precision is :: {mAP}\\\".format(mAP=mean_average_precision(l2)))\\n print(\\\"Vote res :: \\\", vote_res/len(X_anchor))\\n\\n return rank1_acc/len(X_anchor), mean_average_precision(l2)\",\n \"def average_match(e, l, ignore_self=False):\\n # filter out ourself as this will give us a nice 1.0 value\\n # the problem with this is if we are a list of 1, anything will have a better value!\\n if ignore_self:\\n l = [x for x in l if x != e]\\n if len(l) == 0:\\n return 0\\n values = [pairwise[e][x] for x in l]\\n return 1.0*sum(values)/len(values)\",\n \"def summaries(e_dict, m_dict):\\n for key, value in m_dict.items():\\n e_dict[key].append(np.mean(value))\\n return e_dict\",\n \"def average_grade(lst):\\r\\n res = []\\r\\n for stdnt in lst:\\r\\n name, avg = stdnt[0], mean(conv_to_num(stdnt[1:]))\\r\\n res.append([name, avg])\\r\\n\\r\\n\\r\\n return(res)\",\n \"def calculate_metric(self, distance_matrix):\\n ap_scores = []\\n for node_id in range(len(distance_matrix)):\\n sorted_nodes = np.argsort(distance_matrix[node_id]).tolist()\\n neighs = self.neighbors[node_id]\\n n_correct = 0.0\\n precisions = []\\n for i in range(1, len(sorted_nodes)):\\n if sorted_nodes[i] in neighs:\\n n_correct += 1\\n precisions.append(n_correct / i)\\n if n_correct == len(neighs):\\n break\\n\\n ap_scores.append(np.mean(precisions))\\n\\n return np.mean(ap_scores)\",\n \"def average_kappa_for_group(db, groupId):\\n documents = db.documents.find({'groupId': groupId})\\n kappas = []\\n for document in documents:\\n if document_has_annotations(db, document['_id']) and document_has_numbers(db, document['_id']):\\n kappas.append(get_kappa_for_document(db, document['_id']))\\n return sum(kappas)/float(len(kappas))\",\n \"def getAvg(self):\\r\\n\\t\\tdata = self.pair.data\\r\\n\\t\\tif data['avg'] == None:\\r\\n\\t\\t\\treturn None\\r\\n\\t\\treturn 1. / self.pair.data['avg']\",\n \"def score_all_genes(self):\\n scores = pd.DataFrame(self.clf.predict_proba(self.dataset), index=self.dataset.index)[1]\\n scores = pd.DataFrame(scores).sort_values(1, ascending=False)\\n scores['known'] = [int(g in list(self.M.befree_genes + self.M.curated_genes + self.M.sven_genes)) for g in scores.index]\\n scores.columns = ['score', 'known']\\n scores.to_csv(self.save_path + '/all_gene_scores.csv')\\n\\n predictions = pd.DataFrame(self.clf.predict(self.dataset), index=self.dataset.index)\\n predictions['known'] = [int(g in list(self.M.befree_genes + self.M.curated_genes + self.M.sven_genes)) for g in predictions.index]\\n predictions.to_csv(self.save_path + '/predictions.csv')\",\n \"def get_gpa(scores):\\n subjects_gpas = []\\n for score in scores:\\n subjects_gpas.append(calculate_gpa(score))\\n gpa = get_average(subjects_gpas)\\n return gpa\",\n \"def get_averages(self):\\t\\n\\t\\t\\n\\t\\taverages = {}\\n\\t\\tfor subject in self.grades.iterkeys():\\n\\t\\t\\taverages[subject] = float(sum(self.grades[subject])) / len(self.grades[subject])\\n\\t\\treturn averages\",\n \"def average_grades(grades):\\r\\n\\r\\n\\tfor key, value in grades.items(): # iterate through the dictionary for key and value\\r\\n\\t\\tgrades[key] = sum(value)/len(value) # average of the value\\r\\n\\r\\n\\treturn (grades) #return grades\\r\",\n \"def avg_by_elem(p):\\n p, num = p\\n avg = map(lambda x:x/num, p)\\n return tuple(avg)\",\n \"def get_mean(self):\\r\\n for i in range(1,len(self.data[0])):\\r\\n self.prom.append(np.mean(self.data[:,i]))\",\n \"def average(X, ebunch):\\n edge_embeds = np.zeros((len(ebunch), len(X[list(X.keys())[0]])))\\n i = 0\\n for edge in ebunch:\\n edge_embeds[i] = (X[str(edge[0])] + X[str(edge[1])]) / 2.0\\n i += 1\\n return edge_embeds\",\n \"def compute_evidence_weighted_aggregated_veracity_score(\\n gold: Dict[Tuple[int, str], Dict],\\n pred: Dict[Tuple[int, str], Dict],\\n elementwise_evidence_f1: Dict[Tuple[int, str], float],\\n elementwise_evidence_f1_corrected: Dict[Tuple[int, str], float],\\n) -> Dict:\\n\\n accuracies_passages: List[float] = []\\n f1_scores_evidence: List[float] = []\\n f1_scores_corrected_evidence: List[float] = []\\n\\n keys: List[Any] = list(gold.keys())\\n\\n for key in keys:\\n gold_sample: Dict = gold[key]\\n pred_sample: Dict = pred[key]\\n\\n gold_passage_label: str = gold_sample['labels']['passage']\\n predicted_passage_label: str = pred_sample['predicted']\\n\\n accuracies_passages.append(get_instance_accuracy(gold_passage_label, predicted_passage_label))\\n f1_scores_evidence.append(elementwise_evidence_f1[key])\\n f1_scores_corrected_evidence.append(elementwise_evidence_f1_corrected[key])\\n\\n return {\\n 'ev_weighted_accuracy': np.mean(np.array(accuracies_passages) * np.array(f1_scores_evidence)),\\n 'ev_weighted_accuracy_corrected': np.mean(\\n np.array(accuracies_passages) * np.array(f1_scores_corrected_evidence)\\n )\\n }\",\n \"def compute_metrics(self):\\n overall_ret = OrderedDict()\\n for ap_iou_thresh in self.ap_iou_thresh:\\n ret_dict = OrderedDict()\\n rec, prec, ap = eval_det_multiprocessing(self.pred_map_cls, self.gt_map_cls, ovthresh=ap_iou_thresh)\\n for key in sorted(ap.keys()):\\n clsname = self.class2type_map[key] if self.class2type_map else str(key)\\n ret_dict[\\\"%s Average Precision\\\" % (clsname)] = ap[key]\\n ap_vals = np.array(list(ap.values()), dtype=np.float32)\\n ap_vals[np.isnan(ap_vals)] = 0\\n ret_dict[\\\"mAP\\\"] = ap_vals.mean()\\n rec_list = []\\n for key in sorted(ap.keys()):\\n clsname = self.class2type_map[key] if self.class2type_map else str(key)\\n try:\\n ret_dict[\\\"%s Recall\\\" % (clsname)] = rec[key][-1]\\n rec_list.append(rec[key][-1])\\n except:\\n ret_dict[\\\"%s Recall\\\" % (clsname)] = 0\\n rec_list.append(0)\\n ret_dict[\\\"AR\\\"] = np.mean(rec_list)\\n overall_ret[ap_iou_thresh] = ret_dict\\n return overall_ret\",\n \"def grade(population, targetSum, targetProduct):\\n summed = reduce (add,(fitness(x, targetSum, targetProduct) for x in population), 0 )\\n return summed / len(population)\",\n \"def geo_mean(num_list):\\n np_array = np.array(num_list)\\n return np_array.prod() ** (1.0 / len(np_array))\",\n \"def mean_average_position():\\n pass\",\n \"def _score_for_model(meta):\\n mean_acc = list()\\n pipes = meta[\\\"pipeline\\\"]\\n acc = meta[\\\"accuracy\\\"]\\n if \\\"tagger\\\" in pipes:\\n mean_acc.append(acc[\\\"tags_acc\\\"])\\n if \\\"morphologizer\\\" in pipes:\\n mean_acc.append((acc[\\\"morphs_acc\\\"] + acc[\\\"pos_acc\\\"]) / 2)\\n if \\\"parser\\\" in pipes:\\n mean_acc.append((acc[\\\"uas\\\"] + acc[\\\"las\\\"]) / 2)\\n if \\\"ner\\\" in pipes:\\n mean_acc.append((acc[\\\"ents_p\\\"] + acc[\\\"ents_r\\\"] + acc[\\\"ents_f\\\"]) / 3)\\n if \\\"textcat\\\" in pipes:\\n mean_acc.append(acc[\\\"textcat_score\\\"])\\n if \\\"senter\\\" in pipes:\\n mean_acc.append((acc[\\\"sent_p\\\"] + acc[\\\"sent_r\\\"] + acc[\\\"sent_f\\\"]) / 3)\\n return sum(mean_acc) / len(mean_acc)\",\n \"def ensemble_mean(self):\\n return self.mean(dim='mem')\",\n \"def calculate_score(self, edge_list):\\n embs = np.array(\\n [[self.emb[source], self.emb[target]] for source, target in edge_list]\\n )\\n\\n if self.proximity_function == \\\"dot\\\":\\n score_list = [\\n np.dot(source_emb, target_emb) for source_emb, target_emb in embs\\n ]\\n elif self.proximity_function == \\\"cos\\\":\\n score_list = cosine_similarity(embs[:, 0], embs[:, 1])\\n\\n return score_list\",\n \"def calculate_transformation_score(self, aggregated, measure):\\n original_data_count = self.data_dict[measure][\\\"distinct_enum\\\"]\\n aggregated_data_count = len(aggregated)\\n score = 1 - aggregated_data_count/original_data_count\\n return score\",\n \"def get_score(location, grid, shape):\",\n \"def compute_each_score(word_embeddings, each_id_pair): # without weighting scheme\\n emb1 = word_embeddings[each_id_pair[0], :]\\n emb2 = word_embeddings[each_id_pair[1], :]\\n inn = np.inner(emb1, emb2)\\n # print('inner product is {}'.format(inn))\\n emb1norm = np.sqrt(np.inner(emb1, emb1))\\n # print('emb1norm is {}'.format(emb1norm))\\n emb2norm = np.sqrt(np.inner(emb2, emb2))\\n # print('emb2norm is {}'.format(emb2norm))\\n each_pair_score = inn / emb1norm / emb2norm\\n # print('each score is {}\\\\n'.format(each_pair_score))\\n return each_pair_score\",\n \"def compute_ensemble(fopen_list, var_list, range_list, indicesOnCluster, maxIndices, indicesToParticle): #{{{\\n\\n rlzn_ensmbl = compute_rlzn_ensemble(fopen_list, var_list, range_list)\\n\\n # average is over 2nd dimension (if it exists), since first is time\\n #ensmbl = compute_cluster_ensemble(rlzn_ensmbl, indicesOnCluster, maxIndices, indicesToParticle)\\n\\n ensmbl = rlzn_ensmbl\\n\\n return ensmbl #}}}\",\n \"def compute_average_separability_score(self) -> Dict:\\n avg_sep_score = {}\\n for class_pair_key, class_pair_val in self.separability_scores.items():\\n avg_sep_score[class_pair_key] = np.mean(np.array([val for _, val in class_pair_val.items()]))\\n avg_sep_score['agg_with_risk'] = sum(\\n np.array([val for _, val in avg_sep_score.items()]) *\\n RISK\\n ) \\n avg_sep_score['agg'] = sum([val for key, val in avg_sep_score.items() if type(key)==int]) \\n return avg_sep_score\",\n \"def load_average(self):\\n return _favg(self.load_samples)\",\n \"def store_overall_means(src_file: H5File) -> None:\\n perp_sum = 0\\n par_sum = 0\\n ref_sum = 0\\n counts = 0\\n for path in rawnav.pump_group_paths(src_file):\\n perp_path = path + '/perp'\\n par_path = path + '/par'\\n ref_path = path + '/ref'\\n perp_sum += src_file[perp_path].attrs['mean']\\n par_sum += src_file[par_path].attrs['mean']\\n ref_sum += src_file[ref_path].attrs['mean']\\n counts += 1\\n src_file.attrs['perp_mean'] = perp_sum / counts\\n src_file.attrs['par_mean'] = par_sum / counts\\n src_file.attrs['ref_mean'] = ref_sum / counts\\n return\",\n \"def _rouge_score_compute(sentence_results: Dict[str, List[Tensor]]) ->Dict[str, Tensor]:\\n results: Dict[str, Tensor] = {}\\n if sentence_results == {}:\\n return results\\n for rouge_key, scores in sentence_results.items():\\n results[rouge_key] = torch.tensor(scores).mean()\\n return results\",\n \"def average(data):\\n return np.average(data)\",\n \"def top_1_avg(model_topic_labels):\\n blog_model_sum = 0\\n book_model_sum = 0\\n news_model_sum = 0\\n pubmed_model_sum = 0\\n blog_gold_sum = 0\\n book_gold_sum = 0\\n news_gold_sum = 0\\n pubmed_gold_sum = 0\\n\\n for topic_id, labels in model_topic_labels.items():\\n top_model_label = labels[0]\\n model_score = gold_topic_labels[topic_id][top_model_label]\\n gold_score = max(gold_topic_labels[topic_id].values())\\n if topic_id < N_blogs:\\n blog_model_sum += model_score\\n blog_gold_sum += gold_score\\n elif topic_id < N_blogs + N_books:\\n book_model_sum += model_score\\n book_gold_sum += gold_score\\n elif topic_id < N_blogs + N_books + N_news:\\n news_model_sum += model_score\\n news_gold_sum += gold_score\\n else:\\n pubmed_model_sum += model_score\\n pubmed_gold_sum += gold_score\\n\\n top1avg_blogs, upper_bound_blogs = blog_model_sum / N_blogs, blog_gold_sum / N_blogs\\n top1avg_books, upper_bound_books = book_model_sum / N_books, book_gold_sum / N_books\\n top1avg_news, upper_bound_news = news_model_sum / N_news, news_gold_sum / N_news\\n top1avg_pubmed, upper_bound_pubmed = pubmed_model_sum / N_pubmed, pubmed_gold_sum / N_pubmed\\n\\n return (top1avg_blogs, upper_bound_blogs, top1avg_books, upper_bound_books, \\\\\\n top1avg_news, upper_bound_news, top1avg_pubmed, upper_bound_pubmed)\",\n \"def residue_pair_energy(self, res1, res2, pose, sf, emap):\\n\\t\\tpose = pose\\n\\t\\temv = EMapVector()\\n\\t\\tsf_pair.eval_ci_2b(res1,res2,pose,emv)\\n\\t\\tweighted_score = -1*(emv[pair]*sec_struct_weight[pose.secstruct()[res1.seqpos()-1]]*sec_struct_weight[pose.secstruct()[res2.seqpos()-1]])\\n\\t\\temap.set(self.scoreType, weighted_score)\",\n \"def _get_mean(self):\\n return (0.485, 0.456, 0.406)\",\n \"def calculate_all_cycle_gan_metrics(nat_a, nat_b, gen_a, gen_b, cyc_a, cyc_b, combined_results=True):\\n score1 = calculate_single_cycle_gan_metrics(gen_a, nat_a) # space A: generated vs. true data\\n score2 = calculate_single_cycle_gan_metrics(gen_b, nat_b) # space B: generated vs. true data\\n score3 = calculate_single_cycle_gan_metrics(cyc_a, nat_a) # space A: cyclic generated vs. true data\\n score4 = calculate_single_cycle_gan_metrics(cyc_b, nat_b) # space B: cyclic generated vs. true data\\n if not combined_results:\\n print(score1)\\n print(score2)\\n print(score3)\\n print(score4)\\n return [score1, score2, score3, score4]\\n # mean_score = [(w + x + y + z) / 4 for w, x, y, z in zip(score1, score2, score3, score4)]\\n mean_score = [(x + y) / 2 for x, y in zip(score1, score2)]\\n return mean_score\",\n \"def average(self):\\n return self.summation() / self.count()\",\n \"def mape(x, y):\\n return statistics.mean(ape(x, y))\",\n \"def avg():\\n\\n # call sum method to add up the values in the collection & div by the num of items\\n # call len method to compute the # of vals in collection which is divided by sum total \\n mean = sum(inlist) / len(inlist)\\n return mean \\n\\n # alternate method would be calling the reduce method with lamda \\n # return reduce(lambda a, b: a + b, inlist) / len(inlist)\",\n \"def avgmu(self):\\n if self._dataframe is DataframeEnum.SkimmedNtuple:\\n return self._event.averageIntPerXing\\n elif self._dataframe is DataframeEnum.PhysVal:\\n return self._event.avgmu\\n else:\\n self._logger.warning(\\\"Impossible to retrieve the value of avgmu. Unknow dataframe.\\\")\",\n \"def mean(xs):\\n ave = 0\\n for xs_split in xs:\\n num = float(xs_split)\\n print(xs_split)\\n ave = ave+num\\n average = ave/len(xs)\\n return average\",\n \"def aver_and_var(self):\\n # assert not self.is_empty\\n\\n for axis in range(3):\\n c1, c2 = self.bounds[axis]\\n w = self.n_pix_partial[axis]\\n aver = np.average(np.arange(c1, c2), weights=w)\\n var = np.average(np.arange(c1, c2)**2, weights=w) - aver ** 2 # D = E(X^2) - (EX)^2\\n yield aver, var\",\n \"def ensembleMethod(tool_list, score_dict, dir, args):\\n\\n chr_list = score_dict[score_dict.keys()[0]].keys()\\n peaks = []\\n scores = []\\n\\n print len(tool_list)\\n for chr in chr_list:\\n print dir\\n print args\\n print chr_list\\n print score_dict\\n #print tool\\n add_peak, add_score = stacking_peaks(dir, args, tool_list, score_dict, chr=chr)\\n\\n for peak in add_peak:\\n peaks.append(peak)\\n\\n for score in add_score:\\n scores.append(score)\\n ensemble.ensembler(peaks, scores, len(tool_list))\\n peaks = []\\n score = []\\n print peaks, scores\\n\\n print len(peaks), len(scores)\",\n \"def _compute_cluster_averages(self, key=\\\"_scvi_labels\\\"):\\n # find cell label column\\n label_col = self.adata.uns[\\\"_scvi\\\"][\\\"categorical_mappings\\\"][key][\\\"original_key\\\"]\\n\\n # find data slot\\n x_dict = self.adata.uns[\\\"_scvi\\\"][\\\"data_registry\\\"][\\\"X\\\"]\\n if x_dict[\\\"attr_name\\\"] == \\\"X\\\":\\n use_raw = False\\n else:\\n use_raw = True\\n if x_dict[\\\"attr_name\\\"] == \\\"layers\\\":\\n layer = x_dict[\\\"attr_key\\\"]\\n else:\\n layer = None\\n\\n # compute mean expression of each gene in each cluster/batch\\n aver = compute_cluster_averages(self.adata, labels=label_col, use_raw=use_raw, layer=layer)\\n\\n return aver\",\n \"def get_average_grade_of_students(students):\\n total_grade = 0\\n for row in students:\\n total_grade += int(row[5])\\n return total_grade/len(students)\",\n \"def _compute_mean(index, M, R, rake):\\r\\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\\r\\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\\r\\n\\r\\n return mean\",\n \"def _compute_mean(index, M, R, rake):\\r\\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\\r\\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\\r\\n\\r\\n return mean\",\n \"def test_avg_grade(self):\\n\\t\\ts = Student_Analytics()\\n\\t\\tself.assertEqual(s.classify_grade(s.avg_grade(3)),\\\"B\\\")\",\n \"def _compute_mean(self, C, mag, rjb, rake):\\n mean = (C['a1'] +\\n self._compute_linear_magnitude_term(C, mag) +\\n self._compute_quadratic_magnitude_term(C, mag) +\\n self._compute_logarithmic_distance_term(C, mag, rjb) +\\n self._compute_faulting_style_term(C, rake))\\n\\n return mean\",\n \"def score_samples(self, X):\\n ...\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6643462","0.6452144","0.62165403","0.6171676","0.60874385","0.60116637","0.5967243","0.59489244","0.5940046","0.5897672","0.5886396","0.5863131","0.584357","0.58260745","0.58122647","0.58121586","0.5747593","0.5738639","0.5724953","0.5721815","0.57199776","0.570864","0.5702405","0.56995976","0.56905186","0.56877804","0.56819993","0.56817514","0.56653893","0.56653893","0.56653893","0.56653893","0.56653893","0.56632483","0.5654815","0.5646385","0.5640165","0.5632765","0.5623213","0.5607792","0.5601835","0.5597576","0.55950534","0.5590095","0.55856407","0.5585531","0.557714","0.55765927","0.55750054","0.55656004","0.55582917","0.55564654","0.55472535","0.554379","0.55346465","0.5533818","0.55287427","0.55086046","0.5504831","0.55041414","0.5499812","0.5495047","0.54948795","0.54927826","0.5485351","0.54783756","0.54725546","0.54702413","0.5467311","0.5457988","0.5443377","0.543837","0.54346925","0.54273576","0.54258513","0.5425638","0.5413414","0.5409738","0.5400351","0.53924626","0.5391411","0.53878754","0.53818554","0.5381808","0.53751934","0.53705645","0.53643835","0.53643507","0.5361814","0.5357494","0.5355651","0.5355132","0.53474903","0.5345478","0.53439474","0.5343529","0.5337021","0.5337021","0.5335716","0.5328702","0.53286165"],"string":"[\n \"0.6643462\",\n \"0.6452144\",\n \"0.62165403\",\n \"0.6171676\",\n \"0.60874385\",\n \"0.60116637\",\n \"0.5967243\",\n \"0.59489244\",\n \"0.5940046\",\n \"0.5897672\",\n \"0.5886396\",\n \"0.5863131\",\n \"0.584357\",\n \"0.58260745\",\n \"0.58122647\",\n \"0.58121586\",\n \"0.5747593\",\n \"0.5738639\",\n \"0.5724953\",\n \"0.5721815\",\n \"0.57199776\",\n \"0.570864\",\n \"0.5702405\",\n \"0.56995976\",\n \"0.56905186\",\n \"0.56877804\",\n \"0.56819993\",\n \"0.56817514\",\n \"0.56653893\",\n \"0.56653893\",\n \"0.56653893\",\n \"0.56653893\",\n \"0.56653893\",\n \"0.56632483\",\n \"0.5654815\",\n \"0.5646385\",\n \"0.5640165\",\n \"0.5632765\",\n \"0.5623213\",\n \"0.5607792\",\n \"0.5601835\",\n \"0.5597576\",\n \"0.55950534\",\n \"0.5590095\",\n \"0.55856407\",\n \"0.5585531\",\n \"0.557714\",\n \"0.55765927\",\n \"0.55750054\",\n \"0.55656004\",\n \"0.55582917\",\n \"0.55564654\",\n \"0.55472535\",\n \"0.554379\",\n \"0.55346465\",\n \"0.5533818\",\n \"0.55287427\",\n \"0.55086046\",\n \"0.5504831\",\n \"0.55041414\",\n \"0.5499812\",\n \"0.5495047\",\n \"0.54948795\",\n \"0.54927826\",\n \"0.5485351\",\n \"0.54783756\",\n \"0.54725546\",\n \"0.54702413\",\n \"0.5467311\",\n \"0.5457988\",\n \"0.5443377\",\n \"0.543837\",\n \"0.54346925\",\n \"0.54273576\",\n \"0.54258513\",\n \"0.5425638\",\n \"0.5413414\",\n \"0.5409738\",\n \"0.5400351\",\n \"0.53924626\",\n \"0.5391411\",\n \"0.53878754\",\n \"0.53818554\",\n \"0.5381808\",\n \"0.53751934\",\n \"0.53705645\",\n \"0.53643835\",\n \"0.53643507\",\n \"0.5361814\",\n \"0.5357494\",\n \"0.5355651\",\n \"0.5355132\",\n \"0.53474903\",\n \"0.5345478\",\n \"0.53439474\",\n \"0.5343529\",\n \"0.5337021\",\n \"0.5337021\",\n \"0.5335716\",\n \"0.5328702\",\n \"0.53286165\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":172,"cells":{"query":{"kind":"string","value":"Determine relevant entries in crkeng.xml and build a smaller xml file for testing."},"document":{"kind":"string","value":"def build_test_xml():\n\n crkeng_file_path = find_latest_xml_file(shared_res_dir / \"dictionaries\")\n\n print(f\"Building test dictionary files using {crkeng_file_path.name}\")\n\n crkeng_root = ET.parse(str(crkeng_file_path)).getroot()\n\n # relevant entries in crkeng.xml file we want to determine\n relevant_xml_ls: Set[str] = set()\n\n xml_ls: Set[str] = set()\n crkeng_entries = crkeng_root.findall(\".//e\")\n for element in crkeng_entries:\n xml_l = extract_l_str(element)\n xml_ls.add(xml_l)\n\n test_words = get_test_words()\n\n print(f\"Analyzing xml l elements and test words\")\n word_to_analyses = morphodict.analysis.relaxed_analyzer().bulk_lookup(\n xml_ls | test_words\n )\n print(\"Analysis done\")\n\n test_word_lemmas: Set[str] = set()\n\n for test_word in test_words:\n for analysis in word_to_analyses[test_word]:\n lemma = fst_analysis_parser.extract_lemma(analysis)\n if lemma is None:\n logger.warn(\n \"Skipping test word: %s. \"\n \"Could not extract lemma from its analysis: %s\",\n test_word,\n analysis,\n )\n continue\n test_word_lemmas.add(lemma)\n\n for xml_l in tqdm(xml_ls, desc=\"screening relevant entries in crkeng.xml\"):\n if xml_l in test_words:\n relevant_xml_ls.add(xml_l)\n continue\n for xml_l_analysis in word_to_analyses[xml_l]:\n xml_lemma = partition_analysis(xml_l_analysis)[1]\n for test_word_lemma in test_word_lemmas:\n if test_word_lemma == xml_lemma:\n relevant_xml_ls.add(xml_l)\n break\n\n relevant_crkeng_entries = []\n\n for element in crkeng_entries:\n xml_l = extract_l_str(element)\n if xml_l in relevant_xml_ls:\n relevant_crkeng_entries.append(element)\n\n crkeng_xml_utils.write_xml_from_elements(\n list(crkeng_root.findall(\".//source\")) + relevant_crkeng_entries,\n shared_res_dir / \"test_dictionaries\" / \"crkeng.xml\",\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 XML_EC_PL(Name, InputsFile, OutputFile, emin,emax):\n\n\t#On commence par afficher ce qu'on fait\r\n\tprint \" Build xml file \"\r\n\r\tprint InputsFile\n\t#ouverture du fichier dans lequel on place le source model\n\ttry:\n\t\tfresult = open(OutputFile, 'w')\n\texcept:\n\t\tprint \"Coucou\"\r\n \t#ecriture des premieres lignes invariantes\n\tfresult.write('<?xml version=\"1.0\" ?>')\r\n\tfresult.write(\"<source_library title=\\\"source library\\\">\\n\")\n\r\n \t#ouverture du fichier avec les entrees\r\n\tf = open(InputsFile,\"r\")\r\n\tlines = f.readlines()\r\n\t\r\n \t#Ajout des sources detectees dans le catalogue\n\t#Pour chaque ligne du fichier d'entree\r\n\tfor line in range(len(lines)):\n\t\t#Lire les donnees de la ligne\t\t\r\n\t\tdata = lines[line].split()\r\n\t\tname = data[0]\n\n\t\t#Verification : est on en train de traiter la source que l'on veut etudier ou une autre ?\r\n\t\tif str(name) == Name :\r\n\t\t\tmysource = 1\r\n\t\telse:\r\n\t\t\tmysource = 0\n\n\t\t#recuperation des donnees\r\n\t\tRA = data[1]\r\n\t\tDEC = data[2]\r\n\t\tIntegral = float(data[3])*float(Frac)\r\n\t\tGamma= data[4]\n\n\t\t\r\n\t\ttry:\n\t\t\t#essai de definition des donnees pour un PL avec ExpCut\n\t\t\tPrefactor = float(data[5])*float(Frac)\r\n\t\t\tEnergy = float(data[6])\r\n\t#\t\tPrefactor = Prefactor/pow(Energy/100., float(Gamma)) #Densite de flux calculee a Epivot\r\n\t#\t\tPrefactor = Prefactor*pow(1000./100., float(Gamma)) #We do the calculation with (E/1000.)^Gamma\n\t\t\tvariabilite=float(data[8])\n\n#\t\t\tprint variabilite\n\n\n\n\r\n\t\t\tcut = float(data[7]) # Cut est la variable qui nous permettra de savoir si il faut utiliser un cut off (1) ou une loi de puissance normale (2)\r\n\t\texcept:\r\n\t\t\ttry:\r\n\t\t\t\tcut = float(data[5])\r\n\t\t\texcept:\r\n\t\t\t\tprint \" Wrong size of list \"\r\n\t\t\t\tsys.exit()\r\n \t#Si on considere un ccut off exponentiel pour la source :\r\n\t\tif cut == 1:\n\t\t\t#ecriture du nom de la source consideree\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\r\n\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\r\n\t\t\tspectrum_type = \"PLSuperExpCutoff\"\n\t\t\t#Utilisation de la modelisation PLSuperExpCutoff car plus simple et plus intuitive pour nous et pour la modelisation des pulsars si il faut en modeliser\n\r\n\t\t\t#definition des parametres spectraux a prendre en comtpe et de la chaine de caractere a integrer\r\n\n\n\n\t\t\tif variabilite==0.0 or variabilite==2.0:\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"10000000.0\\\" min=\\\"0.0000001\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\r\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.001\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\n\r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\t\t\telif variabilite==1.0 :\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10000000.0\\\" min=\\\"0.0\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.0001\\\"\"\r\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\n\r\n \r\n\n# <spectrum type=\"PLSuperExpCutoff\">\n# <parameter free=\"1\" max=\"100000\" min=\"0\" name=\"Prefactor\" scale=\"1e-10\" value=\"Prefactor*1e-10\"/>\n# <parameter free=\"1\" max=\"0\" min=\"5\" name=\"Index1\" scale=\"-1\" value=\"valeur du catalogue\"/>\n# <parameter free=\"0\" max=\"20000\" min=\"1.0\" name=\"Scale\" scale=\"1\" value=\"Epivot\"/>\n# <parameter free=\"1\" max=\"300000\" min=\"100\" name=\"Cutoff\" scale=\"1\" value=\"3000\"/>\n# <parameter free=\"0\" max=\"5\" min=\"0\" name=\"Index2\" scale=\"1\" value=\"1.5\"/>\n# </spectrum>\n\n\r\n\t\telse:\n\t\t#Sinon (si on considere une loi de puissance simple)\n\t\t#definition de la chaine de caractere comportant le nom de la source\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\n\t\t\tif mysource == 0:\r\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\n\t\t\telse:\n\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\t\t\t\t\n\n\t\t\t#definition de la chaine de caractere correspondant a la forme de fit que l'on souhaite utiliser (Loi de puissance)\r\n\t\t\tspectrum_type = \"PowerLaw2\"\r\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre Integrale\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\telse:\n\t\t\t#sinon on le libere\r\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\n\n\n\n\n\n\t\t\t#Toujours ce facteur....\r\n\t\t\tIntegral = float(Integral)*1e10\r\n\t\t\tscale = 1e-10\n\n\n\t\n\r\n\t\t\tspectrum_lines += \" name=\\\"Integral\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre gamma\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\telse:\n\t\t\t\t#si c'est pas la source que l'on etudie on le laisse libre\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\n\n\t\t\t#fin de la chaine de parametres sur le modele spectral\r\n\t\t\tspectrum_lines += \" name=\\\"Index\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t \n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"1000.0\\\"/>\\n\"\r\n \r\n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\t\t\telse:\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"100\\\"/>\\n\"\n\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"100000.0\\\" Min =\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\n \t\t#ajout du modele spectral a la liste de parametres \r\n\t\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\t\tresult_line += spectrum_lines\r\n\t\tresult_line += \" </spectrum>\\n\"\n\n\t\t\n\n\t\tif mysource==0 and variabilite!=1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telif mysource==0 and variabilite==1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telse:\n #ajout du modele spatial a la liste de parametres \n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\t\t\n\t\tresult_line += \" </source>\\n\"\r\n\t\tfresult.write(result_line+\"\\n\")\r\n #Ajout du fond diffus galactique\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"gal_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"ConstantValue\"\r\n\r\n\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Value\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n\r\n\tresult_line += \" <spatialModel file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/gll_iem_v02.fit\\\" type=\\\"MapCubeFunction\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"1000.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Normalization\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\r\n \t#Ajout du fond diffus extragalactique\r\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"eg_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"FileFunction\"\r\n\r\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Normalization\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/isotropic_iem_v02.txt\\\" type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n \r\n\tresult_line += \" <spatialModel type=\\\"ConstantValue\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"100.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Value\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\n \t#Fermeture des fichiers \r\n\tf.close() \r\n\tfresult.write(\"\\n</source_library>\\n\")\r\n\tfresult.close()\r\n\treturn","def create_gen_xml(self, out_file):\n\n param_list = []\n msg = []\n msg_type = []\n dep_node = []\n for line in self.full_ed_lines:\n param_list.append(line.text())\n dep_pkg = param_list[6].split(', ')\n if dep_pkg[len(dep_pkg) - 1] == '':\n dep_pkg.pop()\n for dep in self.manager.wid.sub_list:\n dep_node.append(dep['msg_type'])\n for dep in self.manager.wid.pub_list:\n dep_node.append(dep['msg_type'])\n for dep in dep_node:\n a, b = dep.split('/')\n msg.append(a)\n msg_type.append(b)\n f = open('../genkernel/templates/package_rosgen.xml')\n o = open(out_file, 'a')\n flag = 0\n while 1:\n line = f.readline()\n if not line: break\n for i in range(6):\n line = line.replace('[{0}]'.format(i), param_list[i])\n line = line.replace('[7]', param_list[7])\n if line.find('[6]') != -1:\n for dep in dep_pkg:\n line_dep = '\\t<depend>{0}</depend>\\n'.format(dep)\n o.write(line_dep)\n flag = 1\n elif line.find('[8]') != -1:\n for dep, tp in zip(msg, msg_type):\n line_dep = '\\t\\t<depend type=\"{1}\">{0}</depend>\\n'.format(dep, tp)\n o.write(line_dep)\n flag = 1\n elif line.find('<subscribers>') != -1:\n o.write('\\t\\t<subscribers>\\n')\n for sub in self.manager.wid.sub_list:\n o.write('\\t\\t\\t<sub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(sub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(sub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(sub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(sub['queue_size']))\n o.write('\\t\\t\\t</sub>\\n')\n o.write('\\t\\t</subscribers>\\n')\n flag = 1\n elif line.find('<publishers>') != -1:\n o.write('\\t\\t<publishers>\\n')\n for pub in self.manager.wid.pub_list:\n o.write('\\t\\t\\t<pub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(pub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(pub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(pub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(pub['queue_size']))\n o.write('\\t\\t\\t</pub>\\n')\n o.write('\\t\\t</publishers>\\n')\n flag = 1\n if flag == 0:\n o.write(line)\n else:\n flag = 0\n o.close()\n f.close()\n self.changed = False","def buildxml(self):\n # assume self._objslock is already held here\n logger.info(\"Emane.buildxml()\")\n self.buildplatformxml()\n self.buildnemxml()\n self.buildtransportxml()\n self.buildeventservicexml()","def makexmlfunc(healpix,ra,dec,week1,week2,distance):\n\t\n\tif week1!=week2:\n\t\tidentity=\"%06d_%d_%d_w%03d_w%03d\" %(healpix,ra,dec,week1,week2)\n\t\tltcube=\"%s/lat_ltcube_weekly_w%03d_w%03d_p203_v001.fits\" %(cfg.home,week1,week2)\n\t\tspacecraft=\"%s/w%03d_w%03d_newspacecraft.fits\" %(cfg.ispace,week1,week2)\n\telse:\n\t\tidentity=\"%06d_%d_%d_w%03d\" %(healpix,ra,dec,week1)\n\t\tltcube=\"%s/lat_spacecraft_weekly_w%03d_p203_v001_ltcube.fits\" %(cfg.home,week1)\n\t\tspacecraft=\"%s/lat_spacecraft_weekly_w%03d_p202_v001.fits \" %(cfg.ispace,week1)\n\n\tregion_filtered=\"%s_region_filtered_gti.fits\" %(identity)\n\tfermisources=\"%s_fermisources_model.xml\" %(identity)\n\tinputmodel=\"%s_input_model.xml\" %(identity)\n\tfermis=\"%s_fermis.xml\" %identity\n\tresponse=\"P7REP_SOURCE_V15\"\n\tmakexmllog=\"%s_output_makexml.log\" %identity\n\tglobal extendedsource\n\tglobal numberofextendedsources\n\textendedlog=\"%s_number_of_extendedsources.log\" %identity\n\tExtendedList=\"ExtendedList.txt\"\n\tOthersList=\"OthersList.txt\"\n\n\t\n\twith open (makexmllog,'r') as outputFile: #opens the makexmllog file from makesyfunc. This document contains info about the extended sources.\n\t\t\n\t\tfor line in outputFile:\n\t\t\t\n\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\tif line.startswith('Added')==True:\n\t\t\t\t\ta,b=line.split('and ')\t\n\t\t\t\t\tb1,b2,b3=b.split(' ')\n\t\t\t\t\n\t\t\t\t\tnumberofextendedsources=int(b1) #b1 is the number of extended sources\n\toutputFile.close()\n\toutputFile=open(inputmodel, 'w')\n\tprint numberofextendedsources\n\n\tif numberofextendedsources==1: #if there is an extended source\n\t\twith open (makexmllog,'r') as outputFile:\n\t\t\n\t\t\tfor line in outputFile:\n\t\t\t\n\t\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\t\tif line.startswith('Extended')==True:\n\t\t\t\t\t\tprint line\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\tc,d=line.split(' in')\n\t\t\t\t\t\n\t\t\t\t\t\tc1,c2,c3,c4=c.split(' ')\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\textendedsource=str(c3) #extracts the name of the extended source from makexmllog\n\t\n\n\t\t\n\n\n\t\toutputFile.close()\t\n\n\n\t\n\n\t\twith open(\"%s\" %fermisources) as thefile: #opens the xml file that was created from makesyfunc\n\t\t\tfor line in thefile:\n\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==True:\n\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\tspecial=str.replace(line,'%s.fits'%extendedsource,'%s/%s.fits' %(cfg.homesy,extendedsource)) \n\t\t\t\t\tprint special #replace with the correct path to the extendedsource(Templates folder)\n\t\t\t\n\t\t\t\t\tspecial1=str.replace(special,'type=\"SpatialMap\"','type=\"SpatialMap\" map_based_integral=\"true\"')\n\t\t\t\t\tprint special1 #instruction from fermi tutorial, you must add map_based...\n\t\t\t\t\toutputFile=open(fermis, 'w') #write to fermis, the original xml with the right path to the extended source\n\t\t\t\t\twith open(\"%s\" %fermisources,'r') as infile:\n\t\t\t\t\t\tfor line in infile:\n\t\t\t\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==False:\n\t\t\t\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\toutputFile.write(special1)\n\t\t\t\t\toutputFile.close()\n\t\t\t\t\t\t\t\t\t\n\n\n\t\t\t\n\t\toutputFile=open(inputmodel, 'w') #final xml file. contains the right path and the source info of \"your\" source.\n\t\twith open(fermis,'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\t\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\t\t\t\n\n\t\toutputFile.close()\n\t\n\t\twith open(\"%s_diffrsp.log\" % (identity), 'w') as outsyputFile: #run diffrsp if you have an extended source.\n\t\t\tsubprocess.call(['%s' %(cfg.pythoncommand),'gtdiffrsp.py', '%s' %(region_filtered),'%s' %(spacecraft), '%s' %inputmodel, '%s' %(response),'%s' %identity ],stdout=outsyputFile)\n\t\t\t\n\t\twith open(ExtendedList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\t\t\t\t\n\tif numberofextendedsources==0: #if there is no extended source\n\t\toutputFile=open('%s' %(inputmodel), 'w') #write to inputmodel, \"your\" source\n\t\twith open('%s' %(fermisources),'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\n\t\t\t\n\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\toutputFile.close()\n\tif numberofextendedsources>1:\n\t\twith open(OthersList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\n\tif numberofextendedsources==1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\\n\\\n \t%s\"%(numberofextendedsources,extendedsource))\n\t\toutsyputFile.close()\n\n\tif numberofextendedsources !=1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\" %(numberofextendedsources))\n\t\toutsyputFile.close()","def test_01_FindXml(self):\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\n # sprint(PrettyFormatAny.form(self.m_root_xml, 'A3-01-A - Entire Xml'))\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection', 'XML - No Controllers section')\n # print(PrettyFormatAny.form(self.m_xml.controller_sect, 'A3-01-B - All Controllers Xml'))\n self.assertEqual(self.m_xml.controller.tag, 'Controller', 'XML - No Controller section')\n # print(PrettyFormatAny.form(self.m_xml.controller, 'A3-01-C - First Controller Xml'))","def generate_xml(self, locations):\n\n ET.SubElement(self.root, 'generator').text = __revision__\n ET.SubElement(self.root, 'generated_at').text = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n\n xmlroot = self.root\n kernel = Kerneladapter()\n\n for locname in locations:\n xml_location = ET.SubElement(xmlroot, 'location')\n location = kernel.location_info(locname)\n ET.SubElement(xml_location, \"location\").text = unicode(locname)\n ET.SubElement(xml_location, \"height\").text = unicode(location['height'])\n ET.SubElement(xml_location, \"attributes\").text = unicode(location['attributes'])\n ET.SubElement(xml_location, \"floorlevel\").text = unicode(location['floorlevel'])\n ET.SubElement(xml_location, \"preference\").text = unicode(location['preference'])\n ET.SubElement(xml_location, \"info\").text = unicode(location['info'])\n ET.SubElement(xml_location, \"reserved_for\").text = unicode(location['reserved_for'])\n\n for mui in location['allocated_by']:\n unit = kernel.unit_info(mui)\n xml_unit = ET.SubElement(xml_location, \"unit\")\n ET.SubElement(xml_unit, \"mui\").text = unicode(unit['mui'])\n ET.SubElement(xml_unit, \"quantity\").text = unicode(unit['quantity'])\n ET.SubElement(xml_unit, \"artnr\").text = unicode(unit['product'])\n ET.SubElement(xml_unit, \"height\").text = unicode(unit['height'])\n ET.SubElement(xml_unit, \"pick_quantity\").text = unicode(unit['pick_quantity'])\n ET.SubElement(xml_unit, 'created_at').text = unit['created_at'].strftime('%Y-%m-%d %H:%M:%S')\n ET.SubElement(xml_unit, \"movements\").text = unicode(unit['movements'])\n ET.SubElement(xml_unit, \"picks\").text = unicode(unit['picks'])\n ET.SubElement(xml_unit, \"attributes\").text = unicode(unit['attributes'])\n try:\n product = produktpass.models.Product.objects.get(artnr=unit['product'])\n ET.SubElement(xml_unit, \"product_name\").text = unicode(product.name)\n except produktpass.models.Product.DoesNotExist:\n ET.SubElement(xml_unit, \"product_name\").text = '???'\n\n return xmlroot","def createXML(config, ccdpars, userpars):\n\n # identify the template\n appLab = ccdpars.appLab.value()\n if config.debug:\n print('DEBUG: createXML: application = ' + appLab)\n print('DEBUG: createXML: application vals = ' + str(config.templates[appLab]))\n\n if config.template_from_server:\n # get template from server\n url = config.http_camera_server + config.http_path_get + '?' + \\\n config.http_search_attr_name + '=' + config.templates[appLab]\n if config.debug:\n print ('DEBUG: url = ' + url)\n sxml = urllib2.urlopen(url).read()\n txml = ET.fromstring(sxml)\n else:\n # get template from local file\n if config.debug:\n print ('DEBUG: directory = ' + config.template_directory)\n lfile = os.path.join(config.template_directory, config.templates[appLab]['app'])\n if config.debug:\n print ('DEBUG: local file = ' + lfile)\n tree = ET.parse(lfile)\n txml = tree.getroot()\n\n # Find all CCD parameters\n cconfig = txml.find('configure_camera')\n pdict = {}\n for param in cconfig.findall('set_parameter'):\n pdict[param.attrib['ref']] = param.attrib\n\n # Set them. This is designed so that missing \n # parameters will cause exceptions to be raised.\n\n # X-binning factor\n pdict['X_BIN']['value'] = ccdpars.xbin.get()\n\n # Y-binning factor\n pdict['X_BIN']['value'] = ccdpars.ybin.get()\n\n # Number of exposures\n pdict['NUM_EXPS']['value'] = '-1' if ccdpars.number.value() == 0 else ccdpars.number.get()\n\n # LED level\n pdict['LED_FLSH']['value'] = ccdpars.led.get()\n\n # Avalanche or normal\n pdict['OUTPUT']['value'] = str(ccdpars.avalanche())\n\n # Avalanche gain\n pdict['HV_GAIN']['value'] = ccdpars.avgain.get()\n\n # Clear or not\n pdict['EN_CLR']['value'] = str(ccdpars.clear())\n\n # Dwell\n pdict['DWELL']['value'] = ccdpars.expose.get()\n\n # Readout speed\n pdict['SPEED']['value'] = '0' if ccdpars.readout == 'Slow' else '1' \\\n if ccdpars.readout == 'Medium' else '2'\n\n # Number of windows -- needed to set output parameters correctly\n nwin = ccdpars.nwin.value()\n\n # Load up enabled windows, null disabled windows\n for nw, win in ccdpars.wframe.wins:\n if nw < nwin:\n pdict['X' + str(nw+1) + '_START']['value'] = win.xstart.get()\n pdict['Y' + str(nw+1) + '_START']['value'] = win.ystart.get()\n pdict['X' + str(nw+1) + '_SIZE']['value'] = win.nx.get()\n pdict['Y' + str(nw+1) + '_SIZE']['value'] = win.ny.get()\n else:\n pdict['X' + str(nw+1) + '_START']['value'] = '1'\n pdict['Y' + str(nw+1) + '_START']['value'] = '1'\n pdict['X' + str(nw+1) + '_SIZE']['value'] = '0'\n pdict['Y' + str(nw+1) + '_SIZE']['value'] = '0'\n\n # Load the user parameters\n uconfig = txml.find('user')\n uconfig.set('target', userpars.target.get())\n uconfig.set('comment', userpars.comment.get())\n uconfig.set('ID', userpars.progid.get())\n uconfig.set('PI', userpars.pi.get())\n uconfig.set('Observers', userpars.observers.get())\n \n return txml","def _populate_from_xml_file(self, xml):\n '''\n example from API: http://www.ga.gov.au/www/argus.argus_api.survey?pSurveyNo=921\n\n <?xml version=\"1.0\" ?>\n <ROWSET>\n <ROW>\n <SURVEYID>921</SURVEYID>\n <SURVEYNAME>Goomalling, WA, 1996</SURVEYNAME>\n <STATE>WA</STATE>\n <OPERATOR>Stockdale Prospecting Ltd.</OPERATOR>\n <CONTRACTOR>Kevron Geophysics Pty Ltd</CONTRACTOR>\n <PROCESSOR>Kevron Geophysics Pty Ltd</PROCESSOR>\n <SURVEY_TYPE>Detailed</SURVEY_TYPE>\n <DATATYPES>MAG,RAL,ELE</DATATYPES>\n <VESSEL>Aero Commander</VESSEL>\n <VESSEL_TYPE>Plane</VESSEL_TYPE>\n <RELEASEDATE/>\n <ONSHORE_OFFSHORE>Onshore</ONSHORE_OFFSHORE>\n <STARTDATE>05-DEC-96</STARTDATE>\n <ENDDATE>22-DEC-96</ENDDATE>\n <WLONG>116.366662</WLONG>\n <ELONG>117.749996</ELONG>\n <SLAT>-31.483336</SLAT>\n <NLAT>-30.566668</NLAT>\n <LINE_KM>35665</LINE_KM>\n <TOTAL_KM/>\n <LINE_SPACING>250</LINE_SPACING>\n <LINE_DIRECTION>180</LINE_DIRECTION>\n <TIE_SPACING/>\n <SQUARE_KM/>\n <CRYSTAL_VOLUME>33.6</CRYSTAL_VOLUME>\n <UP_CRYSTAL_VOLUME>4.2</UP_CRYSTAL_VOLUME>\n <DIGITAL_DATA>MAG,RAL,ELE</DIGITAL_DATA>\n <GEODETIC_DATUM>WGS84</GEODETIC_DATUM>\n <ASL/>\n <AGL>60</AGL>\n <MAG_INSTRUMENT>Scintrex CS2</MAG_INSTRUMENT>\n <RAD_INSTRUMENT>Exploranium GR820</RAD_INSTRUMENT>\n </ROW>\n </ROWSET>\n '''\n # turn the XML doc into a Python object\n root = objectify.fromstring(xml)\n\n if hasattr(root.ROW, 'SURVEYNAME'):\n self.survey_name = root.ROW.SURVEYNAME\n if hasattr(root.ROW, 'STATE'):\n self.state = root.ROW.STATE\n if hasattr(root.ROW, 'OPERATOR'):\n self.operator = root.ROW.OPERATOR\n if hasattr(root.ROW, 'CONTRACTOR'):\n self.contractor = root.ROW.CONTRACTOR\n if hasattr(root.ROW, 'PROCESSOR'):\n self.processor = root.ROW.PROCESSOR\n if hasattr(root.ROW, 'SURVEY_TYPE'):\n self.survey_type = root.ROW.SURVEY_TYPE\n if hasattr(root.ROW, 'DATATYPES'):\n self.data_types = root.ROW.DATATYPES\n if hasattr(root.ROW, 'VESSEL'):\n self.vessel = root.ROW.VESSEL\n if hasattr(root.ROW, 'VESSEL_TYPE'):\n self.vessel_type = root.ROW.VESSEL_TYPE\n if hasattr(root.ROW, 'RELEASEDATE'):\n self.release_date = datetime.strptime(root.ROW.RELEASEDATE.text, \"%Y-%m-%dT%H:%M:%S\") if root.ROW.RELEASEDATE.text is not None else None\n if hasattr(root.ROW, 'ONSHORE_OFFSHORE'):\n self.onshore_offshore = root.ROW.ONSHORE_OFFSHORE\n if hasattr(root.ROW, 'STARTDATE'):\n self.start_date = datetime.strptime(root.ROW.STARTDATE.text, \"%Y-%m-%dT%H:%M:%S\") if root.ROW.STARTDATE.text is not None else None\n if hasattr(root.ROW, 'ENDDATE'):\n self.end_date = datetime.strptime(root.ROW.ENDDATE.text, \"%Y-%m-%dT%H:%M:%S\") if root.ROW.ENDDATE.text is not None else None\n if hasattr(root.ROW, 'WLONG'):\n self.w_long = root.ROW.WLONG\n if hasattr(root.ROW, 'ELONG'):\n self.e_long = root.ROW.ELONG\n if hasattr(root.ROW, 'SLAT'):\n self.s_lat = root.ROW.SLAT\n if hasattr(root.ROW, 'NLAT'):\n self.n_lat = root.ROW.NLAT\n if hasattr(root.ROW, 'LINE_KM'):\n self.line_km = root.ROW.LINE_KM\n if hasattr(root.ROW, 'TOTAL_KM'):\n self.total_km = root.ROW.TOTAL_KM\n if hasattr(root.ROW, 'LINE_SPACING'):\n self.line_spacing = root.ROW.LINE_SPACING\n if hasattr(root.ROW, 'LINE_DIRECTION'):\n self.line_direction = root.ROW.LINE_DIRECTION\n if hasattr(root.ROW, 'TIE_SPACING'):\n self.tie_spacing = root.ROW.TIE_SPACING\n if hasattr(root.ROW, 'SQUARE_KM'):\n self.square_km = root.ROW.SQUARE_KM\n if hasattr(root.ROW, 'CRYSTAL_VOLUME'):\n self.crystal_volume = root.ROW.CRYSTAL_VOLUME\n if hasattr(root.ROW, 'UP_CRYSTAL_VOLUME'):\n self.up_crystal_volume = root.ROW.UP_CRYSTAL_VOLUME\n if hasattr(root.ROW, 'DIGITAL_DATA'):\n self.digital_data = root.ROW.DIGITAL_DATA\n if hasattr(root.ROW, 'GEODETIC_DATUM'):\n self.geodetic_datum = root.ROW.GEODETIC_DATUM\n if hasattr(root.ROW, 'ASL'):\n self.asl = root.ROW.ASL\n if hasattr(root.ROW, 'AGL'):\n self.agl = root.ROW.AGL\n if hasattr(root.ROW, 'MAG_INSTRUMENT'):\n self.mag_instrument = root.ROW.MAG_INSTRUMENT\n if hasattr(root.ROW, 'RAD_INSTRUMENT'):\n self.rad_instrument = root.ROW.RAD_INSTRUMENT","def test_pep8_conformance_pygccxml(self):\n\n print(\"\\r\\n\")\n\n # Get the path to current directory\n path = os.path.dirname(os.path.realpath(__file__))\n path += \"/../pygccxml/\"\n\n self.run_check(path)","def wrez2xml(self,newdoc,newroot):\n\t\twrez = newdoc.createElement('wrez')\n\t\twrez.setAttribute('hasChanged', str(self.hasChanged))\n\t\tnewroot.appendChild(wrez)\n\n\t\tpath = newdoc.createElement('path')\n\t\tpath.setAttribute('value', self.path)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('init_str')\n\t\tpath.setAttribute('value', self.init_str)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('hash_sha512')\n\t\tpath.setAttribute('value', self.hash_sha512)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('src_rip')\n\t\tpath.setAttribute('value', self.src_rip)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('quality')\n\t\tpath.setAttribute('value', self.quality)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('codec')\n\t\tpath.setAttribute('value', self.codec)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('language')\n\t\tpath.setAttribute('value', self.language)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('audio')\n\t\tpath.setAttribute('value', self.audio)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('encoder')\n\t\tpath.setAttribute('value', self.encoder)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('version')\n\t\tpath.setAttribute('value', self.version)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('extension')\n\t\tpath.setAttribute('value', self.extension)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('release_year')\n\t\tpath.setAttribute('value', self.release_year)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('title')\n\t\tpath.setAttribute('value', self.title)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('size')\n\t\tpath.setAttribute('value', str(self.size))\n\t\twrez.appendChild(path)\n\t\treturn wrez","def test_01_FindXml(self):\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection', 'XML - No Controllers section')\n self.assertEqual(self.m_xml.controller.tag, 'Controller', 'XML - No Controller section')","def evaluate(self, xml_gold_path, xml_output_path):\n\n # Go through all files in xml_gold_path directory\n for file in os.listdir(xml_gold_path):\n\n # Set path to file\n file = xml_gold_path+file\n\n # Open files only, ignore subdirectories\n if os.path.isfile(file) and file.lower().endswith('.xml'):\n\n # Open xml files\n chapter_input_gold = open(file, 'r', encoding='utf8')\n chapter_input_test = open(xml_output_path+os.path.split(file)[-1], 'r', encoding='utf8')\n\n # Check if filenams are the same\n chapter_input_gold_name = os.path.split(chapter_input_gold.name)[-1]\n chapter_input_test_name = os.path.split(chapter_input_test.name)[-1]\n\n if chapter_input_gold_name == chapter_input_test_name:\n\n # Console log\n chapter_input_gold_name = chapter_input_gold.name\n chapter_input_test_name = chapter_input_test.name\n #print('Calculating score for: ' + chapter_input_gold_name + ' and: ' + chapter_input_test_name)\n\n # Process xml input file with BeautifulSoup\n chapter_input_gold = BeautifulSoup(chapter_input_gold, 'xml')\n chapter_input_test = BeautifulSoup(chapter_input_test, 'xml')\n\n # Empty variables for collecting Target scores\n target_precision_scores = 0\n target_recall_scores = 0\n target_f1_scores = 0\n target_jaccard_scores = 0\n\n # Empty variables for collecting Focus scores\n focus_precision_scores = 0\n focus_recall_scores = 0\n focus_f1_scores = 0\n focus_jaccard_scores = 0\n\n # Empty variables for collecting Negated scores\n negated_precision_scores = 0\n negated_recall_scores = 0\n negated_f1_scores = 0\n negated_jaccard_scores = 0\n\n # Empty variables for collecting Scope scores\n scope_precision_scores = 0\n scope_recall_scores = 0\n scope_f1_scores = 0\n scope_jaccard_scores = 0\n\n # Count sentences and frames\n sentence_count = 0\n gold_frames_count = 0\n test_frames_count = 0\n\n scope_gold_frames_count = 0\n #scope_test_frames_count = 0\n\n # Find all Gold and Test Sentences\n sentences_gold = chapter_input_gold.find_all('s')\n sentences_test = chapter_input_test.find_all('s')\n\n #targets_gold = chapter_input_gold.find_all('target')\n #targets_test = chapter_input_test.find_all('target')\n\n scope_gold_frames = chapter_input_gold.find_all('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_frames_count = len(scope_gold_frames)\n\n scope_test_frames = chapter_input_test.find_all('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_frames_count = len(scope_test_frames)\n\n # Exit if number of sentences != between Gold and Test files\n if len(sentences_gold) != len(sentences_test):\n raise SystemExit(print('Number of sentences between Gold and Test files does not match.\\nGold:',\n len(sentences_gold), 'Test:', len(sentences_test)))\n\n # Zip Gold and Test Sentences\n for s_gold, s_test in zip(sentences_gold, sentences_test):\n\n sentence_count = sentence_count + 1\n\n gold_frames = s_gold.find_all('frame', {'name' : NEGATION_FRAME_NAME})\n test_frames = s_test.find_all('frame', {'name' : NEGATION_FRAME_NAME})\n\n gold_frames_count = gold_frames_count + len(gold_frames)\n test_frames_count = test_frames_count + len(test_frames)\n\n for item in zip(gold_frames, test_frames):\n\n #print('\\n=========')\n #print('\\nFrame:', item[0].get('id'))\n\n target_gold_list = []\n target_test_list = []\n\n focus_gold_list = []\n focus_test_list = []\n\n negated_gold_list = []\n negated_test_list = []\n\n scope_gold_list = []\n scope_test_list = []\n\n # Flatten a nested list of fenodes\n def flatten(nested_list):\n \"\"\" Flatten a nested list of fenodes \"\"\"\n t_l = []\n for i in nested_list:\n if not isinstance(i, list):\n t_l.append(i)\n else:\n t_l.extend(flatten(i))\n return t_l\n\n # Target\n if item[0].find('target'):\n target_gold = item[0].find('target')\n target_gold_fenode_id = target_gold.find('fenode').get('idref')\n target_gold_word = s_gold.find(id=target_gold_fenode_id).get('word').lower()\n\n try:\n target_test = item[1].find('target')\n target_test_fenode__id = target_test.find('fenode').get('idref')\n target_test_word = s_test.find(id=target_test_fenode__id).get('word').lower()\n except:\n target_test_word = ''\n\n elif item[1].find('target'):\n target_test = item[1].find('target')\n target_test_fenode__id = target_test.find('fenode').get('idref')\n target_test_word = s_test.find(id=target_test_fenode__id).get('word').lower()\n\n try:\n target_gold = item[0].find('target')\n target_gold_fenode_id = target_gold.find('fenode').get('idref')\n target_gold_word = s_gold.find(id=target_gold_fenode_id).get('word').lower()\n except:\n target_gold_word = ''\n\n target_gold_list.append(target_gold_word)\n target_test_list.append(target_test_word)\n\n # Sort lists\n sorted_target_gold_list = sorted(flatten(target_gold_list))\n sorted_target_test_list = sorted(flatten(target_test_list))\n\n #print('\\nTarget [Gold]:', sorted_target_gold_list)\n #print('Target [Test]:', sorted_target_test_list)\n\n\n # Focus\n if item[0].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_gold = item[0].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_gold_fenode_id = focus_gold.find('fenode').get('idref')\n focus_gold_word = s_gold.find(id=focus_gold_fenode_id).get('word').lower()\n except:\n focus_gold_word = ''\n if item[1].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_test = item[1].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_test_fenode_id = focus_test.find('fenode').get('idref')\n focus_test_word = s_test.find(id=focus_test_fenode_id).get('word').lower()\n except:\n focus_test_word = ''\n else:\n focus_test_word = ''\n\n elif item[1].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_test = item[1].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_test_fenode_id = focus_test.find('fenode').get('idref')\n focus_test_word = s_test.find(id=focus_test_fenode_id).get('word').lower()\n except:\n focus_test_word = ''\n if item[0].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_gold = item[0].find('fe', {'name' : FOCUS_TAG_NAME})\n focus_gold_fenode_id = focus_gold.find('fenode').get('idref')\n try:\n focus_gold_word = s_gold.find(id=focus_gold_fenode_id).get('word').lower()\n except AttributeError:\n focus_gold_word = ''\n else:\n focus_gold_word = ''\n\n focus_gold_list.append(focus_gold_word)\n focus_test_list.append(focus_test_word)\n\n # Sort lists\n sorted_focus_gold_list = sorted(flatten(focus_gold_list))\n sorted_focus_test_list = sorted(flatten(focus_test_list))\n\n #print('\\nFocus [Gold]:', sorted_focus_gold_list)\n #print('Focus [Test]:', sorted_focus_test_list)\n\n\n # Negated\n if item[0].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_gold = item[0].find('fe', {'name' : NEGATED_TAG_NAME})\n negated_gold_fenode_id = negated_gold.find('fenode').get('idref')\n try:\n negated_gold_word = s_gold.find(id=negated_gold_fenode_id).get('word').lower()\n except AttributeError:\n negated_gold_word = ''\n if item[1].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_test = item[1].find('fe', {'name' : NEGATED_TAG_NAME})\n try:\n negated_test_fenode_id = negated_test.find('fenode').get('idref')\n negated_test_word = s_test.find(id=negated_test_fenode_id).get('word').lower()\n except:\n negated_test_word = ''\n else:\n negated_test_word = ''\n\n elif item[1].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_test = item[1].find('fe', {'name' : NEGATED_TAG_NAME})\n try:\n negated_test_fenode_id = negated_test.find('fenode').get('idref')\n negated_test_word = s_test.find(id=negated_test_fenode_id).get('word').lower()\n except:\n negated_test_word = ''\n if item[0].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_gold = item[0].find('fe', {'name' : NEGATED_TAG_NAME})\n negated_gold_fenode_id = negated_gold.find('fenode').get('idref')\n try:\n negated_gold_word = s_gold.find(id=negated_gold_fenode_id).get('word').lower()\n except AttributeError:\n negated_gold_word = ''\n else:\n negated_gold_word = ''\n else:\n negated_test_word = ''\n negated_gold_word = ''\n\n negated_gold_list.append(negated_gold_word)\n negated_test_list.append(negated_test_word)\n\n # Sort lists\n sorted_negated_gold_list = sorted(flatten(negated_gold_list))\n sorted_negated_test_list = sorted(flatten(negated_test_list))\n\n #print('\\nNegated [Gold]:', sorted_negated_gold_list)\n #print('Negated [Test]:', sorted_negated_test_list)\n\n\n # Resolve Terminals if Scope on a complex graph\n def resolve_non_terminals(idref):\n \"\"\" This function resolves a complex gold graph to\n a simple flat list of tokens.\n \"\"\"\n nonterminal = s_gold.find(id=idref)\n edges = nonterminal.find_all('edge')\n edge_words = []\n for edge in edges:\n e_id = edge.get('idref')\n if s_gold.find(id=e_id).get('word') is not None:\n try:\n edge_word = s_gold.find(id=e_id).get('word').lower()\n edge_words.append(edge_word)\n except:\n pass\n if s_gold.find(id=e_id).get('word') is None:\n edge_words.append(resolve_non_terminals(e_id))\n\n return edge_words\n\n def resolve_non_terminals_test(idref):\n \"\"\" This function resolves a complex test graph to\n a simple flat list of tokens.\n \"\"\"\n nonterminal = s_test.find(id=idref)\n edges = nonterminal.find_all('edge')\n edge_words = []\n for edge in edges:\n e_id = edge.get('idref')\n if s_test.find(id=e_id).get('word') is not None:\n try:\n edge_word = s_test.find(id=e_id).get('word').lower()\n edge_words.append(edge_word)\n except:\n pass\n if s_test.find(id=e_id).get('word') is None:\n edge_words.append(resolve_non_terminals(e_id))\n\n return edge_words\n\n # Scope\n if item[0].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_gold = item[0].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_fenodes = scope_gold.find_all('fenode')\n for s_g in scope_gold_fenodes:\n s_id = s_g.get('idref')\n if s_gold.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_gold.find(id=s_id).get('word').lower()\n scope_gold_list.append(scope_word)\n except:\n pass\n if s_gold.find(id=s_id).get('word') is None:\n scope_gold_list.append(resolve_non_terminals(s_id))\n else:\n pass\n\n if item[1].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_test = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_fenodes = scope_test.find_all('fenode')\n for s_t in scope_test_fenodes:\n s_id = s_t.get('idref')\n if s_test.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_test.find(id=s_id).get('word').lower()\n scope_test_list.append(scope_word)\n except:\n pass\n elif s_test.find(id=s_id).get('word') is None:\n scope_test_list.append(resolve_non_terminals_test(s_id))\n else:\n scope_test_list.append('')\n\n elif item[1].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_test = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_fenodes = scope_test.find_all('fenode')\n for s_t in scope_test_fenodes:\n s_id = s_t.get('idref')\n if s_test.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_test.find(id=s_id).get('word').lower()\n scope_test_list.append(scope_word)\n except:\n pass\n if s_test.find(id=s_id).get('word') is None:\n scope_test_list.append(resolve_non_terminals_test(s_id))\n else:\n pass\n\n if item[0].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_gold = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_fenodes = scope_gold.find_all('fenode')\n for s_g in scope_gold_fenodes:\n s_id = s_g.get('idref')\n if s_gold.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_gold.find(id=s_id).get('word').lower()\n scope_gold_list.append(scope_word)\n except:\n pass\n if s_gold.find(id=s_id).get('word') is None:\n scope_gold_list.append(resolve_non_terminals(s_id))\n else:\n pass\n else:\n scope_gold_list.append('')\n\n # Sort lists\n sorted_scope_gold_list = sorted(flatten(scope_gold_list))\n sorted_scope_test_list = sorted(flatten(scope_test_list))\n\n #print('\\nScope [Gold]:', sorted_scope_gold_list)\n #print('Scope [Test]:', sorted_scope_test_list)\n\n # If lists are same length, check if items are same\n if len(sorted_scope_gold_list) == len(sorted_scope_test_list):\n sorted_scope_test_list_intersection = set(sorted_scope_gold_list).intersection(sorted_scope_test_list)\n sorted_scope_test_list_intersection = list(sorted_scope_test_list_intersection)\n if len(sorted_scope_test_list_intersection) < len(sorted_scope_test_list):\n difference = len(sorted_scope_test_list) - len(sorted_scope_test_list_intersection)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_test_list_intersection.append('')\n empty_element = empty_element + 1\n \n sorted_scope_test_list = sorted_scope_test_list_intersection\n\n # If lists are different lengths, add empty elements\n elif len(sorted_scope_gold_list) > len(sorted_scope_test_list):\n difference = len(sorted_scope_gold_list) - len(sorted_scope_test_list)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_test_list.append('')\n empty_element = empty_element + 1\n\n elif len(sorted_scope_test_list) > len(sorted_scope_gold_list):\n difference = len(sorted_scope_test_list) - len(sorted_scope_gold_list)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_gold_list.append('')\n empty_element = empty_element + 1\n\n\n # Align items in the lists for sklearn, set 1 for matched items, else set 0\n sorted_target_gold_list_normalized = [1 if element in sorted_target_gold_list and not element == \"\" else 0 for element in sorted_target_gold_list]\n sorted_target_test_list_normalized = [1 if element in sorted_target_gold_list else 0 for element in sorted_target_test_list]\n\n sorted_focus_gold_list_normalized = [1 if element in sorted_focus_gold_list and not element == \"\" else 0 for element in sorted_focus_gold_list]\n sorted_focus_test_list_normalized = [1 if element in sorted_focus_gold_list else 0 for element in sorted_focus_test_list]\n\n sorted_negated_gold_list_normalized = [1 if element in sorted_negated_gold_list and not element == \"\" else 0 for element in sorted_negated_gold_list]\n sorted_negated_test_list_normalized = [1 if element in sorted_negated_gold_list else 0 for element in sorted_negated_test_list]\n\n sorted_scope_gold_list_normalized = [1 if element in sorted_scope_gold_list and not element == \"\" else 0 for element in sorted_scope_gold_list]\n sorted_scope_test_list_normalized = [1 if element in sorted_scope_gold_list else 1 if not element == \"\" else 0 for element in sorted_scope_test_list]\n\n #print(sorted_scope_gold_list_normalized)\n #print(sorted_scope_test_list_normalized)\n\n\n # Sklearn calculations\n #target_precision_scores = target_precision_scores + precision_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n #target_recall_scores = target_recall_scores + recall_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n target_f1_scores = target_f1_scores + f1_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n #target_jaccard_scores = target_jaccard_scores + jaccard_similarity_score(sorted_target_gold_list, sorted_target_test_list)\n\n #focus_precision_scores = focus_precision_scores + precision_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n #focus_recall_scores = focus_recall_scores + recall_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n focus_f1_scores = focus_f1_scores + f1_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n #focus_jaccard_scores = focus_jaccard_scores + jaccard_similarity_score(sorted_focus_gold_list, sorted_focus_test_list)\n\n #negated_precision_scores = negated_precision_scores + precision_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n #negated_recall_scores = negated_recall_scores + recall_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n negated_f1_scores = negated_f1_scores + f1_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n #negated_jaccard_scores = negated_jaccard_scores + jaccard_similarity_score(sorted_negated_gold_list, sorted_negated_test_list)\n\n scope_precision_scores = scope_precision_scores + precision_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_recall_scores = scope_recall_scores + recall_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_f1_scores = scope_f1_scores + f1_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_jaccard_scores = scope_jaccard_scores + jaccard_similarity_score(sorted_scope_gold_list, sorted_scope_test_list)\n\n\n print('\\n=============================')\n print('====== EVALUATION for:', chapter_input_test_name, '======')\n print('Total Sentences:', sentence_count,\n '\\nNegation Gold frames:', gold_frames_count,\n '\\nNegation Test frames:', test_frames_count, '\\n')\n\n print('----- CUEWORDS -----')\n #print('Precision:\\t', target_precision_scores / gold_frames_count)\n #print('Recall:\\t', target_recall_scores / gold_frames_count)\n print('F1 score:\\t', target_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', target_jaccard_scores / gold_frames_count)\n\n print('\\n----- FOCUS -----')\n #print('Precision:\\t', focus_precision_scores / gold_frames_count)\n #print('Recall:\\t', focus_recall_scores / gold_frames_count)\n print('F1 score:\\t', focus_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', focus_jaccard_scores / gold_frames_count)\n\n print('\\n----- NEGATED -----')\n #print('Precision:\\t', negated_precision_scores / gold_frames_count)\n #print('Recall:\\t', negated_recall_scores / gold_frames_count)\n print('F1 score:\\t', negated_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', negated_jaccard_scores / gold_frames_count)\n\n print('\\n----- SCOPE -----\\nScope Gold frames:', scope_gold_frames_count, '\\nScope Test frames:', scope_test_frames_count, '\\n')\n print('Precision:\\t', scope_precision_scores / scope_test_frames_count)\n print('Recall:\\t', scope_recall_scores / scope_test_frames_count)\n print('F1 score:\\t', scope_f1_scores / scope_test_frames_count)\n print('Jaccard similarity:\\t', scope_jaccard_scores / scope_test_frames_count)\n\n print('Done!')","def build(filename=\"JMdict_e.gz\", output_filename=DATABASE_FILENAME):\n # NOTE: The JMdict XML file contains XML entities, that are expanded when\n # parsed using Python's stdlib xml.etree.ElementTree like so:\n # ElementTree.parse(f). That is undesired behavior for our use-case. Oshi\n # needs to parse the short entity string, for example &adj-i; should be\n # \"adj-i\" instead of \"adjective (keiyoushi)\". That's why it uses an external\n # xml parser: lxml that allows you to specify whether to expand entites.\n extension = path.splitext(filename)[1].lower()\n parser = etree.XMLParser(resolve_entities=False)\n if extension == \".gz\":\n with gzip.open(filename) as f:\n tree = etree.parse(f, parser)\n elif extension == \".xml\":\n tree = etree.parse(filename, parser)\n else:\n raise ValueError(\"File extension not supported: \" + extension)\n\n entries = []\n # variables starting with x contain xml element(s)\n for xentry in tree.getroot():\n entry = {}\n entry[\"writings\"] = [x.find('keb').text for x in xentry.findall('k_ele')]\n entry[\"readings\"] = [x.find('reb').text for x in xentry.findall('r_ele')]\n xsenses = xentry.findall('sense')\n senses = []\n # last_tags will contain a reference to previously found tags (JMdict\n # specifies that when pos is empty, the previous one should be used)\n last_tags = []\n for xsense in xsenses:\n tags = []\n xtags = xsense.findall('pos') # + xsense.findall('misc')\n for xtag in xtags:\n match = re.search(r'&([\\w-]+?);', etree.tostring(xtag, encoding=\"utf-8\").decode('utf-8') or \"\")\n if match: tags.append(match.group(1))\n glosses = [x.text for x in xsense.findall('gloss')]\n senses.append({\"glosses\": glosses, \"tags\": tags or last_tags})\n last_tags = tags or last_tags\n entry[\"senses\"] = senses\n entries.append(entry)\n with open(output_filename, 'w', encoding='utf-8') as f:\n json.dump(entries, f, ensure_ascii=False)","def creation_srcmdl(dir_cat,SourceRA,SourceDec,SourceROI,distmin,name,outputfile,emin,emax):\n\tf_liste_sour=\"a.txt\"\n\n\tlect_ca(dir_cat,SourceRA,SourceDec,SourceROI,distmin,name,f_liste_sour,name)\n\tXML_EC_PL(name, f_liste_sour, outputfile, emin,emax)\n\tos.system(\"rm -rf a.txt\")","def test_write(self):\n cases = {\n self.test_eac + \"NE00401.xml\": True,\n self.test_eac + \"NE01501.xml\": False,\n self.test_eac + \"NE01302.xml\": True,\n }\n metadata_url = 'http://www.example.com/metadata.xml'\n presentation_url = 'http://www.example.com/presentation.html'\n for case in cases:\n doc = EacCpf.EacCpf(case, metadata_url, presentation_url)\n self.assertNotEqual(doc, None)\n path = doc.write(self.temp)\n self.assertEquals(os.path.exists(path), True)\n # read the file and try to extract the attributes\n try:\n tree = etree.parse(path)\n ns = {\n EacCpf.DOC_KEY: EacCpf.DOC_NS,\n EacCpf.ESRC_KEY: EacCpf.ESRC_NS,\n }\n # get the url to the metadata file\n metadata = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":metadata\", namespaces=ns)\n self.assertNotEqual(metadata, None)\n self.assertEqual(metadata[0], metadata_url)\n # get the url to the presentation file\n presentation = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":presentation\", namespaces=ns)\n self.assertNotEqual(presentation, None)\n self.assertEqual(presentation[0], presentation_url)\n # get the url to the source file\n source = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":source\", namespaces=ns)\n self.assertNotEqual(source, None)\n self.assertEqual(source[0], case)\n except:\n msg = \"Failed to complete parsing of {0}\".format(case)\n self.log.error(msg, exc_info=True)\n self.fail(msg)","def test_xml_from_file(self):\n j2k = Jp2k(self.j2kfile)\n\n self.jp2h.box = [self.ihdr, self.colr]\n\n xmlb = glymur.jp2box.XMLBox(filename=self.xmlfile)\n boxes = [self.jp2b, self.ftyp, self.jp2h, xmlb, self.jp2c]\n with tempfile.NamedTemporaryFile(suffix=\".jp2\") as tfile:\n j2k.wrap(tfile.name, boxes=boxes)\n jp2 = Jp2k(tfile.name)\n\n output_boxes = [box.box_id for box in jp2.box]\n self.assertEqual(output_boxes, ['jP ', 'ftyp', 'jp2h', 'xml ',\n 'jp2c'])\n\n elts = jp2.box[3].xml.findall('country')\n self.assertEqual(len(elts), 3)\n\n neighbor = elts[1].find('neighbor')\n self.assertEqual(neighbor.attrib['name'], 'Malaysia')\n self.assertEqual(neighbor.attrib['direction'], 'N')","def test_non_regression(self):\n main(\"Source_mobile.xml\", [[\"engine\", \"A320.xml\", \"A320.csv\"]], \"Resultat.xml\", gui=False)\n compare_xml_results(\"Resultat.xml\", \"Reference.xml\", self)","def configureGeoData(data,resultDir):\n xmlfiles = findfiles(['*.xml'],where=data[\"folder\"])\n xmlurls=[]\n fgdclist=[]\n #xmlselect=[]\n for xml in xmlfiles:\n shutil.copy(os.path.join(data['folder'],xml),resultDir)\n xmlurls.append(os.path.join(resulturl,resultDir.split('/')[-1],xml))\n #import xmltodict\n localfilename=os.path.join(data['folder'],xml)\n #xmlselect.append({\"file\":localfilename,\"url\":os.path.join(resulturl,resultDir.split('/')[-1],xml)})\n with open(os.path.join(data['folder'],xml)) as fd:\n stringxml = fd.read()\n #if 'FGDC' in stringxml.upper():\n fgdc={}\n fgdc['url']=os.path.join(resulturl,resultDir.split('/')[-1],xml)\n doc = xmltodict.parse(stringxml,cdata_key='text',attr_prefix='',dict_constructor=dict)\n fgdc['data']=doc\n fgdc['file']=localfilename\n fgdclist.append(fgdc)\n data['xmlurls']=xmlurls\n data['xml']={\"urls\":xmlurls,\"fgdc\":fgdclist,\"files\":xmlfiles}\n return data","def test_01_Xml(self):\n l_xml = self.m_xml.light_sect[1]\n # print(PrettyFormatAny.form(l_xml, 'C4-01-A - XML'))\n self.assertEqual(l_xml.attrib['Name'], TESTING_LIGHT_NAME_1)\n self.assertEqual(l_xml.find('DeviceFamily').text, TESTING_DEVICE_FAMILY_UPB)","def main(*args):\r\n print(START_MESSAGE)\r\n print(\"Script Location:\", location)\r\n print(\"Arguments Passed:\", args)\r\n\r\n root = ET.parse(xmlfile).getroot()\r\n keys = []\r\n out = \"\"\r\n\r\n for child in root[1]:\r\n out += child.attrib['Name'] + \";\" + child[0].text + \"\\n\"\r\n\r\n with open(outputfile, 'w') as f:\r\n f.write(out)","def prepare_xml(original_xml, mangled_xml):\n in_handle = open(original_xml)\n footer = \" </BlastOutput_iterations>\\n</BlastOutput>\\n\"\n header = \"\"\n while True:\n line = in_handle.readline()\n if not line:\n #No hits?\n stop_err(\"Problem with XML file?\")\n if line.strip() == \"<Iteration>\":\n break\n header += line\n\n if \"<BlastOutput_program>blastx</BlastOutput_program>\" in header:\n print \"BLASTX output identified\"\n elif \"<BlastOutput_program>blastp</BlastOutput_program>\" in header:\n print \"BLASTP output identified\"\n else:\n in_handle.close()\n stop_err(\"Expect BLASTP or BLASTX output\")\n\n out_handle = open(mangled_xml, \"w\")\n out_handle.write(header)\n out_handle.write(line)\n count = 1\n while True:\n line = in_handle.readline()\n if not line:\n break\n elif line.strip() == \"<Iteration>\":\n #Insert footer/header\n out_handle.write(footer)\n out_handle.write(header)\n count += 1\n out_handle.write(line)\n\n out_handle.close()\n in_handle.close()\n print \"Input has %i queries\" % count","def parse_CRAFT(kb_data):\n\n print(\"Parsing CRAFT corpus...\")\n corpus_dir = str()\n \n if kb_data.kb == \"chebi\":\n corpus_dir = \"./retrieved_data/corpora/CRAFT-4.0.1/concept-annotation/CHEBI/CHEBI/knowtator/\"\n \n elif kb_data.kb == \"go_bp\":\n corpus_dir = \"./retrieved_data/corpora/CRAFT-4.0.1/concept-annotation/GO_BP/GO_BP/knowtator/\"\n\n output_CRAFT = dict()\n \n for document in os.listdir(corpus_dir): \n root = ET.parse(corpus_dir + document)\n file_id = document.strip('.txt.knowtator.xml')\n annotations = dict()\n\n for annotation in root.iter(\"annotation\"):\n annotation_id = annotation.find('mention').attrib['id']\n annotation_text = annotation.find('spannedText').text\n start_pos, end_pos = annotation.find('span').attrib['start'], annotation.find('span').attrib['end']\n annotations[annotation_id] = [annotation_text, start_pos, end_pos] \n \n for classMention in root.iter(\"classMention\"):\n classMention_id = classMention.attrib['id']\n annotation_values = annotations[classMention_id]\n kb_id = classMention.find('mentionClass').attrib['id']\n \n if kb_id in kb_data.child_to_parent.keys(): # Consider only KB concepts with ONE direct ancestor\n direct_ancestor = kb_data.child_to_parent[kb_id]\n annotation = (annotation_values[0], annotation_values[1], \n annotation_values[2], kb_id, direct_ancestor) \n output_CRAFT = add_annotation_to_output_dict(file_id, annotation, output_CRAFT)\n \n print(\"...Done!\")\n return output_CRAFT","def build_corpus_questions(criteria_incl_question=True, criteria_incl_snip=False, criteria_incl_long=False, level=0):\r\n\r\n\tprint('\\nbuilding questions and answers')\r\n\r\n\tif load_corpus_questions():\r\n\t\treturn\r\n\r\n\timport xml.etree.ElementTree as ET\r\n\r\n\tquestion_count = 0\r\n\tno_abstract_tag = 0\r\n\tno_abstract_file = 0\r\n\tlong_count = 0\r\n\t\r\n\tglobal search_criteria_dict, solution_dict, linked_abstracts_dict\r\n\t\r\n\tsearch_criteria_dict = collections.defaultdict(list)\r\n\tsolution_dict = collections.defaultdict(list)\r\n\tlinked_abstracts_dict = collections.defaultdict(list)\r\n\tcommon_map_dict = collections.defaultdict(list)\r\n\t\r\n\ttree = ET.parse(paths.path_data_questions)\r\n\troot = tree.getroot()\r\n\tfor record in root.findall('record'):\r\n\t\trecord_id = record.get('id')\r\n\t\tquestion_text = preprocess_document(record.find('question').text,True)\r\n\r\n\t\tif level == 0:\r\n\t\t\tkey = record_id # key\r\n\t\t\r\n\t\tanswer = record.find('answer')\r\n\t\tif answer is not None:\r\n\t\t\tfor s in answer.findall('snip'):\r\n\t\t\t\tif s is not None:\r\n\t\t\t\t\tsnip_id = s.get('id')\r\n\t\t\t\t\tsnip_text = preprocess_document(s.find('sniptext').text,True)\r\n\t\t\t\t\t\r\n\t\t\t\t\tif level == 1:\r\n\t\t\t\t\t\tkey = record_id + '_' + snip_id # key\r\n\t\t\t\t\t\r\n\t\t\t\t\tfor i,l in enumerate(s.findall('long')):\r\n\t\t\t\t\t\tif l is not None:\r\n\t\t\t\t\t\t\tlong_id = l.get('id')\r\n\t\t\t\t\t\t\t\r\n\t\t\t\t\t\t\tif level == 2:\r\n\t\t\t\t\t\t\t\tkey = record_id + '_' + snip_id + '_' + long_id # key\r\n\t\t\t\t\t\t\t\t\r\n\t\t\t\t\t\t\tif criteria_incl_question:\r\n\t\t\t\t\t\t\t\tfor x in question_text:\r\n\t\t\t\t\t\t\t\t\tsearch_criteria_dict[key].append(x) # question\r\n\t\t\t\t\t\t\tif criteria_incl_snip:\r\n\t\t\t\t\t\t\t\tfor x in snip_text:\r\n\t\t\t\t\t\t\t\t\tsearch_criteria_dict[key].append(x) # snip\r\n\t\t\t\t\t\t\t\r\n\t\t\t\t\t\t\tlong_text = l.find('longtext')\r\n\t\t\t\t\t\t\tif long_text is not None:\r\n\t\t\t\t\t\t\t\tlong_text = preprocess_document(long_text.text,True)\r\n\t\t\t\t\t\t\t\tfor x in long_text:\r\n\t\t\t\t\t\t\t\t\tsolution_dict[key].append(x) # long - answer\r\n\t\t\t\t\t\t\t\tif criteria_incl_long:\r\n\t\t\t\t\t\t\t\t\tfor x in long_text:\r\n\t\t\t\t\t\t\t\t\t\tsearch_criteria_dict[key].append(x) # long - search\r\n\r\n\t\t\t\t\t\t\tif key not in search_criteria_dict.keys():\r\n\t\t\t\t\t\t\t\tsearch_criteria_dict[key].append('')\r\n\r\n\t\t\t\t\t\t\tlong_refs = l.findall('ref')\r\n\t\t\t\t\t\t\tfor long_ref in long_refs:\r\n\t\t\t\t\t\t\t\tabstract = long_ref.get('abstract')[10:]\r\n\t\t\t\t\t\t\t\tabstract_path = paths.path_data_abstracts + '/' + abstract\r\n\t\t\t\t\t\t\t\tabstract_sentences = abstracts_dict[abstract]\r\n\t\t\t\t\t\t\t\tlinked_abstracts_dict[key].append(abstract) # linked abstracts\r\n\t\t\t\t\t\t\t\t\r\n\t\t\t\t\t\t\t\tlong_count += 1\r\n\t\t\t\t\t\t\t\t\r\n\t\tquestion_count += 1\r\n\t\t# print(str(question_count) + ' : ' + str(question_text) + ' : ' + str(no_abstract_file) + ' : ' + str(no_abstract_tag) + ' : ' + str(long_count))\r\n\r\n\tpickle.dump(search_criteria_dict,open(paths.path_data_questions_pickle,\"wb\"))\r\n\tpickle.dump(solution_dict,open(paths.path_data_answers_pickle,\"wb\"))\r\n\tpickle.dump(linked_abstracts_dict,open(paths.path_data_linkedabstracts_pickle,\"wb\"))\r\n\t\r\n\tprint(len(search_criteria_dict))\r\n\tprint(len(solution_dict))\r\n\tprint(len(linked_abstracts_dict))\r\n\t\r\n\tprint('\\ncorpus build complete')","def test_02_Xml1(self):\n l_xml = self.m_xml.light_sect[1]\n print(PrettyFormatAny.form(l_xml, 'C1-02-A - XML'))\n self.assertEqual(l_xml.attrib['Name'], TESTING_LIGHT_NAME_1)\n self.assertEqual(l_xml.find('DeviceFamily').text, TESTING_DEVICE_FAMILY_UPB)","def test_load_quakeML():\n # Check one cmt file\n with tempfile.TemporaryDirectory() as tmp_dir:\n\n # Cmtfile path\n cmtfile = os.path.join(DATA_DIR, \"testCMT\")\n\n # create new directory\n new_xml_path = os.path.join(tmp_dir, \"tests.xml\")\n xml = read_events(cmtfile)\n xml.write(new_xml_path, format=\"QUAKEML\")\n\n assert(os.path.exists(new_xml_path)\n and os.path.isfile(new_xml_path))\n\n print(\"QuakeML\\n\", CMTSource.from_quakeml_file(new_xml_path))\n print(\"CMT\\n\", CMTSource.from_CMTSOLUTION_file(cmtfile))\n assertDictAlmostEqual(CMTSource.from_quakeml_file(new_xml_path),\n CMTSource.from_CMTSOLUTION_file(cmtfile))","def GenerateXML(dictionary, fileName=\"labelling.xml\") : \n root = gfg.Element(\"annotation\") \n #the big section is called Annotation\n for key in dictionary:\n #for every polygon list in inside object witho subelement name and attributes and the type \"polygon\"\n objectElement = gfg.Element(\"object\") \n root.append(objectElement) \n subElement1 = gfg.SubElement(objectElement, \"name:\".strip(\":\"))\n subElement1.text = str(dictionary[key][\"name\"])\n subElement2 = gfg.SubElement(objectElement, \"attributes\".strip(\":\"))\n subElement2.text = str(dictionary[key][\"attributes\"])\n subElement3 = gfg.SubElement(objectElement, \"polygon\")\n \n for i in range(0, len(dictionary[key])-2):\n #for every vertex of the polygon list it's rounded x, y on xml\n SubInsidePolygon = gfg.SubElement(subElement3, \"pt\")\n sub_x = gfg.SubElement(SubInsidePolygon, \"x\")\n sub_y = gfg.SubElement(SubInsidePolygon, \"y\")\n sub_x.text = str(int(round(dictionary[key][\"x_y_\" + str(i)][0])))\n sub_y.text = str(int(round(dictionary[key][\"x_y_\" + str(i)][1])))\n tree = gfg.ElementTree(root) \n #create the xml tree\n with open (fileName, \"wb\") as files : \n tree.write(files) \n #if xml does not exist create one otherwise rewrite to it","def __createXMLFileForClear():\r\n #description\r\n #Root\r\n clear_root = Element('clear-users-request', {'xmlns':SYMPLECTIC_XMLNS_URI,} )\r\n #Feed\r\n SubElement(clear_root, 'feed-id').text = IMPORT_USERS_FEED_ID\r\n #Convert to ElementTree and write xml version to file\r\n xml_filename = SYMPLECTIC_LOCAL_XML_FOLDER + SYMPLECTIC_LOCAL_USER_FOLDER + SYMPLECTIC_LOCAL_USER_CLEARFILE\r\n ElementTree(clear_root).write(xml_filename)\r\n #Return xml filename\r\n return xml_filename","def setUpClass(cls):\n import os\n for root in cls.prod_s2_ssc:\n os.makedirs(root)\n metadata = root.split(\".\")[0] + \".HDR\"\n TestFunctions.touch(metadata)\n for root in cls.prod_s2_mus:\n os.makedirs(root)\n metadata = os.path.join(root, root + \"_MTD_ALL.xml\")\n TestFunctions.touch(metadata)\n for root in cls.prod_s2_nat:\n os.makedirs(root)\n metadata = os.path.join(root, \"MTD_MSIL1C.xml\")\n TestFunctions.touch(metadata)","def xml_parser_dielectrics(request, tmpdir_factory):\n testdir = os.path.dirname(__file__)\n xmlfile = testdir + \"/dielectrics.xml\"\n tmpfile = str(tmpdir_factory.mktemp('data').join('basic_trunc.xml'))\n xml_truncate(request.param, xmlfile, tmpfile)\n xml = vasprun.Xml(tmpfile, event = False)\n \n return xml","def getXML(self):\n nodes = list(self.nodes(data=True))\n nodes.sort()\n node_string = ''\n for n in nodes:\n attribute_string = ''\n keys = list(n[1].keys())\n keys.sort()\n for k in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(k, n[1][k], k)\n modification_string = ''\n modified_by = self.predecessors(n[0])\n if modified_by:\n for mod in modified_by:\n modification_string += \"\"\"<modified_by>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifyingNode> %s </modifyingNode>\\n\"\"\"%mod.getTagID()\n modification_string += \\\n \"\"\"<modifyingCategory> %s </modifyingCategory>\\n\"\"\"%mod.getCategory()\n modification_string += \"\"\"</modified_by>\\n\"\"\"\n modifies = self.successors(n[0])\n if modifies:\n for modified in modifies:\n modification_string += \"\"\"<modifies>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifiedNode> {0} </modifiedNode>\\n\"\"\".format(modified.getTagID())\n modification_string += \\\n \"\"\"</modifies>\\n\"\"\"\n node_string += \\\n NODE_XML_SKEL.format(attribute_string+\"{0}\".format(n[0].getXML()) +\\\n modification_string)\n edges = list(self.edges(data=True))\n edges.sort()\n edge_string = ''\n for edge in edges:\n keys = list(edge[2].keys())\n keys.sort()\n attribute_string = ''\n for key in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(key, edge[2][key], key)\n edge_string += \"{0}\".format(EDGE_XML_SKEL.format(edge[0].getTagID(),\n edge[1].getTagID(),\n attribute_string))\n\n return CONTEXT_MARKUP_XML_SKEL.format(xmlScrub(self.getRawText()),\n xmlScrub(self.getText()),\n node_string,\n edge_string)","def generateXMLmodel(quickLogger,\n base,\n galactic_file=\"gal_2yearp7v6_v0.fits\",\n isotropic_file=\"iso_p7v6source.txt\",\n catalog_file=\"gll_psc_v07.fit\"):\n\n\n try:\n checkForFiles(quickLogger,[base+\"_model.xml\"])\n quickLogger.info(base+\"_model.xml exists, won't create a new one.\")\n except(FileNotFound):\n quickLogger.info(base+\"_model.xml doesn't exist, will create a new one.\") \n try:\n checkForFiles(quickLogger,[base+\"_filtered_gti.fits\",galactic_file,isotropic_file,catalog_file])\n import make2FGLxml\n mymodel = make2FGLxml.srcList(catalog_file,base+\"_filtered_gti.fits\",base+\"_model.xml\")\n mymodel.makeModel(galactic_file, 'gal_2yearp7v6_v0', isotropic_file, 'iso_p7v6source')\n quickLogger.info(\"NOTE: if there are extended sources in your ROI, make sure the \"\\\n +\"correspoinding diffuse template is in the working directory.\")\n except(FileNotFound):\n raise FileNotFound","def buildnemxml(self):\n for n in sorted(self._objs.keys()):\n emanenode = self._objs[n]\n emanenode.buildnemxmlfiles(self)","def process_xml(self):\n self.process_gpx_file(str(self.filename))","def hlsp_to_xml(config):\n\n # Check the user-provided config file path.\n config = cp.check_existing_file(config)\n if config is None:\n return\n\n # Try to read in the yaml config file.\n try:\n parameters = read_yaml(config)\n except (FileNotFoundError, TypeError) as err:\n print(err)\n return\n\n # Make sure the config file has all the expected sections\n for section in EXPECTED_CONFIGS:\n if section not in parameters:\n print(\"{0} does not define '{1}'!\".format(config, section))\n return\n\n # Make sure all necessary filepaths have been provided\n for path in EXPECTED_PATHS:\n if path not in parameters[\"filepaths\"]:\n print(\"{0} is missing an '{1}' filepath!\".format(config, path))\n return\n\n # Config parameters have been checked, now read into variables\n paths = parameters[\"filepaths\"]\n hlsppath = paths[\"hlsppath\"]\n output = paths[\"output\"]\n overwrite = paths[\"overwrite\"]\n\n extensions = parameters[\"file_types\"]\n header_type = parameters[\"header_type\"]\n data_type = parameters[\"data_type\"]\n keyword_updates = parameters[\"keyword_updates\"]\n uniques = parameters[\"unique_parameters\"]\n\n # Set up logging\n outdir = os.path.dirname(output)\n logfile = os.path.join(outdir, LOG)\n logfile = cp.check_new_file(logfile)\n if logfile is None:\n return\n logging.basicConfig(filename=logfile,\n format='***%(levelname)s from %(module)s: %(message)s',\n level=logging.DEBUG, filemode='w')\n logging.info(\"Logging started at {0}\".format(\n datetime.datetime.now().isoformat()))\n\n # Prepare the output file\n output = cp.check_new_file(output)\n if output is None:\n return\n print(\"Opening {0}\".format(output))\n if overwrite or not os.path.isfile(output):\n with open(output, 'w') as xmlfile:\n xmlfile.close()\n else:\n err = \"{0} already exists. Set overwrite=True to proceed.\".format(\n output)\n logging.error(err)\n print(err)\n return\n\n # Begin the lxml tree and add the main subelements\n composite = etree.Element(\"CompositeObservation\")\n xmltree = etree.ElementTree(composite)\n metadata = etree.SubElement(composite, \"metadataList\")\n provenance = etree.SubElement(composite, \"provenance\")\n products = etree.SubElement(composite, \"productList\")\n\n # Create the CAOMxmlList we will save CAOMxml objects into\n caomlist = CAOMxmlList()\n\n # Read the static CAOM values from the yaml file\n print(\"Creating standard HLSP entries...\")\n statics = cp.check_existing_file(STATICS)\n if statics is None:\n return\n try:\n static_values = read_yaml(statics)\n except (FileNotFoundError, TypeError) as err:\n logging.error(err)\n print(err)\n return\n\n # Add standard entries\n caomlist = add_value_caomxml(caomlist, static_values[\"hlsp\"])\n\n # Add some conditional entries\n if data_type == \"timeseries\":\n caomlist = add_value_caomxml(caomlist, static_values[\"timeseries\"])\n if header_type == \"kepler\":\n caomlist = add_value_caomxml(caomlist, static_values[\"kepler\"])\n print(\"...done!\")\n\n # Add information from the header keywords table.\n print(\"Adding entries from fits headers...\")\n caomlist = add_header_entries(caomlist, KEYWORD_TABLE, header_type)\n print(\"...done!\")\n\n # Add CAOMxml entries for HLSP-specifiic CAOM parameters.\n print(\"Adding unique entries for this HLSP...\")\n if uniques is None:\n logging.warning(\"No unique parameters provided in the yaml config.\")\n else:\n caomlist = add_value_caomxml(caomlist, uniques)\n print(\"...done!\")\n\n # Add product entries to the list of CAOMxml objects\n print(\"Generating the productList...\")\n caomlist = add_product_caomxml(caomlist, hlsppath, extensions, data_type)\n print(\"...done!\")\n\n # Make final tweaks to caomlist\n print(\"Making final adjustments...\")\n caomlist = adjust_defaults(caomlist, header_type, keyword_updates)\n print(\"...done!\")\n\n # Create the head string to write to doctype\n head_strings = []\n head_strings.append(\"<!-- Process HLSP for CAOM ingestion -->\")\n head_strings.append(\"\")\n head = \"\\n\".join(head_strings)\n\n # Add CAOMxml elements to xmltree\n print(\"Writing everything to XML...\")\n for entry in sorted(caomlist):\n\n # Skip extra top-level entries caused by recursion in add_value_caomxml\n if xmltree.find(entry.label) is None:\n entry.send_to_lxml(xmltree)\n\n # Write the xml tree to the OUTPUT file\n # (doctype not a valid argument for python 2.x)\n xmltree.write(output,\n encoding=\"utf-8\",\n xml_declaration=True,\n #doctype=head,\n pretty_print=True)\n print(\"...XML file generated!\")\n\n # Print out log stats before finishing\n check_log(logfile)\n logging.info(\"Logging finished at {0}\".format(\n datetime.datetime.now().isoformat()))","def citation_validation(self):\n for file in filter(lambda x: x.startswith('citation'), listdir(bs_directory)):\n print \"Processing\", file\n bs = BeautifulSoup(open(file), 'xml')\n # find ground_truth file\n ground_truth = BeautifulSoup(open(self.ground_truth_directory + file.split(\".\")[0] + '.xml'), 'xml')\n self.__citation_correction(ground_truth, bs)\n file = open(self.citation_output + file, \"wb\")\n file.write(bs.prettify().encode('utf-8'))","def test_XML(browser, filename, languages='en'):\n wait = browser.waiter()\n\n source_files = glob(os.path.abspath(os.path.join('test-data', filename)))\n languages = languages.split(',')\n\n if len(source_files) == 0:\n print('Error: No such file')\n\n for n, source_path in enumerate(source_files):\n\n if not os.path.isfile(source_path):\n print(\"File not found: %s\" % source_path)\n return\n\n local_content = open(source_path, 'rb').read()\n try:\n ElementTree.fromstring(local_content)\n except ElementTree.ParseError as e:\n print('%sError: The file \"%s\" contains invalid XML:%s' % (Fore.RED, os.path.basename(source_path), Style.RESET_ALL))\n print(Fore.RED + str(e) + Style.RESET_ALL)\n return\n\n source_path_root, source_path_ext = os.path.splitext(source_path)\n\n for m, lang in enumerate(languages):\n\n png_path = '%s_%s.png' % (source_path_root, lang)\n html_path = '%s_%s.html' % (source_path_root, lang)\n\n tmp = tempfile.NamedTemporaryFile('w+b')\n with open(source_path, 'rb') as op:\n tmp.write(re.sub('<preferred_language>[a-z]+</preferred_language>',\n '<preferred_language>%s</preferred_language>' % lang,\n op.read().decode('utf-8')).encode('utf-8'))\n tmp.flush()\n\n try:\n element = browser.driver.find_element_by_id('cbuttonupload')\n except NoSuchElementException:\n browser.get('/mng/action/home.do')\n\n # Open Alma configuration\n browser.wait_for(By.XPATH, '//*[@aria-label=\"Open Alma configuration\"]')\n browser.click(By.XPATH, '//*[@aria-label=\"Open Alma configuration\"]')\n browser.click(By.XPATH, '//*[@href=\"#CONF_MENU5\"]')\n browser.click(By.XPATH, '//*[text() = \"Notification Template\"]')\n\n browser.wait_for(By.ID, 'cbuttonupload')\n\n # Set language\n element = browser.driver.find_element_by_id('pageBeanuserPreferredLanguage')\n element.click()\n element = browser.driver.find_element_by_id('pageBeanuserPreferredLanguage_hiddenSelect')\n select = Select(element)\n opts = {el.get_attribute('value'): el.get_attribute('innerText') for el in select.options}\n longLangName = opts[lang]\n\n cur = n * len(languages) + m + 1\n tot = len(languages) * len(source_files)\n print('[%d/%d] Testing \"%s\" using language \"%s\"' % (cur, tot,\n os.path.basename(source_path),\n longLangName))\n\n element = wait.until(EC.element_to_be_clickable(\n (By.XPATH, '//ul[@id=\"pageBeanuserPreferredLanguage_hiddenSelect_list\"]/li[@title=\"%s\"]/a' % longLangName)\n ))\n element.click()\n\n\n # Upload the XML\n file_field = browser.driver.find_element_by_id('pageBeannewFormFile')\n file_field.send_keys(tmp.name)\n\n upload_btn = browser.driver.find_element_by_id('cbuttonupload')\n upload_btn.click()\n\n browser.wait_for(By.CSS_SELECTOR, '.infoErrorMessages')\n\n run_btn = wait.until(\n EC.element_to_be_clickable((By.ID, 'PAGE_BUTTONS_admconfigure_notification_templaterun_xsl'))\n )\n\n cwh = browser.driver.current_window_handle\n\n run_btn.click()\n time.sleep(1)\n\n # Take a screenshot\n found_win = False\n for handle in browser.driver.window_handles:\n browser.driver.switch_to_window(handle)\n if 'beanContentParam=htmlContent' in browser.driver.current_url:\n browser.driver.set_window_size(browser.config.get('screenshot', 'width'), 600)\n with open(html_path, 'w+b') as html_file:\n html_file.write(browser.driver.page_source.encode('utf-8'))\n print('Saved output: %s' % html_path)\n if browser.driver.save_screenshot(png_path):\n print('Saved screenshot: %s' % png_path)\n else:\n print('Failed to save screenshot')\n found_win = True\n break\n\n if not found_win:\n print(Fore.RED + 'ERROR: Failed to produce output!' + Fore.RESET)\n browser.driver.switch_to_window(cwh)\n tmp.close()","def before_running(res, src_iso_path, dest_path, project, XML_FILE):\n path_list = [\"common_setting/Generic\",\"common_setting/DVD\"]\n if os.name == 'nt':\n if project.upper() == 'DVDFAB 8' or project.upper() == 'DVDFAB8':\n for path in path_list:\n tree, nodes = windows_xml.read_xml(XML_FILE, path, xml_temp) \n fab_logpath = get_xml_value(nodes[0], 'LogFolder')\n burn_engine_type = get_xml_value(nodes[0], 'BurnEngineType')\n tempfolder_path = get_xml_value(nodes[0], 'TempFolder')\n else:\n for path in path_list:\n tree, nodes = windows_xml.read_xml(XML_FILE, path, xml_temp) \n fab_logpath = get_xml_value(nodes[0], 'LogFolder')\n burn_engine_type = get_xml_value(nodes[0], 'BDBurnEngineType')\n tempfolder_path = get_xml_value(nodes[0], 'TempFolder') \n else:\n if project.upper() == 'DVDFAB 8' or project.upper() == 'DVDFAB8':\n for path in path_list:\n tree, nodes = myxml.read_xml(XML_FILE, path, xml_temp)\n fab_logpath = get_xml_value(nodes[0], 'LogFolder')\n burn_engine_type = get_xml_value(nodes[0], 'BurnEngineType')\n tempfolder_path = get_xml_value(nodes[0], 'TempFolder')\t\n else:\n for path in path_list:\n tree, nodes = myxml.read_xml(XML_FILE, path, xml_temp) \n fab_logpath = get_xml_value(nodes[0], 'LogFolder')\n burn_engine_type = get_xml_value(nodes[0], 'BDBurnEngineType')\n tempfolder_path = get_xml_value(nodes[0], 'TempFolder')\t\t\t\t\n \n dest_path = tempfolder_path if '.ISO' == os.path.splitext(res[6].upper())[1] else dest_path\n initlog('before running, dest_path is: %s' % dest_path) \n tempfolder_path = ''.join((tempfolder_path, 'ReportCrash')).replace(\"_nbsp;\",\" \")\n fab_logpath = fab_logpath.replace(\"_nbsp;\",\" \")\n initlog(\"fab_logpath is: %s; tempfolder_path is: %s\" %(fab_logpath, tempfolder_path))\n logpath = (fab_logpath, tempfolder_path) \n remove_fab_logfile(fab_logpath)\n return dest_path, logpath, burn_engine_type","def buildtransportxml(self):\n try:\n subprocess.check_call([\"emanegentransportxml\", \"platform.xml\"], cwd=self.session.session_dir)\n except subprocess.CalledProcessError:\n logger.exception(\"error running emanegentransportxml\")","def get_match_criteria(self):\n #-- factory attributes ----\n print(\"\"\"\nWhat glidein/factory attributres are you using in the match expression?\nI have computed my best estimate for your match string,\nplease verify and correct if needed.\n\"\"\")\n default_factory_attributes = string.join(self.extract_factory_attrs(), ',')\n factory_attributes = raw_input(\"Factory attributes: [%s] \"%default_factory_attributes)\n if factory_attributes == \"\":\n factory_attributes = default_factory_attributes\n if factory_attributes == \"\":\n factory_attributes = []\n else:\n factory_attributes = string.split(factory_attributes, ',')\n\n #--- job_attributes --\n print(\"\"\"\nWhat job attributes are you using in the match expression?\nI have computed my best estimate for your match string,\nplease verify and correct if needed.\n\"\"\")\n default_job_attributes = string.join(self.extract_job_attrs(), ',')\n job_attributes = raw_input(\"Job attributes: [%s] \" % default_job_attributes)\n if job_attributes == \"\":\n job_attributes = default_job_attributes\n if job_attributes == \"\":\n job_attributes = []\n else:\n job_attributes = string.split(job_attributes, ',')\n\n #--- create xml ----\n data = \"\"\"\n%(indent2)s<group name=\"%(group_name)s\" enabled=\"True\">\n%(indent3)s<match match_expr=%(match_string)s start_expr=\"True\">\n%(factory_attributes)s\n%(job_attributes)s\n%(indent3)s</match>\n%(indent2)s</group>\n\"\"\" % \\\n{ \"indent2\": common.indent(2),\n \"indent3\": common.indent(3),\n \"indent4\": common.indent(4),\n \"group_name\": self.group_name(),\n \"match_string\": glideinwms.lib.xmlFormat.xml_quoteattr(self.match_string()),\n \"factory_attributes\": self.factory_data(factory_attributes),\n \"job_attributes\": self.job_data(job_attributes),\n}\n return data","def makeCourse( xmlFile, genPath, importPaths, commonFiles, rendererContent=True):\n\ttry:\n\n\t\t# parse the command line\n\t\tConfig.add_option('--verbose', help='Set verbosity to maximum', dest='verbosity', default=0, action='store_const', const=2)\n\t\tConfig.add_option('-v', '--verbosity', help='Set the verbosity level (0: quiet, 1: display the command lines, 2: display command lines and their outputs', dest='verbosity', default=0, type=int)\n\t\tConfig.add_option('-d', '--debug', help='Create the files in the debug/ folder, instead of in a temporary one', dest='debug', action='store_true', default=False)\n\t\tConfig.add_option('-f', '--force', help='Force the generation of the documents, even if nothing changes from last run', dest='force', action='store_true', default=False)\n\t\tConfig.add_option('-q', '--quick', help='Quick pdf generation (do not compile twice the latex, do not produce handout, etc.)', dest='quick', action='store_true', default=False)\n\t\tConfig.add_option('-w', '--wordpress', help='Publish to wordpress', dest='wordpress', default=False, action='store_true')\n\t\tConfig.add_option('-c', '--HTMLcorrection', help='Display an HTML correction', dest='HTMLcorrection', default=False, action='store_true')\n\t\tConfig.add_option('-s', '--shared', help='Copy the required files to the <shared> path (via ssh)', default=False,\taction='store_true')\n\t\tConfig.parse()\n\t\targs = Config.args\n\t\toptions = Config.options\n\t\tConfig.importPaths = importPaths \n\t\tConfig.commonFiles = commonFiles\n\t\tConfig.allSessions = { x.__name__:x for x in Session.__subclasses__()}\t# list of the created session classes\n\t\tConfig.rendererContent = rendererContent\n\t\t\n\t\t# clean the debug directory in debug mode\n\t\tbasePath = os.path.abspath('.')+'/'\t\t\t# base path (from where the script is run, because the path are relative)\n\t\tif options.debug:\n\t\t\tif os.path.exists('debug/'):\n\t\t\t\trunCommand(['rm','-rf','debug/'])\n\n\t\t# open and parse the course file\n\t\twith codecs.open(xmlFile, encoding='utf-8') as f:\n\t\t\tbs = BeautifulSoup(f, features=\"xml\")\n\n\n\t\t# build the recursively the sessions\n\t\ttop = createTagSession( bs, father=None )\t\t# bs.contents[0]\n\t\tsessionsToBuild = Session.sessionsToBuild\t\t# get the list of the sessions object\n\t\t\n\n\t\t\"\"\"\n\t\timportFiles( bs.contents[0], importPaths)\n\n\t\t# get the list of sessions we can build (with a 'make' method)\n\t\tbuildableSessions = { x.__name__:x for x in Session.__subclasses__() if 'make' in x.__dict__ }\n\n\t\t#This set the PATH for PyDev only...\n\t\tos.environ['PATH'] = os.environ['PATH']+':'+os.getenv('PATH')\n\n\n\t\t# build the list of Sessions to build\n\t\tsessionsToBuild = []\n\t\tfor name,session in buildableSessions.items():\n\t\t\tsessionsToBuild.extend( session(tag, commonFiles) for tag in bs(name) )\n\t\t\"\"\"\n\t\t\n\t\t\n\n\t\t# if possible, load the previous xml file, and look for the differences\n\t\tdirName,baseName = split(xmlFile) \n\t\ttry:\n\t\t\twith open(dirName+\"/.\"+baseName+\".makeCourse\", \"rb\") as f:\n\t\t\t\tdata = load( f )\n\t\t\t\tfor s in sessionsToBuild:\n\t\t\t\t\tif s.name in data:\n\t\t\t\t\t\ts.checkDifferences( data[s.name] )\n\t\texcept IOError:\n\t\t\tpass\n\n\n\t\t# build every argument in the command line arguments\n\t\tsomethingHasBeDone = False\n\t\tfor s in sessionsToBuild:\n\t\t\tif (not args) or (\"all\" in args) or (s.name in args) or (s.type in args):\n\t\t\t\t\n\t\t\t\tcd( basePath)\n\t\t\t\t\n\t\t\t\t# check if something has to be done\n\t\t\t\tif s.shouldBeMake(basePath+'/'+genPath, options) or options.force:\n\t\t\t\t\tsomethingHasBeDone = True\n\n\t\t\t\t\t#Make one build (TP, course, etc.)\n\t\t\t\t\tprint ( Fore.BLUE+\"*) Make \"+Style.BRIGHT+s.name+Fore.RESET+Style.NORMAL)\n\n\t\t\t\t\t# make temp directory and copy all the file in resources dir\n\t\t\t\t\tif options.debug:\n\t\t\t\t\t\ttmp = \"debug/\"+s.name+'/'\n\t\t\t\t\t\tcreateDirectory(tmp)\n\t\t\t\t\telse:\n\t\t\t\t\t\ttmp = mkdtemp()\n\n\t\t\t\t\ts.prepareResources(tmp )\n\t\t\t\t\tcd( tmp)\n\n\t\t\t\t\t# call the custom function associated with the type, to produce the documents\n\t\t\t\t\ts.make(options)\n\n\t\t\t\t\t# then move the files in the right place\n\t\t\t\t\tfor f in s.files(options):\n\t\t\t\t\t\tcreateDirectory( basePath+'/'+genPath.format( **s.dict ) )\n\t\t\t\t\t\tnewFile = basePath+'/'+genPath.format( **s.dict )+f\n\t\t\t\t\t\tif not os.path.exists(f):\n\t\t\t\t\t\t\tprint( Fore.YELLOW+'The file '+f+' has not been created by '+s.type+' function !'+Fore.RESET)\n\t\t\t\t\t\trunCommand( ['cp', f, newFile])\n\n\t\t\t\t\t# del the temporary directory or clean debug directory\n\t\t\t\t\tif not options.debug:\n\t\t\t\t\t\trunCommand( ['rm', '-rf', tmp])\n\t\t\t\telse:\n\t\t\t\t\tif options.verbosity>0:\n\t\t\t\t\t\tprint( Fore.BLUE + \"*) Nothing changed for \"+Style.BRIGHT+s.name+Style.NORMAL+\", skipped\"+Fore.RESET)\n\n\n\n\t\tif not somethingHasBeDone:\n\t\t\tprint( Fore.BLUE + \"Nothing has changed, nothing to do, so nothing has been done...\" + Fore.RESET)\n\n\n\t\t# save the data file\n\t\tdata = {L.name: {key:md5(str(val).encode('utf-8')).hexdigest() for key,val in L.dict.items()} for L in sessionsToBuild }\n\t\tcd( basePath)\n\t\twith open(dirName+\"/.\"+baseName+\".makeCourse\", 'wb') as f:\n\t\t\tdump( data, f)\n\n\n\n\n\n\n\n\texcept mkcException as err:\n\t\tprint( err )","def test_xml_to_attributes_and_back(self):\n # etree_to_dict(e) and dict_to_etree(d)\n e = open(EXAMPLE_SECTION_FILENAME, 'r').read()\n e = ET.XML(e)\n d = etree_to_dict(e)\n all_attributes = read_section_dict(d)\n d = make_section_dict(*all_attributes)\n e = dict_to_xml_str(d)\n e = prettify(e)\n\n if SHOW_RESULTS:\n print(e)\n\n xml_file = StringIO(unicode(e))\n self.assertEqual(verify_files(xml_file, open(SECTION_DTD_FILENAME, 'r')), True)","def generate_files(self):\n\t\tapply_stemmer, xml_file, query_file, expected_file = self.read_config_file()\n\t\tself.generate_query_file(query_file, xml_file, apply_stemmer)\n\t\tself.generate_expected_file(expected_file, xml_file)\n\t\tlogging.info('FINALIZADO: MÓDULO PROCESSADOR DE CONSULTAS')","def create_entity_claim_input_file_doc_ret():\n claim_doc = open(r\"C:\\study\\technion\\MSc\\Thesis\\Y!\\rawClaim_SW.txt\").read().strip()\n \"remove the stop words from the claims\"\n SW_doc = r\"C:\\study\\technion\\MSc\\Thesis\\Y!\\stopWords.xml\"\n stopWords_list = []\n claims_no_SW_dict = {}\n with open(SW_doc, 'r') as f:\n line = f.readline()\n while line !=\"\":\n if \"<word>\" in line:\n stopWords_list.append(line.split(\"<word>\")[1].split(\"</word>\")[0])\n line = f.readline()\n \n for i,line in enumerate(claim_doc.split(\"\\n\")):\n clmLMdocLM_doc_ret_query_file = open(\"LMdocLM_doc_ret_query_file_clm_\"+str(i+1),\"wb\")\n clmLMdocLM_doc_ret_query_file.write(\"<parameters>\\n\")\n curr_claim_words = line.split(\"|\")[1].lower().split()\n curr_entity_words = line.split(\"|\")[0].lower().split()\n noSW_claim = \"\"\n noSW_entity = \"\"\n for word in curr_claim_words:\n if word not in stopWords_list: \n noSW_claim += word+\" \"\n for word in curr_entity_words:\n if word not in stopWords_list: \n noSW_entity += word+\" \"\n# clmLMdocLM_doc_ret_query_file.write(\"<query><number>\"+str(i+1)+\"</number><text>\"+noSW_entity+\"|\"+noSW_claim+\"</text></query>\\n\")\n# clmLMdocLM_doc_ret_query_file.write(\"</parameters>\")\n# clmLMdocLM_doc_ret_query_file.close()\n claims_no_SW_dict[str(i+1)] = (noSW_entity,noSW_claim)\n save_pickle(\"claims_no_SW_dict\", claims_no_SW_dict)","def write_and_clean(urn, lang, parsed, citations,target):\n\n os.makedirs(\"cache\", exist_ok=True)\n\n\n if \"grc\" not in urn and \"lat\" not in urn:\n type_text = \"translation\"\n else:\n type_text = \"edition\"\n\n \"\"\"\n Change TEI.2 tag to TEI \n \"\"\"\n # We change the main tag\n TEI = parsed.getroot()\n # We change the root tag to TEI\n TEI.tag = \"TEI\"\n # We change the main tag\n TEI = parsed.getroot()\n\n \"\"\"\n Moving every children of //body into a new div with a @n attribute\n \"\"\"\n body = parsed.xpath(\"//body\")[0]\n # Get its children\n child_body = body.getchildren()\n\n # For each child of body, remove it from body\n for child in child_body:\n body.remove(child)\n\n # Create a new div with the informations\n div = etree.Element(\n \"div\",\n attrib = { \n \"type\":type_text,\n \"n\": urn,\n \"{http://www.w3.org/XML/1998/namespace}lang\" : lang\n }\n )\n\n # Add the full list of children of body to the newly created div\n div.extend(child_body)\n # Add this new div in body\n body.append(div)\n\n # Add them to the current encodingDesc\n refsDecl = \"\"\"<tei:refsDecl n=\"CTS\" xmlns:tei=\"http://www.tei-c.org/ns/1.0\">\\n\"\"\" + \"\\n\".join([str(citation) for citation in citations]) + \"\"\"\\n</tei:refsDecl>\"\"\"\n # Parse it\n refsDecl = etree.fromstring(refsDecl)\n # Find encodingDesc\n encodingDesc = parsed.xpath(\"//encodingDesc\")[0]\n encodingDesc.append(refsDecl)\n\n \"\"\"\n Search for old //encodingDesc/refsDecl and refsDecl/state and correct them\n \"\"\"\n refsDecls = parsed.xpath(\"//encodingDesc/refsDecl[@doctype]\")\n for refsDecl in refsDecls:\n refsDecl.set(\"n\", refsDecl.get(\"doctype\"))\n del refsDecl.attrib[\"doctype\"]\n\n states = parsed.xpath(\"//encodingDesc/refsDecl/state\")\n for state in states:\n state.tag = \"refState\"\n\n \"\"\"\n Change language@id to ident\n \"\"\"\n languages = parsed.xpath(\"//langUsage/language[@id]\") + parsed.xpath(\"//langUsage/lang[@id]\")\n for lang in languages:\n lang.set(\"ident\", lang.attrib[\"id\"])\n del lang.attrib[\"id\"]\n\n \"\"\"\n Change pb@id to pb@n\n \"\"\"\n pbs = parsed.xpath(\"//pb[@id]\")\n for pb in pbs:\n pb.set(\"n\", pb.attrib[\"id\"])\n del pb.attrib[\"id\"]\n\n \"\"\"\n Clean keyboarding/p\n \"\"\"\n ps = parsed.xpath(\"//sourceDesc/p\")\n for p in ps:\n p.getparent().remove(p)\n\n \"\"\"\n Clear attributes of text and body\n \"\"\"\n body_text = parsed.xpath(\"//body\") + parsed.xpath(\"//text\")\n for tag in body_text:\n for key in tag.attrib:\n del tag.attrib[key]\n\n\n \"\"\"\n Clear refsDecl/step\n \"\"\"\n refsdecls_step = parsed.xpath(\"//refsDecl/step/parent::refsDecl\")\n for step_parent in refsdecls_step:\n step_parent.getparent().remove(step_parent)\n\n \"\"\"\n Clear refsDecl/step\n \"\"\"\n refsdecls_step = parsed.xpath(\"//refsDecl/step/parent::refsDecl\")\n for step_parent in refsdecls_step:\n step_parent.getparent().remove(step_parent)\n\n \"\"\"\n Fix anchored\n \"\"\"\n anchoreds = parsed.xpath(\"//*[@anchored='yes']\")\n for anchored in anchoreds:\n anchored.set(\"anchored\", \"true\")\n\n # Convert to xml\n \"\"\" \n Create a new document so we can have tei namespace \n \"\"\"\n # And now some other CTS Magic\n New_Root = etree.Element(\n \"{http://www.tei-c.org/ns/1.0}TEI\",\n nsmap = { None : \"http://www.tei-c.org/ns/1.0\" } # Creating a new element allows us to use a default namespace\n )\n New_Root.text = \"\\n\"\n # Add children of old root to New_Root\n New_Root.extend(TEI.getchildren())\n\n # We create a new document\n New_Doc = etree.ElementTree(New_Root)\n # And now some other CTS Magic\n \n New_Doc = P4P5(New_Doc)\n\n # save xml\n os.makedirs(os.path.dirname(target), exist_ok=True)\n with open (target, \"w\") as xmlfile:\n xmlfile.write(\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n\"\"\"+etree.tostring(New_Doc, encoding=str))\n\n # And now we write cts informations\n try:\n cts.cts_metadata(urn)\n except Exception as E:\n print(E)","def write_to_xml(dictData, metadata, xmlfile):\n\tfout = codecs.open(xmlfile, 'w', 'utf-8')\n\tfout.write('<?xml version = \"1.0\" encoding = \"UTF-8\" standalone = \"no\" ?>\\n')\n\tfout.write('<?xml-stylesheet type=\"text/xsl\" href=\"maketable.xsl\"?>\\n')\n\tfout.write('<root>\\n')\n\tfout.write('<meta>\\n')\n\tfor key, value in metadata.items():\n\t\tfout.write('<' + key + '>' + value + '</' + key + '>\\n')\n\tfout.write('</meta>\\n')\n\tfout.write('<content>\\n')\n\tfor (hw, meanings, verse, verseNumDetails, pageNumDetails) in dictData:\n\t\txmlline = ''\n\t\txmlline += '<word><headword>' + hw + '</headword><meanings>'\n\t\tfor meaning in meanings:\n\t\t\txmlline += '<m>' + meaning + '</m>'\n\t\txmlline += '</meanings>'\n\t\txmlline += '<verse>'\n\t\tlines = verse.split('<BR>')\n\t\tfor line in lines:\n\t\t\txmlline += '<line>' + line + '</line>'\n\t\txmlline += '</verse>'\n\t\txmlline += '<verseNumber>' + verseNumDetails + '</verseNumber>'\n\t\txmlline += '<pageNumber>' + pageNumDetails + '</pageNumber></word>'\n\t\t# Write in babylon format. <BR><BR> is to separate verses.\n\t\tfout.write(xmlline + '\\n')\n\t\txmlline = ''\n\tfout.write('</content>\\n</root>')\n\tfout.close()\n\n\t# Give some summary to the user\n\tprint('XML file generated. Success!')\n\tprint('{} metadata lines and {} content lines written to XML file.'.format(len(metadata), len(dictData)))","def create_conf_xml(self):\n path = os.path.join(\n self.buildout['buildout']['parts-directory'],\n self.name)\n if not os.path.isdir(path):\n os.makedirs(path)\n\n xml_path = os.path.join(path, 'uwsgi.xml')\n\n conf = \"\"\n for key, value in self.conf.items():\n if value.lower() in ('true', 'on', 'yes'):\n conf += \"<%s/>\\n\" % key\n elif value and value.lower() not in ('false', 'off', 'yes'):\n conf += \"<%s>%s</%s>\\n\" % (key, value, key)\n\n\n requirements, ws = self.egg.working_set()\n eggs_paths = [dist.location for dist in ws]\n eggs_paths.extend(self.get_extra_paths())\n # order preserving unique\n unique_egg_paths = []\n for p in eggs_paths:\n if p not in unique_egg_paths:\n unique_egg_paths.append(p)\n\n for path in map(realpath, unique_egg_paths):\n conf += \"<pythonpath>%s</pythonpath>\\n\" % path\n\n f = open(xml_path, 'w')\n f.write(\"<uwsgi>\\n%s</uwsgi>\" % conf)\n f.close()\n return xml_path","def test_01_FindXml(self):","def xml_to_conll(self, xml_file_path):\n\n if not os.path.exists(CONLL_PATH):\n self.create_directories(CONLL_PATH)\n\n\n for file in os.listdir(xml_file_path):\n\n # Set path to file\n file = xml_file_path+file\n\n # Open files only, ignore subdirectories\n if os.path.isfile(file) and file.lower().endswith('.xml'):\n\n # Open Files\n chapter_input = open(file, 'r', encoding='utf8')\n\n # Create Same Filename in Output Folder\n chapter_output = open(CONLL_PATH+os.path.split(file)[-1]+'.conll', 'w', encoding='utf8')\n\n print('Converting: ' + chapter_input.name + ' to Conll09 file: ' + chapter_output.name)\n\n chapter_input = BeautifulSoup(chapter_input, 'xml')\n for sentence in chapter_input.find_all('s'):\n line_id = 0\n for terminal in sentence.find_all('t'):\n line_id, terminal_id, form, lemma, plemma = line_id+1, terminal.get('id'), terminal.get('word'), terminal.get('lemma'), terminal.get('lemma')\n pos, ppos = terminal.get('pos'), terminal.get('pos')\n feat, pfeat, head, phead, deprel, pdeprel, fillpred, pred, apred1 = \"_\" * 9 # <3 Python!\n chapter_output.write(\"%s\" \"\\t\" \"%s\" \"\\t\" \"%s\" \"\\t\" \"%s\" \"\\t\" \"%s\" \"\\t\" \"%s\" \"\\t\" \"%s\" \"\\t\"\n \"%s\" \"\\t\" \"%s\" \"\\t\" \"%s\" \"\\t\" \"%s\" \"\\t\" \"%s\" \"\\t\" \"%s\" \"\\t\" \"%s\" \"\\t\" \"%s\" \"\\n\"\n % (str(line_id)+\"-\"+terminal_id, form, lemma, plemma, pos, ppos, feat, pfeat, head, phead, deprel, pdeprel, fillpred, pred, apred1))\n chapter_output.write(\"\\n\")\n\n chapter_output.close()\n\n print(\"Done!\")","def test_01_Xml0(self):\n l_xml = self.m_xml.light_sect[0]\n print(PrettyFormatAny.form(l_xml, 'C1-01-A - XML'))\n self.assertEqual(l_xml.attrib['Name'], TESTING_LIGHT_NAME_0)\n self.assertEqual(l_xml.find('DeviceFamily').text, TESTING_DEVICE_FAMILY_INSTEON)","def test_xml_safety_flag(self):\r\n\r\n self._setstaff_login()\r\n response = self._add_edx4edx()\r\n self.assertIn('GIT_IMPORT_WITH_XMLMODULESTORE', response.content)\r\n\r\n def_ms = modulestore()\r\n course = def_ms.courses.get('{0}/edx4edx_lite'.format(\r\n os.path.abspath(settings.DATA_DIR)), None)\r\n self.assertIsNone(course)","def test_build(self):\n version = \"1.2.3\"\n input1, output1 = self.getArbitraryLoreInputAndOutput(version)\n input2, output2 = self.getArbitraryLoreInputAndOutput(version)\n\n self.howtoDir.child(\"one.xhtml\").setContent(input1)\n self.howtoDir.child(\"two.xhtml\").setContent(input2)\n\n self.builder.build(version, self.howtoDir, self.howtoDir,\n self.templateFile)\n out1 = self.howtoDir.child('one.html')\n out2 = self.howtoDir.child('two.html')\n self.assertXMLEqual(out1.getContent(), output1)\n self.assertXMLEqual(out2.getContent(), output2)","def test_basic_xml(self):\n j2k = Jp2k(self.j2kfile)\n\n self.jp2h.box = [self.ihdr, self.colr]\n\n doc = ET.parse(BytesIO(b'<?xml version=\"1.0\"?><data>0</data>'))\n xmlb = glymur.jp2box.XMLBox(xml=doc)\n self.assertEqual(ET.tostring(xmlb.xml.getroot()),\n b'<data>0</data>')\n\n boxes = [self.jp2b, self.ftyp, self.jp2h, xmlb, self.jp2c]\n\n with tempfile.NamedTemporaryFile(suffix=\".jp2\") as tfile:\n j2k.wrap(tfile.name, boxes=boxes)\n jp2 = Jp2k(tfile.name)\n self.assertEqual(jp2.box[3].box_id, 'xml ')\n self.assertEqual(ET.tostring(jp2.box[3].xml.getroot()),\n b'<data>0</data>')","def parseXML(xml_file, xml_file2):\r\n #tree = ET.ElementTree(file=xml_file)\r\n tree = ET.ElementTree(file=xml_file)\r\n #print (tree.getroot())\r\n root = tree.getroot()\r\n\r\n #tree2 = ET.ElementTree(file=xml_file2)\r\n tree2 = ET.ElementTree(file=xml_file2)\r\n root2 = tree2.getroot()\r\n\r\n #print (\"tag=%s, attrib=%s\" % (root.tag, root.attrib))\r\n from prettytable import PrettyTable\r\n t = PrettyTable(['N','Component', env, env2])\r\n count=1\r\n for child in root:\r\n for child2 in root2: \r\n if child.get('name') == child2.get('name'): \r\n if child.get('version') != child2.get('version'):\r\n if stg_filter == 1: \r\n if child.get('name')[:7].find(\"STAGING\") != 0:\r\n #print(child.get('name')[:7].find(\"STAGING\"))\r\n #print (\"---------STABLE-------\", child.get('name'), \"-->\" , child.get('version'), \"---------PROD-------\",child2.get('name'), \"-->\" , child2.get('version'))\r\n #print (child2.get('name'), \"------->\" , child2.get('version'))\r\n #print(\"hola\")\r\n #t.add_row([child.get('name'), child.get('version'), child2.get('version')])\r\n t.add_row([count,child.get('name'), child.get('version'), child2.get('version')])\r\n #t.add_row(['Bob', 19])\r\n count=count+1\r\n else:\r\n #print (\"---------STABLE-------\", child.get('name'), \"-->\" , child.get('version'), \"---------PROD-------\",child2.get('name'), \"-->\" , child2.get('version'))\r\n #print (child2.get('name'), \"------->\" , child2.get('version'))\r\n #print(\"hola\")\r\n #t.add_row([child.get('name'), child.get('version'), child2.get('version')])\r\n t.add_row([count,child.get('name'), child.get('version'), child2.get('version')])\r\n #t.add_row(['Bob', 19])\r\n count=count+1 \r\n print (t)","def setUp(self):\r\n super(TestImport, self).setUp()\r\n self.content_dir = path(tempfile.mkdtemp())\r\n self.addCleanup(shutil.rmtree, self.content_dir)\r\n\r\n # Create good course xml\r\n self.good_dir = self.create_course_xml(self.content_dir, self.BASE_COURSE_KEY)\r\n\r\n # Create run changed course xml\r\n self.dupe_dir = self.create_course_xml(self.content_dir, self.DIFF_KEY)\r\n\r\n # Create course XML where TRUNCATED_COURSE.org == BASE_COURSE_ID.org\r\n # and BASE_COURSE_ID.startswith(TRUNCATED_COURSE.course)\r\n self.course_dir = self.create_course_xml(self.content_dir, self.TRUNCATED_KEY)","def xml_parser_specific(request, tmpdir_factory):\n testdir = os.path.dirname(__file__)\n xmlfile = testdir + \"/specific.xml\"\n tmpfile = str(tmpdir_factory.mktemp('data').join('basic_trunc.xml'))\n xml_truncate(request.param, xmlfile, tmpfile)\n xml = vasprun.Xml(tmpfile, event = False)\n return xml","def buildGPXDocument(gpxFileName, someGPXDocument):\n # obtains the DOM representation of the GPX file\n # (the content of the file instantiated in a structure of xml.dom.minidom)\n dom = parse(gpxFileName)\n for trk in dom.getElementsByTagName(\"trk\"):\n someGPXDocument.setTrack(buildTrack(trk))\n for rte in dom.getElementsByTagName(\"rte\"):\n someGPXDocument.setRoute(buildRoute(rte)) \n someGPXDocument.setWayPoints(buildWayPointList(dom))","def example_xml_file40():\n return load_xml('datacite-v4.0-full-example.xml')","def sample_xml(opts,file):\r\n with open(file, opts) as xml:\r\n return xml.read()","def testBuildElement(self):\n self.assertEqual(\n b'<ColorCorrectionRef ref=\"uniqueId\"/>\\n',\n self.ccr.xml\n )","def thredds_catalog(self, tmpdir_factory):\n input_dir = os.path.abspath(\"esacci_esgf/test_input_catalogs\")\n output_dir = str(tmpdir_factory.mktemp(\"output\", numbered=True))\n # Process all catalogs in input dir and create aggregations with WMS\n test_files = glob(\"{}/*.xml\".format(input_dir))\n assert test_files, \"No test catalogs found\"\n\n pb = ProcessBatch([\"-aw\", \"-o\", output_dir] + test_files)\n pb.do_all()\n tree = ET.ElementTree()\n tree.parse(os.path.join(output_dir, os.listdir(input_dir)[0]))\n return tree.getroot()","def test_02_Tags(self):\n # print(PrettyFormatAny.form(self.m_xml, 'Xml'))\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\n self.assertEqual(self.m_xml.computer_div.tag, 'ComputerDivision')\n self.assertEqual(self.m_xml.house_div.tag, 'HouseDivision')\n self.assertEqual(self.m_xml.lighting_sect.tag, 'LightingSection')\n self.assertEqual(self.m_xml.button_sect.tag, 'ButtonSection')\n self.assertEqual(self.m_xml.button.tag, 'Button')\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection')\n self.assertEqual(self.m_xml.controller.tag, 'Controller')\n self.assertEqual(self.m_xml.light_sect.tag, 'LightSection')\n self.assertEqual(self.m_xml.light.tag, 'Light')","def test_xml_from_dict(self):\n d = make_section_dict() # using default values\n e = dict_to_xml_str(d)\n e = prettify(e)\n\n if SHOW_RESULTS:\n print(e)\n\n xml_file = StringIO(unicode(e))\n self.assertTrue(verify_files(xml_file, open(SECTION_DTD_FILENAME, 'r')))","def xml_bdsc(alignment, data, outdir, yaml, yaml_dir, yaml_glob, clock, mcmc, length, hot, intervals, prefix, sample_prior, model_prior, tag):\n\n if yaml_dir is not None:\n yaml_files = {f.stem: f for f in yaml_dir.glob(f\"{yaml_glob}\")}\n else:\n yaml_files = {prefix: yaml}\n\n outdir.mkdir(parents=True, exist_ok=True)\n\n for prefix, y in yaml_files.items():\n\n bdsc = BirthDeathSkylineContemporary(\n alignment=alignment,\n data=data,\n clock_model=clock,\n chain_type=mcmc,\n chain_length=length,\n chain_number=hot+1,\n prefix=prefix,\n sample_prior=sample_prior\n )\n\n bdsc.print_configuration()\n bdsc.check_configuration()\n\n config = bdsc.read_config(file=yaml)\n\n # Set model prior configuration\n model_priors = config.get('priors').get('model')\n # Modify the model prior configs if settings are passed\n if model_prior:\n model_priors = modify_model_priors(model_priors, model_prior, tag, prefix)\n\n bdsc.set_model_priors(prior_config=model_priors, distribution=True)\n\n # Set clock prior configuration\n clock_priors = config.get('priors').get('clock')\n bdsc.set_clock(prior_config=clock_priors)\n\n if intervals:\n # Set slice configurations and overwrite associated priors\n slice_config = config.get('priors').get('intervals')\n bdsc.set_slices(slice_config=slice_config)\n\n bdsc.construct_template(\n xml=outdir / f'{prefix}.xml'\n )","def main():\n #short GPS Test\n filename = 'KML_short_test.kml'\n gps_filename = 'gps_short_test.txt'\n gpsfile = open(gps_filename, 'r')\n file = open(filename, 'w')\n addHeader(file)\n coordinate_lst = convert(gpsfile)\n cleaned = GPS_to_CostMap.clean_gps_data(coordinate_lst)\n write_coordinates(cleaned, file)\n addTrailer(file)\n file.close()\n\n #Repeat test\n filename = 'KML_repeat_test1.kml'\n gps_filename = 'gps_1.txt'\n gpsfile = open(gps_filename, 'r')\n file = open(filename, 'w')\n addHeader(file)\n coordinate_lst = convert(gpsfile)\n cleaned = GPS_to_CostMap.clean_gps_data(coordinate_lst)\n write_coordinates(cleaned, file)\n addTrailer(file)\n file.close()\n\n filename = 'KML_repeat_test2.kml'\n gps_filename = 'gps_1.txt'\n gpsfile = open(gps_filename, 'r')\n file = open(filename, 'w')\n addHeader(file)\n coordinate_lst = convert(gpsfile)\n cleaned = GPS_to_CostMap.clean_gps_data(coordinate_lst)\n write_coordinates(cleaned, file)\n addTrailer(file)\n file.close()","def main(self):\n root = etree.Element(\"OpenSCENARIO\")\n self.get_header(root)\n self.get_parameter_declarations(root)\n etree.SubElement(root, \"CatalogLocations\")\n self.get_road_network(root)\n self.get_entities(root)\n storyboard = etree.SubElement(root, \"Storyboard\")\n self.get_init(storyboard)\n story = etree.SubElement(storyboard, \"Story\")\n story.set(\"name\", \"OSC Generated Story\")\n act = etree.SubElement(story, \"Act\")\n act.set(\"name\", \"OSC Generated Act\")\n self.get_maneuvers(act)\n self.get_story_start_trigger(act)\n self.get_story_stop_trigger(act)\n self.get_end_eval_criteria(storyboard)\n\n generated_xml = etree.tostring(root)\n self.write_xosc(generated_xml)","def example_xml_file41():\n return load_xml('datacite-v4.1-full-example.xml')","def test_valid_xml(self):\r\n self.build_problem()\r\n self.assertTrue(True)","def _get_eps_xml(self):\n format_path = os.path.join(os.path.dirname(__file__), \"formats\")\n\n # loop through files where filename starts with \"eps_ascat\".\n for filename in fnmatch.filter(os.listdir(format_path), \"eps_ascat*\"):\n doc = etree.parse(os.path.join(format_path, filename))\n file_extension = doc.xpath(\"//file-extensions\")[0].getchildren()[0]\n\n format_version = doc.xpath(\"//format-version\")\n for elem in format_version:\n major = elem.getchildren()[0]\n minor = elem.getchildren()[1]\n\n # return the xml file matching the metadata of the datafile.\n if major.text == self.mphr[\"FORMAT_MAJOR_VERSION\"] and \\\n minor.text == self.mphr[\"FORMAT_MINOR_VERSION\"] and \\\n self.mphr[\n \"PROCESSING_LEVEL\"] in file_extension.text and \\\n self.mphr[\"PRODUCT_TYPE\"] in file_extension.text:\n return os.path.join(format_path, filename)","def collect_data(self, output_dir=os.path.join(ROOT_DIR, \"output\", \"license_check.out\")):\n # read rules from RULE_XML\n _dom = xml.dom.minidom.parse(RULE_XML)\n _root = _dom.documentElement\n if _root:\n items_node = _root.getElementsByTagName(\"items\")\n if items_node:\n # load rule.xml into item_list\n item_list = items_node[0].getElementsByTagName(\"item\")\n license_check_result_dict = {}\n # iterate to check every item\n for _item in item_list:\n product = _item.getAttribute('product')\n # the product is exit if there are one or more conditions fit\n if product in license_check_result_dict.keys():\n license_check_result_dict[product] = \\\n license_check_result_dict[product] or self.check_product(_item)\n else:\n license_check_result_dict[product] = self.check_product(_item)\n # write dict to json file\n ProcessJson.output_json_file(license_check_result_dict, output_dir)","def _construct_data_xml(self, xml_file_list):\n award_dict = {}\n award_list = []\n for xml_file in xml_file_list:\n xml_file.seek(0)\n tree = ET.parse(xml_file)\n root = tree.getroot()\n\n for response in root:\n temp_dict = {}\n for award in response:\n if award.tag == 'entry':\n continue\n try:\n # temp_dict[award.tag].append(award.text)\n temp_dict[award.tag] = award.text\n except KeyError:\n print(\"KeyError\")\n # temp_dict[award.tag] = [award.text]\n\n # if 'entry' in temp_dict.keys():\n # del temp_dict['entry']\n if len(temp_dict) > 0:\n award_list.append(temp_dict)\n\n return award_list","def generate_expected_file(self, expected_file, xml_name):\n\t\tlogging.info('Gerando arquivo de documentos esperados')\n\t\tcontent = self.read_xml(xml_name)\n\n\t\twith open(expected_file, 'w', newline='') as csvfile:\n\t\t\tfieldnames = ['QueryNumber', 'DocNumber', 'DocVotes']\n\t\t\twriter = csv.DictWriter(csvfile, fieldnames=fieldnames)\n\n\t\t\twriter.writeheader()\n\t\t\tfor index in range(0, len(content['QueryNumber'])):\n\t\t\t\tcount_results = 0\n\t\t\t\tlogging.info('Escrevendo documentos da consulta '+str(index+1)+'/'+str(len(content['QueryNumber'])))\n\t\t\t\tfor result in content['Records'][index]:\n\t\t\t\t\twriter.writerow({'QueryNumber': content['QueryNumber'][index], 'DocNumber': result[0], \n\t\t\t\t\t\t\t\t\t 'DocVotes': result[1]})\n\t\t\t\t\tcount_results += 1\n\t\t\t\t\tif count_results == int(content['Results'][index]): break","def test_XmlDumpAllRevs(self):\n pages = get_entries('article-pear.xml', allrevisions=True)\n self.assertLength(pages, 4)\n self.assertEqual('Automated conversion', pages[0].comment)\n self.assertEqual('Pear', pages[0].title)\n self.assertEqual('24278', pages[0].id)\n self.assertTrue(pages[0].text.startswith('Pears are [[tree]]s of'))\n self.assertEqual('Quercusrobur', pages[1].username)\n self.assertEqual('Pear', pages[0].title)","def _get_all_xml(self):\n\n # add all xml files to list\n for file in os.listdir(self._hero_folder):\n if file.endswith(\".xml\"):\n self._xml_list.append(file)\n\n # read all attr, skill, spell, fight_talent entries of hero file\n for _, value in enumerate(self._xml_list):\n name = value.replace(\".xml\", '')\n hero_root = self._parse_xml(value)\n attrs = self._read_attributes(hero_root)\n skills = self._read_skills(hero_root)\n spells = self._read_spells(hero_root)\n fight_talents = self._read_fight_talents(hero_root)\n advantages = self._read_advantages(hero_root)\n special_skills = self._read_special_skills(hero_root)\n\n # some entries are both skill and special skill, e.g.\n # \"Ritualkenntnis: Hexe\", special skill does not need to be tested\n # so it is removed\n for skill in skills:\n for index, special_skill in enumerate(special_skills):\n if skill.name == special_skill.name:\n special_skills.pop(index)\n\n self._heroes.update({name: Hero(name,\n hero_root,\n attrs,\n skills,\n spells,\n fight_talents,\n advantages,\n special_skills)})","def sensibility_conformity_to_xml(xml_path):\n\tprint('ADDING SENSBIL and CFM to:', xml_path)\n\ttree = ET.parse(xml_path)\n\troot = tree.getroot()\n\n\tmetrics_dic = create_dict_from_xml(xml_path)\n\n\tvalsensibility = calculate_sensibility(metrics_dic)\n\tvalconformity = calculate_conformity(metrics_dic)\n\n\tsensibility_attributes = {\"name\": \"sensibility\", \"value\": str(valsensibility), \"symbol\": \"SENSBIL\",\n\t\t\t\t\t\t\t \"type\": \"similarity\", \"unit\": \"voxel\"}\n\tSENSBIL = ET.Element(\"SENSBIL\", attrib=sensibility_attributes)\n\tconformity_attributes = {\"name\": \"conformity\", \"value\": str(valconformity), \"symbol\": \"CFM\", \"type\": \"similarity\",\n\t\t\t\t\t\t\t \"unit\": \"voxel\"}\n\tCFM = ET.Element(\"CFM\", attrib=conformity_attributes)\n\n\troot[2].insert(2, SENSBIL)\n\troot[2].insert(3, CFM)\n\ttree.write(xml_path)","def parse2016(filename, qdict, cdict):\n \n tree = ET.parse(filename)\n root = tree.getroot()\n\n for child in root:\n # Each child represents a new (original question, related question) pair\n orgq_id = child.attrib[\"ORGQ_ID\"]\n relq_id = child[2].attrib[\"THREAD_SEQUENCE\"]\n orgq_comment = []\n relq_comment = []\n # get orgq_comment, relq_comment\n orgq_subject = child[0].text if child[0].text != None else \"\"\n orgq_body = child[1].text if child[1].text != None else \"\"\n DUPLICATE = True if \"SubtaskA_Skip_Because_Same_As_RelQuestion_ID\" in child[2].attrib else False \n for rel in child[2]:\n if rel.tag == \"RelQuestion\":\n relq_subject = rel[0].text if rel[0].text != None else \"\"\n relq_body = rel[1].text if rel[1].text != None else \"\"\n elif rel.tag == \"RelComment\":\n c_text = rel[0].text\n orgq_c_label = rel.attrib[\"RELC_RELEVANCE2ORGQ\"]\n orgq_comment.append((c_text, orgq_c_label))\n relq_c_label = rel.attrib[\"RELC_RELEVANCE2RELQ\"]\n relq_comment.append((c_text, relq_c_label))\n\n if DUPLICATE is False:\n qdict[relq_id] = (relq_subject, relq_body)\n cdict[relq_id] = relq_comment\n \n if (orgq_id in qdict) != (orgq_id in cdict):\n print(\"WARNING qdict inconsistent with cdict\")\n elif orgq_id not in qdict:\n qdict[orgq_id] = (orgq_subject, orgq_body)\n cdict[orgq_id] = relq_comment\n else:\n cdict[orgq_id] = cdict[orgq_id] + orgq_comment\n \n return qdict, cdict","def complete_xml_parsing(self):\n for item in self.entities:\n item.severity = self.parsed_severity\n item.cwes.extend(self.parsed_cwes)\n item.advisory_id = self.parsed_advisory_id\n item.attack_vector = self.parsed_attack_vector\n if self.parsed_cvss_base != '' and is_correct_score(self.parsed_cvss_base):\n cvss_v3 = CvssV3(base_sc=self.parsed_cvss_base)\n if self.parsed_cvss_temporal != '' \\\n and is_correct_score(self.parsed_cvss_temporal):\n cvss_v3.temporal_sc = self.parsed_cvss_temporal\n item.cvss_v3 = cvss_v3\n item.cvss_base_sc_v3 = self.parsed_cvss_base\n item.cvss_temporal_score_v3 = self.parsed_cvss_temporal\n item.published = self.parsed_date","def cueword_statistics(self, xml_file_path):\n\n print('Extracting cueword statistics from:', xml_file_path, 'to:', CUEWORDS_STATS_PATH)\n\n if not os.path.exists(CUEWORDS_STATS_PATH):\n self.create_directories(CUEWORDS_STATS_PATH)\n\n # Go through all files in xml_file_path directory\n for file in os.listdir(xml_file_path):\n\n # For each file, open, parseXML\n file = xml_file_path+file\n\n # Open files only, ignore subdirectories\n if os.path.isfile(file) and file.lower().endswith('.xml'):\n\n chapter_input = open(file, 'r', encoding='utf8')\n chapter_output = open(CUEWORDS_STATS_PATH+os.path.split(file)[-1]+'_stats.txt',\n 'w', encoding='utf8')\n\n # Try html.parser for ignoring lower and UPPER Tag and attr names\n chapter_input = BeautifulSoup(chapter_input, 'xml')\n\n for sentence in chapter_input.find_all('s'):\n # Terminals and Semantics\n #terminals = sentence.find_all('t')\n semantics = sentence.find('sem')\n\n # If splitwords exist\n if semantics.find('splitwords'):\n splitwords = semantics.find('splitwords')\n splitword = splitwords.find_all('splitword')\n\n # For each splitword\n for s_w in splitword:\n\n # Get reference id\n # <splitword idref=\"x\">\n splitword_idref = s_w.get('idref')\n\n # Get corresponding terminal and its POS tag\n # <t id=\"x\" pos=\"ADJA\" word=\"unerschütterlichen\"/>\n terminal = sentence.find(id=splitword_idref).get('word')\n pos = sentence.find(id=splitword_idref).get('pos')\n\n #print(splitword_idref,'\\t',terminal,'\\t',pos)\n chapter_output.write('\\n' '=SPLITWORDS=' '\\n')\n chapter_output.write('%s' '\\t' '%s' '\\t' '%s' '\\n' %\n (splitword_idref, terminal, pos))\n\n # Find parts of splitword\n parts = s_w.find_all('part')\n part1 = parts[0].get('id')\n part2 = parts[1].get('id')\n\n for part in parts:\n part_word = part.get('word')\n part_id = part.get('id')\n #print(part_id,'\\t',part_word)\n chapter_output.write('%s' '\\t' '%s' '\\n'\n % (part_id, part_word))\n\n # Find corresponding frames\n frames = semantics.find('frames')\n frame = frames.find_all('frame')\n\n for frame_tag in frame:\n\n # skip first letter in case of n|Negation\n if frame_tag['name'] == NEGATION_FRAME_NAME:\n\n # Find target\n target = frame_tag.find('target')\n fenode = target.find('fenode')\n fenode_id = fenode.get('idref')\n\n # Check part ID if == target ID\n if part1 == fenode_id or part2 == fenode_id or splitword_idref == fenode_id:\n\n part_word = sentence.find(id=fenode_id).get('word')\n #print(fenode_id,'\\t','target')\n chapter_output.write('%s' '\\t' '%s' '\\n'\n % (fenode_id, 'TARGET'))\n\n\n # try and except blocks because of parser lowerUPPER errors\n\n #Find Negated\n try:\n negated = frame_tag.find('fe', {'name' : NEGATED_TAG_NAME})\n negated_fenode_idref = negated.find('fenode').get('idref')\n except AttributeError:\n negated = ''\n negated_fenode_idref = ''\n #print(negated_fenode_idref,'\\t',negated['name'].lower())\n try:\n chapter_output.write('%s' '\\t' '%s' '\\n'\n % (negated_fenode_idref, negated['name'].upper()))\n except TypeError:\n chapter_output.write('')\n\n #Find Scope\n try:\n scope = frame_tag.find('fe', {'name' : SCOPE_TAG_NAME})\n scope_fenode_idref = scope.find('fenode').get('idref')\n except AttributeError:\n scope = ''\n scope_fenode_idref = ''\n #print(scope_fenode_idref,'\\t',scope['name'].lower())\n try:\n chapter_output.write('%s' '\\t' '%s' '\\n'\n % (scope_fenode_idref, scope['name'].upper()))\n except TypeError:\n chapter_output.write('')\n\n #Find Focus\n try:\n focus = frame_tag.find('fe', {'name' : FOCUS_TAG_NAME})\n focus_fenode_idref = focus.find('fenode').get('idref')\n except AttributeError:\n focus = ''\n focus_fenode_idref = ''\n\n #print(focus_fenode_idref,'\\t',focus['name'].lower())\n try:\n chapter_output.write('%s' '\\t' '%s' '\\n'\n % (focus_fenode_idref, focus['name'].upper()))\n except TypeError:\n chapter_output.write('')\n\n #end if splitwords\n\n else:\n\n # If Frames exist\n if semantics.find('frames'):\n\n frames = semantics.find('frames')\n frame = frames.find_all('frame')\n\n chapter_output.write('\\n' '=SCOPE/FOCUS=' '\\n')\n\n for frame_tag in frame:\n\n # skip first letter in case of n|Negation\n if frame_tag['name'] == NEGATION_FRAME_NAME:\n\n #scope_list = []\n\n # Find target\n target = frame_tag.find('target')\n fenode = target.find('fenode')\n fenode_id = fenode.get('idref')\n\n word = sentence.find(id=fenode_id).get('word')\n pos = sentence.find(id=fenode_id).get('pos')\n\n chapter_output.write('%s' '\\t' '%s' '\\t' '%s' '\\n' % (fenode_id, word, pos))\n chapter_output.write('%s' '\\t' '%s' '\\n' % (fenode_id, 'TARGET'))\n\n #Find Negated\n if frame_tag.find('fe', {'name' : NEGATED_TAG_NAME}):\n try:\n negated = frame_tag.find('fe', {'name' : NEGATED_TAG_NAME})\n negated_fenode_idref = negated.find('fenode').get('idref')\n negated_word = sentence.find(id=negated_fenode_idref).get('word')\n negated_pos = sentence.find(id=negated_fenode_idref).get('pos')\n except AttributeError:\n negated = ''\n negated_fenode_idref = ''\n negated_word = ''\n negated_pos = ''\n\n chapter_output.write('%s' '\\t' '%s' '\\t' '%s' '\\t' '%s' '\\n'\n % (negated_fenode_idref, negated['name'].upper(), negated_word, negated_pos))\n\n\n # Resolve Terminals if Scope on a complex graph\n def resolve_non_terminals(idref):\n \"\"\" This function resolves a complex graph to\n a simple flat list of tokens.\n \"\"\"\n nonterminal = sentence.find(id=idref)\n edges = nonterminal.find_all('edge')\n edge_words = []\n for edge in edges:\n e_id = edge.get('idref')\n if sentence.find(id=e_id).get('word') is not None:\n try:\n edge_word = sentence.find(id=e_id).get('word')\n edge_words.append(edge_word)\n except:\n pass\n if sentence.find(id=e_id).get('word') is None:\n edge_words.append(resolve_non_terminals(e_id))\n\n return edge_words\n\n scopelist = []\n\n if frame_tag.find('fe', {'name' : SCOPE_TAG_NAME}):\n scope = frame_tag.find('fe', {'name' : SCOPE_TAG_NAME})\n scope_fenode = scope.find_all('fenode')\n for s_f in scope_fenode:\n s_id = s_f.get('idref')\n if sentence.find(id=s_id).get('word') is not None:\n try:\n scope_word = sentence.find(id=s_id).get('word')\n #scope_pos = scope_word.get('pos')\n scopelist.append(scope_word)\n except:\n pass\n if sentence.find(id=s_id).get('word') is None:\n pass\n else:\n pass\n\n chapter_output.write('%s' '\\t' '%s' '\\t' '%s' '\\n'\n % (s_id, scope['name'].upper(), resolve_non_terminals(s_id)))\n\n focuslist = []\n\n\n #chapter_output.write(str(scope_list))\n #Find Focus\n if frame_tag.find('fe', {'name' : FOCUS_TAG_NAME}):\n focus = frame_tag.find('fe', {'name' : FOCUS_TAG_NAME})\n focus_fenode = focus.find_all('fenode')\n for f_f in focus_fenode:\n f_id = f_f.get('idref')\n if sentence.find(id=f_id).get('word') is not None:\n try:\n focus_word = sentence.find(id=f_id).get('word')\n focus_pos = sentence.find(id=f_id).get('pos')\n focuslist.append(focus_word)\n except:\n pass\n if sentence.find(id=f_id).get('word') is None:\n pass\n else:\n pass\n\n chapter_output.write('%s' '\\t' '%s' '\\t' '%s' '\\t' '%s' '\\t' '%s' '\\n'\n % (f_id, focus['name'].upper(), focus_pos, focus_word, resolve_non_terminals(f_id)))\n\n\n chapter_output.close()\n\n print('Cuewords statistics extracted to:', chapter_output.name)","def gexfFormat(profile, recom, filename):\n # ! ids are raw -> strings\n clickedItems = set(map(lambda x: str(x[0]), profile)) # set of clicked items\n recomItems = set() # set of recommended items\n \n with open(filename, 'w') as f:\n # write header\n f.write(\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n\"\"\")\n f.write(\"\"\"<gexf xmlns:viz=\"http:///www.gexf.net/1.2/viz\" version=\"1.2\" xmlns=\"http://www.gexf.net/1.2\">\\n\"\"\")\n f.write(\"\"\"<graph defaultedgetype=\"undirected\" idtype=\"string\" type=\"static\">\\n\"\"\")\n \n # write edges\n f.write(\"\"\"<edges>\\n\"\"\")\n id = 0\n for click in range(0, len(profile)): # for all the clicks\n print(\"Number of processed clicks: \", click)\n for rec in recom[click]: # for the topN recommendations\n f.write(\"<edge id=\\\"\" + str(id) + \"\\\" source=\\\"\" + str(rec[0]) + \"\\\" target=\\\"\" + str(profile[click][0]) + \"\\\" weight=\\\"\" + str(rec[1]) + \"\\\"/>\\n\")\n recomItems.add(str(rec[0]))\n id += 1\n \n f.write(\"\"\"</edges>\\n\"\"\")\n \n f.write(\"\"\"<nodes>\\n\"\"\")\n # write clicked item-nodes in an outter ring\n angleStep = 2*np.pi / float(len(clickedItems)) # polar coordinates angle step\n angle = 0 # polar coordinates angle [0, 2pi]\n R = 1000 # outter\n for item in clickedItems: # for all the clicks\n target = str(item)\n f.write(\"<node id=\\\"\" + target + \"\\\">\\n\")\n f.write(\"\\t\")\n f.write(\"\"\"<viz:color r=\"255\" g=\"0\" b=\"0\"></viz:color>\\n\"\"\") # red color\n f.write(\"<viz:position x=\\\"\" + str(R * np.cos(angle)) + \"\\\" y=\\\"\" + str(R * np.sin(angle)) + \"\\\" z=\\\"0.0\\\"/>\") # ring position\n f.write(\"</node>\\n\")\n angle += angleStep\n \n # write the rest item-nodes in an inner ring\n angleStep = 2*np.pi / float(len(recomItems - clickedItems)) # polar coordinates angle step\n angle = 0 # polar coordinates angle [0, 2pi]\n R = 600 # outter\n for item in recomItems - clickedItems: # for the rest of the items\n target = str(item)\n f.write(\"<node id=\\\"\" + target + \"\\\">\\n\")\n f.write(\"\\t\")\n f.write(\"<viz:position x=\\\"\" + str(R * np.cos(angle)) + \"\\\" y=\\\"\" + str(R * np.sin(angle)) + \"\\\" z=\\\"0.0\\\"/>\") # ring position\n f.write(\"</node>\\n\")\n angle += angleStep\n \n f.write(\"\"\"</nodes>\\n\"\"\")\n f.write(\"\"\"</graph>\\n</gexf>\"\"\")","def _create_xml_report(self, test, xml_obj):\n xml_report_path = os.path.join(test.work_dir,\n self.XML_REPORT_PATH)\n with open(xml_report_path, 'w') as xml_report:\n xml_report.write(etree.tostring(xml_obj, pretty_print=True))","def buildNecessaryData():\n emaildata = loadEmailData()\n emailids = list(emaildata.keys())\n if os.stat('res/dictionary.txt').st_size == 0:\n print(\"Creating word list...\")\n createWordList(emailids, emaildata)\n print(\"Counting all words...\")\n englishwords = importDictionary()\n countAllWords(emaildata, englishwords)","def get_results(self):\n d = {}\n# r = {}\n for analyser in self.xml_tree.getroot():\n for child in analyser:\n if child.tag == 'all-records':\n for record in child:\n attributes = record.attrib\n sample = attributes['sampleId']\n assay_id = attributes['assayId']\n genotype = attributes['genotypeId']\n quality = attributes['description'].split('.')[0]\n if re.match(r'rs\\d+', assay_id):\n if sample in d:\n if assay_id in d[sample]:\n for allele in list(genotype):\n if allele not in d[sample][assay_id]['genotype']:\n d[sample][assay_id]['genotype'] += allele\n if quality not in d[sample][assay_id]['quality']:\n d[sample][assay_id]['quality'].append(quality)\n else:\n d[sample][assay_id] = {'genotype': genotype, 'quality': [quality]}\n else:\n d[sample] = {assay_id: {'genotype': genotype, 'quality': [quality]}}\n# if sample in r:\n# if assay_id in r[sample]:\n# for allele in list(genotype):\n# if allele not in r[sample][assay_id]:\n# r[sample][assay_id] += allele\n# else:\n# r[sample][assay_id] = genotype\n# else:\n# r[sample] = {assay_id: genotype}\n# for k, v in r.items():\n# for k1, v1, in v.items():\n# if len(v1) == 1:\n# v[k1] += v1\n# pprint.pprint(r)\n# df = pd.DataFrame.from_dict(r).transpose()\n# print(df)\n# df.to_excel('snpcheck.xlsx')\n return d","def makedocs(projectfolder):\n featuremodel_path = path.join(projectfolder, \"productline\", \"model.xml\")\n configs_path = path.join(projectfolder, \"productline\", \"configs\")\n bddfeatures_path = path.join(projectfolder, \"bddfeatures\")\n testreports_path = path.join(projectfolder, \"testreports\")\n\n fmparser = parsers.FeatureModelParser()\n resultsparser = parsers.TestResultsParser()\n feature_tree_renderer = ftrenderer.FeatureTreeRenderer()\n\n docs_dir = path.join(projectfolder, \"docs/generated\")\n if path.exists(docs_dir):\n shutil.rmtree(docs_dir)\n makedirs(docs_dir)\n\n lektor_templates_path = \"doc_templates\"\n utilities.sed_inplace(\n path.join(lektor_templates_path, \"aplet.lektorproject\"),\n r'<<PROJECT>>',\n CONFIG[\"project_name\"])\n\n products = {}\n product_names = get_product_names_from_configs_path(configs_path)\n for product_name in product_names:\n productconfig_filepath = path.join(projectfolder, \"productline/configs\", product_name + \".config\")\n product_html_report_name = \"report{0}.html\".format(product_name)\n product_html_results_src = path.join(testreports_path, product_html_report_name)\n product_xml_report_name = \"report{0}.xml\".format(product_name)\n product_xml_results_src = path.join(testreports_path, product_xml_report_name)\n\n with open(productconfig_filepath, \"r\") as productconfig_file:\n products[product_name] = {}\n products[product_name]['features'] = [feature.strip() for feature in productconfig_file.readlines()]\n\n current_product_lektor_dir = path.join(lektor_templates_path, \"content/products\", product_name)\n if not path.exists(current_product_lektor_dir):\n makedirs(current_product_lektor_dir)\n\n product_filepath = path.join(current_product_lektor_dir,\"contents.lr\")\n shutil.copyfile(path.join(lektor_templates_path, \"helpers/product_contents.lr\"), product_filepath)\n\n feature_model = fmparser.parse_from_file(featuremodel_path)\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_product_from_file(product_xml_results_src)\n configparser = parsers.ProductConfigParser(feature_model.root_feature.name)\n product_features = configparser.parse_config(productconfig_filepath)\n feature_model.trim_based_on_config(product_features)\n feature_model.add_gherkin_pieces(gherkin_pieces)\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\n\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\n feature_tree_renderer.render_as_svg(current_product_lektor_dir, \"feature_model\")\n\n utilities.sed_inplace(product_filepath, r'<<PRODUCT>>', product_name)\n product_test_status = feature_model.root_feature.test_status\n utilities.sed_inplace(product_filepath, \"<<TEST_STATUS>>\", product_test_status.name)\n\n # Copy test run html report to generated docs\n if path.exists(product_html_results_src):\n shutil.copyfile(product_html_results_src, path.join(current_product_lektor_dir, product_html_report_name))\n\n click.echo(\"- Generating feature model SVG...\")\n click.echo(featuremodel_path)\n\n feature_model = fmparser.parse_from_file(featuremodel_path)\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_dir(testreports_path)\n feature_model.add_gherkin_pieces(gherkin_pieces)\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\n\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\n feature_tree_renderer.render_as_svg(path.join(lektor_templates_path, \"content/\"), \"feature_model\")\n\n click.echo(\"- Building site\")\n lektor_cmd = [\"lektor\", \"--project\", lektor_templates_path, \"build\", \"-O\", path.abspath(docs_dir)]\n click.echo(\"Running: \" + subprocess.list2cmdline(lektor_cmd))\n subprocess.call(lektor_cmd)\n\n product_map_renderer = mapbuilder.ProductMapRenderer()\n productline_generated_filepath = path.join(docs_dir, \"index.html\")\n html = product_map_renderer.get_productmap_html(feature_model, products)\n utilities.sed_inplace(productline_generated_filepath, r'<<PRODUCTMAP>>', html)","def create_xml_regression(lfiles, lsbj, foxml):\n\n impl = xml.dom.minidom.getDOMImplementation()\n doc = impl.createDocument(None, \"some_tag\", None)\n top_element = doc.documentElement\n\n e = doc.createElement('subject')\n e.setAttribute('id', 'case')\n\n for i, fn in enumerate(lfiles):\n v = doc.createElement('visit')\n v.setAttribute('id', \"subj{}\".format(i))\n\n f = doc.createElement('filename')\n f.setAttribute('object_id', \"face\")\n t = doc.createTextNode(fn)\n f.appendChild(t)\n\n a = doc.createElement('age')\n x = doc.createTextNode(str(lsbj[i][\"age\"]))\n a.appendChild(x)\n\n\n v.appendChild(f)\n v.appendChild(a)\n e.appendChild(v)\n\n top_element.appendChild(e)\n\n with open(foxml, \"w\") as fo:\n fo.write(doc.toprettyxml())","def load_xml_files_erisk(local_dir, token_position=0):\n users = {}\n prep = Preprocessor()\n c = 0\n for dir_path, dir_names, filenames in os.walk(local_dir):\n for name in filenames:\n tok = name.split(\"_\")\n if token_position > 0:\n key = tok[0] + tok[token_position]\n else:\n key = tok[token_position]\n key = key.strip(\".xml\")\n full_file = os.path.abspath(os.path.join(dir_path, name))\n dom = ET.parse(full_file, parser=ET.XMLParser(encoding=\"utf-8\"))\n writing = dom.findall('WRITING')\n for w in writing:\n title = w.find('TITLE').text\n text = w.find('TEXT').text\n post = title + \" \" + text\n # preprocess text\n new_text = prep.tokenize_reddit(post)\n\n if key in users.keys():\n users[key] += new_text + ' end_ '\n else:\n users[key] = new_text + ' end_ '\n\n c += 1\n print(\"Preprocessed chunk: \", c)\n\n return users","def test_xml_files_with_missing_info():\n\n # Test when k is missing from constant type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/k_const.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when A is missing from Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when E is missing from Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/E_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when A is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_mod_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when b is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/b_mod_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when E is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/E_mod_arr.xml\"\n parser = XMLParser(xml_filename)","def example_xml_file43():\n return load_xml('datacite-v4.3-full-example.xml')","def buildxml2(self):\n # assume self._objslock is already held here\n logger.info(\"Emane.buildxml2()\")\n # on master, control network bridge added earlier in startup()\n ctrlnet = self.session.add_remove_control_net(net_index=0, remove=False, conf_required=False)\n self.buildplatformxml2(ctrlnet)\n self.buildnemxml()\n self.buildeventservicexml()","def process_cvat_xml(xml_file, image_dir, output_dir):\n KNOWN_TAGS = {'box', 'image', 'attribute'}\n #output_dir = os.path.join(output_dir, \"Annotations\")\n os.makedirs(output_dir, exist_ok=True)\n cvat_xml = etree.parse(xml_file)\n\n basename = os.path.splitext( os.path.basename( xml_file ) )[0]\n\n tracks= cvat_xml.findall( './/track' )\n\n if (tracks is not None) and (len(tracks) > 0):\n frames = {}\n\n for track in tracks:\n trackid = int(track.get(\"id\"))\n label = track.get(\"label\")\n boxes = track.findall( './box' )\n for box in boxes:\n frameid = int(box.get('frame'))\n outside = int(box.get('outside'))\n ## occluded and pose are not tested within tracks\n occluded = 0 ## Default if not found\n if 'occluded' in box.attrib: ## this is an attribute of 'box' element\n occluded = int(box.get('occluded'))\n pose = 'Unspecified'\n for attr in box.findall('attribute'):\n if (attr.get('name') == 'type'): ## Used for view type\n pose = attr.text\n #keyframe = int(box.get('keyframe')) #currently unused\n xtl = float(box.get('xtl'))\n ytl = float(box.get('ytl'))\n xbr = float(box.get('xbr'))\n ybr = float(box.get('ybr'))\n \n frame = frames.get( frameid, {} )\n \n if outside == 0:\n frame[ trackid ] = { 'xtl': xtl, 'ytl': ytl, 'xbr': xbr, 'ybr': ybr, 'label': label,\n 'pose': pose, 'truncated': occluded }\n\n frames[ frameid ] = frame\n\n width = int(cvat_xml.find('.//original_size/width').text)\n height = int(cvat_xml.find('.//original_size/height').text)\n\n # Spit out a list of each object for each frame\n for frameid in sorted(frames.keys()):\n print( frameid )\n\n image_name = \"%s_%08d.jpg\" % (basename, frameid) ## KM: Revisit this for tracks. Hardcoded?\n image_path = os.path.join(image_dir, image_name)\n if not os.path.exists(image_path):\n log.warn('{} image cannot be found. Is `{}` image directory correct?'.\n format(image_path, image_dir))\n writer = Writer(image_path, width, height)\n\n frame = frames[frameid]\n\n objids = sorted(frame.keys())\n\n for objid in objids:\n\n box = frame[objid]\n\n label = box.get('label')\n occluded = box.get('occluded')\n pose = box.get('pose')\n xmin = float(box.get('xtl'))\n ymin = float(box.get('ytl'))\n xmax = float(box.get('xbr'))\n ymax = float(box.get('ybr'))\n\n writer.addObject(label, xmin, ymin, xmax, ymax, pose, occluded)\n\n anno_name = os.path.basename(os.path.splitext(image_name)[0] + '.xml')\n anno_dir = os.path.dirname(os.path.join(output_dir, image_name))\n os.makedirs(anno_dir, exist_ok=True)\n writer.save(os.path.join(anno_dir, anno_name))\n\n else:\n for img_tag in cvat_xml.findall('image'):\n ## Discard path component; we expect user to provide path to images directory.\n ## It is probably easier for users to provide full path to images directory\n ## rather than having to figure out how much of the path is embedded in the XML\n ## as a relative or absolute path by CVAT.\n image_name = os.path.basename(img_tag.get('name'))\n width = img_tag.get('width')\n height = img_tag.get('height')\n image_path = os.path.join(image_dir, image_name)\n if not os.path.exists(image_path):\n log.warn('{} image cannot be found. Is `{}` image directory correct?'.\n format(image_path, image_dir))\n writer = Writer(image_path, width, height)\n\n unknown_tags = {x.tag for x in img_tag.iter()}.difference(KNOWN_TAGS)\n if unknown_tags:\n log.warn('Ignoring tags for image {}: {}'.format(image_path, unknown_tags))\n\n for box in img_tag.findall('box'):\n label = box.get('label')\n occluded = 0 ## Default if not found\n if 'occluded' in box.attrib: ## this is an attribute of 'box' element\n occluded = int(box.get('occluded'))\n pose = 'Unspecified' ## Default if not found\n for attr in box.findall('attribute'):\n if (attr.get('name') == 'type'): ## Used for view type\n pose = attr.text\n\n xmin = float(box.get('xtl'))\n ymin = float(box.get('ytl'))\n xmax = float(box.get('xbr'))\n ymax = float(box.get('ybr'))\n\n writer.addObject(label, xmin, ymin, xmax, ymax, pose, occluded)\n\n anno_name = os.path.basename(os.path.splitext(image_name)[0] + '.xml')\n anno_dir = output_dir #os.path.dirname(os.path.join(output_dir, image_name))\n os.makedirs(anno_dir, exist_ok=True)\n #print(\"Writing {} (image: {})\".format(anno_name, image_name))\n writer.save(os.path.join(anno_dir, anno_name))","def make_inert_xml(mech, species, out_file):\n file_type = '.xml'\n _check_input_filetype(mech, file_type)\n out_file = _check_output_filetype(out_file, file_type)\n species = _enforce_species_list(species)\n mech_dir, in_loc, out_loc = _get_file_locations(mech, out_file)\n\n with open(in_loc, 'r') as f:\n data_in = f.read()\n\n indicator = '<reactionData id=\"reaction_data\">'\n start_loc = data_in.find(indicator) + len(indicator) + 1\n header = data_in[:start_loc]\n to_scan = data_in[start_loc:]\n rxn_indicator = '<!-- reaction'\n scanned = to_scan.split(rxn_indicator)[1:]\n new_rxns = ''\n\n for loc, rxn in enumerate(scanned):\n # if any of the desired species are in the current reaction, delete\n # it from the mechanism\n rxn = rxn_indicator + rxn\n eqn_indicators = ['<equation>', '</equation>']\n eqn_start = rxn.find(eqn_indicators[0]) + len(eqn_indicators[0])\n eqn_end = rxn.find(eqn_indicators[1])\n eqn = rxn[eqn_start:eqn_end]\n\n if not any([_find_specie_in_str(s, eqn) for s in species]):\n new_rxns += rxn\n\n new_mech = header + '\\n\\n' + new_rxns\n with open(out_loc, 'w') as f:\n f.writelines(new_mech)\n f.flush()","def print_xml_config(config_dictionary,**kwargs):\n \n #Check if we have passed a filename\n #If not, pass a default filename\n if 'config_file' in kwargs:\n config_file = kwargs['config_file']\n else:\n config_file = 'ebtel_config.xml'\n \n #Open the file\n f = open(config_file,'w')\n \n #Print necessary header info\n f.write('<?xml version=\"1.0\" ?>\\n')\n f.write('<input>\\n')\n\n #Loop through dictionary and print to xml file\n for key in config_dictionary:\n #Print tab delimiter, brackets and keyword\n f.write('\\t<')\n f.write(key)\n f.write('>')\n #Check if entry is a list\n #If so print it as a list\n if isinstance(config_dictionary[key],list) or type(config_dictionary[key]).__name__ == 'ndarray':\n #Make temporary list\n temp = config_dictionary[key]\n #Skip to new line\n f.write('\\n')\n #Begin loop over list\n for i in range(len(config_dictionary[key])):\n f.write('\\t\\t<')\n f.write(key+str(i))\n f.write('>')\n f.write(str(temp[i]))\n f.write('</')\n f.write(key+str(i))\n f.write('>\\n')\n #Print additional tab to preserve alignment\n f.write('\\t')\n else:\n #Print value\n f.write(str(config_dictionary[key]))\n #Close the brackets and print newline\n f.write('</')\n f.write(key)\n f.write('>\\n')\n \n #Close the main node of the file\n f.write('</input>')\n \n #Close the file\n f.close()","def test_augmentsXML(self):\n fileName = self.mktemp()\n fp = FilePath(fileName)\n fp.setContent(oldAugmentsFormat)\n upgradeAugmentsXML(fp)\n self.assertEquals(fp.getContent(), newAugmentsFormat)","def __set_xml():\n if len(activity) == 0:\n\n OS = DRIVER.OS\n xml_path = os.path.join(prjDir, \"config\", \"element_android.xml\")\n if OS == \"iOS\":\n xml_path = os.path.join(prjDir, \"config\", \"element_iOS.xml\")\n\n # open the xml file\n per = elementTree.parse(xml_path)\n all_element = per.findall('activity')\n\n for firstElement in all_element:\n activity_name = firstElement.get(\"name\")\n\n element = {}\n\n for secondElement in firstElement.getchildren():\n element_name = secondElement.get(\"name\")\n\n element_child = {}\n for thirdElement in secondElement.getchildren():\n\n element_child[thirdElement.tag] = thirdElement.text\n\n element[element_name] = element_child\n activity[activity_name] = element","def get_test_resources():\n with open(\"test_data/repo/data/textgroup/work/textgroup.work.version-lat1.xml\") as file:\n text = Text(resource=file, urn=\"urn:cts:latinLit:textgroup.work.version-lat1\")\n\n with open(\"test_data/repo/full_inventory.xml\") as file:\n inventory = TextInventory(resource=file)\n work = inventory[\"urn:cts:latinLit:textgroup.work\"]\n textgroup = inventory[\"urn:cts:latinLit:textgroup\"]\n edition = inventory[\"urn:cts:latinLit:textgroup.work.version-lat1\"]\n\n return {\n \"text\": text,\n \"work\": work,\n \"textgroup\": textgroup,\n \"edition\": edition\n }","def main():\n\n print (f'Reading schema file {args.schemafile} and writing RST to directory {args.outdir}')\n\n schema = xmlschema.XMLSchema(args.schemafile)\n\n # create warning.rst file for deprectaion warnings\n with open(\"warnings.rst\", \"w\") as warnfile:\n print(\".. Put any comments here\\n\", file=warnfile)\n print(\" Warning, this file is regenerated from the annotations in the schema file.\\n\", file=warnfile)\n print(\" Any changes will be overwritten by convert_xsd_to_rst.py.\\n\\n\\n\", file=warnfile)\n print(\"\\n\", file=warnfile)\n print(\"The following are potential future changes, as tagged in the schema with <warning> elements in the documentation. They may result in modifications or deletions in future versions of StationXML.\\n\", file=warnfile)\n print(\"\\n\\n\", file=warnfile)\n\n level_xpaths = ['fsx:FDSNStationXML',\n 'fsx:FDSNStationXML/fsx:Network',\n 'fsx:FDSNStationXML/fsx:Network/fsx:Station',\n 'fsx:FDSNStationXML/fsx:Network/fsx:Station/fsx:Channel',\n 'fsx:FDSNStationXML/fsx:Network/fsx:Station/fsx:Channel/fsx:Response']\n\n words = set()\n for i, xpath in enumerate(level_xpaths):\n xsd_element = schema.find(xpath)\n\n stop_element = None\n this_element = os.path.basename(xpath).split(':')[1]\n if i < 4:\n stop_element = os.path.basename(level_xpaths[i+1]).split(':')[1]\n\n level_elem = walk_tree(xsd_element)\n\n # Use Preamble instead of root element name\n if this_element==\"FDSNStationXML\":\n this_element=\"Preamble\"\n\n # Generate output file name for this level\n rst_file = os.path.join (args.outdir, f'level-{this_element.lower()}.rst')\n\n if args.verbose:\n print (f'Writing to {rst_file}')\n\n with open(rst_file, 'w') as outfile:\n print(\".. Put any comments here\\n\", file=outfile)\n print(\" Warning, this file is regenerated from the annotations in the schema file.\\n\", file=outfile)\n print(\" Any changes will be overwritten by convert_xsd_to_rst.py.\\n\", file=outfile)\n\n write_tree(level_elem, stop_element, outfile = outfile)\n\n recur_spelling(words, level_elem)\n save_spelling(words)","def addEntry(self, listDictions):\n ## load xml\n improvDoc = loadIMProvFile(self.argsFile)\n entrname= 'Job'\n for dictions in listDictions:\n report = IMProvNode(entrname , None, **dictions)\n improvDoc.addNode(report)\n outfile = file( self.argsFile, 'w').write(str(improvDoc))\n return","def read_xml(self):\n connection = urlopen(self.url)\n in_xml = connection.read()\n state = ElementTree.fromstring(in_xml)\n records = []\n record = []\n\n # Specific to CHP\n # TODO(David) Nested for loops are bad. Change this to be more\n # efficient, possibly use generators.\n for center in state:\n rec_center = center.attrib['ID']\n\n for dispatch in center:\n rec_dispatch = dispatch.attrib['ID']\n\n for log in dispatch:\n record = [rec_center, rec_dispatch]\n\n record.append(log.attrib['ID'])\n\n log_time = log.find('LogTime').text.strip('\"')\n log_type = log.find('LogType').text.strip('\"')\n location = log.find('Location').text.strip('\"')\n loc_desc = log.find('LocationDesc').text.strip('\"')\n area = log.find('Area').text.strip('\"')\n\n record.append(log_time)\n record.append(log_type)\n record.append(location)\n record.append(loc_desc)\n record.append(area)\n\n latlon = log.find('LATLON').text.strip('\"')\n\n (lat, lon) = latlon.split(':')\n lat = str(lat[:2]) + '.' + str(lat[2:])\n lon = '-' + str(lon[:3]) + '.' + str(lon[3:])\n\n record.append(lat)\n record.append(lon)\n\n records.append(record)\n\n self.records = records","def build_configs():","def generate_xml_tree(self):\n try:\n tree = et.parse(self.file)\n self.root = tree.getroot()\n self.blast_output = self.root[8]\n self.iteration = self.blast_output[0]\n self.iteration_hit = self.iteration[4]\n\n for i in self.iteration_hit:\n self.hits.append(i)\n\n for i in self.hits:\n h = []\n for j in i:\n h.append(j)\n\n for hsp in h[5]:\n procent = \"{0:.2f}\".format(int(hsp[10].text) / int(hsp[13].text) * 100)\n procent = float(procent)\n self.aligns.append(Alignment(h[2].text,\n hsp[1].text,\n procent,\n hsp[12].text,\n hsp[10].text,\n hsp[13].text,\n hsp[14].text,\n hsp[15].text,\n hsp[16].text))\n self.main_alignments.append(MainAlignment(i[2].text,\n self.aligns))\n self.aligns = []\n except IndexError:\n \"Bad file.\"","def main():\n glob_pattern = \"{root}/{child}/*.xml\".format(root=MANCHESTER_ROOT, child=TARGET_CHILD)\n corpus_files = glob(glob_pattern)\n for filename in corpus_files:\n print(filename)\n to_csv(filtered_parent_freq_count([filename], 2))","def main(src_xml, out='output.txt', sep='::'):\n \n soup = bs(open(src_xml).read(), 'lxml') \n data = [(p[0].text, s_convert(p[1].text), p[2].text)\n for p in zip(soup('weightedfrequency'),\n soup('headword'),\n soup('shortdefinition'))]\n res = ''\n words = []\n for item in data:\n try:\n if item[1].replace('\\n', '') in words:\n continue\n else:\n res += '{}{}{}{}{}\\n'.format(item[0],\n sep,\n item[1].replace('\\n', ''),\n sep,\n item[2].replace('\\n', ''))\n words.append(item[1].replace('\\n', ''))\n except:\n continue\n with open(out, 'w') as f:\n f.write(res)\n return res"],"string":"[\n \"def XML_EC_PL(Name, InputsFile, OutputFile, emin,emax):\\n\\n\\t#On commence par afficher ce qu'on fait\\r\\n\\tprint \\\" Build xml file \\\"\\r\\n\\r\\tprint InputsFile\\n\\t#ouverture du fichier dans lequel on place le source model\\n\\ttry:\\n\\t\\tfresult = open(OutputFile, 'w')\\n\\texcept:\\n\\t\\tprint \\\"Coucou\\\"\\r\\n \\t#ecriture des premieres lignes invariantes\\n\\tfresult.write('<?xml version=\\\"1.0\\\" ?>')\\r\\n\\tfresult.write(\\\"<source_library title=\\\\\\\"source library\\\\\\\">\\\\n\\\")\\n\\r\\n \\t#ouverture du fichier avec les entrees\\r\\n\\tf = open(InputsFile,\\\"r\\\")\\r\\n\\tlines = f.readlines()\\r\\n\\t\\r\\n \\t#Ajout des sources detectees dans le catalogue\\n\\t#Pour chaque ligne du fichier d'entree\\r\\n\\tfor line in range(len(lines)):\\n\\t\\t#Lire les donnees de la ligne\\t\\t\\r\\n\\t\\tdata = lines[line].split()\\r\\n\\t\\tname = data[0]\\n\\n\\t\\t#Verification : est on en train de traiter la source que l'on veut etudier ou une autre ?\\r\\n\\t\\tif str(name) == Name :\\r\\n\\t\\t\\tmysource = 1\\r\\n\\t\\telse:\\r\\n\\t\\t\\tmysource = 0\\n\\n\\t\\t#recuperation des donnees\\r\\n\\t\\tRA = data[1]\\r\\n\\t\\tDEC = data[2]\\r\\n\\t\\tIntegral = float(data[3])*float(Frac)\\r\\n\\t\\tGamma= data[4]\\n\\n\\t\\t\\r\\n\\t\\ttry:\\n\\t\\t\\t#essai de definition des donnees pour un PL avec ExpCut\\n\\t\\t\\tPrefactor = float(data[5])*float(Frac)\\r\\n\\t\\t\\tEnergy = float(data[6])\\r\\n\\t#\\t\\tPrefactor = Prefactor/pow(Energy/100., float(Gamma)) #Densite de flux calculee a Epivot\\r\\n\\t#\\t\\tPrefactor = Prefactor*pow(1000./100., float(Gamma)) #We do the calculation with (E/1000.)^Gamma\\n\\t\\t\\tvariabilite=float(data[8])\\n\\n#\\t\\t\\tprint variabilite\\n\\n\\n\\n\\r\\n\\t\\t\\tcut = float(data[7]) # Cut est la variable qui nous permettra de savoir si il faut utiliser un cut off (1) ou une loi de puissance normale (2)\\r\\n\\t\\texcept:\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\tcut = float(data[5])\\r\\n\\t\\t\\texcept:\\r\\n\\t\\t\\t\\tprint \\\" Wrong size of list \\\"\\r\\n\\t\\t\\t\\tsys.exit()\\r\\n \\t#Si on considere un ccut off exponentiel pour la source :\\r\\n\\t\\tif cut == 1:\\n\\t\\t\\t#ecriture du nom de la source consideree\\r\\n\\t\\t\\tresult_line=\\\" <source \\\"\\r\\n\\t\\t\\tresult_line += \\\"name=\\\\\\\"\\\"+name+\\\"\\\\\\\"\\\"\\r\\n\\t\\t\\tresult_line += \\\" type=\\\\\\\"PointSource\\\\\\\">\\\\n\\\"\\r\\n\\t\\t\\tspectrum_type = \\\"PLSuperExpCutoff\\\"\\n\\t\\t\\t#Utilisation de la modelisation PLSuperExpCutoff car plus simple et plus intuitive pour nous et pour la modelisation des pulsars si il faut en modeliser\\n\\r\\n\\t\\t\\t#definition des parametres spectraux a prendre en comtpe et de la chaine de caractere a integrer\\r\\n\\n\\n\\n\\t\\t\\tif variabilite==0.0 or variabilite==2.0:\\n\\t\\t\\t\\tspectrum_lines = \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"10000000.0\\\\\\\" min=\\\\\\\"0.0000001\\\\\\\"\\\"\\n\\n\\t\\t\\t\\t#d'ou vient ce 1e-12\\r\\n\\t\\t\\t\\tIntegral = float(Prefactor)*1.0e10\\r\\n\\t\\t\\t\\tscale = 1.0e-10\\n\\r\\n\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Prefactor\\\\\\\" scale=\\\\\\\"\\\"+str(scale)+\\\"\\\\\\\" value=\\\\\\\"\\\"\\r\\n\\t\\t\\t\\tspectrum_lines += str(Integral)+\\\"\\\\\\\" />\\\\n\\\"\\r\\n \\r\\n\\t\\t\\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"5.0\\\\\\\" min=\\\\\\\"0.\\\\\\\"\\\"\\r\\n\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Index1\\\\\\\" scale=\\\\\\\"-1.0\\\\\\\" value=\\\\\\\"\\\"\\r\\n\\t\\t\\t\\tspectrum_lines += str(Gamma)+\\\"\\\\\\\"/>\\\\n\\\"\\r\\n \\r\\n\\t\\t\\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"20000.0\\\\\\\" min=\\\\\\\"1.0\\\\\\\"\\\"\\r\\n\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Scale\\\\\\\" scale=\\\\\\\"1.0\\\\\\\" value=\\\\\\\"\\\"+str(Energy)+\\\"\\\\\\\"/>\\\\n\\\"\\r\\n \\r\\n\\t\\t\\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"100.0\\\\\\\" min=\\\\\\\"0.001\\\\\\\"\\\"\\n\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Cutoff\\\\\\\" scale=\\\\\\\"1000.0\\\\\\\" value=\\\\\\\"30.0\\\\\\\"/>\\\\n\\\"\\n\\r\\n\\t\\t\\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"5.0\\\\\\\" min=\\\\\\\"0.0\\\\\\\"\\\"\\r\\n\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Index2\\\\\\\" scale=\\\\\\\"1.0\\\\\\\" value=\\\\\\\"1.0\\\\\\\"/>\\\\n\\\"\\n\\t\\t\\telif variabilite==1.0 :\\n\\t\\t\\t\\tspectrum_lines = \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"10000000.0\\\\\\\" min=\\\\\\\"0.0\\\\\\\"\\\"\\n\\n\\t\\t\\t\\t#d'ou vient ce 1e-12\\r\\n\\t\\t\\t\\tIntegral = float(Prefactor)*1.0e10\\r\\n\\t\\t\\t\\tscale = 1.0e-10\\n\\n\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Prefactor\\\\\\\" scale=\\\\\\\"\\\"+str(scale)+\\\"\\\\\\\" value=\\\\\\\"\\\"\\r\\n\\t\\t\\t\\tspectrum_lines += str(Integral)+\\\"\\\\\\\" />\\\\n\\\"\\r\\n \\r\\n\\t\\t\\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"5.0\\\\\\\" min=\\\\\\\"0.\\\\\\\"\\\"\\r\\n\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Index1\\\\\\\" scale=\\\\\\\"-1.0\\\\\\\" value=\\\\\\\"\\\"\\r\\n\\t\\t\\t\\tspectrum_lines += str(Gamma)+\\\"\\\\\\\"/>\\\\n\\\"\\r\\n \\r\\n\\t\\t\\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"20000.0\\\\\\\" min=\\\\\\\"1.0\\\\\\\"\\\"\\r\\n\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Scale\\\\\\\" scale=\\\\\\\"1.0\\\\\\\" value=\\\\\\\"\\\"+str(Energy)+\\\"\\\\\\\"/>\\\\n\\\"\\r\\n \\r\\n\\t\\t\\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"100.0\\\\\\\" min=\\\\\\\"0.0001\\\\\\\"\\\"\\r\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Cutoff\\\\\\\" scale=\\\\\\\"1000.0\\\\\\\" value=\\\\\\\"30.0\\\\\\\"/>\\\\n\\\"\\r\\n \\r\\n\\t\\t\\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"5.0\\\\\\\" min=\\\\\\\"0.0\\\\\\\"\\\"\\r\\n\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Index2\\\\\\\" scale=\\\\\\\"1.0\\\\\\\" value=\\\\\\\"1.0\\\\\\\"/>\\\\n\\\"\\n\\n\\r\\n \\r\\n\\n# <spectrum type=\\\"PLSuperExpCutoff\\\">\\n# <parameter free=\\\"1\\\" max=\\\"100000\\\" min=\\\"0\\\" name=\\\"Prefactor\\\" scale=\\\"1e-10\\\" value=\\\"Prefactor*1e-10\\\"/>\\n# <parameter free=\\\"1\\\" max=\\\"0\\\" min=\\\"5\\\" name=\\\"Index1\\\" scale=\\\"-1\\\" value=\\\"valeur du catalogue\\\"/>\\n# <parameter free=\\\"0\\\" max=\\\"20000\\\" min=\\\"1.0\\\" name=\\\"Scale\\\" scale=\\\"1\\\" value=\\\"Epivot\\\"/>\\n# <parameter free=\\\"1\\\" max=\\\"300000\\\" min=\\\"100\\\" name=\\\"Cutoff\\\" scale=\\\"1\\\" value=\\\"3000\\\"/>\\n# <parameter free=\\\"0\\\" max=\\\"5\\\" min=\\\"0\\\" name=\\\"Index2\\\" scale=\\\"1\\\" value=\\\"1.5\\\"/>\\n# </spectrum>\\n\\n\\r\\n\\t\\telse:\\n\\t\\t#Sinon (si on considere une loi de puissance simple)\\n\\t\\t#definition de la chaine de caractere comportant le nom de la source\\r\\n\\t\\t\\tresult_line=\\\" <source \\\"\\r\\n\\t\\t\\tresult_line += \\\"name=\\\\\\\"\\\"+name+\\\"\\\\\\\"\\\"\\n\\t\\t\\tif mysource == 0:\\r\\t\\t\\t\\tresult_line += \\\" type=\\\\\\\"PointSource\\\\\\\">\\\\n\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\tresult_line += \\\" type=\\\\\\\"PointSource\\\\\\\">\\\\n\\\"\\t\\t\\t\\t\\n\\n\\t\\t\\t#definition de la chaine de caractere correspondant a la forme de fit que l'on souhaite utiliser (Loi de puissance)\\r\\n\\t\\t\\tspectrum_type = \\\"PowerLaw2\\\"\\r\\n\\r\\n\\t\\t\\tif mysource == 0 and variabilite!=1.0:\\n\\t\\t\\t#si ce n'est pas la source que l'on etudie on fige le parametre Integrale\\n\\t\\t\\t\\tspectrum_lines = \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"1000000.0\\\\\\\" min=\\\\\\\"0.0\\\\\\\"\\\"\\r\\n\\t\\t\\telse:\\n\\t\\t\\t#sinon on le libere\\r\\n\\t\\t\\t\\tspectrum_lines = \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"1000000.0\\\\\\\" min=\\\\\\\"0.0\\\\\\\"\\\"\\n\\n\\n\\n\\n\\n\\t\\t\\t#Toujours ce facteur....\\r\\n\\t\\t\\tIntegral = float(Integral)*1e10\\r\\n\\t\\t\\tscale = 1e-10\\n\\n\\n\\t\\n\\r\\n\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Integral\\\\\\\" scale=\\\\\\\"\\\"+str(scale)+\\\"\\\\\\\" value=\\\\\\\"\\\"\\r\\n\\t\\t\\tspectrum_lines += str(Integral)+\\\"\\\\\\\" />\\\\n\\\"\\n\\r\\n\\t\\t\\tif mysource == 0 and variabilite!=1.0:\\n\\t\\t\\t\\t#si ce n'est pas la source que l'on etudie on fige le parametre gamma\\r\\n\\t\\t \\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"5.0\\\\\\\" min=\\\\\\\"0.\\\\\\\"\\\"\\r\\n\\t\\t\\telse:\\n\\t\\t\\t\\t#si c'est pas la source que l'on etudie on le laisse libre\\r\\n\\t\\t \\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"5.0\\\\\\\" min=\\\\\\\"0.\\\\\\\"\\\"\\n\\n\\t\\t\\t#fin de la chaine de parametres sur le modele spectral\\r\\n\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"Index\\\\\\\" scale=\\\\\\\"-1.0\\\\\\\" value=\\\\\\\"\\\"\\r\\n\\t\\t\\tspectrum_lines += str(Gamma)+\\\"\\\\\\\"/>\\\\n\\\"\\r\\n \\r\\n\\t\\t\\tif mysource == 0 and variabilite!=1.0:\\n\\t \\n\\t\\t\\t spectrum_lines += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"200000.0\\\\\\\" min=\\\\\\\"20.0\\\\\\\"\\\"\\r\\n\\t\\t\\t spectrum_lines += \\\" name=\\\\\\\"LowerLimit\\\\\\\" scale=\\\\\\\"1.0\\\\\\\" value=\\\\\\\"1000.0\\\\\\\"/>\\\\n\\\"\\r\\n \\r\\n\\t\\t\\t spectrum_lines += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"1000000.0\\\\\\\" min=\\\\\\\"20.0\\\\\\\"\\\"\\r\\n\\t\\t\\t spectrum_lines += \\\" name=\\\\\\\"UpperLimit\\\\\\\" scale=\\\\\\\"1.0\\\\\\\" value=\\\\\\\"100000.0\\\\\\\"/>\\\\n\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"200000.0\\\\\\\" min=\\\\\\\"20.0\\\\\\\"\\\"\\n\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"LowerLimit\\\\\\\" scale=\\\\\\\"1.0\\\\\\\" value=\\\\\\\"100\\\\\\\"/>\\\\n\\\"\\n\\n\\t\\t\\t\\tspectrum_lines += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"100000.0\\\\\\\" Min =\\\\\\\"20.0\\\\\\\"\\\"\\n\\t\\t\\t\\tspectrum_lines += \\\" name=\\\\\\\"UpperLimit\\\\\\\" scale=\\\\\\\"1.0\\\\\\\" value=\\\\\\\"100000.0\\\\\\\"/>\\\\n\\\"\\n\\n \\t\\t#ajout du modele spectral a la liste de parametres \\r\\n\\t\\tresult_line += \\\" <spectrum type=\\\\\\\"\\\"+spectrum_type+\\\"\\\\\\\">\\\\n\\\"\\r\\t\\tresult_line += spectrum_lines\\r\\n\\t\\tresult_line += \\\" </spectrum>\\\\n\\\"\\n\\n\\t\\t\\n\\n\\t\\tif mysource==0 and variabilite!=1.0:\\n \\t\\t\\t#ajout du modele spatial a la liste de parametres \\r\\n\\t\\t\\tresult_line += \\\" <spatialModel type=\\\\\\\"SkyDirFunction\\\\\\\">\\\\n\\\"\\r\\n\\t\\t\\tresult_line += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"360\\\\\\\" min=\\\\\\\"-360\\\\\\\"\\\"\\r\\n\\t\\t\\tresult_line += \\\" name=\\\\\\\"RA\\\\\\\" scale=\\\\\\\"1\\\\\\\" value=\\\\\\\"\\\"+RA+\\\"\\\\\\\"/>\\\\n\\\"\\r\\n\\t\\t\\tresult_line += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"90\\\\\\\" min=\\\\\\\"-90\\\\\\\"\\\"\\r\\n\\t\\t\\tresult_line += \\\" name=\\\\\\\"DEC\\\\\\\" scale=\\\\\\\"1\\\\\\\" value=\\\\\\\"\\\"+DEC+\\\"\\\\\\\"/>\\\\n\\\"\\r\\n\\t\\t\\tresult_line += \\\" </spatialModel>\\\\n\\\"\\n\\t\\telif mysource==0 and variabilite==1.0:\\n \\t\\t\\t#ajout du modele spatial a la liste de parametres \\r\\n\\t\\t\\tresult_line += \\\" <spatialModel type=\\\\\\\"SkyDirFunction\\\\\\\">\\\\n\\\"\\r\\n\\t\\t\\tresult_line += \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"360\\\\\\\" min=\\\\\\\"-360\\\\\\\"\\\"\\r\\n\\t\\t\\tresult_line += \\\" name=\\\\\\\"RA\\\\\\\" scale=\\\\\\\"1\\\\\\\" value=\\\\\\\"\\\"+RA+\\\"\\\\\\\"/>\\\\n\\\"\\r\\n\\t\\t\\tresult_line += \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"90\\\\\\\" min=\\\\\\\"-90\\\\\\\"\\\"\\r\\n\\t\\t\\tresult_line += \\\" name=\\\\\\\"DEC\\\\\\\" scale=\\\\\\\"1\\\\\\\" value=\\\\\\\"\\\"+DEC+\\\"\\\\\\\"/>\\\\n\\\"\\r\\n\\t\\t\\tresult_line += \\\" </spatialModel>\\\\n\\\"\\n\\t\\telse:\\n #ajout du modele spatial a la liste de parametres \\n\\t\\t\\tresult_line += \\\" <spatialModel type=\\\\\\\"SkyDirFunction\\\\\\\">\\\\n\\\"\\n\\t\\t\\tresult_line += \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"360\\\\\\\" min=\\\\\\\"-360\\\\\\\"\\\"\\n\\t\\t\\tresult_line += \\\" name=\\\\\\\"RA\\\\\\\" scale=\\\\\\\"1\\\\\\\" value=\\\\\\\"\\\"+RA+\\\"\\\\\\\"/>\\\\n\\\"\\n\\t\\t\\tresult_line += \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"90\\\\\\\" min=\\\\\\\"-90\\\\\\\"\\\"\\n\\t\\t\\tresult_line += \\\" name=\\\\\\\"DEC\\\\\\\" scale=\\\\\\\"1\\\\\\\" value=\\\\\\\"\\\"+DEC+\\\"\\\\\\\"/>\\\\n\\\"\\n\\t\\t\\tresult_line += \\\" </spatialModel>\\\\n\\\"\\n\\t\\t\\t\\n\\t\\tresult_line += \\\" </source>\\\\n\\\"\\r\\n\\t\\tfresult.write(result_line+\\\"\\\\n\\\")\\r\\n #Ajout du fond diffus galactique\\n\\tresult_line=\\\" <source \\\"\\r\\n\\tresult_line += \\\"name=\\\\\\\"gal_v02\\\\\\\"\\\"\\r\\n\\tresult_line += \\\" type=\\\\\\\"DiffuseSource\\\\\\\">\\\\n\\\"\\r\\n\\tspectrum_type = \\\"ConstantValue\\\"\\r\\n\\r\\n\\tspectrum_lines = \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"10.0\\\\\\\" min=\\\\\\\"0\\\\\\\"\\\"\\r\\n\\tspectrum_lines += \\\" name=\\\\\\\"Value\\\\\\\" scale=\\\\\\\"1.0\\\\\\\" value=\\\\\\\"\\\"+str(Frac)+\\\"\\\\\\\" />\\\\n\\\"\\r\\n\\r\\n\\tresult_line += \\\" <spectrum type=\\\\\\\"\\\"+spectrum_type+\\\"\\\\\\\">\\\\n\\\"\\r\\n\\tresult_line += spectrum_lines\\r\\n\\tresult_line += \\\" </spectrum>\\\\n\\\"\\r\\n\\r\\n\\tresult_line += \\\" <spatialModel file=\\\\\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/gll_iem_v02.fit\\\\\\\" type=\\\\\\\"MapCubeFunction\\\\\\\">\\\\n\\\"\\r\\n\\tresult_line += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"1000.0\\\\\\\" min=\\\\\\\"0.0\\\\\\\"\\\"\\r\\n\\tresult_line += \\\" name=\\\\\\\"Normalization\\\\\\\" scale=\\\\\\\"1\\\\\\\" value=\\\\\\\"1.0\\\\\\\"/>\\\\n\\\"\\r\\n\\tresult_line += \\\" </spatialModel>\\\\n\\\"\\r\\n\\tresult_line += \\\" </source>\\\\n\\\"\\r\\n\\tfresult.write(result_line+\\\"\\\\n\\\")\\r\\n\\r\\n \\t#Ajout du fond diffus extragalactique\\r\\n\\tresult_line=\\\" <source \\\"\\r\\n\\tresult_line += \\\"name=\\\\\\\"eg_v02\\\\\\\"\\\"\\r\\n\\tresult_line += \\\" type=\\\\\\\"DiffuseSource\\\\\\\">\\\\n\\\"\\r\\n\\tspectrum_type = \\\"FileFunction\\\"\\r\\n\\r\\tspectrum_lines = \\\" <parameter free=\\\\\\\"1\\\\\\\" max=\\\\\\\"10.0\\\\\\\" min=\\\\\\\"0\\\\\\\"\\\"\\r\\n\\tspectrum_lines += \\\" name=\\\\\\\"Normalization\\\\\\\" scale=\\\\\\\"1.0\\\\\\\" value=\\\\\\\"\\\"+str(Frac)+\\\"\\\\\\\" />\\\\n\\\"\\r\\n\\r\\n\\tresult_line += \\\" <spectrum file=\\\\\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/isotropic_iem_v02.txt\\\\\\\" type=\\\\\\\"\\\"+spectrum_type+\\\"\\\\\\\">\\\\n\\\"\\r\\n\\tresult_line += spectrum_lines\\r\\n\\tresult_line += \\\" </spectrum>\\\\n\\\"\\r\\n \\r\\n\\tresult_line += \\\" <spatialModel type=\\\\\\\"ConstantValue\\\\\\\">\\\\n\\\"\\r\\n\\tresult_line += \\\" <parameter free=\\\\\\\"0\\\\\\\" max=\\\\\\\"100.0\\\\\\\" min=\\\\\\\"0.0\\\\\\\"\\\"\\r\\n\\tresult_line += \\\" name=\\\\\\\"Value\\\\\\\" scale=\\\\\\\"1\\\\\\\" value=\\\\\\\"1.0\\\\\\\"/>\\\\n\\\"\\r\\n\\tresult_line += \\\" </spatialModel>\\\\n\\\"\\r\\n\\tresult_line += \\\" </source>\\\\n\\\"\\r\\n\\tfresult.write(result_line+\\\"\\\\n\\\")\\r\\n\\n \\t#Fermeture des fichiers \\r\\n\\tf.close() \\r\\n\\tfresult.write(\\\"\\\\n</source_library>\\\\n\\\")\\r\\n\\tfresult.close()\\r\\n\\treturn\",\n \"def create_gen_xml(self, out_file):\\n\\n param_list = []\\n msg = []\\n msg_type = []\\n dep_node = []\\n for line in self.full_ed_lines:\\n param_list.append(line.text())\\n dep_pkg = param_list[6].split(', ')\\n if dep_pkg[len(dep_pkg) - 1] == '':\\n dep_pkg.pop()\\n for dep in self.manager.wid.sub_list:\\n dep_node.append(dep['msg_type'])\\n for dep in self.manager.wid.pub_list:\\n dep_node.append(dep['msg_type'])\\n for dep in dep_node:\\n a, b = dep.split('/')\\n msg.append(a)\\n msg_type.append(b)\\n f = open('../genkernel/templates/package_rosgen.xml')\\n o = open(out_file, 'a')\\n flag = 0\\n while 1:\\n line = f.readline()\\n if not line: break\\n for i in range(6):\\n line = line.replace('[{0}]'.format(i), param_list[i])\\n line = line.replace('[7]', param_list[7])\\n if line.find('[6]') != -1:\\n for dep in dep_pkg:\\n line_dep = '\\\\t<depend>{0}</depend>\\\\n'.format(dep)\\n o.write(line_dep)\\n flag = 1\\n elif line.find('[8]') != -1:\\n for dep, tp in zip(msg, msg_type):\\n line_dep = '\\\\t\\\\t<depend type=\\\"{1}\\\">{0}</depend>\\\\n'.format(dep, tp)\\n o.write(line_dep)\\n flag = 1\\n elif line.find('<subscribers>') != -1:\\n o.write('\\\\t\\\\t<subscribers>\\\\n')\\n for sub in self.manager.wid.sub_list:\\n o.write('\\\\t\\\\t\\\\t<sub>\\\\n')\\n o.write('\\\\t\\\\t\\\\t\\\\t<name>{0}</name>\\\\n'.format(sub['name']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<msg_type>{0}</msg_type>\\\\n'.format(sub['msg_type']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<topic_name>{0}</topic_name>\\\\n'.format(sub['topic_name']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<queue_size>{0}</queue_size>\\\\n'.format(sub['queue_size']))\\n o.write('\\\\t\\\\t\\\\t</sub>\\\\n')\\n o.write('\\\\t\\\\t</subscribers>\\\\n')\\n flag = 1\\n elif line.find('<publishers>') != -1:\\n o.write('\\\\t\\\\t<publishers>\\\\n')\\n for pub in self.manager.wid.pub_list:\\n o.write('\\\\t\\\\t\\\\t<pub>\\\\n')\\n o.write('\\\\t\\\\t\\\\t\\\\t<name>{0}</name>\\\\n'.format(pub['name']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<msg_type>{0}</msg_type>\\\\n'.format(pub['msg_type']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<topic_name>{0}</topic_name>\\\\n'.format(pub['topic_name']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<queue_size>{0}</queue_size>\\\\n'.format(pub['queue_size']))\\n o.write('\\\\t\\\\t\\\\t</pub>\\\\n')\\n o.write('\\\\t\\\\t</publishers>\\\\n')\\n flag = 1\\n if flag == 0:\\n o.write(line)\\n else:\\n flag = 0\\n o.close()\\n f.close()\\n self.changed = False\",\n \"def buildxml(self):\\n # assume self._objslock is already held here\\n logger.info(\\\"Emane.buildxml()\\\")\\n self.buildplatformxml()\\n self.buildnemxml()\\n self.buildtransportxml()\\n self.buildeventservicexml()\",\n \"def makexmlfunc(healpix,ra,dec,week1,week2,distance):\\n\\t\\n\\tif week1!=week2:\\n\\t\\tidentity=\\\"%06d_%d_%d_w%03d_w%03d\\\" %(healpix,ra,dec,week1,week2)\\n\\t\\tltcube=\\\"%s/lat_ltcube_weekly_w%03d_w%03d_p203_v001.fits\\\" %(cfg.home,week1,week2)\\n\\t\\tspacecraft=\\\"%s/w%03d_w%03d_newspacecraft.fits\\\" %(cfg.ispace,week1,week2)\\n\\telse:\\n\\t\\tidentity=\\\"%06d_%d_%d_w%03d\\\" %(healpix,ra,dec,week1)\\n\\t\\tltcube=\\\"%s/lat_spacecraft_weekly_w%03d_p203_v001_ltcube.fits\\\" %(cfg.home,week1)\\n\\t\\tspacecraft=\\\"%s/lat_spacecraft_weekly_w%03d_p202_v001.fits \\\" %(cfg.ispace,week1)\\n\\n\\tregion_filtered=\\\"%s_region_filtered_gti.fits\\\" %(identity)\\n\\tfermisources=\\\"%s_fermisources_model.xml\\\" %(identity)\\n\\tinputmodel=\\\"%s_input_model.xml\\\" %(identity)\\n\\tfermis=\\\"%s_fermis.xml\\\" %identity\\n\\tresponse=\\\"P7REP_SOURCE_V15\\\"\\n\\tmakexmllog=\\\"%s_output_makexml.log\\\" %identity\\n\\tglobal extendedsource\\n\\tglobal numberofextendedsources\\n\\textendedlog=\\\"%s_number_of_extendedsources.log\\\" %identity\\n\\tExtendedList=\\\"ExtendedList.txt\\\"\\n\\tOthersList=\\\"OthersList.txt\\\"\\n\\n\\t\\n\\twith open (makexmllog,'r') as outputFile: #opens the makexmllog file from makesyfunc. This document contains info about the extended sources.\\n\\t\\t\\n\\t\\tfor line in outputFile:\\n\\t\\t\\t\\n\\t\\t\\twith open (makexmllog,'r') as File:\\n\\t\\t\\t\\tif line.startswith('Added')==True:\\n\\t\\t\\t\\t\\ta,b=line.split('and ')\\t\\n\\t\\t\\t\\t\\tb1,b2,b3=b.split(' ')\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tnumberofextendedsources=int(b1) #b1 is the number of extended sources\\n\\toutputFile.close()\\n\\toutputFile=open(inputmodel, 'w')\\n\\tprint numberofextendedsources\\n\\n\\tif numberofextendedsources==1: #if there is an extended source\\n\\t\\twith open (makexmllog,'r') as outputFile:\\n\\t\\t\\n\\t\\t\\tfor line in outputFile:\\n\\t\\t\\t\\n\\t\\t\\t\\twith open (makexmllog,'r') as File:\\n\\t\\t\\t\\t\\tif line.startswith('Extended')==True:\\n\\t\\t\\t\\t\\t\\tprint line\\n\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\tc,d=line.split(' in')\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\tc1,c2,c3,c4=c.split(' ')\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\textendedsource=str(c3) #extracts the name of the extended source from makexmllog\\n\\t\\n\\n\\t\\t\\n\\n\\n\\t\\toutputFile.close()\\t\\n\\n\\n\\t\\n\\n\\t\\twith open(\\\"%s\\\" %fermisources) as thefile: #opens the xml file that was created from makesyfunc\\n\\t\\t\\tfor line in thefile:\\n\\t\\t\\t\\tif line.startswith('\\t<spatialModel file=\\\"%s.fits\\\"' %(extendedsource))==True:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tspecial=str.replace(line,'%s.fits'%extendedsource,'%s/%s.fits' %(cfg.homesy,extendedsource)) \\n\\t\\t\\t\\t\\tprint special #replace with the correct path to the extendedsource(Templates folder)\\n\\t\\t\\t\\n\\t\\t\\t\\t\\tspecial1=str.replace(special,'type=\\\"SpatialMap\\\"','type=\\\"SpatialMap\\\" map_based_integral=\\\"true\\\"')\\n\\t\\t\\t\\t\\tprint special1 #instruction from fermi tutorial, you must add map_based...\\n\\t\\t\\t\\t\\toutputFile=open(fermis, 'w') #write to fermis, the original xml with the right path to the extended source\\n\\t\\t\\t\\t\\twith open(\\\"%s\\\" %fermisources,'r') as infile:\\n\\t\\t\\t\\t\\t\\tfor line in infile:\\n\\t\\t\\t\\t\\t\\t\\tif line.startswith('\\t<spatialModel file=\\\"%s.fits\\\"' %(extendedsource))==False:\\n\\t\\t\\t\\t\\t\\t\\t\\toutputFile.write(line)\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\toutputFile.write(special1)\\n\\t\\t\\t\\t\\toutputFile.close()\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\n\\n\\t\\t\\t\\n\\t\\toutputFile=open(inputmodel, 'w') #final xml file. contains the right path and the source info of \\\"your\\\" source.\\n\\t\\twith open(fermis,'r') as infile:\\n\\t\\t\\tfor line in infile:\\n\\t\\t\\t\\tif line.startswith('</source_library>')==False:\\n\\t\\t\\t\\t\\toutputFile.write(line)\\n\\t\\t\\t\\t\\t\\t\\t\\n\\t\\toutputFile.write('\\\\n\\\\\\n\\t\\t\\t<!-- My sources -->\\\\n\\\\\\n\\t\\t\\t<source name=\\\"%f_%f\\\" type=\\\"PointSource\\\">\\\\n\\\\\\n\\t\\t\\t<spectrum type=\\\"PowerLaw\\\">\\\\n\\\\\\n\\t\\t\\t<parameter free=\\\"1\\\" max=\\\"1000.0\\\" min=\\\"0.001\\\" name=\\\"Prefactor\\\" scale=\\\"1e-09\\\" value=\\\"10\\\"/>\\\\n\\\\\\n\\t\\t\\t<parameter free=\\\"1\\\" max=\\\"-1.0\\\" min=\\\"-5.0\\\" name=\\\"Index\\\" scale=\\\"1.0\\\" value=\\\"-2.1\\\"/>\\\\n\\\\\\n\\t\\t\\t<parameter free=\\\"0\\\" max=\\\"2000.0\\\" min=\\\"30.0\\\" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"100.0\\\"/>\\\\n\\\\\\n\\t\\t\\t</spectrum>\\\\n\\\\\\n\\t\\t\\t<spatialModel type=\\\"SkyDirFunction\\\">\\\\n\\\\\\n\\t\\t\\t<parameter free=\\\"0\\\" max=\\\"360\\\" min=\\\"-360\\\" name=\\\"RA\\\" scale=\\\"1.0\\\" value=\\\"%f\\\"/>\\\\n\\\\\\n\\t\\t\\t<parameter free=\\\"0\\\" max=\\\"90\\\" min=\\\"-90\\\" name=\\\"DEC\\\" scale=\\\"1.0\\\" value=\\\"%f\\\"/>\\\\n\\\\\\n\\t\\t\\t</spatialModel>\\\\n\\\\\\n\\t\\t\\t</source>\\\\n\\\\\\n\\t\\t\\t</source_library>\\\\n' % (ra,dec,ra,dec))\\n\\n\\t\\t\\t\\t\\n\\n\\t\\toutputFile.close()\\n\\t\\n\\t\\twith open(\\\"%s_diffrsp.log\\\" % (identity), 'w') as outsyputFile: #run diffrsp if you have an extended source.\\n\\t\\t\\tsubprocess.call(['%s' %(cfg.pythoncommand),'gtdiffrsp.py', '%s' %(region_filtered),'%s' %(spacecraft), '%s' %inputmodel, '%s' %(response),'%s' %identity ],stdout=outsyputFile)\\n\\t\\t\\t\\n\\t\\twith open(ExtendedList,\\\"a+\\\") as outsyFile:\\n\\t\\t\\toutsyFile.write(\\\"%d %f %f %d %d %f\\\\n\\\" %(healpix,ra,dec,week1,week2,distance))\\n\\t\\t\\t\\t\\t\\n\\tif numberofextendedsources==0: #if there is no extended source\\n\\t\\toutputFile=open('%s' %(inputmodel), 'w') #write to inputmodel, \\\"your\\\" source\\n\\t\\twith open('%s' %(fermisources),'r') as infile:\\n\\t\\t\\tfor line in infile:\\n\\t\\t\\t\\tif line.startswith('</source_library>')==False:\\n\\t\\t\\t\\t\\toutputFile.write(line)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\n\\n\\t\\toutputFile.write('\\\\n\\\\\\n\\t\\t\\t<!-- My sources -->\\\\n\\\\\\n\\t\\t\\t<source name=\\\"%f_%f\\\" type=\\\"PointSource\\\">\\\\n\\\\\\n\\t\\t\\t<spectrum type=\\\"PowerLaw\\\">\\\\n\\\\\\n\\t\\t\\t<parameter free=\\\"1\\\" max=\\\"1000.0\\\" min=\\\"0.001\\\" name=\\\"Prefactor\\\" scale=\\\"1e-09\\\" value=\\\"10\\\"/>\\\\n\\\\\\n\\t\\t\\t<parameter free=\\\"1\\\" max=\\\"-1.0\\\" min=\\\"-5.0\\\" name=\\\"Index\\\" scale=\\\"1.0\\\" value=\\\"-2.1\\\"/>\\\\n\\\\\\n\\t\\t\\t<parameter free=\\\"0\\\" max=\\\"2000.0\\\" min=\\\"30.0\\\" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"100.0\\\"/>\\\\n\\\\\\n\\t\\t\\t</spectrum>\\\\n\\\\\\n\\t\\t\\t<spatialModel type=\\\"SkyDirFunction\\\">\\\\n\\\\\\n\\t\\t\\t<parameter free=\\\"0\\\" max=\\\"360\\\" min=\\\"-360\\\" name=\\\"RA\\\" scale=\\\"1.0\\\" value=\\\"%f\\\"/>\\\\n\\\\\\n\\t\\t\\t<parameter free=\\\"0\\\" max=\\\"90\\\" min=\\\"-90\\\" name=\\\"DEC\\\" scale=\\\"1.0\\\" value=\\\"%f\\\"/>\\\\n\\\\\\n\\t\\t\\t</spatialModel>\\\\n\\\\\\n\\t\\t\\t</source>\\\\n\\\\\\n\\t\\t\\t</source_library>\\\\n' % (ra,dec,ra,dec))\\n\\n\\t\\toutputFile.close()\\n\\tif numberofextendedsources>1:\\n\\t\\twith open(OthersList,\\\"a+\\\") as outsyFile:\\n\\t\\t\\toutsyFile.write(\\\"%d %f %f %d %d %f\\\\n\\\" %(healpix,ra,dec,week1,week2,distance))\\n\\t\\n\\tif numberofextendedsources==1:\\n\\t\\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\\n\\t\\toutsyputFile.write(\\\"%s\\\\n\\\\\\n \\t%s\\\"%(numberofextendedsources,extendedsource))\\n\\t\\toutsyputFile.close()\\n\\n\\tif numberofextendedsources !=1:\\n\\t\\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\\n\\t\\toutsyputFile.write(\\\"%s\\\" %(numberofextendedsources))\\n\\t\\toutsyputFile.close()\",\n \"def test_01_FindXml(self):\\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\\n # sprint(PrettyFormatAny.form(self.m_root_xml, 'A3-01-A - Entire Xml'))\\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection', 'XML - No Controllers section')\\n # print(PrettyFormatAny.form(self.m_xml.controller_sect, 'A3-01-B - All Controllers Xml'))\\n self.assertEqual(self.m_xml.controller.tag, 'Controller', 'XML - No Controller section')\\n # print(PrettyFormatAny.form(self.m_xml.controller, 'A3-01-C - First Controller Xml'))\",\n \"def generate_xml(self, locations):\\n\\n ET.SubElement(self.root, 'generator').text = __revision__\\n ET.SubElement(self.root, 'generated_at').text = datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n\\n xmlroot = self.root\\n kernel = Kerneladapter()\\n\\n for locname in locations:\\n xml_location = ET.SubElement(xmlroot, 'location')\\n location = kernel.location_info(locname)\\n ET.SubElement(xml_location, \\\"location\\\").text = unicode(locname)\\n ET.SubElement(xml_location, \\\"height\\\").text = unicode(location['height'])\\n ET.SubElement(xml_location, \\\"attributes\\\").text = unicode(location['attributes'])\\n ET.SubElement(xml_location, \\\"floorlevel\\\").text = unicode(location['floorlevel'])\\n ET.SubElement(xml_location, \\\"preference\\\").text = unicode(location['preference'])\\n ET.SubElement(xml_location, \\\"info\\\").text = unicode(location['info'])\\n ET.SubElement(xml_location, \\\"reserved_for\\\").text = unicode(location['reserved_for'])\\n\\n for mui in location['allocated_by']:\\n unit = kernel.unit_info(mui)\\n xml_unit = ET.SubElement(xml_location, \\\"unit\\\")\\n ET.SubElement(xml_unit, \\\"mui\\\").text = unicode(unit['mui'])\\n ET.SubElement(xml_unit, \\\"quantity\\\").text = unicode(unit['quantity'])\\n ET.SubElement(xml_unit, \\\"artnr\\\").text = unicode(unit['product'])\\n ET.SubElement(xml_unit, \\\"height\\\").text = unicode(unit['height'])\\n ET.SubElement(xml_unit, \\\"pick_quantity\\\").text = unicode(unit['pick_quantity'])\\n ET.SubElement(xml_unit, 'created_at').text = unit['created_at'].strftime('%Y-%m-%d %H:%M:%S')\\n ET.SubElement(xml_unit, \\\"movements\\\").text = unicode(unit['movements'])\\n ET.SubElement(xml_unit, \\\"picks\\\").text = unicode(unit['picks'])\\n ET.SubElement(xml_unit, \\\"attributes\\\").text = unicode(unit['attributes'])\\n try:\\n product = produktpass.models.Product.objects.get(artnr=unit['product'])\\n ET.SubElement(xml_unit, \\\"product_name\\\").text = unicode(product.name)\\n except produktpass.models.Product.DoesNotExist:\\n ET.SubElement(xml_unit, \\\"product_name\\\").text = '???'\\n\\n return xmlroot\",\n \"def createXML(config, ccdpars, userpars):\\n\\n # identify the template\\n appLab = ccdpars.appLab.value()\\n if config.debug:\\n print('DEBUG: createXML: application = ' + appLab)\\n print('DEBUG: createXML: application vals = ' + str(config.templates[appLab]))\\n\\n if config.template_from_server:\\n # get template from server\\n url = config.http_camera_server + config.http_path_get + '?' + \\\\\\n config.http_search_attr_name + '=' + config.templates[appLab]\\n if config.debug:\\n print ('DEBUG: url = ' + url)\\n sxml = urllib2.urlopen(url).read()\\n txml = ET.fromstring(sxml)\\n else:\\n # get template from local file\\n if config.debug:\\n print ('DEBUG: directory = ' + config.template_directory)\\n lfile = os.path.join(config.template_directory, config.templates[appLab]['app'])\\n if config.debug:\\n print ('DEBUG: local file = ' + lfile)\\n tree = ET.parse(lfile)\\n txml = tree.getroot()\\n\\n # Find all CCD parameters\\n cconfig = txml.find('configure_camera')\\n pdict = {}\\n for param in cconfig.findall('set_parameter'):\\n pdict[param.attrib['ref']] = param.attrib\\n\\n # Set them. This is designed so that missing \\n # parameters will cause exceptions to be raised.\\n\\n # X-binning factor\\n pdict['X_BIN']['value'] = ccdpars.xbin.get()\\n\\n # Y-binning factor\\n pdict['X_BIN']['value'] = ccdpars.ybin.get()\\n\\n # Number of exposures\\n pdict['NUM_EXPS']['value'] = '-1' if ccdpars.number.value() == 0 else ccdpars.number.get()\\n\\n # LED level\\n pdict['LED_FLSH']['value'] = ccdpars.led.get()\\n\\n # Avalanche or normal\\n pdict['OUTPUT']['value'] = str(ccdpars.avalanche())\\n\\n # Avalanche gain\\n pdict['HV_GAIN']['value'] = ccdpars.avgain.get()\\n\\n # Clear or not\\n pdict['EN_CLR']['value'] = str(ccdpars.clear())\\n\\n # Dwell\\n pdict['DWELL']['value'] = ccdpars.expose.get()\\n\\n # Readout speed\\n pdict['SPEED']['value'] = '0' if ccdpars.readout == 'Slow' else '1' \\\\\\n if ccdpars.readout == 'Medium' else '2'\\n\\n # Number of windows -- needed to set output parameters correctly\\n nwin = ccdpars.nwin.value()\\n\\n # Load up enabled windows, null disabled windows\\n for nw, win in ccdpars.wframe.wins:\\n if nw < nwin:\\n pdict['X' + str(nw+1) + '_START']['value'] = win.xstart.get()\\n pdict['Y' + str(nw+1) + '_START']['value'] = win.ystart.get()\\n pdict['X' + str(nw+1) + '_SIZE']['value'] = win.nx.get()\\n pdict['Y' + str(nw+1) + '_SIZE']['value'] = win.ny.get()\\n else:\\n pdict['X' + str(nw+1) + '_START']['value'] = '1'\\n pdict['Y' + str(nw+1) + '_START']['value'] = '1'\\n pdict['X' + str(nw+1) + '_SIZE']['value'] = '0'\\n pdict['Y' + str(nw+1) + '_SIZE']['value'] = '0'\\n\\n # Load the user parameters\\n uconfig = txml.find('user')\\n uconfig.set('target', userpars.target.get())\\n uconfig.set('comment', userpars.comment.get())\\n uconfig.set('ID', userpars.progid.get())\\n uconfig.set('PI', userpars.pi.get())\\n uconfig.set('Observers', userpars.observers.get())\\n \\n return txml\",\n \"def _populate_from_xml_file(self, xml):\\n '''\\n example from API: http://www.ga.gov.au/www/argus.argus_api.survey?pSurveyNo=921\\n\\n <?xml version=\\\"1.0\\\" ?>\\n <ROWSET>\\n <ROW>\\n <SURVEYID>921</SURVEYID>\\n <SURVEYNAME>Goomalling, WA, 1996</SURVEYNAME>\\n <STATE>WA</STATE>\\n <OPERATOR>Stockdale Prospecting Ltd.</OPERATOR>\\n <CONTRACTOR>Kevron Geophysics Pty Ltd</CONTRACTOR>\\n <PROCESSOR>Kevron Geophysics Pty Ltd</PROCESSOR>\\n <SURVEY_TYPE>Detailed</SURVEY_TYPE>\\n <DATATYPES>MAG,RAL,ELE</DATATYPES>\\n <VESSEL>Aero Commander</VESSEL>\\n <VESSEL_TYPE>Plane</VESSEL_TYPE>\\n <RELEASEDATE/>\\n <ONSHORE_OFFSHORE>Onshore</ONSHORE_OFFSHORE>\\n <STARTDATE>05-DEC-96</STARTDATE>\\n <ENDDATE>22-DEC-96</ENDDATE>\\n <WLONG>116.366662</WLONG>\\n <ELONG>117.749996</ELONG>\\n <SLAT>-31.483336</SLAT>\\n <NLAT>-30.566668</NLAT>\\n <LINE_KM>35665</LINE_KM>\\n <TOTAL_KM/>\\n <LINE_SPACING>250</LINE_SPACING>\\n <LINE_DIRECTION>180</LINE_DIRECTION>\\n <TIE_SPACING/>\\n <SQUARE_KM/>\\n <CRYSTAL_VOLUME>33.6</CRYSTAL_VOLUME>\\n <UP_CRYSTAL_VOLUME>4.2</UP_CRYSTAL_VOLUME>\\n <DIGITAL_DATA>MAG,RAL,ELE</DIGITAL_DATA>\\n <GEODETIC_DATUM>WGS84</GEODETIC_DATUM>\\n <ASL/>\\n <AGL>60</AGL>\\n <MAG_INSTRUMENT>Scintrex CS2</MAG_INSTRUMENT>\\n <RAD_INSTRUMENT>Exploranium GR820</RAD_INSTRUMENT>\\n </ROW>\\n </ROWSET>\\n '''\\n # turn the XML doc into a Python object\\n root = objectify.fromstring(xml)\\n\\n if hasattr(root.ROW, 'SURVEYNAME'):\\n self.survey_name = root.ROW.SURVEYNAME\\n if hasattr(root.ROW, 'STATE'):\\n self.state = root.ROW.STATE\\n if hasattr(root.ROW, 'OPERATOR'):\\n self.operator = root.ROW.OPERATOR\\n if hasattr(root.ROW, 'CONTRACTOR'):\\n self.contractor = root.ROW.CONTRACTOR\\n if hasattr(root.ROW, 'PROCESSOR'):\\n self.processor = root.ROW.PROCESSOR\\n if hasattr(root.ROW, 'SURVEY_TYPE'):\\n self.survey_type = root.ROW.SURVEY_TYPE\\n if hasattr(root.ROW, 'DATATYPES'):\\n self.data_types = root.ROW.DATATYPES\\n if hasattr(root.ROW, 'VESSEL'):\\n self.vessel = root.ROW.VESSEL\\n if hasattr(root.ROW, 'VESSEL_TYPE'):\\n self.vessel_type = root.ROW.VESSEL_TYPE\\n if hasattr(root.ROW, 'RELEASEDATE'):\\n self.release_date = datetime.strptime(root.ROW.RELEASEDATE.text, \\\"%Y-%m-%dT%H:%M:%S\\\") if root.ROW.RELEASEDATE.text is not None else None\\n if hasattr(root.ROW, 'ONSHORE_OFFSHORE'):\\n self.onshore_offshore = root.ROW.ONSHORE_OFFSHORE\\n if hasattr(root.ROW, 'STARTDATE'):\\n self.start_date = datetime.strptime(root.ROW.STARTDATE.text, \\\"%Y-%m-%dT%H:%M:%S\\\") if root.ROW.STARTDATE.text is not None else None\\n if hasattr(root.ROW, 'ENDDATE'):\\n self.end_date = datetime.strptime(root.ROW.ENDDATE.text, \\\"%Y-%m-%dT%H:%M:%S\\\") if root.ROW.ENDDATE.text is not None else None\\n if hasattr(root.ROW, 'WLONG'):\\n self.w_long = root.ROW.WLONG\\n if hasattr(root.ROW, 'ELONG'):\\n self.e_long = root.ROW.ELONG\\n if hasattr(root.ROW, 'SLAT'):\\n self.s_lat = root.ROW.SLAT\\n if hasattr(root.ROW, 'NLAT'):\\n self.n_lat = root.ROW.NLAT\\n if hasattr(root.ROW, 'LINE_KM'):\\n self.line_km = root.ROW.LINE_KM\\n if hasattr(root.ROW, 'TOTAL_KM'):\\n self.total_km = root.ROW.TOTAL_KM\\n if hasattr(root.ROW, 'LINE_SPACING'):\\n self.line_spacing = root.ROW.LINE_SPACING\\n if hasattr(root.ROW, 'LINE_DIRECTION'):\\n self.line_direction = root.ROW.LINE_DIRECTION\\n if hasattr(root.ROW, 'TIE_SPACING'):\\n self.tie_spacing = root.ROW.TIE_SPACING\\n if hasattr(root.ROW, 'SQUARE_KM'):\\n self.square_km = root.ROW.SQUARE_KM\\n if hasattr(root.ROW, 'CRYSTAL_VOLUME'):\\n self.crystal_volume = root.ROW.CRYSTAL_VOLUME\\n if hasattr(root.ROW, 'UP_CRYSTAL_VOLUME'):\\n self.up_crystal_volume = root.ROW.UP_CRYSTAL_VOLUME\\n if hasattr(root.ROW, 'DIGITAL_DATA'):\\n self.digital_data = root.ROW.DIGITAL_DATA\\n if hasattr(root.ROW, 'GEODETIC_DATUM'):\\n self.geodetic_datum = root.ROW.GEODETIC_DATUM\\n if hasattr(root.ROW, 'ASL'):\\n self.asl = root.ROW.ASL\\n if hasattr(root.ROW, 'AGL'):\\n self.agl = root.ROW.AGL\\n if hasattr(root.ROW, 'MAG_INSTRUMENT'):\\n self.mag_instrument = root.ROW.MAG_INSTRUMENT\\n if hasattr(root.ROW, 'RAD_INSTRUMENT'):\\n self.rad_instrument = root.ROW.RAD_INSTRUMENT\",\n \"def test_pep8_conformance_pygccxml(self):\\n\\n print(\\\"\\\\r\\\\n\\\")\\n\\n # Get the path to current directory\\n path = os.path.dirname(os.path.realpath(__file__))\\n path += \\\"/../pygccxml/\\\"\\n\\n self.run_check(path)\",\n \"def wrez2xml(self,newdoc,newroot):\\n\\t\\twrez = newdoc.createElement('wrez')\\n\\t\\twrez.setAttribute('hasChanged', str(self.hasChanged))\\n\\t\\tnewroot.appendChild(wrez)\\n\\n\\t\\tpath = newdoc.createElement('path')\\n\\t\\tpath.setAttribute('value', self.path)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('init_str')\\n\\t\\tpath.setAttribute('value', self.init_str)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('hash_sha512')\\n\\t\\tpath.setAttribute('value', self.hash_sha512)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('src_rip')\\n\\t\\tpath.setAttribute('value', self.src_rip)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('quality')\\n\\t\\tpath.setAttribute('value', self.quality)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('codec')\\n\\t\\tpath.setAttribute('value', self.codec)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('language')\\n\\t\\tpath.setAttribute('value', self.language)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('audio')\\n\\t\\tpath.setAttribute('value', self.audio)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('encoder')\\n\\t\\tpath.setAttribute('value', self.encoder)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('version')\\n\\t\\tpath.setAttribute('value', self.version)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('extension')\\n\\t\\tpath.setAttribute('value', self.extension)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('release_year')\\n\\t\\tpath.setAttribute('value', self.release_year)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('title')\\n\\t\\tpath.setAttribute('value', self.title)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('size')\\n\\t\\tpath.setAttribute('value', str(self.size))\\n\\t\\twrez.appendChild(path)\\n\\t\\treturn wrez\",\n \"def test_01_FindXml(self):\\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection', 'XML - No Controllers section')\\n self.assertEqual(self.m_xml.controller.tag, 'Controller', 'XML - No Controller section')\",\n \"def evaluate(self, xml_gold_path, xml_output_path):\\n\\n # Go through all files in xml_gold_path directory\\n for file in os.listdir(xml_gold_path):\\n\\n # Set path to file\\n file = xml_gold_path+file\\n\\n # Open files only, ignore subdirectories\\n if os.path.isfile(file) and file.lower().endswith('.xml'):\\n\\n # Open xml files\\n chapter_input_gold = open(file, 'r', encoding='utf8')\\n chapter_input_test = open(xml_output_path+os.path.split(file)[-1], 'r', encoding='utf8')\\n\\n # Check if filenams are the same\\n chapter_input_gold_name = os.path.split(chapter_input_gold.name)[-1]\\n chapter_input_test_name = os.path.split(chapter_input_test.name)[-1]\\n\\n if chapter_input_gold_name == chapter_input_test_name:\\n\\n # Console log\\n chapter_input_gold_name = chapter_input_gold.name\\n chapter_input_test_name = chapter_input_test.name\\n #print('Calculating score for: ' + chapter_input_gold_name + ' and: ' + chapter_input_test_name)\\n\\n # Process xml input file with BeautifulSoup\\n chapter_input_gold = BeautifulSoup(chapter_input_gold, 'xml')\\n chapter_input_test = BeautifulSoup(chapter_input_test, 'xml')\\n\\n # Empty variables for collecting Target scores\\n target_precision_scores = 0\\n target_recall_scores = 0\\n target_f1_scores = 0\\n target_jaccard_scores = 0\\n\\n # Empty variables for collecting Focus scores\\n focus_precision_scores = 0\\n focus_recall_scores = 0\\n focus_f1_scores = 0\\n focus_jaccard_scores = 0\\n\\n # Empty variables for collecting Negated scores\\n negated_precision_scores = 0\\n negated_recall_scores = 0\\n negated_f1_scores = 0\\n negated_jaccard_scores = 0\\n\\n # Empty variables for collecting Scope scores\\n scope_precision_scores = 0\\n scope_recall_scores = 0\\n scope_f1_scores = 0\\n scope_jaccard_scores = 0\\n\\n # Count sentences and frames\\n sentence_count = 0\\n gold_frames_count = 0\\n test_frames_count = 0\\n\\n scope_gold_frames_count = 0\\n #scope_test_frames_count = 0\\n\\n # Find all Gold and Test Sentences\\n sentences_gold = chapter_input_gold.find_all('s')\\n sentences_test = chapter_input_test.find_all('s')\\n\\n #targets_gold = chapter_input_gold.find_all('target')\\n #targets_test = chapter_input_test.find_all('target')\\n\\n scope_gold_frames = chapter_input_gold.find_all('fe', {'name' : SCOPE_TAG_NAME})\\n scope_gold_frames_count = len(scope_gold_frames)\\n\\n scope_test_frames = chapter_input_test.find_all('fe', {'name' : SCOPE_TAG_NAME})\\n scope_test_frames_count = len(scope_test_frames)\\n\\n # Exit if number of sentences != between Gold and Test files\\n if len(sentences_gold) != len(sentences_test):\\n raise SystemExit(print('Number of sentences between Gold and Test files does not match.\\\\nGold:',\\n len(sentences_gold), 'Test:', len(sentences_test)))\\n\\n # Zip Gold and Test Sentences\\n for s_gold, s_test in zip(sentences_gold, sentences_test):\\n\\n sentence_count = sentence_count + 1\\n\\n gold_frames = s_gold.find_all('frame', {'name' : NEGATION_FRAME_NAME})\\n test_frames = s_test.find_all('frame', {'name' : NEGATION_FRAME_NAME})\\n\\n gold_frames_count = gold_frames_count + len(gold_frames)\\n test_frames_count = test_frames_count + len(test_frames)\\n\\n for item in zip(gold_frames, test_frames):\\n\\n #print('\\\\n=========')\\n #print('\\\\nFrame:', item[0].get('id'))\\n\\n target_gold_list = []\\n target_test_list = []\\n\\n focus_gold_list = []\\n focus_test_list = []\\n\\n negated_gold_list = []\\n negated_test_list = []\\n\\n scope_gold_list = []\\n scope_test_list = []\\n\\n # Flatten a nested list of fenodes\\n def flatten(nested_list):\\n \\\"\\\"\\\" Flatten a nested list of fenodes \\\"\\\"\\\"\\n t_l = []\\n for i in nested_list:\\n if not isinstance(i, list):\\n t_l.append(i)\\n else:\\n t_l.extend(flatten(i))\\n return t_l\\n\\n # Target\\n if item[0].find('target'):\\n target_gold = item[0].find('target')\\n target_gold_fenode_id = target_gold.find('fenode').get('idref')\\n target_gold_word = s_gold.find(id=target_gold_fenode_id).get('word').lower()\\n\\n try:\\n target_test = item[1].find('target')\\n target_test_fenode__id = target_test.find('fenode').get('idref')\\n target_test_word = s_test.find(id=target_test_fenode__id).get('word').lower()\\n except:\\n target_test_word = ''\\n\\n elif item[1].find('target'):\\n target_test = item[1].find('target')\\n target_test_fenode__id = target_test.find('fenode').get('idref')\\n target_test_word = s_test.find(id=target_test_fenode__id).get('word').lower()\\n\\n try:\\n target_gold = item[0].find('target')\\n target_gold_fenode_id = target_gold.find('fenode').get('idref')\\n target_gold_word = s_gold.find(id=target_gold_fenode_id).get('word').lower()\\n except:\\n target_gold_word = ''\\n\\n target_gold_list.append(target_gold_word)\\n target_test_list.append(target_test_word)\\n\\n # Sort lists\\n sorted_target_gold_list = sorted(flatten(target_gold_list))\\n sorted_target_test_list = sorted(flatten(target_test_list))\\n\\n #print('\\\\nTarget [Gold]:', sorted_target_gold_list)\\n #print('Target [Test]:', sorted_target_test_list)\\n\\n\\n # Focus\\n if item[0].find('fe', {'name' : FOCUS_TAG_NAME}):\\n focus_gold = item[0].find('fe', {'name' : FOCUS_TAG_NAME})\\n try:\\n focus_gold_fenode_id = focus_gold.find('fenode').get('idref')\\n focus_gold_word = s_gold.find(id=focus_gold_fenode_id).get('word').lower()\\n except:\\n focus_gold_word = ''\\n if item[1].find('fe', {'name' : FOCUS_TAG_NAME}):\\n focus_test = item[1].find('fe', {'name' : FOCUS_TAG_NAME})\\n try:\\n focus_test_fenode_id = focus_test.find('fenode').get('idref')\\n focus_test_word = s_test.find(id=focus_test_fenode_id).get('word').lower()\\n except:\\n focus_test_word = ''\\n else:\\n focus_test_word = ''\\n\\n elif item[1].find('fe', {'name' : FOCUS_TAG_NAME}):\\n focus_test = item[1].find('fe', {'name' : FOCUS_TAG_NAME})\\n try:\\n focus_test_fenode_id = focus_test.find('fenode').get('idref')\\n focus_test_word = s_test.find(id=focus_test_fenode_id).get('word').lower()\\n except:\\n focus_test_word = ''\\n if item[0].find('fe', {'name' : FOCUS_TAG_NAME}):\\n focus_gold = item[0].find('fe', {'name' : FOCUS_TAG_NAME})\\n focus_gold_fenode_id = focus_gold.find('fenode').get('idref')\\n try:\\n focus_gold_word = s_gold.find(id=focus_gold_fenode_id).get('word').lower()\\n except AttributeError:\\n focus_gold_word = ''\\n else:\\n focus_gold_word = ''\\n\\n focus_gold_list.append(focus_gold_word)\\n focus_test_list.append(focus_test_word)\\n\\n # Sort lists\\n sorted_focus_gold_list = sorted(flatten(focus_gold_list))\\n sorted_focus_test_list = sorted(flatten(focus_test_list))\\n\\n #print('\\\\nFocus [Gold]:', sorted_focus_gold_list)\\n #print('Focus [Test]:', sorted_focus_test_list)\\n\\n\\n # Negated\\n if item[0].find('fe', {'name' : NEGATED_TAG_NAME}):\\n negated_gold = item[0].find('fe', {'name' : NEGATED_TAG_NAME})\\n negated_gold_fenode_id = negated_gold.find('fenode').get('idref')\\n try:\\n negated_gold_word = s_gold.find(id=negated_gold_fenode_id).get('word').lower()\\n except AttributeError:\\n negated_gold_word = ''\\n if item[1].find('fe', {'name' : NEGATED_TAG_NAME}):\\n negated_test = item[1].find('fe', {'name' : NEGATED_TAG_NAME})\\n try:\\n negated_test_fenode_id = negated_test.find('fenode').get('idref')\\n negated_test_word = s_test.find(id=negated_test_fenode_id).get('word').lower()\\n except:\\n negated_test_word = ''\\n else:\\n negated_test_word = ''\\n\\n elif item[1].find('fe', {'name' : NEGATED_TAG_NAME}):\\n negated_test = item[1].find('fe', {'name' : NEGATED_TAG_NAME})\\n try:\\n negated_test_fenode_id = negated_test.find('fenode').get('idref')\\n negated_test_word = s_test.find(id=negated_test_fenode_id).get('word').lower()\\n except:\\n negated_test_word = ''\\n if item[0].find('fe', {'name' : NEGATED_TAG_NAME}):\\n negated_gold = item[0].find('fe', {'name' : NEGATED_TAG_NAME})\\n negated_gold_fenode_id = negated_gold.find('fenode').get('idref')\\n try:\\n negated_gold_word = s_gold.find(id=negated_gold_fenode_id).get('word').lower()\\n except AttributeError:\\n negated_gold_word = ''\\n else:\\n negated_gold_word = ''\\n else:\\n negated_test_word = ''\\n negated_gold_word = ''\\n\\n negated_gold_list.append(negated_gold_word)\\n negated_test_list.append(negated_test_word)\\n\\n # Sort lists\\n sorted_negated_gold_list = sorted(flatten(negated_gold_list))\\n sorted_negated_test_list = sorted(flatten(negated_test_list))\\n\\n #print('\\\\nNegated [Gold]:', sorted_negated_gold_list)\\n #print('Negated [Test]:', sorted_negated_test_list)\\n\\n\\n # Resolve Terminals if Scope on a complex graph\\n def resolve_non_terminals(idref):\\n \\\"\\\"\\\" This function resolves a complex gold graph to\\n a simple flat list of tokens.\\n \\\"\\\"\\\"\\n nonterminal = s_gold.find(id=idref)\\n edges = nonterminal.find_all('edge')\\n edge_words = []\\n for edge in edges:\\n e_id = edge.get('idref')\\n if s_gold.find(id=e_id).get('word') is not None:\\n try:\\n edge_word = s_gold.find(id=e_id).get('word').lower()\\n edge_words.append(edge_word)\\n except:\\n pass\\n if s_gold.find(id=e_id).get('word') is None:\\n edge_words.append(resolve_non_terminals(e_id))\\n\\n return edge_words\\n\\n def resolve_non_terminals_test(idref):\\n \\\"\\\"\\\" This function resolves a complex test graph to\\n a simple flat list of tokens.\\n \\\"\\\"\\\"\\n nonterminal = s_test.find(id=idref)\\n edges = nonterminal.find_all('edge')\\n edge_words = []\\n for edge in edges:\\n e_id = edge.get('idref')\\n if s_test.find(id=e_id).get('word') is not None:\\n try:\\n edge_word = s_test.find(id=e_id).get('word').lower()\\n edge_words.append(edge_word)\\n except:\\n pass\\n if s_test.find(id=e_id).get('word') is None:\\n edge_words.append(resolve_non_terminals(e_id))\\n\\n return edge_words\\n\\n # Scope\\n if item[0].find('fe', {'name' : SCOPE_TAG_NAME}):\\n scope_gold = item[0].find('fe', {'name' : SCOPE_TAG_NAME})\\n scope_gold_fenodes = scope_gold.find_all('fenode')\\n for s_g in scope_gold_fenodes:\\n s_id = s_g.get('idref')\\n if s_gold.find(id=s_id).get('word') is not None:\\n try:\\n scope_word = s_gold.find(id=s_id).get('word').lower()\\n scope_gold_list.append(scope_word)\\n except:\\n pass\\n if s_gold.find(id=s_id).get('word') is None:\\n scope_gold_list.append(resolve_non_terminals(s_id))\\n else:\\n pass\\n\\n if item[1].find('fe', {'name' : SCOPE_TAG_NAME}):\\n scope_test = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\\n scope_test_fenodes = scope_test.find_all('fenode')\\n for s_t in scope_test_fenodes:\\n s_id = s_t.get('idref')\\n if s_test.find(id=s_id).get('word') is not None:\\n try:\\n scope_word = s_test.find(id=s_id).get('word').lower()\\n scope_test_list.append(scope_word)\\n except:\\n pass\\n elif s_test.find(id=s_id).get('word') is None:\\n scope_test_list.append(resolve_non_terminals_test(s_id))\\n else:\\n scope_test_list.append('')\\n\\n elif item[1].find('fe', {'name' : SCOPE_TAG_NAME}):\\n scope_test = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\\n scope_test_fenodes = scope_test.find_all('fenode')\\n for s_t in scope_test_fenodes:\\n s_id = s_t.get('idref')\\n if s_test.find(id=s_id).get('word') is not None:\\n try:\\n scope_word = s_test.find(id=s_id).get('word').lower()\\n scope_test_list.append(scope_word)\\n except:\\n pass\\n if s_test.find(id=s_id).get('word') is None:\\n scope_test_list.append(resolve_non_terminals_test(s_id))\\n else:\\n pass\\n\\n if item[0].find('fe', {'name' : SCOPE_TAG_NAME}):\\n scope_gold = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\\n scope_gold_fenodes = scope_gold.find_all('fenode')\\n for s_g in scope_gold_fenodes:\\n s_id = s_g.get('idref')\\n if s_gold.find(id=s_id).get('word') is not None:\\n try:\\n scope_word = s_gold.find(id=s_id).get('word').lower()\\n scope_gold_list.append(scope_word)\\n except:\\n pass\\n if s_gold.find(id=s_id).get('word') is None:\\n scope_gold_list.append(resolve_non_terminals(s_id))\\n else:\\n pass\\n else:\\n scope_gold_list.append('')\\n\\n # Sort lists\\n sorted_scope_gold_list = sorted(flatten(scope_gold_list))\\n sorted_scope_test_list = sorted(flatten(scope_test_list))\\n\\n #print('\\\\nScope [Gold]:', sorted_scope_gold_list)\\n #print('Scope [Test]:', sorted_scope_test_list)\\n\\n # If lists are same length, check if items are same\\n if len(sorted_scope_gold_list) == len(sorted_scope_test_list):\\n sorted_scope_test_list_intersection = set(sorted_scope_gold_list).intersection(sorted_scope_test_list)\\n sorted_scope_test_list_intersection = list(sorted_scope_test_list_intersection)\\n if len(sorted_scope_test_list_intersection) < len(sorted_scope_test_list):\\n difference = len(sorted_scope_test_list) - len(sorted_scope_test_list_intersection)\\n empty_element = 0\\n\\n while empty_element < difference:\\n sorted_scope_test_list_intersection.append('')\\n empty_element = empty_element + 1\\n \\n sorted_scope_test_list = sorted_scope_test_list_intersection\\n\\n # If lists are different lengths, add empty elements\\n elif len(sorted_scope_gold_list) > len(sorted_scope_test_list):\\n difference = len(sorted_scope_gold_list) - len(sorted_scope_test_list)\\n empty_element = 0\\n\\n while empty_element < difference:\\n sorted_scope_test_list.append('')\\n empty_element = empty_element + 1\\n\\n elif len(sorted_scope_test_list) > len(sorted_scope_gold_list):\\n difference = len(sorted_scope_test_list) - len(sorted_scope_gold_list)\\n empty_element = 0\\n\\n while empty_element < difference:\\n sorted_scope_gold_list.append('')\\n empty_element = empty_element + 1\\n\\n\\n # Align items in the lists for sklearn, set 1 for matched items, else set 0\\n sorted_target_gold_list_normalized = [1 if element in sorted_target_gold_list and not element == \\\"\\\" else 0 for element in sorted_target_gold_list]\\n sorted_target_test_list_normalized = [1 if element in sorted_target_gold_list else 0 for element in sorted_target_test_list]\\n\\n sorted_focus_gold_list_normalized = [1 if element in sorted_focus_gold_list and not element == \\\"\\\" else 0 for element in sorted_focus_gold_list]\\n sorted_focus_test_list_normalized = [1 if element in sorted_focus_gold_list else 0 for element in sorted_focus_test_list]\\n\\n sorted_negated_gold_list_normalized = [1 if element in sorted_negated_gold_list and not element == \\\"\\\" else 0 for element in sorted_negated_gold_list]\\n sorted_negated_test_list_normalized = [1 if element in sorted_negated_gold_list else 0 for element in sorted_negated_test_list]\\n\\n sorted_scope_gold_list_normalized = [1 if element in sorted_scope_gold_list and not element == \\\"\\\" else 0 for element in sorted_scope_gold_list]\\n sorted_scope_test_list_normalized = [1 if element in sorted_scope_gold_list else 1 if not element == \\\"\\\" else 0 for element in sorted_scope_test_list]\\n\\n #print(sorted_scope_gold_list_normalized)\\n #print(sorted_scope_test_list_normalized)\\n\\n\\n # Sklearn calculations\\n #target_precision_scores = target_precision_scores + precision_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\\n #target_recall_scores = target_recall_scores + recall_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\\n target_f1_scores = target_f1_scores + f1_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\\n #target_jaccard_scores = target_jaccard_scores + jaccard_similarity_score(sorted_target_gold_list, sorted_target_test_list)\\n\\n #focus_precision_scores = focus_precision_scores + precision_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\\n #focus_recall_scores = focus_recall_scores + recall_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\\n focus_f1_scores = focus_f1_scores + f1_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\\n #focus_jaccard_scores = focus_jaccard_scores + jaccard_similarity_score(sorted_focus_gold_list, sorted_focus_test_list)\\n\\n #negated_precision_scores = negated_precision_scores + precision_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\\n #negated_recall_scores = negated_recall_scores + recall_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\\n negated_f1_scores = negated_f1_scores + f1_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\\n #negated_jaccard_scores = negated_jaccard_scores + jaccard_similarity_score(sorted_negated_gold_list, sorted_negated_test_list)\\n\\n scope_precision_scores = scope_precision_scores + precision_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\\n scope_recall_scores = scope_recall_scores + recall_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\\n scope_f1_scores = scope_f1_scores + f1_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\\n scope_jaccard_scores = scope_jaccard_scores + jaccard_similarity_score(sorted_scope_gold_list, sorted_scope_test_list)\\n\\n\\n print('\\\\n=============================')\\n print('====== EVALUATION for:', chapter_input_test_name, '======')\\n print('Total Sentences:', sentence_count,\\n '\\\\nNegation Gold frames:', gold_frames_count,\\n '\\\\nNegation Test frames:', test_frames_count, '\\\\n')\\n\\n print('----- CUEWORDS -----')\\n #print('Precision:\\\\t', target_precision_scores / gold_frames_count)\\n #print('Recall:\\\\t', target_recall_scores / gold_frames_count)\\n print('F1 score:\\\\t', target_f1_scores / gold_frames_count)\\n #print('Jaccard similarity:\\\\t', target_jaccard_scores / gold_frames_count)\\n\\n print('\\\\n----- FOCUS -----')\\n #print('Precision:\\\\t', focus_precision_scores / gold_frames_count)\\n #print('Recall:\\\\t', focus_recall_scores / gold_frames_count)\\n print('F1 score:\\\\t', focus_f1_scores / gold_frames_count)\\n #print('Jaccard similarity:\\\\t', focus_jaccard_scores / gold_frames_count)\\n\\n print('\\\\n----- NEGATED -----')\\n #print('Precision:\\\\t', negated_precision_scores / gold_frames_count)\\n #print('Recall:\\\\t', negated_recall_scores / gold_frames_count)\\n print('F1 score:\\\\t', negated_f1_scores / gold_frames_count)\\n #print('Jaccard similarity:\\\\t', negated_jaccard_scores / gold_frames_count)\\n\\n print('\\\\n----- SCOPE -----\\\\nScope Gold frames:', scope_gold_frames_count, '\\\\nScope Test frames:', scope_test_frames_count, '\\\\n')\\n print('Precision:\\\\t', scope_precision_scores / scope_test_frames_count)\\n print('Recall:\\\\t', scope_recall_scores / scope_test_frames_count)\\n print('F1 score:\\\\t', scope_f1_scores / scope_test_frames_count)\\n print('Jaccard similarity:\\\\t', scope_jaccard_scores / scope_test_frames_count)\\n\\n print('Done!')\",\n \"def build(filename=\\\"JMdict_e.gz\\\", output_filename=DATABASE_FILENAME):\\n # NOTE: The JMdict XML file contains XML entities, that are expanded when\\n # parsed using Python's stdlib xml.etree.ElementTree like so:\\n # ElementTree.parse(f). That is undesired behavior for our use-case. Oshi\\n # needs to parse the short entity string, for example &adj-i; should be\\n # \\\"adj-i\\\" instead of \\\"adjective (keiyoushi)\\\". That's why it uses an external\\n # xml parser: lxml that allows you to specify whether to expand entites.\\n extension = path.splitext(filename)[1].lower()\\n parser = etree.XMLParser(resolve_entities=False)\\n if extension == \\\".gz\\\":\\n with gzip.open(filename) as f:\\n tree = etree.parse(f, parser)\\n elif extension == \\\".xml\\\":\\n tree = etree.parse(filename, parser)\\n else:\\n raise ValueError(\\\"File extension not supported: \\\" + extension)\\n\\n entries = []\\n # variables starting with x contain xml element(s)\\n for xentry in tree.getroot():\\n entry = {}\\n entry[\\\"writings\\\"] = [x.find('keb').text for x in xentry.findall('k_ele')]\\n entry[\\\"readings\\\"] = [x.find('reb').text for x in xentry.findall('r_ele')]\\n xsenses = xentry.findall('sense')\\n senses = []\\n # last_tags will contain a reference to previously found tags (JMdict\\n # specifies that when pos is empty, the previous one should be used)\\n last_tags = []\\n for xsense in xsenses:\\n tags = []\\n xtags = xsense.findall('pos') # + xsense.findall('misc')\\n for xtag in xtags:\\n match = re.search(r'&([\\\\w-]+?);', etree.tostring(xtag, encoding=\\\"utf-8\\\").decode('utf-8') or \\\"\\\")\\n if match: tags.append(match.group(1))\\n glosses = [x.text for x in xsense.findall('gloss')]\\n senses.append({\\\"glosses\\\": glosses, \\\"tags\\\": tags or last_tags})\\n last_tags = tags or last_tags\\n entry[\\\"senses\\\"] = senses\\n entries.append(entry)\\n with open(output_filename, 'w', encoding='utf-8') as f:\\n json.dump(entries, f, ensure_ascii=False)\",\n \"def creation_srcmdl(dir_cat,SourceRA,SourceDec,SourceROI,distmin,name,outputfile,emin,emax):\\n\\tf_liste_sour=\\\"a.txt\\\"\\n\\n\\tlect_ca(dir_cat,SourceRA,SourceDec,SourceROI,distmin,name,f_liste_sour,name)\\n\\tXML_EC_PL(name, f_liste_sour, outputfile, emin,emax)\\n\\tos.system(\\\"rm -rf a.txt\\\")\",\n \"def test_write(self):\\n cases = {\\n self.test_eac + \\\"NE00401.xml\\\": True,\\n self.test_eac + \\\"NE01501.xml\\\": False,\\n self.test_eac + \\\"NE01302.xml\\\": True,\\n }\\n metadata_url = 'http://www.example.com/metadata.xml'\\n presentation_url = 'http://www.example.com/presentation.html'\\n for case in cases:\\n doc = EacCpf.EacCpf(case, metadata_url, presentation_url)\\n self.assertNotEqual(doc, None)\\n path = doc.write(self.temp)\\n self.assertEquals(os.path.exists(path), True)\\n # read the file and try to extract the attributes\\n try:\\n tree = etree.parse(path)\\n ns = {\\n EacCpf.DOC_KEY: EacCpf.DOC_NS,\\n EacCpf.ESRC_KEY: EacCpf.ESRC_NS,\\n }\\n # get the url to the metadata file\\n metadata = tree.xpath(\\\"//doc:eac-cpf/@\\\" + EacCpf.ESRC_KEY + \\\":metadata\\\", namespaces=ns)\\n self.assertNotEqual(metadata, None)\\n self.assertEqual(metadata[0], metadata_url)\\n # get the url to the presentation file\\n presentation = tree.xpath(\\\"//doc:eac-cpf/@\\\" + EacCpf.ESRC_KEY + \\\":presentation\\\", namespaces=ns)\\n self.assertNotEqual(presentation, None)\\n self.assertEqual(presentation[0], presentation_url)\\n # get the url to the source file\\n source = tree.xpath(\\\"//doc:eac-cpf/@\\\" + EacCpf.ESRC_KEY + \\\":source\\\", namespaces=ns)\\n self.assertNotEqual(source, None)\\n self.assertEqual(source[0], case)\\n except:\\n msg = \\\"Failed to complete parsing of {0}\\\".format(case)\\n self.log.error(msg, exc_info=True)\\n self.fail(msg)\",\n \"def test_xml_from_file(self):\\n j2k = Jp2k(self.j2kfile)\\n\\n self.jp2h.box = [self.ihdr, self.colr]\\n\\n xmlb = glymur.jp2box.XMLBox(filename=self.xmlfile)\\n boxes = [self.jp2b, self.ftyp, self.jp2h, xmlb, self.jp2c]\\n with tempfile.NamedTemporaryFile(suffix=\\\".jp2\\\") as tfile:\\n j2k.wrap(tfile.name, boxes=boxes)\\n jp2 = Jp2k(tfile.name)\\n\\n output_boxes = [box.box_id for box in jp2.box]\\n self.assertEqual(output_boxes, ['jP ', 'ftyp', 'jp2h', 'xml ',\\n 'jp2c'])\\n\\n elts = jp2.box[3].xml.findall('country')\\n self.assertEqual(len(elts), 3)\\n\\n neighbor = elts[1].find('neighbor')\\n self.assertEqual(neighbor.attrib['name'], 'Malaysia')\\n self.assertEqual(neighbor.attrib['direction'], 'N')\",\n \"def test_non_regression(self):\\n main(\\\"Source_mobile.xml\\\", [[\\\"engine\\\", \\\"A320.xml\\\", \\\"A320.csv\\\"]], \\\"Resultat.xml\\\", gui=False)\\n compare_xml_results(\\\"Resultat.xml\\\", \\\"Reference.xml\\\", self)\",\n \"def configureGeoData(data,resultDir):\\n xmlfiles = findfiles(['*.xml'],where=data[\\\"folder\\\"])\\n xmlurls=[]\\n fgdclist=[]\\n #xmlselect=[]\\n for xml in xmlfiles:\\n shutil.copy(os.path.join(data['folder'],xml),resultDir)\\n xmlurls.append(os.path.join(resulturl,resultDir.split('/')[-1],xml))\\n #import xmltodict\\n localfilename=os.path.join(data['folder'],xml)\\n #xmlselect.append({\\\"file\\\":localfilename,\\\"url\\\":os.path.join(resulturl,resultDir.split('/')[-1],xml)})\\n with open(os.path.join(data['folder'],xml)) as fd:\\n stringxml = fd.read()\\n #if 'FGDC' in stringxml.upper():\\n fgdc={}\\n fgdc['url']=os.path.join(resulturl,resultDir.split('/')[-1],xml)\\n doc = xmltodict.parse(stringxml,cdata_key='text',attr_prefix='',dict_constructor=dict)\\n fgdc['data']=doc\\n fgdc['file']=localfilename\\n fgdclist.append(fgdc)\\n data['xmlurls']=xmlurls\\n data['xml']={\\\"urls\\\":xmlurls,\\\"fgdc\\\":fgdclist,\\\"files\\\":xmlfiles}\\n return data\",\n \"def test_01_Xml(self):\\n l_xml = self.m_xml.light_sect[1]\\n # print(PrettyFormatAny.form(l_xml, 'C4-01-A - XML'))\\n self.assertEqual(l_xml.attrib['Name'], TESTING_LIGHT_NAME_1)\\n self.assertEqual(l_xml.find('DeviceFamily').text, TESTING_DEVICE_FAMILY_UPB)\",\n \"def main(*args):\\r\\n print(START_MESSAGE)\\r\\n print(\\\"Script Location:\\\", location)\\r\\n print(\\\"Arguments Passed:\\\", args)\\r\\n\\r\\n root = ET.parse(xmlfile).getroot()\\r\\n keys = []\\r\\n out = \\\"\\\"\\r\\n\\r\\n for child in root[1]:\\r\\n out += child.attrib['Name'] + \\\";\\\" + child[0].text + \\\"\\\\n\\\"\\r\\n\\r\\n with open(outputfile, 'w') as f:\\r\\n f.write(out)\",\n \"def prepare_xml(original_xml, mangled_xml):\\n in_handle = open(original_xml)\\n footer = \\\" </BlastOutput_iterations>\\\\n</BlastOutput>\\\\n\\\"\\n header = \\\"\\\"\\n while True:\\n line = in_handle.readline()\\n if not line:\\n #No hits?\\n stop_err(\\\"Problem with XML file?\\\")\\n if line.strip() == \\\"<Iteration>\\\":\\n break\\n header += line\\n\\n if \\\"<BlastOutput_program>blastx</BlastOutput_program>\\\" in header:\\n print \\\"BLASTX output identified\\\"\\n elif \\\"<BlastOutput_program>blastp</BlastOutput_program>\\\" in header:\\n print \\\"BLASTP output identified\\\"\\n else:\\n in_handle.close()\\n stop_err(\\\"Expect BLASTP or BLASTX output\\\")\\n\\n out_handle = open(mangled_xml, \\\"w\\\")\\n out_handle.write(header)\\n out_handle.write(line)\\n count = 1\\n while True:\\n line = in_handle.readline()\\n if not line:\\n break\\n elif line.strip() == \\\"<Iteration>\\\":\\n #Insert footer/header\\n out_handle.write(footer)\\n out_handle.write(header)\\n count += 1\\n out_handle.write(line)\\n\\n out_handle.close()\\n in_handle.close()\\n print \\\"Input has %i queries\\\" % count\",\n \"def parse_CRAFT(kb_data):\\n\\n print(\\\"Parsing CRAFT corpus...\\\")\\n corpus_dir = str()\\n \\n if kb_data.kb == \\\"chebi\\\":\\n corpus_dir = \\\"./retrieved_data/corpora/CRAFT-4.0.1/concept-annotation/CHEBI/CHEBI/knowtator/\\\"\\n \\n elif kb_data.kb == \\\"go_bp\\\":\\n corpus_dir = \\\"./retrieved_data/corpora/CRAFT-4.0.1/concept-annotation/GO_BP/GO_BP/knowtator/\\\"\\n\\n output_CRAFT = dict()\\n \\n for document in os.listdir(corpus_dir): \\n root = ET.parse(corpus_dir + document)\\n file_id = document.strip('.txt.knowtator.xml')\\n annotations = dict()\\n\\n for annotation in root.iter(\\\"annotation\\\"):\\n annotation_id = annotation.find('mention').attrib['id']\\n annotation_text = annotation.find('spannedText').text\\n start_pos, end_pos = annotation.find('span').attrib['start'], annotation.find('span').attrib['end']\\n annotations[annotation_id] = [annotation_text, start_pos, end_pos] \\n \\n for classMention in root.iter(\\\"classMention\\\"):\\n classMention_id = classMention.attrib['id']\\n annotation_values = annotations[classMention_id]\\n kb_id = classMention.find('mentionClass').attrib['id']\\n \\n if kb_id in kb_data.child_to_parent.keys(): # Consider only KB concepts with ONE direct ancestor\\n direct_ancestor = kb_data.child_to_parent[kb_id]\\n annotation = (annotation_values[0], annotation_values[1], \\n annotation_values[2], kb_id, direct_ancestor) \\n output_CRAFT = add_annotation_to_output_dict(file_id, annotation, output_CRAFT)\\n \\n print(\\\"...Done!\\\")\\n return output_CRAFT\",\n \"def build_corpus_questions(criteria_incl_question=True, criteria_incl_snip=False, criteria_incl_long=False, level=0):\\r\\n\\r\\n\\tprint('\\\\nbuilding questions and answers')\\r\\n\\r\\n\\tif load_corpus_questions():\\r\\n\\t\\treturn\\r\\n\\r\\n\\timport xml.etree.ElementTree as ET\\r\\n\\r\\n\\tquestion_count = 0\\r\\n\\tno_abstract_tag = 0\\r\\n\\tno_abstract_file = 0\\r\\n\\tlong_count = 0\\r\\n\\t\\r\\n\\tglobal search_criteria_dict, solution_dict, linked_abstracts_dict\\r\\n\\t\\r\\n\\tsearch_criteria_dict = collections.defaultdict(list)\\r\\n\\tsolution_dict = collections.defaultdict(list)\\r\\n\\tlinked_abstracts_dict = collections.defaultdict(list)\\r\\n\\tcommon_map_dict = collections.defaultdict(list)\\r\\n\\t\\r\\n\\ttree = ET.parse(paths.path_data_questions)\\r\\n\\troot = tree.getroot()\\r\\n\\tfor record in root.findall('record'):\\r\\n\\t\\trecord_id = record.get('id')\\r\\n\\t\\tquestion_text = preprocess_document(record.find('question').text,True)\\r\\n\\r\\n\\t\\tif level == 0:\\r\\n\\t\\t\\tkey = record_id # key\\r\\n\\t\\t\\r\\n\\t\\tanswer = record.find('answer')\\r\\n\\t\\tif answer is not None:\\r\\n\\t\\t\\tfor s in answer.findall('snip'):\\r\\n\\t\\t\\t\\tif s is not None:\\r\\n\\t\\t\\t\\t\\tsnip_id = s.get('id')\\r\\n\\t\\t\\t\\t\\tsnip_text = preprocess_document(s.find('sniptext').text,True)\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\tif level == 1:\\r\\n\\t\\t\\t\\t\\t\\tkey = record_id + '_' + snip_id # key\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\tfor i,l in enumerate(s.findall('long')):\\r\\n\\t\\t\\t\\t\\t\\tif l is not None:\\r\\n\\t\\t\\t\\t\\t\\t\\tlong_id = l.get('id')\\r\\n\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t\\tif level == 2:\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tkey = record_id + '_' + snip_id + '_' + long_id # key\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t\\tif criteria_incl_question:\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tfor x in question_text:\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tsearch_criteria_dict[key].append(x) # question\\r\\n\\t\\t\\t\\t\\t\\t\\tif criteria_incl_snip:\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tfor x in snip_text:\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tsearch_criteria_dict[key].append(x) # snip\\r\\n\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t\\tlong_text = l.find('longtext')\\r\\n\\t\\t\\t\\t\\t\\t\\tif long_text is not None:\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tlong_text = preprocess_document(long_text.text,True)\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tfor x in long_text:\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tsolution_dict[key].append(x) # long - answer\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tif criteria_incl_long:\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tfor x in long_text:\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tsearch_criteria_dict[key].append(x) # long - search\\r\\n\\r\\n\\t\\t\\t\\t\\t\\t\\tif key not in search_criteria_dict.keys():\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tsearch_criteria_dict[key].append('')\\r\\n\\r\\n\\t\\t\\t\\t\\t\\t\\tlong_refs = l.findall('ref')\\r\\n\\t\\t\\t\\t\\t\\t\\tfor long_ref in long_refs:\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tabstract = long_ref.get('abstract')[10:]\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tabstract_path = paths.path_data_abstracts + '/' + abstract\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tabstract_sentences = abstracts_dict[abstract]\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tlinked_abstracts_dict[key].append(abstract) # linked abstracts\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tlong_count += 1\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\tquestion_count += 1\\r\\n\\t\\t# print(str(question_count) + ' : ' + str(question_text) + ' : ' + str(no_abstract_file) + ' : ' + str(no_abstract_tag) + ' : ' + str(long_count))\\r\\n\\r\\n\\tpickle.dump(search_criteria_dict,open(paths.path_data_questions_pickle,\\\"wb\\\"))\\r\\n\\tpickle.dump(solution_dict,open(paths.path_data_answers_pickle,\\\"wb\\\"))\\r\\n\\tpickle.dump(linked_abstracts_dict,open(paths.path_data_linkedabstracts_pickle,\\\"wb\\\"))\\r\\n\\t\\r\\n\\tprint(len(search_criteria_dict))\\r\\n\\tprint(len(solution_dict))\\r\\n\\tprint(len(linked_abstracts_dict))\\r\\n\\t\\r\\n\\tprint('\\\\ncorpus build complete')\",\n \"def test_02_Xml1(self):\\n l_xml = self.m_xml.light_sect[1]\\n print(PrettyFormatAny.form(l_xml, 'C1-02-A - XML'))\\n self.assertEqual(l_xml.attrib['Name'], TESTING_LIGHT_NAME_1)\\n self.assertEqual(l_xml.find('DeviceFamily').text, TESTING_DEVICE_FAMILY_UPB)\",\n \"def test_load_quakeML():\\n # Check one cmt file\\n with tempfile.TemporaryDirectory() as tmp_dir:\\n\\n # Cmtfile path\\n cmtfile = os.path.join(DATA_DIR, \\\"testCMT\\\")\\n\\n # create new directory\\n new_xml_path = os.path.join(tmp_dir, \\\"tests.xml\\\")\\n xml = read_events(cmtfile)\\n xml.write(new_xml_path, format=\\\"QUAKEML\\\")\\n\\n assert(os.path.exists(new_xml_path)\\n and os.path.isfile(new_xml_path))\\n\\n print(\\\"QuakeML\\\\n\\\", CMTSource.from_quakeml_file(new_xml_path))\\n print(\\\"CMT\\\\n\\\", CMTSource.from_CMTSOLUTION_file(cmtfile))\\n assertDictAlmostEqual(CMTSource.from_quakeml_file(new_xml_path),\\n CMTSource.from_CMTSOLUTION_file(cmtfile))\",\n \"def GenerateXML(dictionary, fileName=\\\"labelling.xml\\\") : \\n root = gfg.Element(\\\"annotation\\\") \\n #the big section is called Annotation\\n for key in dictionary:\\n #for every polygon list in inside object witho subelement name and attributes and the type \\\"polygon\\\"\\n objectElement = gfg.Element(\\\"object\\\") \\n root.append(objectElement) \\n subElement1 = gfg.SubElement(objectElement, \\\"name:\\\".strip(\\\":\\\"))\\n subElement1.text = str(dictionary[key][\\\"name\\\"])\\n subElement2 = gfg.SubElement(objectElement, \\\"attributes\\\".strip(\\\":\\\"))\\n subElement2.text = str(dictionary[key][\\\"attributes\\\"])\\n subElement3 = gfg.SubElement(objectElement, \\\"polygon\\\")\\n \\n for i in range(0, len(dictionary[key])-2):\\n #for every vertex of the polygon list it's rounded x, y on xml\\n SubInsidePolygon = gfg.SubElement(subElement3, \\\"pt\\\")\\n sub_x = gfg.SubElement(SubInsidePolygon, \\\"x\\\")\\n sub_y = gfg.SubElement(SubInsidePolygon, \\\"y\\\")\\n sub_x.text = str(int(round(dictionary[key][\\\"x_y_\\\" + str(i)][0])))\\n sub_y.text = str(int(round(dictionary[key][\\\"x_y_\\\" + str(i)][1])))\\n tree = gfg.ElementTree(root) \\n #create the xml tree\\n with open (fileName, \\\"wb\\\") as files : \\n tree.write(files) \\n #if xml does not exist create one otherwise rewrite to it\",\n \"def __createXMLFileForClear():\\r\\n #description\\r\\n #Root\\r\\n clear_root = Element('clear-users-request', {'xmlns':SYMPLECTIC_XMLNS_URI,} )\\r\\n #Feed\\r\\n SubElement(clear_root, 'feed-id').text = IMPORT_USERS_FEED_ID\\r\\n #Convert to ElementTree and write xml version to file\\r\\n xml_filename = SYMPLECTIC_LOCAL_XML_FOLDER + SYMPLECTIC_LOCAL_USER_FOLDER + SYMPLECTIC_LOCAL_USER_CLEARFILE\\r\\n ElementTree(clear_root).write(xml_filename)\\r\\n #Return xml filename\\r\\n return xml_filename\",\n \"def setUpClass(cls):\\n import os\\n for root in cls.prod_s2_ssc:\\n os.makedirs(root)\\n metadata = root.split(\\\".\\\")[0] + \\\".HDR\\\"\\n TestFunctions.touch(metadata)\\n for root in cls.prod_s2_mus:\\n os.makedirs(root)\\n metadata = os.path.join(root, root + \\\"_MTD_ALL.xml\\\")\\n TestFunctions.touch(metadata)\\n for root in cls.prod_s2_nat:\\n os.makedirs(root)\\n metadata = os.path.join(root, \\\"MTD_MSIL1C.xml\\\")\\n TestFunctions.touch(metadata)\",\n \"def xml_parser_dielectrics(request, tmpdir_factory):\\n testdir = os.path.dirname(__file__)\\n xmlfile = testdir + \\\"/dielectrics.xml\\\"\\n tmpfile = str(tmpdir_factory.mktemp('data').join('basic_trunc.xml'))\\n xml_truncate(request.param, xmlfile, tmpfile)\\n xml = vasprun.Xml(tmpfile, event = False)\\n \\n return xml\",\n \"def getXML(self):\\n nodes = list(self.nodes(data=True))\\n nodes.sort()\\n node_string = ''\\n for n in nodes:\\n attribute_string = ''\\n keys = list(n[1].keys())\\n keys.sort()\\n for k in keys:\\n attribute_string += \\\"\\\"\\\"<{0}> {1} </{2}>\\\\n\\\"\\\"\\\".format(k, n[1][k], k)\\n modification_string = ''\\n modified_by = self.predecessors(n[0])\\n if modified_by:\\n for mod in modified_by:\\n modification_string += \\\"\\\"\\\"<modified_by>\\\\n\\\"\\\"\\\"\\n modification_string += \\\\\\n \\\"\\\"\\\"<modifyingNode> %s </modifyingNode>\\\\n\\\"\\\"\\\"%mod.getTagID()\\n modification_string += \\\\\\n \\\"\\\"\\\"<modifyingCategory> %s </modifyingCategory>\\\\n\\\"\\\"\\\"%mod.getCategory()\\n modification_string += \\\"\\\"\\\"</modified_by>\\\\n\\\"\\\"\\\"\\n modifies = self.successors(n[0])\\n if modifies:\\n for modified in modifies:\\n modification_string += \\\"\\\"\\\"<modifies>\\\\n\\\"\\\"\\\"\\n modification_string += \\\\\\n \\\"\\\"\\\"<modifiedNode> {0} </modifiedNode>\\\\n\\\"\\\"\\\".format(modified.getTagID())\\n modification_string += \\\\\\n \\\"\\\"\\\"</modifies>\\\\n\\\"\\\"\\\"\\n node_string += \\\\\\n NODE_XML_SKEL.format(attribute_string+\\\"{0}\\\".format(n[0].getXML()) +\\\\\\n modification_string)\\n edges = list(self.edges(data=True))\\n edges.sort()\\n edge_string = ''\\n for edge in edges:\\n keys = list(edge[2].keys())\\n keys.sort()\\n attribute_string = ''\\n for key in keys:\\n attribute_string += \\\"\\\"\\\"<{0}> {1} </{2}>\\\\n\\\"\\\"\\\".format(key, edge[2][key], key)\\n edge_string += \\\"{0}\\\".format(EDGE_XML_SKEL.format(edge[0].getTagID(),\\n edge[1].getTagID(),\\n attribute_string))\\n\\n return CONTEXT_MARKUP_XML_SKEL.format(xmlScrub(self.getRawText()),\\n xmlScrub(self.getText()),\\n node_string,\\n edge_string)\",\n \"def generateXMLmodel(quickLogger,\\n base,\\n galactic_file=\\\"gal_2yearp7v6_v0.fits\\\",\\n isotropic_file=\\\"iso_p7v6source.txt\\\",\\n catalog_file=\\\"gll_psc_v07.fit\\\"):\\n\\n\\n try:\\n checkForFiles(quickLogger,[base+\\\"_model.xml\\\"])\\n quickLogger.info(base+\\\"_model.xml exists, won't create a new one.\\\")\\n except(FileNotFound):\\n quickLogger.info(base+\\\"_model.xml doesn't exist, will create a new one.\\\") \\n try:\\n checkForFiles(quickLogger,[base+\\\"_filtered_gti.fits\\\",galactic_file,isotropic_file,catalog_file])\\n import make2FGLxml\\n mymodel = make2FGLxml.srcList(catalog_file,base+\\\"_filtered_gti.fits\\\",base+\\\"_model.xml\\\")\\n mymodel.makeModel(galactic_file, 'gal_2yearp7v6_v0', isotropic_file, 'iso_p7v6source')\\n quickLogger.info(\\\"NOTE: if there are extended sources in your ROI, make sure the \\\"\\\\\\n +\\\"correspoinding diffuse template is in the working directory.\\\")\\n except(FileNotFound):\\n raise FileNotFound\",\n \"def buildnemxml(self):\\n for n in sorted(self._objs.keys()):\\n emanenode = self._objs[n]\\n emanenode.buildnemxmlfiles(self)\",\n \"def process_xml(self):\\n self.process_gpx_file(str(self.filename))\",\n \"def hlsp_to_xml(config):\\n\\n # Check the user-provided config file path.\\n config = cp.check_existing_file(config)\\n if config is None:\\n return\\n\\n # Try to read in the yaml config file.\\n try:\\n parameters = read_yaml(config)\\n except (FileNotFoundError, TypeError) as err:\\n print(err)\\n return\\n\\n # Make sure the config file has all the expected sections\\n for section in EXPECTED_CONFIGS:\\n if section not in parameters:\\n print(\\\"{0} does not define '{1}'!\\\".format(config, section))\\n return\\n\\n # Make sure all necessary filepaths have been provided\\n for path in EXPECTED_PATHS:\\n if path not in parameters[\\\"filepaths\\\"]:\\n print(\\\"{0} is missing an '{1}' filepath!\\\".format(config, path))\\n return\\n\\n # Config parameters have been checked, now read into variables\\n paths = parameters[\\\"filepaths\\\"]\\n hlsppath = paths[\\\"hlsppath\\\"]\\n output = paths[\\\"output\\\"]\\n overwrite = paths[\\\"overwrite\\\"]\\n\\n extensions = parameters[\\\"file_types\\\"]\\n header_type = parameters[\\\"header_type\\\"]\\n data_type = parameters[\\\"data_type\\\"]\\n keyword_updates = parameters[\\\"keyword_updates\\\"]\\n uniques = parameters[\\\"unique_parameters\\\"]\\n\\n # Set up logging\\n outdir = os.path.dirname(output)\\n logfile = os.path.join(outdir, LOG)\\n logfile = cp.check_new_file(logfile)\\n if logfile is None:\\n return\\n logging.basicConfig(filename=logfile,\\n format='***%(levelname)s from %(module)s: %(message)s',\\n level=logging.DEBUG, filemode='w')\\n logging.info(\\\"Logging started at {0}\\\".format(\\n datetime.datetime.now().isoformat()))\\n\\n # Prepare the output file\\n output = cp.check_new_file(output)\\n if output is None:\\n return\\n print(\\\"Opening {0}\\\".format(output))\\n if overwrite or not os.path.isfile(output):\\n with open(output, 'w') as xmlfile:\\n xmlfile.close()\\n else:\\n err = \\\"{0} already exists. Set overwrite=True to proceed.\\\".format(\\n output)\\n logging.error(err)\\n print(err)\\n return\\n\\n # Begin the lxml tree and add the main subelements\\n composite = etree.Element(\\\"CompositeObservation\\\")\\n xmltree = etree.ElementTree(composite)\\n metadata = etree.SubElement(composite, \\\"metadataList\\\")\\n provenance = etree.SubElement(composite, \\\"provenance\\\")\\n products = etree.SubElement(composite, \\\"productList\\\")\\n\\n # Create the CAOMxmlList we will save CAOMxml objects into\\n caomlist = CAOMxmlList()\\n\\n # Read the static CAOM values from the yaml file\\n print(\\\"Creating standard HLSP entries...\\\")\\n statics = cp.check_existing_file(STATICS)\\n if statics is None:\\n return\\n try:\\n static_values = read_yaml(statics)\\n except (FileNotFoundError, TypeError) as err:\\n logging.error(err)\\n print(err)\\n return\\n\\n # Add standard entries\\n caomlist = add_value_caomxml(caomlist, static_values[\\\"hlsp\\\"])\\n\\n # Add some conditional entries\\n if data_type == \\\"timeseries\\\":\\n caomlist = add_value_caomxml(caomlist, static_values[\\\"timeseries\\\"])\\n if header_type == \\\"kepler\\\":\\n caomlist = add_value_caomxml(caomlist, static_values[\\\"kepler\\\"])\\n print(\\\"...done!\\\")\\n\\n # Add information from the header keywords table.\\n print(\\\"Adding entries from fits headers...\\\")\\n caomlist = add_header_entries(caomlist, KEYWORD_TABLE, header_type)\\n print(\\\"...done!\\\")\\n\\n # Add CAOMxml entries for HLSP-specifiic CAOM parameters.\\n print(\\\"Adding unique entries for this HLSP...\\\")\\n if uniques is None:\\n logging.warning(\\\"No unique parameters provided in the yaml config.\\\")\\n else:\\n caomlist = add_value_caomxml(caomlist, uniques)\\n print(\\\"...done!\\\")\\n\\n # Add product entries to the list of CAOMxml objects\\n print(\\\"Generating the productList...\\\")\\n caomlist = add_product_caomxml(caomlist, hlsppath, extensions, data_type)\\n print(\\\"...done!\\\")\\n\\n # Make final tweaks to caomlist\\n print(\\\"Making final adjustments...\\\")\\n caomlist = adjust_defaults(caomlist, header_type, keyword_updates)\\n print(\\\"...done!\\\")\\n\\n # Create the head string to write to doctype\\n head_strings = []\\n head_strings.append(\\\"<!-- Process HLSP for CAOM ingestion -->\\\")\\n head_strings.append(\\\"\\\")\\n head = \\\"\\\\n\\\".join(head_strings)\\n\\n # Add CAOMxml elements to xmltree\\n print(\\\"Writing everything to XML...\\\")\\n for entry in sorted(caomlist):\\n\\n # Skip extra top-level entries caused by recursion in add_value_caomxml\\n if xmltree.find(entry.label) is None:\\n entry.send_to_lxml(xmltree)\\n\\n # Write the xml tree to the OUTPUT file\\n # (doctype not a valid argument for python 2.x)\\n xmltree.write(output,\\n encoding=\\\"utf-8\\\",\\n xml_declaration=True,\\n #doctype=head,\\n pretty_print=True)\\n print(\\\"...XML file generated!\\\")\\n\\n # Print out log stats before finishing\\n check_log(logfile)\\n logging.info(\\\"Logging finished at {0}\\\".format(\\n datetime.datetime.now().isoformat()))\",\n \"def citation_validation(self):\\n for file in filter(lambda x: x.startswith('citation'), listdir(bs_directory)):\\n print \\\"Processing\\\", file\\n bs = BeautifulSoup(open(file), 'xml')\\n # find ground_truth file\\n ground_truth = BeautifulSoup(open(self.ground_truth_directory + file.split(\\\".\\\")[0] + '.xml'), 'xml')\\n self.__citation_correction(ground_truth, bs)\\n file = open(self.citation_output + file, \\\"wb\\\")\\n file.write(bs.prettify().encode('utf-8'))\",\n \"def test_XML(browser, filename, languages='en'):\\n wait = browser.waiter()\\n\\n source_files = glob(os.path.abspath(os.path.join('test-data', filename)))\\n languages = languages.split(',')\\n\\n if len(source_files) == 0:\\n print('Error: No such file')\\n\\n for n, source_path in enumerate(source_files):\\n\\n if not os.path.isfile(source_path):\\n print(\\\"File not found: %s\\\" % source_path)\\n return\\n\\n local_content = open(source_path, 'rb').read()\\n try:\\n ElementTree.fromstring(local_content)\\n except ElementTree.ParseError as e:\\n print('%sError: The file \\\"%s\\\" contains invalid XML:%s' % (Fore.RED, os.path.basename(source_path), Style.RESET_ALL))\\n print(Fore.RED + str(e) + Style.RESET_ALL)\\n return\\n\\n source_path_root, source_path_ext = os.path.splitext(source_path)\\n\\n for m, lang in enumerate(languages):\\n\\n png_path = '%s_%s.png' % (source_path_root, lang)\\n html_path = '%s_%s.html' % (source_path_root, lang)\\n\\n tmp = tempfile.NamedTemporaryFile('w+b')\\n with open(source_path, 'rb') as op:\\n tmp.write(re.sub('<preferred_language>[a-z]+</preferred_language>',\\n '<preferred_language>%s</preferred_language>' % lang,\\n op.read().decode('utf-8')).encode('utf-8'))\\n tmp.flush()\\n\\n try:\\n element = browser.driver.find_element_by_id('cbuttonupload')\\n except NoSuchElementException:\\n browser.get('/mng/action/home.do')\\n\\n # Open Alma configuration\\n browser.wait_for(By.XPATH, '//*[@aria-label=\\\"Open Alma configuration\\\"]')\\n browser.click(By.XPATH, '//*[@aria-label=\\\"Open Alma configuration\\\"]')\\n browser.click(By.XPATH, '//*[@href=\\\"#CONF_MENU5\\\"]')\\n browser.click(By.XPATH, '//*[text() = \\\"Notification Template\\\"]')\\n\\n browser.wait_for(By.ID, 'cbuttonupload')\\n\\n # Set language\\n element = browser.driver.find_element_by_id('pageBeanuserPreferredLanguage')\\n element.click()\\n element = browser.driver.find_element_by_id('pageBeanuserPreferredLanguage_hiddenSelect')\\n select = Select(element)\\n opts = {el.get_attribute('value'): el.get_attribute('innerText') for el in select.options}\\n longLangName = opts[lang]\\n\\n cur = n * len(languages) + m + 1\\n tot = len(languages) * len(source_files)\\n print('[%d/%d] Testing \\\"%s\\\" using language \\\"%s\\\"' % (cur, tot,\\n os.path.basename(source_path),\\n longLangName))\\n\\n element = wait.until(EC.element_to_be_clickable(\\n (By.XPATH, '//ul[@id=\\\"pageBeanuserPreferredLanguage_hiddenSelect_list\\\"]/li[@title=\\\"%s\\\"]/a' % longLangName)\\n ))\\n element.click()\\n\\n\\n # Upload the XML\\n file_field = browser.driver.find_element_by_id('pageBeannewFormFile')\\n file_field.send_keys(tmp.name)\\n\\n upload_btn = browser.driver.find_element_by_id('cbuttonupload')\\n upload_btn.click()\\n\\n browser.wait_for(By.CSS_SELECTOR, '.infoErrorMessages')\\n\\n run_btn = wait.until(\\n EC.element_to_be_clickable((By.ID, 'PAGE_BUTTONS_admconfigure_notification_templaterun_xsl'))\\n )\\n\\n cwh = browser.driver.current_window_handle\\n\\n run_btn.click()\\n time.sleep(1)\\n\\n # Take a screenshot\\n found_win = False\\n for handle in browser.driver.window_handles:\\n browser.driver.switch_to_window(handle)\\n if 'beanContentParam=htmlContent' in browser.driver.current_url:\\n browser.driver.set_window_size(browser.config.get('screenshot', 'width'), 600)\\n with open(html_path, 'w+b') as html_file:\\n html_file.write(browser.driver.page_source.encode('utf-8'))\\n print('Saved output: %s' % html_path)\\n if browser.driver.save_screenshot(png_path):\\n print('Saved screenshot: %s' % png_path)\\n else:\\n print('Failed to save screenshot')\\n found_win = True\\n break\\n\\n if not found_win:\\n print(Fore.RED + 'ERROR: Failed to produce output!' + Fore.RESET)\\n browser.driver.switch_to_window(cwh)\\n tmp.close()\",\n \"def before_running(res, src_iso_path, dest_path, project, XML_FILE):\\n path_list = [\\\"common_setting/Generic\\\",\\\"common_setting/DVD\\\"]\\n if os.name == 'nt':\\n if project.upper() == 'DVDFAB 8' or project.upper() == 'DVDFAB8':\\n for path in path_list:\\n tree, nodes = windows_xml.read_xml(XML_FILE, path, xml_temp) \\n fab_logpath = get_xml_value(nodes[0], 'LogFolder')\\n burn_engine_type = get_xml_value(nodes[0], 'BurnEngineType')\\n tempfolder_path = get_xml_value(nodes[0], 'TempFolder')\\n else:\\n for path in path_list:\\n tree, nodes = windows_xml.read_xml(XML_FILE, path, xml_temp) \\n fab_logpath = get_xml_value(nodes[0], 'LogFolder')\\n burn_engine_type = get_xml_value(nodes[0], 'BDBurnEngineType')\\n tempfolder_path = get_xml_value(nodes[0], 'TempFolder') \\n else:\\n if project.upper() == 'DVDFAB 8' or project.upper() == 'DVDFAB8':\\n for path in path_list:\\n tree, nodes = myxml.read_xml(XML_FILE, path, xml_temp)\\n fab_logpath = get_xml_value(nodes[0], 'LogFolder')\\n burn_engine_type = get_xml_value(nodes[0], 'BurnEngineType')\\n tempfolder_path = get_xml_value(nodes[0], 'TempFolder')\\t\\n else:\\n for path in path_list:\\n tree, nodes = myxml.read_xml(XML_FILE, path, xml_temp) \\n fab_logpath = get_xml_value(nodes[0], 'LogFolder')\\n burn_engine_type = get_xml_value(nodes[0], 'BDBurnEngineType')\\n tempfolder_path = get_xml_value(nodes[0], 'TempFolder')\\t\\t\\t\\t\\n \\n dest_path = tempfolder_path if '.ISO' == os.path.splitext(res[6].upper())[1] else dest_path\\n initlog('before running, dest_path is: %s' % dest_path) \\n tempfolder_path = ''.join((tempfolder_path, 'ReportCrash')).replace(\\\"_nbsp;\\\",\\\" \\\")\\n fab_logpath = fab_logpath.replace(\\\"_nbsp;\\\",\\\" \\\")\\n initlog(\\\"fab_logpath is: %s; tempfolder_path is: %s\\\" %(fab_logpath, tempfolder_path))\\n logpath = (fab_logpath, tempfolder_path) \\n remove_fab_logfile(fab_logpath)\\n return dest_path, logpath, burn_engine_type\",\n \"def buildtransportxml(self):\\n try:\\n subprocess.check_call([\\\"emanegentransportxml\\\", \\\"platform.xml\\\"], cwd=self.session.session_dir)\\n except subprocess.CalledProcessError:\\n logger.exception(\\\"error running emanegentransportxml\\\")\",\n \"def get_match_criteria(self):\\n #-- factory attributes ----\\n print(\\\"\\\"\\\"\\nWhat glidein/factory attributres are you using in the match expression?\\nI have computed my best estimate for your match string,\\nplease verify and correct if needed.\\n\\\"\\\"\\\")\\n default_factory_attributes = string.join(self.extract_factory_attrs(), ',')\\n factory_attributes = raw_input(\\\"Factory attributes: [%s] \\\"%default_factory_attributes)\\n if factory_attributes == \\\"\\\":\\n factory_attributes = default_factory_attributes\\n if factory_attributes == \\\"\\\":\\n factory_attributes = []\\n else:\\n factory_attributes = string.split(factory_attributes, ',')\\n\\n #--- job_attributes --\\n print(\\\"\\\"\\\"\\nWhat job attributes are you using in the match expression?\\nI have computed my best estimate for your match string,\\nplease verify and correct if needed.\\n\\\"\\\"\\\")\\n default_job_attributes = string.join(self.extract_job_attrs(), ',')\\n job_attributes = raw_input(\\\"Job attributes: [%s] \\\" % default_job_attributes)\\n if job_attributes == \\\"\\\":\\n job_attributes = default_job_attributes\\n if job_attributes == \\\"\\\":\\n job_attributes = []\\n else:\\n job_attributes = string.split(job_attributes, ',')\\n\\n #--- create xml ----\\n data = \\\"\\\"\\\"\\n%(indent2)s<group name=\\\"%(group_name)s\\\" enabled=\\\"True\\\">\\n%(indent3)s<match match_expr=%(match_string)s start_expr=\\\"True\\\">\\n%(factory_attributes)s\\n%(job_attributes)s\\n%(indent3)s</match>\\n%(indent2)s</group>\\n\\\"\\\"\\\" % \\\\\\n{ \\\"indent2\\\": common.indent(2),\\n \\\"indent3\\\": common.indent(3),\\n \\\"indent4\\\": common.indent(4),\\n \\\"group_name\\\": self.group_name(),\\n \\\"match_string\\\": glideinwms.lib.xmlFormat.xml_quoteattr(self.match_string()),\\n \\\"factory_attributes\\\": self.factory_data(factory_attributes),\\n \\\"job_attributes\\\": self.job_data(job_attributes),\\n}\\n return data\",\n \"def makeCourse( xmlFile, genPath, importPaths, commonFiles, rendererContent=True):\\n\\ttry:\\n\\n\\t\\t# parse the command line\\n\\t\\tConfig.add_option('--verbose', help='Set verbosity to maximum', dest='verbosity', default=0, action='store_const', const=2)\\n\\t\\tConfig.add_option('-v', '--verbosity', help='Set the verbosity level (0: quiet, 1: display the command lines, 2: display command lines and their outputs', dest='verbosity', default=0, type=int)\\n\\t\\tConfig.add_option('-d', '--debug', help='Create the files in the debug/ folder, instead of in a temporary one', dest='debug', action='store_true', default=False)\\n\\t\\tConfig.add_option('-f', '--force', help='Force the generation of the documents, even if nothing changes from last run', dest='force', action='store_true', default=False)\\n\\t\\tConfig.add_option('-q', '--quick', help='Quick pdf generation (do not compile twice the latex, do not produce handout, etc.)', dest='quick', action='store_true', default=False)\\n\\t\\tConfig.add_option('-w', '--wordpress', help='Publish to wordpress', dest='wordpress', default=False, action='store_true')\\n\\t\\tConfig.add_option('-c', '--HTMLcorrection', help='Display an HTML correction', dest='HTMLcorrection', default=False, action='store_true')\\n\\t\\tConfig.add_option('-s', '--shared', help='Copy the required files to the <shared> path (via ssh)', default=False,\\taction='store_true')\\n\\t\\tConfig.parse()\\n\\t\\targs = Config.args\\n\\t\\toptions = Config.options\\n\\t\\tConfig.importPaths = importPaths \\n\\t\\tConfig.commonFiles = commonFiles\\n\\t\\tConfig.allSessions = { x.__name__:x for x in Session.__subclasses__()}\\t# list of the created session classes\\n\\t\\tConfig.rendererContent = rendererContent\\n\\t\\t\\n\\t\\t# clean the debug directory in debug mode\\n\\t\\tbasePath = os.path.abspath('.')+'/'\\t\\t\\t# base path (from where the script is run, because the path are relative)\\n\\t\\tif options.debug:\\n\\t\\t\\tif os.path.exists('debug/'):\\n\\t\\t\\t\\trunCommand(['rm','-rf','debug/'])\\n\\n\\t\\t# open and parse the course file\\n\\t\\twith codecs.open(xmlFile, encoding='utf-8') as f:\\n\\t\\t\\tbs = BeautifulSoup(f, features=\\\"xml\\\")\\n\\n\\n\\t\\t# build the recursively the sessions\\n\\t\\ttop = createTagSession( bs, father=None )\\t\\t# bs.contents[0]\\n\\t\\tsessionsToBuild = Session.sessionsToBuild\\t\\t# get the list of the sessions object\\n\\t\\t\\n\\n\\t\\t\\\"\\\"\\\"\\n\\t\\timportFiles( bs.contents[0], importPaths)\\n\\n\\t\\t# get the list of sessions we can build (with a 'make' method)\\n\\t\\tbuildableSessions = { x.__name__:x for x in Session.__subclasses__() if 'make' in x.__dict__ }\\n\\n\\t\\t#This set the PATH for PyDev only...\\n\\t\\tos.environ['PATH'] = os.environ['PATH']+':'+os.getenv('PATH')\\n\\n\\n\\t\\t# build the list of Sessions to build\\n\\t\\tsessionsToBuild = []\\n\\t\\tfor name,session in buildableSessions.items():\\n\\t\\t\\tsessionsToBuild.extend( session(tag, commonFiles) for tag in bs(name) )\\n\\t\\t\\\"\\\"\\\"\\n\\t\\t\\n\\t\\t\\n\\n\\t\\t# if possible, load the previous xml file, and look for the differences\\n\\t\\tdirName,baseName = split(xmlFile) \\n\\t\\ttry:\\n\\t\\t\\twith open(dirName+\\\"/.\\\"+baseName+\\\".makeCourse\\\", \\\"rb\\\") as f:\\n\\t\\t\\t\\tdata = load( f )\\n\\t\\t\\t\\tfor s in sessionsToBuild:\\n\\t\\t\\t\\t\\tif s.name in data:\\n\\t\\t\\t\\t\\t\\ts.checkDifferences( data[s.name] )\\n\\t\\texcept IOError:\\n\\t\\t\\tpass\\n\\n\\n\\t\\t# build every argument in the command line arguments\\n\\t\\tsomethingHasBeDone = False\\n\\t\\tfor s in sessionsToBuild:\\n\\t\\t\\tif (not args) or (\\\"all\\\" in args) or (s.name in args) or (s.type in args):\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tcd( basePath)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# check if something has to be done\\n\\t\\t\\t\\tif s.shouldBeMake(basePath+'/'+genPath, options) or options.force:\\n\\t\\t\\t\\t\\tsomethingHasBeDone = True\\n\\n\\t\\t\\t\\t\\t#Make one build (TP, course, etc.)\\n\\t\\t\\t\\t\\tprint ( Fore.BLUE+\\\"*) Make \\\"+Style.BRIGHT+s.name+Fore.RESET+Style.NORMAL)\\n\\n\\t\\t\\t\\t\\t# make temp directory and copy all the file in resources dir\\n\\t\\t\\t\\t\\tif options.debug:\\n\\t\\t\\t\\t\\t\\ttmp = \\\"debug/\\\"+s.name+'/'\\n\\t\\t\\t\\t\\t\\tcreateDirectory(tmp)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\ttmp = mkdtemp()\\n\\n\\t\\t\\t\\t\\ts.prepareResources(tmp )\\n\\t\\t\\t\\t\\tcd( tmp)\\n\\n\\t\\t\\t\\t\\t# call the custom function associated with the type, to produce the documents\\n\\t\\t\\t\\t\\ts.make(options)\\n\\n\\t\\t\\t\\t\\t# then move the files in the right place\\n\\t\\t\\t\\t\\tfor f in s.files(options):\\n\\t\\t\\t\\t\\t\\tcreateDirectory( basePath+'/'+genPath.format( **s.dict ) )\\n\\t\\t\\t\\t\\t\\tnewFile = basePath+'/'+genPath.format( **s.dict )+f\\n\\t\\t\\t\\t\\t\\tif not os.path.exists(f):\\n\\t\\t\\t\\t\\t\\t\\tprint( Fore.YELLOW+'The file '+f+' has not been created by '+s.type+' function !'+Fore.RESET)\\n\\t\\t\\t\\t\\t\\trunCommand( ['cp', f, newFile])\\n\\n\\t\\t\\t\\t\\t# del the temporary directory or clean debug directory\\n\\t\\t\\t\\t\\tif not options.debug:\\n\\t\\t\\t\\t\\t\\trunCommand( ['rm', '-rf', tmp])\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif options.verbosity>0:\\n\\t\\t\\t\\t\\t\\tprint( Fore.BLUE + \\\"*) Nothing changed for \\\"+Style.BRIGHT+s.name+Style.NORMAL+\\\", skipped\\\"+Fore.RESET)\\n\\n\\n\\n\\t\\tif not somethingHasBeDone:\\n\\t\\t\\tprint( Fore.BLUE + \\\"Nothing has changed, nothing to do, so nothing has been done...\\\" + Fore.RESET)\\n\\n\\n\\t\\t# save the data file\\n\\t\\tdata = {L.name: {key:md5(str(val).encode('utf-8')).hexdigest() for key,val in L.dict.items()} for L in sessionsToBuild }\\n\\t\\tcd( basePath)\\n\\t\\twith open(dirName+\\\"/.\\\"+baseName+\\\".makeCourse\\\", 'wb') as f:\\n\\t\\t\\tdump( data, f)\\n\\n\\n\\n\\n\\n\\n\\n\\texcept mkcException as err:\\n\\t\\tprint( err )\",\n \"def test_xml_to_attributes_and_back(self):\\n # etree_to_dict(e) and dict_to_etree(d)\\n e = open(EXAMPLE_SECTION_FILENAME, 'r').read()\\n e = ET.XML(e)\\n d = etree_to_dict(e)\\n all_attributes = read_section_dict(d)\\n d = make_section_dict(*all_attributes)\\n e = dict_to_xml_str(d)\\n e = prettify(e)\\n\\n if SHOW_RESULTS:\\n print(e)\\n\\n xml_file = StringIO(unicode(e))\\n self.assertEqual(verify_files(xml_file, open(SECTION_DTD_FILENAME, 'r')), True)\",\n \"def generate_files(self):\\n\\t\\tapply_stemmer, xml_file, query_file, expected_file = self.read_config_file()\\n\\t\\tself.generate_query_file(query_file, xml_file, apply_stemmer)\\n\\t\\tself.generate_expected_file(expected_file, xml_file)\\n\\t\\tlogging.info('FINALIZADO: MÓDULO PROCESSADOR DE CONSULTAS')\",\n \"def create_entity_claim_input_file_doc_ret():\\n claim_doc = open(r\\\"C:\\\\study\\\\technion\\\\MSc\\\\Thesis\\\\Y!\\\\rawClaim_SW.txt\\\").read().strip()\\n \\\"remove the stop words from the claims\\\"\\n SW_doc = r\\\"C:\\\\study\\\\technion\\\\MSc\\\\Thesis\\\\Y!\\\\stopWords.xml\\\"\\n stopWords_list = []\\n claims_no_SW_dict = {}\\n with open(SW_doc, 'r') as f:\\n line = f.readline()\\n while line !=\\\"\\\":\\n if \\\"<word>\\\" in line:\\n stopWords_list.append(line.split(\\\"<word>\\\")[1].split(\\\"</word>\\\")[0])\\n line = f.readline()\\n \\n for i,line in enumerate(claim_doc.split(\\\"\\\\n\\\")):\\n clmLMdocLM_doc_ret_query_file = open(\\\"LMdocLM_doc_ret_query_file_clm_\\\"+str(i+1),\\\"wb\\\")\\n clmLMdocLM_doc_ret_query_file.write(\\\"<parameters>\\\\n\\\")\\n curr_claim_words = line.split(\\\"|\\\")[1].lower().split()\\n curr_entity_words = line.split(\\\"|\\\")[0].lower().split()\\n noSW_claim = \\\"\\\"\\n noSW_entity = \\\"\\\"\\n for word in curr_claim_words:\\n if word not in stopWords_list: \\n noSW_claim += word+\\\" \\\"\\n for word in curr_entity_words:\\n if word not in stopWords_list: \\n noSW_entity += word+\\\" \\\"\\n# clmLMdocLM_doc_ret_query_file.write(\\\"<query><number>\\\"+str(i+1)+\\\"</number><text>\\\"+noSW_entity+\\\"|\\\"+noSW_claim+\\\"</text></query>\\\\n\\\")\\n# clmLMdocLM_doc_ret_query_file.write(\\\"</parameters>\\\")\\n# clmLMdocLM_doc_ret_query_file.close()\\n claims_no_SW_dict[str(i+1)] = (noSW_entity,noSW_claim)\\n save_pickle(\\\"claims_no_SW_dict\\\", claims_no_SW_dict)\",\n \"def write_and_clean(urn, lang, parsed, citations,target):\\n\\n os.makedirs(\\\"cache\\\", exist_ok=True)\\n\\n\\n if \\\"grc\\\" not in urn and \\\"lat\\\" not in urn:\\n type_text = \\\"translation\\\"\\n else:\\n type_text = \\\"edition\\\"\\n\\n \\\"\\\"\\\"\\n Change TEI.2 tag to TEI \\n \\\"\\\"\\\"\\n # We change the main tag\\n TEI = parsed.getroot()\\n # We change the root tag to TEI\\n TEI.tag = \\\"TEI\\\"\\n # We change the main tag\\n TEI = parsed.getroot()\\n\\n \\\"\\\"\\\"\\n Moving every children of //body into a new div with a @n attribute\\n \\\"\\\"\\\"\\n body = parsed.xpath(\\\"//body\\\")[0]\\n # Get its children\\n child_body = body.getchildren()\\n\\n # For each child of body, remove it from body\\n for child in child_body:\\n body.remove(child)\\n\\n # Create a new div with the informations\\n div = etree.Element(\\n \\\"div\\\",\\n attrib = { \\n \\\"type\\\":type_text,\\n \\\"n\\\": urn,\\n \\\"{http://www.w3.org/XML/1998/namespace}lang\\\" : lang\\n }\\n )\\n\\n # Add the full list of children of body to the newly created div\\n div.extend(child_body)\\n # Add this new div in body\\n body.append(div)\\n\\n # Add them to the current encodingDesc\\n refsDecl = \\\"\\\"\\\"<tei:refsDecl n=\\\"CTS\\\" xmlns:tei=\\\"http://www.tei-c.org/ns/1.0\\\">\\\\n\\\"\\\"\\\" + \\\"\\\\n\\\".join([str(citation) for citation in citations]) + \\\"\\\"\\\"\\\\n</tei:refsDecl>\\\"\\\"\\\"\\n # Parse it\\n refsDecl = etree.fromstring(refsDecl)\\n # Find encodingDesc\\n encodingDesc = parsed.xpath(\\\"//encodingDesc\\\")[0]\\n encodingDesc.append(refsDecl)\\n\\n \\\"\\\"\\\"\\n Search for old //encodingDesc/refsDecl and refsDecl/state and correct them\\n \\\"\\\"\\\"\\n refsDecls = parsed.xpath(\\\"//encodingDesc/refsDecl[@doctype]\\\")\\n for refsDecl in refsDecls:\\n refsDecl.set(\\\"n\\\", refsDecl.get(\\\"doctype\\\"))\\n del refsDecl.attrib[\\\"doctype\\\"]\\n\\n states = parsed.xpath(\\\"//encodingDesc/refsDecl/state\\\")\\n for state in states:\\n state.tag = \\\"refState\\\"\\n\\n \\\"\\\"\\\"\\n Change language@id to ident\\n \\\"\\\"\\\"\\n languages = parsed.xpath(\\\"//langUsage/language[@id]\\\") + parsed.xpath(\\\"//langUsage/lang[@id]\\\")\\n for lang in languages:\\n lang.set(\\\"ident\\\", lang.attrib[\\\"id\\\"])\\n del lang.attrib[\\\"id\\\"]\\n\\n \\\"\\\"\\\"\\n Change pb@id to pb@n\\n \\\"\\\"\\\"\\n pbs = parsed.xpath(\\\"//pb[@id]\\\")\\n for pb in pbs:\\n pb.set(\\\"n\\\", pb.attrib[\\\"id\\\"])\\n del pb.attrib[\\\"id\\\"]\\n\\n \\\"\\\"\\\"\\n Clean keyboarding/p\\n \\\"\\\"\\\"\\n ps = parsed.xpath(\\\"//sourceDesc/p\\\")\\n for p in ps:\\n p.getparent().remove(p)\\n\\n \\\"\\\"\\\"\\n Clear attributes of text and body\\n \\\"\\\"\\\"\\n body_text = parsed.xpath(\\\"//body\\\") + parsed.xpath(\\\"//text\\\")\\n for tag in body_text:\\n for key in tag.attrib:\\n del tag.attrib[key]\\n\\n\\n \\\"\\\"\\\"\\n Clear refsDecl/step\\n \\\"\\\"\\\"\\n refsdecls_step = parsed.xpath(\\\"//refsDecl/step/parent::refsDecl\\\")\\n for step_parent in refsdecls_step:\\n step_parent.getparent().remove(step_parent)\\n\\n \\\"\\\"\\\"\\n Clear refsDecl/step\\n \\\"\\\"\\\"\\n refsdecls_step = parsed.xpath(\\\"//refsDecl/step/parent::refsDecl\\\")\\n for step_parent in refsdecls_step:\\n step_parent.getparent().remove(step_parent)\\n\\n \\\"\\\"\\\"\\n Fix anchored\\n \\\"\\\"\\\"\\n anchoreds = parsed.xpath(\\\"//*[@anchored='yes']\\\")\\n for anchored in anchoreds:\\n anchored.set(\\\"anchored\\\", \\\"true\\\")\\n\\n # Convert to xml\\n \\\"\\\"\\\" \\n Create a new document so we can have tei namespace \\n \\\"\\\"\\\"\\n # And now some other CTS Magic\\n New_Root = etree.Element(\\n \\\"{http://www.tei-c.org/ns/1.0}TEI\\\",\\n nsmap = { None : \\\"http://www.tei-c.org/ns/1.0\\\" } # Creating a new element allows us to use a default namespace\\n )\\n New_Root.text = \\\"\\\\n\\\"\\n # Add children of old root to New_Root\\n New_Root.extend(TEI.getchildren())\\n\\n # We create a new document\\n New_Doc = etree.ElementTree(New_Root)\\n # And now some other CTS Magic\\n \\n New_Doc = P4P5(New_Doc)\\n\\n # save xml\\n os.makedirs(os.path.dirname(target), exist_ok=True)\\n with open (target, \\\"w\\\") as xmlfile:\\n xmlfile.write(\\\"\\\"\\\"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\\\n\\\"\\\"\\\"+etree.tostring(New_Doc, encoding=str))\\n\\n # And now we write cts informations\\n try:\\n cts.cts_metadata(urn)\\n except Exception as E:\\n print(E)\",\n \"def write_to_xml(dictData, metadata, xmlfile):\\n\\tfout = codecs.open(xmlfile, 'w', 'utf-8')\\n\\tfout.write('<?xml version = \\\"1.0\\\" encoding = \\\"UTF-8\\\" standalone = \\\"no\\\" ?>\\\\n')\\n\\tfout.write('<?xml-stylesheet type=\\\"text/xsl\\\" href=\\\"maketable.xsl\\\"?>\\\\n')\\n\\tfout.write('<root>\\\\n')\\n\\tfout.write('<meta>\\\\n')\\n\\tfor key, value in metadata.items():\\n\\t\\tfout.write('<' + key + '>' + value + '</' + key + '>\\\\n')\\n\\tfout.write('</meta>\\\\n')\\n\\tfout.write('<content>\\\\n')\\n\\tfor (hw, meanings, verse, verseNumDetails, pageNumDetails) in dictData:\\n\\t\\txmlline = ''\\n\\t\\txmlline += '<word><headword>' + hw + '</headword><meanings>'\\n\\t\\tfor meaning in meanings:\\n\\t\\t\\txmlline += '<m>' + meaning + '</m>'\\n\\t\\txmlline += '</meanings>'\\n\\t\\txmlline += '<verse>'\\n\\t\\tlines = verse.split('<BR>')\\n\\t\\tfor line in lines:\\n\\t\\t\\txmlline += '<line>' + line + '</line>'\\n\\t\\txmlline += '</verse>'\\n\\t\\txmlline += '<verseNumber>' + verseNumDetails + '</verseNumber>'\\n\\t\\txmlline += '<pageNumber>' + pageNumDetails + '</pageNumber></word>'\\n\\t\\t# Write in babylon format. <BR><BR> is to separate verses.\\n\\t\\tfout.write(xmlline + '\\\\n')\\n\\t\\txmlline = ''\\n\\tfout.write('</content>\\\\n</root>')\\n\\tfout.close()\\n\\n\\t# Give some summary to the user\\n\\tprint('XML file generated. Success!')\\n\\tprint('{} metadata lines and {} content lines written to XML file.'.format(len(metadata), len(dictData)))\",\n \"def create_conf_xml(self):\\n path = os.path.join(\\n self.buildout['buildout']['parts-directory'],\\n self.name)\\n if not os.path.isdir(path):\\n os.makedirs(path)\\n\\n xml_path = os.path.join(path, 'uwsgi.xml')\\n\\n conf = \\\"\\\"\\n for key, value in self.conf.items():\\n if value.lower() in ('true', 'on', 'yes'):\\n conf += \\\"<%s/>\\\\n\\\" % key\\n elif value and value.lower() not in ('false', 'off', 'yes'):\\n conf += \\\"<%s>%s</%s>\\\\n\\\" % (key, value, key)\\n\\n\\n requirements, ws = self.egg.working_set()\\n eggs_paths = [dist.location for dist in ws]\\n eggs_paths.extend(self.get_extra_paths())\\n # order preserving unique\\n unique_egg_paths = []\\n for p in eggs_paths:\\n if p not in unique_egg_paths:\\n unique_egg_paths.append(p)\\n\\n for path in map(realpath, unique_egg_paths):\\n conf += \\\"<pythonpath>%s</pythonpath>\\\\n\\\" % path\\n\\n f = open(xml_path, 'w')\\n f.write(\\\"<uwsgi>\\\\n%s</uwsgi>\\\" % conf)\\n f.close()\\n return xml_path\",\n \"def test_01_FindXml(self):\",\n \"def xml_to_conll(self, xml_file_path):\\n\\n if not os.path.exists(CONLL_PATH):\\n self.create_directories(CONLL_PATH)\\n\\n\\n for file in os.listdir(xml_file_path):\\n\\n # Set path to file\\n file = xml_file_path+file\\n\\n # Open files only, ignore subdirectories\\n if os.path.isfile(file) and file.lower().endswith('.xml'):\\n\\n # Open Files\\n chapter_input = open(file, 'r', encoding='utf8')\\n\\n # Create Same Filename in Output Folder\\n chapter_output = open(CONLL_PATH+os.path.split(file)[-1]+'.conll', 'w', encoding='utf8')\\n\\n print('Converting: ' + chapter_input.name + ' to Conll09 file: ' + chapter_output.name)\\n\\n chapter_input = BeautifulSoup(chapter_input, 'xml')\\n for sentence in chapter_input.find_all('s'):\\n line_id = 0\\n for terminal in sentence.find_all('t'):\\n line_id, terminal_id, form, lemma, plemma = line_id+1, terminal.get('id'), terminal.get('word'), terminal.get('lemma'), terminal.get('lemma')\\n pos, ppos = terminal.get('pos'), terminal.get('pos')\\n feat, pfeat, head, phead, deprel, pdeprel, fillpred, pred, apred1 = \\\"_\\\" * 9 # <3 Python!\\n chapter_output.write(\\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\"\\n \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\t\\\" \\\"%s\\\" \\\"\\\\n\\\"\\n % (str(line_id)+\\\"-\\\"+terminal_id, form, lemma, plemma, pos, ppos, feat, pfeat, head, phead, deprel, pdeprel, fillpred, pred, apred1))\\n chapter_output.write(\\\"\\\\n\\\")\\n\\n chapter_output.close()\\n\\n print(\\\"Done!\\\")\",\n \"def test_01_Xml0(self):\\n l_xml = self.m_xml.light_sect[0]\\n print(PrettyFormatAny.form(l_xml, 'C1-01-A - XML'))\\n self.assertEqual(l_xml.attrib['Name'], TESTING_LIGHT_NAME_0)\\n self.assertEqual(l_xml.find('DeviceFamily').text, TESTING_DEVICE_FAMILY_INSTEON)\",\n \"def test_xml_safety_flag(self):\\r\\n\\r\\n self._setstaff_login()\\r\\n response = self._add_edx4edx()\\r\\n self.assertIn('GIT_IMPORT_WITH_XMLMODULESTORE', response.content)\\r\\n\\r\\n def_ms = modulestore()\\r\\n course = def_ms.courses.get('{0}/edx4edx_lite'.format(\\r\\n os.path.abspath(settings.DATA_DIR)), None)\\r\\n self.assertIsNone(course)\",\n \"def test_build(self):\\n version = \\\"1.2.3\\\"\\n input1, output1 = self.getArbitraryLoreInputAndOutput(version)\\n input2, output2 = self.getArbitraryLoreInputAndOutput(version)\\n\\n self.howtoDir.child(\\\"one.xhtml\\\").setContent(input1)\\n self.howtoDir.child(\\\"two.xhtml\\\").setContent(input2)\\n\\n self.builder.build(version, self.howtoDir, self.howtoDir,\\n self.templateFile)\\n out1 = self.howtoDir.child('one.html')\\n out2 = self.howtoDir.child('two.html')\\n self.assertXMLEqual(out1.getContent(), output1)\\n self.assertXMLEqual(out2.getContent(), output2)\",\n \"def test_basic_xml(self):\\n j2k = Jp2k(self.j2kfile)\\n\\n self.jp2h.box = [self.ihdr, self.colr]\\n\\n doc = ET.parse(BytesIO(b'<?xml version=\\\"1.0\\\"?><data>0</data>'))\\n xmlb = glymur.jp2box.XMLBox(xml=doc)\\n self.assertEqual(ET.tostring(xmlb.xml.getroot()),\\n b'<data>0</data>')\\n\\n boxes = [self.jp2b, self.ftyp, self.jp2h, xmlb, self.jp2c]\\n\\n with tempfile.NamedTemporaryFile(suffix=\\\".jp2\\\") as tfile:\\n j2k.wrap(tfile.name, boxes=boxes)\\n jp2 = Jp2k(tfile.name)\\n self.assertEqual(jp2.box[3].box_id, 'xml ')\\n self.assertEqual(ET.tostring(jp2.box[3].xml.getroot()),\\n b'<data>0</data>')\",\n \"def parseXML(xml_file, xml_file2):\\r\\n #tree = ET.ElementTree(file=xml_file)\\r\\n tree = ET.ElementTree(file=xml_file)\\r\\n #print (tree.getroot())\\r\\n root = tree.getroot()\\r\\n\\r\\n #tree2 = ET.ElementTree(file=xml_file2)\\r\\n tree2 = ET.ElementTree(file=xml_file2)\\r\\n root2 = tree2.getroot()\\r\\n\\r\\n #print (\\\"tag=%s, attrib=%s\\\" % (root.tag, root.attrib))\\r\\n from prettytable import PrettyTable\\r\\n t = PrettyTable(['N','Component', env, env2])\\r\\n count=1\\r\\n for child in root:\\r\\n for child2 in root2: \\r\\n if child.get('name') == child2.get('name'): \\r\\n if child.get('version') != child2.get('version'):\\r\\n if stg_filter == 1: \\r\\n if child.get('name')[:7].find(\\\"STAGING\\\") != 0:\\r\\n #print(child.get('name')[:7].find(\\\"STAGING\\\"))\\r\\n #print (\\\"---------STABLE-------\\\", child.get('name'), \\\"-->\\\" , child.get('version'), \\\"---------PROD-------\\\",child2.get('name'), \\\"-->\\\" , child2.get('version'))\\r\\n #print (child2.get('name'), \\\"------->\\\" , child2.get('version'))\\r\\n #print(\\\"hola\\\")\\r\\n #t.add_row([child.get('name'), child.get('version'), child2.get('version')])\\r\\n t.add_row([count,child.get('name'), child.get('version'), child2.get('version')])\\r\\n #t.add_row(['Bob', 19])\\r\\n count=count+1\\r\\n else:\\r\\n #print (\\\"---------STABLE-------\\\", child.get('name'), \\\"-->\\\" , child.get('version'), \\\"---------PROD-------\\\",child2.get('name'), \\\"-->\\\" , child2.get('version'))\\r\\n #print (child2.get('name'), \\\"------->\\\" , child2.get('version'))\\r\\n #print(\\\"hola\\\")\\r\\n #t.add_row([child.get('name'), child.get('version'), child2.get('version')])\\r\\n t.add_row([count,child.get('name'), child.get('version'), child2.get('version')])\\r\\n #t.add_row(['Bob', 19])\\r\\n count=count+1 \\r\\n print (t)\",\n \"def setUp(self):\\r\\n super(TestImport, self).setUp()\\r\\n self.content_dir = path(tempfile.mkdtemp())\\r\\n self.addCleanup(shutil.rmtree, self.content_dir)\\r\\n\\r\\n # Create good course xml\\r\\n self.good_dir = self.create_course_xml(self.content_dir, self.BASE_COURSE_KEY)\\r\\n\\r\\n # Create run changed course xml\\r\\n self.dupe_dir = self.create_course_xml(self.content_dir, self.DIFF_KEY)\\r\\n\\r\\n # Create course XML where TRUNCATED_COURSE.org == BASE_COURSE_ID.org\\r\\n # and BASE_COURSE_ID.startswith(TRUNCATED_COURSE.course)\\r\\n self.course_dir = self.create_course_xml(self.content_dir, self.TRUNCATED_KEY)\",\n \"def xml_parser_specific(request, tmpdir_factory):\\n testdir = os.path.dirname(__file__)\\n xmlfile = testdir + \\\"/specific.xml\\\"\\n tmpfile = str(tmpdir_factory.mktemp('data').join('basic_trunc.xml'))\\n xml_truncate(request.param, xmlfile, tmpfile)\\n xml = vasprun.Xml(tmpfile, event = False)\\n return xml\",\n \"def buildGPXDocument(gpxFileName, someGPXDocument):\\n # obtains the DOM representation of the GPX file\\n # (the content of the file instantiated in a structure of xml.dom.minidom)\\n dom = parse(gpxFileName)\\n for trk in dom.getElementsByTagName(\\\"trk\\\"):\\n someGPXDocument.setTrack(buildTrack(trk))\\n for rte in dom.getElementsByTagName(\\\"rte\\\"):\\n someGPXDocument.setRoute(buildRoute(rte)) \\n someGPXDocument.setWayPoints(buildWayPointList(dom))\",\n \"def example_xml_file40():\\n return load_xml('datacite-v4.0-full-example.xml')\",\n \"def sample_xml(opts,file):\\r\\n with open(file, opts) as xml:\\r\\n return xml.read()\",\n \"def testBuildElement(self):\\n self.assertEqual(\\n b'<ColorCorrectionRef ref=\\\"uniqueId\\\"/>\\\\n',\\n self.ccr.xml\\n )\",\n \"def thredds_catalog(self, tmpdir_factory):\\n input_dir = os.path.abspath(\\\"esacci_esgf/test_input_catalogs\\\")\\n output_dir = str(tmpdir_factory.mktemp(\\\"output\\\", numbered=True))\\n # Process all catalogs in input dir and create aggregations with WMS\\n test_files = glob(\\\"{}/*.xml\\\".format(input_dir))\\n assert test_files, \\\"No test catalogs found\\\"\\n\\n pb = ProcessBatch([\\\"-aw\\\", \\\"-o\\\", output_dir] + test_files)\\n pb.do_all()\\n tree = ET.ElementTree()\\n tree.parse(os.path.join(output_dir, os.listdir(input_dir)[0]))\\n return tree.getroot()\",\n \"def test_02_Tags(self):\\n # print(PrettyFormatAny.form(self.m_xml, 'Xml'))\\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\\n self.assertEqual(self.m_xml.computer_div.tag, 'ComputerDivision')\\n self.assertEqual(self.m_xml.house_div.tag, 'HouseDivision')\\n self.assertEqual(self.m_xml.lighting_sect.tag, 'LightingSection')\\n self.assertEqual(self.m_xml.button_sect.tag, 'ButtonSection')\\n self.assertEqual(self.m_xml.button.tag, 'Button')\\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection')\\n self.assertEqual(self.m_xml.controller.tag, 'Controller')\\n self.assertEqual(self.m_xml.light_sect.tag, 'LightSection')\\n self.assertEqual(self.m_xml.light.tag, 'Light')\",\n \"def test_xml_from_dict(self):\\n d = make_section_dict() # using default values\\n e = dict_to_xml_str(d)\\n e = prettify(e)\\n\\n if SHOW_RESULTS:\\n print(e)\\n\\n xml_file = StringIO(unicode(e))\\n self.assertTrue(verify_files(xml_file, open(SECTION_DTD_FILENAME, 'r')))\",\n \"def xml_bdsc(alignment, data, outdir, yaml, yaml_dir, yaml_glob, clock, mcmc, length, hot, intervals, prefix, sample_prior, model_prior, tag):\\n\\n if yaml_dir is not None:\\n yaml_files = {f.stem: f for f in yaml_dir.glob(f\\\"{yaml_glob}\\\")}\\n else:\\n yaml_files = {prefix: yaml}\\n\\n outdir.mkdir(parents=True, exist_ok=True)\\n\\n for prefix, y in yaml_files.items():\\n\\n bdsc = BirthDeathSkylineContemporary(\\n alignment=alignment,\\n data=data,\\n clock_model=clock,\\n chain_type=mcmc,\\n chain_length=length,\\n chain_number=hot+1,\\n prefix=prefix,\\n sample_prior=sample_prior\\n )\\n\\n bdsc.print_configuration()\\n bdsc.check_configuration()\\n\\n config = bdsc.read_config(file=yaml)\\n\\n # Set model prior configuration\\n model_priors = config.get('priors').get('model')\\n # Modify the model prior configs if settings are passed\\n if model_prior:\\n model_priors = modify_model_priors(model_priors, model_prior, tag, prefix)\\n\\n bdsc.set_model_priors(prior_config=model_priors, distribution=True)\\n\\n # Set clock prior configuration\\n clock_priors = config.get('priors').get('clock')\\n bdsc.set_clock(prior_config=clock_priors)\\n\\n if intervals:\\n # Set slice configurations and overwrite associated priors\\n slice_config = config.get('priors').get('intervals')\\n bdsc.set_slices(slice_config=slice_config)\\n\\n bdsc.construct_template(\\n xml=outdir / f'{prefix}.xml'\\n )\",\n \"def main():\\n #short GPS Test\\n filename = 'KML_short_test.kml'\\n gps_filename = 'gps_short_test.txt'\\n gpsfile = open(gps_filename, 'r')\\n file = open(filename, 'w')\\n addHeader(file)\\n coordinate_lst = convert(gpsfile)\\n cleaned = GPS_to_CostMap.clean_gps_data(coordinate_lst)\\n write_coordinates(cleaned, file)\\n addTrailer(file)\\n file.close()\\n\\n #Repeat test\\n filename = 'KML_repeat_test1.kml'\\n gps_filename = 'gps_1.txt'\\n gpsfile = open(gps_filename, 'r')\\n file = open(filename, 'w')\\n addHeader(file)\\n coordinate_lst = convert(gpsfile)\\n cleaned = GPS_to_CostMap.clean_gps_data(coordinate_lst)\\n write_coordinates(cleaned, file)\\n addTrailer(file)\\n file.close()\\n\\n filename = 'KML_repeat_test2.kml'\\n gps_filename = 'gps_1.txt'\\n gpsfile = open(gps_filename, 'r')\\n file = open(filename, 'w')\\n addHeader(file)\\n coordinate_lst = convert(gpsfile)\\n cleaned = GPS_to_CostMap.clean_gps_data(coordinate_lst)\\n write_coordinates(cleaned, file)\\n addTrailer(file)\\n file.close()\",\n \"def main(self):\\n root = etree.Element(\\\"OpenSCENARIO\\\")\\n self.get_header(root)\\n self.get_parameter_declarations(root)\\n etree.SubElement(root, \\\"CatalogLocations\\\")\\n self.get_road_network(root)\\n self.get_entities(root)\\n storyboard = etree.SubElement(root, \\\"Storyboard\\\")\\n self.get_init(storyboard)\\n story = etree.SubElement(storyboard, \\\"Story\\\")\\n story.set(\\\"name\\\", \\\"OSC Generated Story\\\")\\n act = etree.SubElement(story, \\\"Act\\\")\\n act.set(\\\"name\\\", \\\"OSC Generated Act\\\")\\n self.get_maneuvers(act)\\n self.get_story_start_trigger(act)\\n self.get_story_stop_trigger(act)\\n self.get_end_eval_criteria(storyboard)\\n\\n generated_xml = etree.tostring(root)\\n self.write_xosc(generated_xml)\",\n \"def example_xml_file41():\\n return load_xml('datacite-v4.1-full-example.xml')\",\n \"def test_valid_xml(self):\\r\\n self.build_problem()\\r\\n self.assertTrue(True)\",\n \"def _get_eps_xml(self):\\n format_path = os.path.join(os.path.dirname(__file__), \\\"formats\\\")\\n\\n # loop through files where filename starts with \\\"eps_ascat\\\".\\n for filename in fnmatch.filter(os.listdir(format_path), \\\"eps_ascat*\\\"):\\n doc = etree.parse(os.path.join(format_path, filename))\\n file_extension = doc.xpath(\\\"//file-extensions\\\")[0].getchildren()[0]\\n\\n format_version = doc.xpath(\\\"//format-version\\\")\\n for elem in format_version:\\n major = elem.getchildren()[0]\\n minor = elem.getchildren()[1]\\n\\n # return the xml file matching the metadata of the datafile.\\n if major.text == self.mphr[\\\"FORMAT_MAJOR_VERSION\\\"] and \\\\\\n minor.text == self.mphr[\\\"FORMAT_MINOR_VERSION\\\"] and \\\\\\n self.mphr[\\n \\\"PROCESSING_LEVEL\\\"] in file_extension.text and \\\\\\n self.mphr[\\\"PRODUCT_TYPE\\\"] in file_extension.text:\\n return os.path.join(format_path, filename)\",\n \"def collect_data(self, output_dir=os.path.join(ROOT_DIR, \\\"output\\\", \\\"license_check.out\\\")):\\n # read rules from RULE_XML\\n _dom = xml.dom.minidom.parse(RULE_XML)\\n _root = _dom.documentElement\\n if _root:\\n items_node = _root.getElementsByTagName(\\\"items\\\")\\n if items_node:\\n # load rule.xml into item_list\\n item_list = items_node[0].getElementsByTagName(\\\"item\\\")\\n license_check_result_dict = {}\\n # iterate to check every item\\n for _item in item_list:\\n product = _item.getAttribute('product')\\n # the product is exit if there are one or more conditions fit\\n if product in license_check_result_dict.keys():\\n license_check_result_dict[product] = \\\\\\n license_check_result_dict[product] or self.check_product(_item)\\n else:\\n license_check_result_dict[product] = self.check_product(_item)\\n # write dict to json file\\n ProcessJson.output_json_file(license_check_result_dict, output_dir)\",\n \"def _construct_data_xml(self, xml_file_list):\\n award_dict = {}\\n award_list = []\\n for xml_file in xml_file_list:\\n xml_file.seek(0)\\n tree = ET.parse(xml_file)\\n root = tree.getroot()\\n\\n for response in root:\\n temp_dict = {}\\n for award in response:\\n if award.tag == 'entry':\\n continue\\n try:\\n # temp_dict[award.tag].append(award.text)\\n temp_dict[award.tag] = award.text\\n except KeyError:\\n print(\\\"KeyError\\\")\\n # temp_dict[award.tag] = [award.text]\\n\\n # if 'entry' in temp_dict.keys():\\n # del temp_dict['entry']\\n if len(temp_dict) > 0:\\n award_list.append(temp_dict)\\n\\n return award_list\",\n \"def generate_expected_file(self, expected_file, xml_name):\\n\\t\\tlogging.info('Gerando arquivo de documentos esperados')\\n\\t\\tcontent = self.read_xml(xml_name)\\n\\n\\t\\twith open(expected_file, 'w', newline='') as csvfile:\\n\\t\\t\\tfieldnames = ['QueryNumber', 'DocNumber', 'DocVotes']\\n\\t\\t\\twriter = csv.DictWriter(csvfile, fieldnames=fieldnames)\\n\\n\\t\\t\\twriter.writeheader()\\n\\t\\t\\tfor index in range(0, len(content['QueryNumber'])):\\n\\t\\t\\t\\tcount_results = 0\\n\\t\\t\\t\\tlogging.info('Escrevendo documentos da consulta '+str(index+1)+'/'+str(len(content['QueryNumber'])))\\n\\t\\t\\t\\tfor result in content['Records'][index]:\\n\\t\\t\\t\\t\\twriter.writerow({'QueryNumber': content['QueryNumber'][index], 'DocNumber': result[0], \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t 'DocVotes': result[1]})\\n\\t\\t\\t\\t\\tcount_results += 1\\n\\t\\t\\t\\t\\tif count_results == int(content['Results'][index]): break\",\n \"def test_XmlDumpAllRevs(self):\\n pages = get_entries('article-pear.xml', allrevisions=True)\\n self.assertLength(pages, 4)\\n self.assertEqual('Automated conversion', pages[0].comment)\\n self.assertEqual('Pear', pages[0].title)\\n self.assertEqual('24278', pages[0].id)\\n self.assertTrue(pages[0].text.startswith('Pears are [[tree]]s of'))\\n self.assertEqual('Quercusrobur', pages[1].username)\\n self.assertEqual('Pear', pages[0].title)\",\n \"def _get_all_xml(self):\\n\\n # add all xml files to list\\n for file in os.listdir(self._hero_folder):\\n if file.endswith(\\\".xml\\\"):\\n self._xml_list.append(file)\\n\\n # read all attr, skill, spell, fight_talent entries of hero file\\n for _, value in enumerate(self._xml_list):\\n name = value.replace(\\\".xml\\\", '')\\n hero_root = self._parse_xml(value)\\n attrs = self._read_attributes(hero_root)\\n skills = self._read_skills(hero_root)\\n spells = self._read_spells(hero_root)\\n fight_talents = self._read_fight_talents(hero_root)\\n advantages = self._read_advantages(hero_root)\\n special_skills = self._read_special_skills(hero_root)\\n\\n # some entries are both skill and special skill, e.g.\\n # \\\"Ritualkenntnis: Hexe\\\", special skill does not need to be tested\\n # so it is removed\\n for skill in skills:\\n for index, special_skill in enumerate(special_skills):\\n if skill.name == special_skill.name:\\n special_skills.pop(index)\\n\\n self._heroes.update({name: Hero(name,\\n hero_root,\\n attrs,\\n skills,\\n spells,\\n fight_talents,\\n advantages,\\n special_skills)})\",\n \"def sensibility_conformity_to_xml(xml_path):\\n\\tprint('ADDING SENSBIL and CFM to:', xml_path)\\n\\ttree = ET.parse(xml_path)\\n\\troot = tree.getroot()\\n\\n\\tmetrics_dic = create_dict_from_xml(xml_path)\\n\\n\\tvalsensibility = calculate_sensibility(metrics_dic)\\n\\tvalconformity = calculate_conformity(metrics_dic)\\n\\n\\tsensibility_attributes = {\\\"name\\\": \\\"sensibility\\\", \\\"value\\\": str(valsensibility), \\\"symbol\\\": \\\"SENSBIL\\\",\\n\\t\\t\\t\\t\\t\\t\\t \\\"type\\\": \\\"similarity\\\", \\\"unit\\\": \\\"voxel\\\"}\\n\\tSENSBIL = ET.Element(\\\"SENSBIL\\\", attrib=sensibility_attributes)\\n\\tconformity_attributes = {\\\"name\\\": \\\"conformity\\\", \\\"value\\\": str(valconformity), \\\"symbol\\\": \\\"CFM\\\", \\\"type\\\": \\\"similarity\\\",\\n\\t\\t\\t\\t\\t\\t\\t \\\"unit\\\": \\\"voxel\\\"}\\n\\tCFM = ET.Element(\\\"CFM\\\", attrib=conformity_attributes)\\n\\n\\troot[2].insert(2, SENSBIL)\\n\\troot[2].insert(3, CFM)\\n\\ttree.write(xml_path)\",\n \"def parse2016(filename, qdict, cdict):\\n \\n tree = ET.parse(filename)\\n root = tree.getroot()\\n\\n for child in root:\\n # Each child represents a new (original question, related question) pair\\n orgq_id = child.attrib[\\\"ORGQ_ID\\\"]\\n relq_id = child[2].attrib[\\\"THREAD_SEQUENCE\\\"]\\n orgq_comment = []\\n relq_comment = []\\n # get orgq_comment, relq_comment\\n orgq_subject = child[0].text if child[0].text != None else \\\"\\\"\\n orgq_body = child[1].text if child[1].text != None else \\\"\\\"\\n DUPLICATE = True if \\\"SubtaskA_Skip_Because_Same_As_RelQuestion_ID\\\" in child[2].attrib else False \\n for rel in child[2]:\\n if rel.tag == \\\"RelQuestion\\\":\\n relq_subject = rel[0].text if rel[0].text != None else \\\"\\\"\\n relq_body = rel[1].text if rel[1].text != None else \\\"\\\"\\n elif rel.tag == \\\"RelComment\\\":\\n c_text = rel[0].text\\n orgq_c_label = rel.attrib[\\\"RELC_RELEVANCE2ORGQ\\\"]\\n orgq_comment.append((c_text, orgq_c_label))\\n relq_c_label = rel.attrib[\\\"RELC_RELEVANCE2RELQ\\\"]\\n relq_comment.append((c_text, relq_c_label))\\n\\n if DUPLICATE is False:\\n qdict[relq_id] = (relq_subject, relq_body)\\n cdict[relq_id] = relq_comment\\n \\n if (orgq_id in qdict) != (orgq_id in cdict):\\n print(\\\"WARNING qdict inconsistent with cdict\\\")\\n elif orgq_id not in qdict:\\n qdict[orgq_id] = (orgq_subject, orgq_body)\\n cdict[orgq_id] = relq_comment\\n else:\\n cdict[orgq_id] = cdict[orgq_id] + orgq_comment\\n \\n return qdict, cdict\",\n \"def complete_xml_parsing(self):\\n for item in self.entities:\\n item.severity = self.parsed_severity\\n item.cwes.extend(self.parsed_cwes)\\n item.advisory_id = self.parsed_advisory_id\\n item.attack_vector = self.parsed_attack_vector\\n if self.parsed_cvss_base != '' and is_correct_score(self.parsed_cvss_base):\\n cvss_v3 = CvssV3(base_sc=self.parsed_cvss_base)\\n if self.parsed_cvss_temporal != '' \\\\\\n and is_correct_score(self.parsed_cvss_temporal):\\n cvss_v3.temporal_sc = self.parsed_cvss_temporal\\n item.cvss_v3 = cvss_v3\\n item.cvss_base_sc_v3 = self.parsed_cvss_base\\n item.cvss_temporal_score_v3 = self.parsed_cvss_temporal\\n item.published = self.parsed_date\",\n \"def cueword_statistics(self, xml_file_path):\\n\\n print('Extracting cueword statistics from:', xml_file_path, 'to:', CUEWORDS_STATS_PATH)\\n\\n if not os.path.exists(CUEWORDS_STATS_PATH):\\n self.create_directories(CUEWORDS_STATS_PATH)\\n\\n # Go through all files in xml_file_path directory\\n for file in os.listdir(xml_file_path):\\n\\n # For each file, open, parseXML\\n file = xml_file_path+file\\n\\n # Open files only, ignore subdirectories\\n if os.path.isfile(file) and file.lower().endswith('.xml'):\\n\\n chapter_input = open(file, 'r', encoding='utf8')\\n chapter_output = open(CUEWORDS_STATS_PATH+os.path.split(file)[-1]+'_stats.txt',\\n 'w', encoding='utf8')\\n\\n # Try html.parser for ignoring lower and UPPER Tag and attr names\\n chapter_input = BeautifulSoup(chapter_input, 'xml')\\n\\n for sentence in chapter_input.find_all('s'):\\n # Terminals and Semantics\\n #terminals = sentence.find_all('t')\\n semantics = sentence.find('sem')\\n\\n # If splitwords exist\\n if semantics.find('splitwords'):\\n splitwords = semantics.find('splitwords')\\n splitword = splitwords.find_all('splitword')\\n\\n # For each splitword\\n for s_w in splitword:\\n\\n # Get reference id\\n # <splitword idref=\\\"x\\\">\\n splitword_idref = s_w.get('idref')\\n\\n # Get corresponding terminal and its POS tag\\n # <t id=\\\"x\\\" pos=\\\"ADJA\\\" word=\\\"unerschütterlichen\\\"/>\\n terminal = sentence.find(id=splitword_idref).get('word')\\n pos = sentence.find(id=splitword_idref).get('pos')\\n\\n #print(splitword_idref,'\\\\t',terminal,'\\\\t',pos)\\n chapter_output.write('\\\\n' '=SPLITWORDS=' '\\\\n')\\n chapter_output.write('%s' '\\\\t' '%s' '\\\\t' '%s' '\\\\n' %\\n (splitword_idref, terminal, pos))\\n\\n # Find parts of splitword\\n parts = s_w.find_all('part')\\n part1 = parts[0].get('id')\\n part2 = parts[1].get('id')\\n\\n for part in parts:\\n part_word = part.get('word')\\n part_id = part.get('id')\\n #print(part_id,'\\\\t',part_word)\\n chapter_output.write('%s' '\\\\t' '%s' '\\\\n'\\n % (part_id, part_word))\\n\\n # Find corresponding frames\\n frames = semantics.find('frames')\\n frame = frames.find_all('frame')\\n\\n for frame_tag in frame:\\n\\n # skip first letter in case of n|Negation\\n if frame_tag['name'] == NEGATION_FRAME_NAME:\\n\\n # Find target\\n target = frame_tag.find('target')\\n fenode = target.find('fenode')\\n fenode_id = fenode.get('idref')\\n\\n # Check part ID if == target ID\\n if part1 == fenode_id or part2 == fenode_id or splitword_idref == fenode_id:\\n\\n part_word = sentence.find(id=fenode_id).get('word')\\n #print(fenode_id,'\\\\t','target')\\n chapter_output.write('%s' '\\\\t' '%s' '\\\\n'\\n % (fenode_id, 'TARGET'))\\n\\n\\n # try and except blocks because of parser lowerUPPER errors\\n\\n #Find Negated\\n try:\\n negated = frame_tag.find('fe', {'name' : NEGATED_TAG_NAME})\\n negated_fenode_idref = negated.find('fenode').get('idref')\\n except AttributeError:\\n negated = ''\\n negated_fenode_idref = ''\\n #print(negated_fenode_idref,'\\\\t',negated['name'].lower())\\n try:\\n chapter_output.write('%s' '\\\\t' '%s' '\\\\n'\\n % (negated_fenode_idref, negated['name'].upper()))\\n except TypeError:\\n chapter_output.write('')\\n\\n #Find Scope\\n try:\\n scope = frame_tag.find('fe', {'name' : SCOPE_TAG_NAME})\\n scope_fenode_idref = scope.find('fenode').get('idref')\\n except AttributeError:\\n scope = ''\\n scope_fenode_idref = ''\\n #print(scope_fenode_idref,'\\\\t',scope['name'].lower())\\n try:\\n chapter_output.write('%s' '\\\\t' '%s' '\\\\n'\\n % (scope_fenode_idref, scope['name'].upper()))\\n except TypeError:\\n chapter_output.write('')\\n\\n #Find Focus\\n try:\\n focus = frame_tag.find('fe', {'name' : FOCUS_TAG_NAME})\\n focus_fenode_idref = focus.find('fenode').get('idref')\\n except AttributeError:\\n focus = ''\\n focus_fenode_idref = ''\\n\\n #print(focus_fenode_idref,'\\\\t',focus['name'].lower())\\n try:\\n chapter_output.write('%s' '\\\\t' '%s' '\\\\n'\\n % (focus_fenode_idref, focus['name'].upper()))\\n except TypeError:\\n chapter_output.write('')\\n\\n #end if splitwords\\n\\n else:\\n\\n # If Frames exist\\n if semantics.find('frames'):\\n\\n frames = semantics.find('frames')\\n frame = frames.find_all('frame')\\n\\n chapter_output.write('\\\\n' '=SCOPE/FOCUS=' '\\\\n')\\n\\n for frame_tag in frame:\\n\\n # skip first letter in case of n|Negation\\n if frame_tag['name'] == NEGATION_FRAME_NAME:\\n\\n #scope_list = []\\n\\n # Find target\\n target = frame_tag.find('target')\\n fenode = target.find('fenode')\\n fenode_id = fenode.get('idref')\\n\\n word = sentence.find(id=fenode_id).get('word')\\n pos = sentence.find(id=fenode_id).get('pos')\\n\\n chapter_output.write('%s' '\\\\t' '%s' '\\\\t' '%s' '\\\\n' % (fenode_id, word, pos))\\n chapter_output.write('%s' '\\\\t' '%s' '\\\\n' % (fenode_id, 'TARGET'))\\n\\n #Find Negated\\n if frame_tag.find('fe', {'name' : NEGATED_TAG_NAME}):\\n try:\\n negated = frame_tag.find('fe', {'name' : NEGATED_TAG_NAME})\\n negated_fenode_idref = negated.find('fenode').get('idref')\\n negated_word = sentence.find(id=negated_fenode_idref).get('word')\\n negated_pos = sentence.find(id=negated_fenode_idref).get('pos')\\n except AttributeError:\\n negated = ''\\n negated_fenode_idref = ''\\n negated_word = ''\\n negated_pos = ''\\n\\n chapter_output.write('%s' '\\\\t' '%s' '\\\\t' '%s' '\\\\t' '%s' '\\\\n'\\n % (negated_fenode_idref, negated['name'].upper(), negated_word, negated_pos))\\n\\n\\n # Resolve Terminals if Scope on a complex graph\\n def resolve_non_terminals(idref):\\n \\\"\\\"\\\" This function resolves a complex graph to\\n a simple flat list of tokens.\\n \\\"\\\"\\\"\\n nonterminal = sentence.find(id=idref)\\n edges = nonterminal.find_all('edge')\\n edge_words = []\\n for edge in edges:\\n e_id = edge.get('idref')\\n if sentence.find(id=e_id).get('word') is not None:\\n try:\\n edge_word = sentence.find(id=e_id).get('word')\\n edge_words.append(edge_word)\\n except:\\n pass\\n if sentence.find(id=e_id).get('word') is None:\\n edge_words.append(resolve_non_terminals(e_id))\\n\\n return edge_words\\n\\n scopelist = []\\n\\n if frame_tag.find('fe', {'name' : SCOPE_TAG_NAME}):\\n scope = frame_tag.find('fe', {'name' : SCOPE_TAG_NAME})\\n scope_fenode = scope.find_all('fenode')\\n for s_f in scope_fenode:\\n s_id = s_f.get('idref')\\n if sentence.find(id=s_id).get('word') is not None:\\n try:\\n scope_word = sentence.find(id=s_id).get('word')\\n #scope_pos = scope_word.get('pos')\\n scopelist.append(scope_word)\\n except:\\n pass\\n if sentence.find(id=s_id).get('word') is None:\\n pass\\n else:\\n pass\\n\\n chapter_output.write('%s' '\\\\t' '%s' '\\\\t' '%s' '\\\\n'\\n % (s_id, scope['name'].upper(), resolve_non_terminals(s_id)))\\n\\n focuslist = []\\n\\n\\n #chapter_output.write(str(scope_list))\\n #Find Focus\\n if frame_tag.find('fe', {'name' : FOCUS_TAG_NAME}):\\n focus = frame_tag.find('fe', {'name' : FOCUS_TAG_NAME})\\n focus_fenode = focus.find_all('fenode')\\n for f_f in focus_fenode:\\n f_id = f_f.get('idref')\\n if sentence.find(id=f_id).get('word') is not None:\\n try:\\n focus_word = sentence.find(id=f_id).get('word')\\n focus_pos = sentence.find(id=f_id).get('pos')\\n focuslist.append(focus_word)\\n except:\\n pass\\n if sentence.find(id=f_id).get('word') is None:\\n pass\\n else:\\n pass\\n\\n chapter_output.write('%s' '\\\\t' '%s' '\\\\t' '%s' '\\\\t' '%s' '\\\\t' '%s' '\\\\n'\\n % (f_id, focus['name'].upper(), focus_pos, focus_word, resolve_non_terminals(f_id)))\\n\\n\\n chapter_output.close()\\n\\n print('Cuewords statistics extracted to:', chapter_output.name)\",\n \"def gexfFormat(profile, recom, filename):\\n # ! ids are raw -> strings\\n clickedItems = set(map(lambda x: str(x[0]), profile)) # set of clicked items\\n recomItems = set() # set of recommended items\\n \\n with open(filename, 'w') as f:\\n # write header\\n f.write(\\\"\\\"\\\"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\\\n\\\"\\\"\\\")\\n f.write(\\\"\\\"\\\"<gexf xmlns:viz=\\\"http:///www.gexf.net/1.2/viz\\\" version=\\\"1.2\\\" xmlns=\\\"http://www.gexf.net/1.2\\\">\\\\n\\\"\\\"\\\")\\n f.write(\\\"\\\"\\\"<graph defaultedgetype=\\\"undirected\\\" idtype=\\\"string\\\" type=\\\"static\\\">\\\\n\\\"\\\"\\\")\\n \\n # write edges\\n f.write(\\\"\\\"\\\"<edges>\\\\n\\\"\\\"\\\")\\n id = 0\\n for click in range(0, len(profile)): # for all the clicks\\n print(\\\"Number of processed clicks: \\\", click)\\n for rec in recom[click]: # for the topN recommendations\\n f.write(\\\"<edge id=\\\\\\\"\\\" + str(id) + \\\"\\\\\\\" source=\\\\\\\"\\\" + str(rec[0]) + \\\"\\\\\\\" target=\\\\\\\"\\\" + str(profile[click][0]) + \\\"\\\\\\\" weight=\\\\\\\"\\\" + str(rec[1]) + \\\"\\\\\\\"/>\\\\n\\\")\\n recomItems.add(str(rec[0]))\\n id += 1\\n \\n f.write(\\\"\\\"\\\"</edges>\\\\n\\\"\\\"\\\")\\n \\n f.write(\\\"\\\"\\\"<nodes>\\\\n\\\"\\\"\\\")\\n # write clicked item-nodes in an outter ring\\n angleStep = 2*np.pi / float(len(clickedItems)) # polar coordinates angle step\\n angle = 0 # polar coordinates angle [0, 2pi]\\n R = 1000 # outter\\n for item in clickedItems: # for all the clicks\\n target = str(item)\\n f.write(\\\"<node id=\\\\\\\"\\\" + target + \\\"\\\\\\\">\\\\n\\\")\\n f.write(\\\"\\\\t\\\")\\n f.write(\\\"\\\"\\\"<viz:color r=\\\"255\\\" g=\\\"0\\\" b=\\\"0\\\"></viz:color>\\\\n\\\"\\\"\\\") # red color\\n f.write(\\\"<viz:position x=\\\\\\\"\\\" + str(R * np.cos(angle)) + \\\"\\\\\\\" y=\\\\\\\"\\\" + str(R * np.sin(angle)) + \\\"\\\\\\\" z=\\\\\\\"0.0\\\\\\\"/>\\\") # ring position\\n f.write(\\\"</node>\\\\n\\\")\\n angle += angleStep\\n \\n # write the rest item-nodes in an inner ring\\n angleStep = 2*np.pi / float(len(recomItems - clickedItems)) # polar coordinates angle step\\n angle = 0 # polar coordinates angle [0, 2pi]\\n R = 600 # outter\\n for item in recomItems - clickedItems: # for the rest of the items\\n target = str(item)\\n f.write(\\\"<node id=\\\\\\\"\\\" + target + \\\"\\\\\\\">\\\\n\\\")\\n f.write(\\\"\\\\t\\\")\\n f.write(\\\"<viz:position x=\\\\\\\"\\\" + str(R * np.cos(angle)) + \\\"\\\\\\\" y=\\\\\\\"\\\" + str(R * np.sin(angle)) + \\\"\\\\\\\" z=\\\\\\\"0.0\\\\\\\"/>\\\") # ring position\\n f.write(\\\"</node>\\\\n\\\")\\n angle += angleStep\\n \\n f.write(\\\"\\\"\\\"</nodes>\\\\n\\\"\\\"\\\")\\n f.write(\\\"\\\"\\\"</graph>\\\\n</gexf>\\\"\\\"\\\")\",\n \"def _create_xml_report(self, test, xml_obj):\\n xml_report_path = os.path.join(test.work_dir,\\n self.XML_REPORT_PATH)\\n with open(xml_report_path, 'w') as xml_report:\\n xml_report.write(etree.tostring(xml_obj, pretty_print=True))\",\n \"def buildNecessaryData():\\n emaildata = loadEmailData()\\n emailids = list(emaildata.keys())\\n if os.stat('res/dictionary.txt').st_size == 0:\\n print(\\\"Creating word list...\\\")\\n createWordList(emailids, emaildata)\\n print(\\\"Counting all words...\\\")\\n englishwords = importDictionary()\\n countAllWords(emaildata, englishwords)\",\n \"def get_results(self):\\n d = {}\\n# r = {}\\n for analyser in self.xml_tree.getroot():\\n for child in analyser:\\n if child.tag == 'all-records':\\n for record in child:\\n attributes = record.attrib\\n sample = attributes['sampleId']\\n assay_id = attributes['assayId']\\n genotype = attributes['genotypeId']\\n quality = attributes['description'].split('.')[0]\\n if re.match(r'rs\\\\d+', assay_id):\\n if sample in d:\\n if assay_id in d[sample]:\\n for allele in list(genotype):\\n if allele not in d[sample][assay_id]['genotype']:\\n d[sample][assay_id]['genotype'] += allele\\n if quality not in d[sample][assay_id]['quality']:\\n d[sample][assay_id]['quality'].append(quality)\\n else:\\n d[sample][assay_id] = {'genotype': genotype, 'quality': [quality]}\\n else:\\n d[sample] = {assay_id: {'genotype': genotype, 'quality': [quality]}}\\n# if sample in r:\\n# if assay_id in r[sample]:\\n# for allele in list(genotype):\\n# if allele not in r[sample][assay_id]:\\n# r[sample][assay_id] += allele\\n# else:\\n# r[sample][assay_id] = genotype\\n# else:\\n# r[sample] = {assay_id: genotype}\\n# for k, v in r.items():\\n# for k1, v1, in v.items():\\n# if len(v1) == 1:\\n# v[k1] += v1\\n# pprint.pprint(r)\\n# df = pd.DataFrame.from_dict(r).transpose()\\n# print(df)\\n# df.to_excel('snpcheck.xlsx')\\n return d\",\n \"def makedocs(projectfolder):\\n featuremodel_path = path.join(projectfolder, \\\"productline\\\", \\\"model.xml\\\")\\n configs_path = path.join(projectfolder, \\\"productline\\\", \\\"configs\\\")\\n bddfeatures_path = path.join(projectfolder, \\\"bddfeatures\\\")\\n testreports_path = path.join(projectfolder, \\\"testreports\\\")\\n\\n fmparser = parsers.FeatureModelParser()\\n resultsparser = parsers.TestResultsParser()\\n feature_tree_renderer = ftrenderer.FeatureTreeRenderer()\\n\\n docs_dir = path.join(projectfolder, \\\"docs/generated\\\")\\n if path.exists(docs_dir):\\n shutil.rmtree(docs_dir)\\n makedirs(docs_dir)\\n\\n lektor_templates_path = \\\"doc_templates\\\"\\n utilities.sed_inplace(\\n path.join(lektor_templates_path, \\\"aplet.lektorproject\\\"),\\n r'<<PROJECT>>',\\n CONFIG[\\\"project_name\\\"])\\n\\n products = {}\\n product_names = get_product_names_from_configs_path(configs_path)\\n for product_name in product_names:\\n productconfig_filepath = path.join(projectfolder, \\\"productline/configs\\\", product_name + \\\".config\\\")\\n product_html_report_name = \\\"report{0}.html\\\".format(product_name)\\n product_html_results_src = path.join(testreports_path, product_html_report_name)\\n product_xml_report_name = \\\"report{0}.xml\\\".format(product_name)\\n product_xml_results_src = path.join(testreports_path, product_xml_report_name)\\n\\n with open(productconfig_filepath, \\\"r\\\") as productconfig_file:\\n products[product_name] = {}\\n products[product_name]['features'] = [feature.strip() for feature in productconfig_file.readlines()]\\n\\n current_product_lektor_dir = path.join(lektor_templates_path, \\\"content/products\\\", product_name)\\n if not path.exists(current_product_lektor_dir):\\n makedirs(current_product_lektor_dir)\\n\\n product_filepath = path.join(current_product_lektor_dir,\\\"contents.lr\\\")\\n shutil.copyfile(path.join(lektor_templates_path, \\\"helpers/product_contents.lr\\\"), product_filepath)\\n\\n feature_model = fmparser.parse_from_file(featuremodel_path)\\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_product_from_file(product_xml_results_src)\\n configparser = parsers.ProductConfigParser(feature_model.root_feature.name)\\n product_features = configparser.parse_config(productconfig_filepath)\\n feature_model.trim_based_on_config(product_features)\\n feature_model.add_gherkin_pieces(gherkin_pieces)\\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\\n\\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\\n feature_tree_renderer.render_as_svg(current_product_lektor_dir, \\\"feature_model\\\")\\n\\n utilities.sed_inplace(product_filepath, r'<<PRODUCT>>', product_name)\\n product_test_status = feature_model.root_feature.test_status\\n utilities.sed_inplace(product_filepath, \\\"<<TEST_STATUS>>\\\", product_test_status.name)\\n\\n # Copy test run html report to generated docs\\n if path.exists(product_html_results_src):\\n shutil.copyfile(product_html_results_src, path.join(current_product_lektor_dir, product_html_report_name))\\n\\n click.echo(\\\"- Generating feature model SVG...\\\")\\n click.echo(featuremodel_path)\\n\\n feature_model = fmparser.parse_from_file(featuremodel_path)\\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_dir(testreports_path)\\n feature_model.add_gherkin_pieces(gherkin_pieces)\\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\\n\\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\\n feature_tree_renderer.render_as_svg(path.join(lektor_templates_path, \\\"content/\\\"), \\\"feature_model\\\")\\n\\n click.echo(\\\"- Building site\\\")\\n lektor_cmd = [\\\"lektor\\\", \\\"--project\\\", lektor_templates_path, \\\"build\\\", \\\"-O\\\", path.abspath(docs_dir)]\\n click.echo(\\\"Running: \\\" + subprocess.list2cmdline(lektor_cmd))\\n subprocess.call(lektor_cmd)\\n\\n product_map_renderer = mapbuilder.ProductMapRenderer()\\n productline_generated_filepath = path.join(docs_dir, \\\"index.html\\\")\\n html = product_map_renderer.get_productmap_html(feature_model, products)\\n utilities.sed_inplace(productline_generated_filepath, r'<<PRODUCTMAP>>', html)\",\n \"def create_xml_regression(lfiles, lsbj, foxml):\\n\\n impl = xml.dom.minidom.getDOMImplementation()\\n doc = impl.createDocument(None, \\\"some_tag\\\", None)\\n top_element = doc.documentElement\\n\\n e = doc.createElement('subject')\\n e.setAttribute('id', 'case')\\n\\n for i, fn in enumerate(lfiles):\\n v = doc.createElement('visit')\\n v.setAttribute('id', \\\"subj{}\\\".format(i))\\n\\n f = doc.createElement('filename')\\n f.setAttribute('object_id', \\\"face\\\")\\n t = doc.createTextNode(fn)\\n f.appendChild(t)\\n\\n a = doc.createElement('age')\\n x = doc.createTextNode(str(lsbj[i][\\\"age\\\"]))\\n a.appendChild(x)\\n\\n\\n v.appendChild(f)\\n v.appendChild(a)\\n e.appendChild(v)\\n\\n top_element.appendChild(e)\\n\\n with open(foxml, \\\"w\\\") as fo:\\n fo.write(doc.toprettyxml())\",\n \"def load_xml_files_erisk(local_dir, token_position=0):\\n users = {}\\n prep = Preprocessor()\\n c = 0\\n for dir_path, dir_names, filenames in os.walk(local_dir):\\n for name in filenames:\\n tok = name.split(\\\"_\\\")\\n if token_position > 0:\\n key = tok[0] + tok[token_position]\\n else:\\n key = tok[token_position]\\n key = key.strip(\\\".xml\\\")\\n full_file = os.path.abspath(os.path.join(dir_path, name))\\n dom = ET.parse(full_file, parser=ET.XMLParser(encoding=\\\"utf-8\\\"))\\n writing = dom.findall('WRITING')\\n for w in writing:\\n title = w.find('TITLE').text\\n text = w.find('TEXT').text\\n post = title + \\\" \\\" + text\\n # preprocess text\\n new_text = prep.tokenize_reddit(post)\\n\\n if key in users.keys():\\n users[key] += new_text + ' end_ '\\n else:\\n users[key] = new_text + ' end_ '\\n\\n c += 1\\n print(\\\"Preprocessed chunk: \\\", c)\\n\\n return users\",\n \"def test_xml_files_with_missing_info():\\n\\n # Test when k is missing from constant type reaction\\n with pytest.raises(ValueError):\\n xml_filename = \\\"tests/test_xml_files/k_const.xml\\\"\\n parser = XMLParser(xml_filename)\\n\\n # Test when A is missing from Arrhenius type reaction\\n with pytest.raises(ValueError):\\n xml_filename = \\\"tests/test_xml_files/A_arr.xml\\\"\\n parser = XMLParser(xml_filename)\\n\\n # Test when E is missing from Arrhenius type reaction\\n with pytest.raises(ValueError):\\n xml_filename = \\\"tests/test_xml_files/E_arr.xml\\\"\\n parser = XMLParser(xml_filename)\\n\\n # Test when A is missing from modified Arrhenius type reaction\\n with pytest.raises(ValueError):\\n xml_filename = \\\"tests/test_xml_files/A_mod_arr.xml\\\"\\n parser = XMLParser(xml_filename)\\n\\n # Test when b is missing from modified Arrhenius type reaction\\n with pytest.raises(ValueError):\\n xml_filename = \\\"tests/test_xml_files/b_mod_arr.xml\\\"\\n parser = XMLParser(xml_filename)\\n\\n # Test when E is missing from modified Arrhenius type reaction\\n with pytest.raises(ValueError):\\n xml_filename = \\\"tests/test_xml_files/E_mod_arr.xml\\\"\\n parser = XMLParser(xml_filename)\",\n \"def example_xml_file43():\\n return load_xml('datacite-v4.3-full-example.xml')\",\n \"def buildxml2(self):\\n # assume self._objslock is already held here\\n logger.info(\\\"Emane.buildxml2()\\\")\\n # on master, control network bridge added earlier in startup()\\n ctrlnet = self.session.add_remove_control_net(net_index=0, remove=False, conf_required=False)\\n self.buildplatformxml2(ctrlnet)\\n self.buildnemxml()\\n self.buildeventservicexml()\",\n \"def process_cvat_xml(xml_file, image_dir, output_dir):\\n KNOWN_TAGS = {'box', 'image', 'attribute'}\\n #output_dir = os.path.join(output_dir, \\\"Annotations\\\")\\n os.makedirs(output_dir, exist_ok=True)\\n cvat_xml = etree.parse(xml_file)\\n\\n basename = os.path.splitext( os.path.basename( xml_file ) )[0]\\n\\n tracks= cvat_xml.findall( './/track' )\\n\\n if (tracks is not None) and (len(tracks) > 0):\\n frames = {}\\n\\n for track in tracks:\\n trackid = int(track.get(\\\"id\\\"))\\n label = track.get(\\\"label\\\")\\n boxes = track.findall( './box' )\\n for box in boxes:\\n frameid = int(box.get('frame'))\\n outside = int(box.get('outside'))\\n ## occluded and pose are not tested within tracks\\n occluded = 0 ## Default if not found\\n if 'occluded' in box.attrib: ## this is an attribute of 'box' element\\n occluded = int(box.get('occluded'))\\n pose = 'Unspecified'\\n for attr in box.findall('attribute'):\\n if (attr.get('name') == 'type'): ## Used for view type\\n pose = attr.text\\n #keyframe = int(box.get('keyframe')) #currently unused\\n xtl = float(box.get('xtl'))\\n ytl = float(box.get('ytl'))\\n xbr = float(box.get('xbr'))\\n ybr = float(box.get('ybr'))\\n \\n frame = frames.get( frameid, {} )\\n \\n if outside == 0:\\n frame[ trackid ] = { 'xtl': xtl, 'ytl': ytl, 'xbr': xbr, 'ybr': ybr, 'label': label,\\n 'pose': pose, 'truncated': occluded }\\n\\n frames[ frameid ] = frame\\n\\n width = int(cvat_xml.find('.//original_size/width').text)\\n height = int(cvat_xml.find('.//original_size/height').text)\\n\\n # Spit out a list of each object for each frame\\n for frameid in sorted(frames.keys()):\\n print( frameid )\\n\\n image_name = \\\"%s_%08d.jpg\\\" % (basename, frameid) ## KM: Revisit this for tracks. Hardcoded?\\n image_path = os.path.join(image_dir, image_name)\\n if not os.path.exists(image_path):\\n log.warn('{} image cannot be found. Is `{}` image directory correct?'.\\n format(image_path, image_dir))\\n writer = Writer(image_path, width, height)\\n\\n frame = frames[frameid]\\n\\n objids = sorted(frame.keys())\\n\\n for objid in objids:\\n\\n box = frame[objid]\\n\\n label = box.get('label')\\n occluded = box.get('occluded')\\n pose = box.get('pose')\\n xmin = float(box.get('xtl'))\\n ymin = float(box.get('ytl'))\\n xmax = float(box.get('xbr'))\\n ymax = float(box.get('ybr'))\\n\\n writer.addObject(label, xmin, ymin, xmax, ymax, pose, occluded)\\n\\n anno_name = os.path.basename(os.path.splitext(image_name)[0] + '.xml')\\n anno_dir = os.path.dirname(os.path.join(output_dir, image_name))\\n os.makedirs(anno_dir, exist_ok=True)\\n writer.save(os.path.join(anno_dir, anno_name))\\n\\n else:\\n for img_tag in cvat_xml.findall('image'):\\n ## Discard path component; we expect user to provide path to images directory.\\n ## It is probably easier for users to provide full path to images directory\\n ## rather than having to figure out how much of the path is embedded in the XML\\n ## as a relative or absolute path by CVAT.\\n image_name = os.path.basename(img_tag.get('name'))\\n width = img_tag.get('width')\\n height = img_tag.get('height')\\n image_path = os.path.join(image_dir, image_name)\\n if not os.path.exists(image_path):\\n log.warn('{} image cannot be found. Is `{}` image directory correct?'.\\n format(image_path, image_dir))\\n writer = Writer(image_path, width, height)\\n\\n unknown_tags = {x.tag for x in img_tag.iter()}.difference(KNOWN_TAGS)\\n if unknown_tags:\\n log.warn('Ignoring tags for image {}: {}'.format(image_path, unknown_tags))\\n\\n for box in img_tag.findall('box'):\\n label = box.get('label')\\n occluded = 0 ## Default if not found\\n if 'occluded' in box.attrib: ## this is an attribute of 'box' element\\n occluded = int(box.get('occluded'))\\n pose = 'Unspecified' ## Default if not found\\n for attr in box.findall('attribute'):\\n if (attr.get('name') == 'type'): ## Used for view type\\n pose = attr.text\\n\\n xmin = float(box.get('xtl'))\\n ymin = float(box.get('ytl'))\\n xmax = float(box.get('xbr'))\\n ymax = float(box.get('ybr'))\\n\\n writer.addObject(label, xmin, ymin, xmax, ymax, pose, occluded)\\n\\n anno_name = os.path.basename(os.path.splitext(image_name)[0] + '.xml')\\n anno_dir = output_dir #os.path.dirname(os.path.join(output_dir, image_name))\\n os.makedirs(anno_dir, exist_ok=True)\\n #print(\\\"Writing {} (image: {})\\\".format(anno_name, image_name))\\n writer.save(os.path.join(anno_dir, anno_name))\",\n \"def make_inert_xml(mech, species, out_file):\\n file_type = '.xml'\\n _check_input_filetype(mech, file_type)\\n out_file = _check_output_filetype(out_file, file_type)\\n species = _enforce_species_list(species)\\n mech_dir, in_loc, out_loc = _get_file_locations(mech, out_file)\\n\\n with open(in_loc, 'r') as f:\\n data_in = f.read()\\n\\n indicator = '<reactionData id=\\\"reaction_data\\\">'\\n start_loc = data_in.find(indicator) + len(indicator) + 1\\n header = data_in[:start_loc]\\n to_scan = data_in[start_loc:]\\n rxn_indicator = '<!-- reaction'\\n scanned = to_scan.split(rxn_indicator)[1:]\\n new_rxns = ''\\n\\n for loc, rxn in enumerate(scanned):\\n # if any of the desired species are in the current reaction, delete\\n # it from the mechanism\\n rxn = rxn_indicator + rxn\\n eqn_indicators = ['<equation>', '</equation>']\\n eqn_start = rxn.find(eqn_indicators[0]) + len(eqn_indicators[0])\\n eqn_end = rxn.find(eqn_indicators[1])\\n eqn = rxn[eqn_start:eqn_end]\\n\\n if not any([_find_specie_in_str(s, eqn) for s in species]):\\n new_rxns += rxn\\n\\n new_mech = header + '\\\\n\\\\n' + new_rxns\\n with open(out_loc, 'w') as f:\\n f.writelines(new_mech)\\n f.flush()\",\n \"def print_xml_config(config_dictionary,**kwargs):\\n \\n #Check if we have passed a filename\\n #If not, pass a default filename\\n if 'config_file' in kwargs:\\n config_file = kwargs['config_file']\\n else:\\n config_file = 'ebtel_config.xml'\\n \\n #Open the file\\n f = open(config_file,'w')\\n \\n #Print necessary header info\\n f.write('<?xml version=\\\"1.0\\\" ?>\\\\n')\\n f.write('<input>\\\\n')\\n\\n #Loop through dictionary and print to xml file\\n for key in config_dictionary:\\n #Print tab delimiter, brackets and keyword\\n f.write('\\\\t<')\\n f.write(key)\\n f.write('>')\\n #Check if entry is a list\\n #If so print it as a list\\n if isinstance(config_dictionary[key],list) or type(config_dictionary[key]).__name__ == 'ndarray':\\n #Make temporary list\\n temp = config_dictionary[key]\\n #Skip to new line\\n f.write('\\\\n')\\n #Begin loop over list\\n for i in range(len(config_dictionary[key])):\\n f.write('\\\\t\\\\t<')\\n f.write(key+str(i))\\n f.write('>')\\n f.write(str(temp[i]))\\n f.write('</')\\n f.write(key+str(i))\\n f.write('>\\\\n')\\n #Print additional tab to preserve alignment\\n f.write('\\\\t')\\n else:\\n #Print value\\n f.write(str(config_dictionary[key]))\\n #Close the brackets and print newline\\n f.write('</')\\n f.write(key)\\n f.write('>\\\\n')\\n \\n #Close the main node of the file\\n f.write('</input>')\\n \\n #Close the file\\n f.close()\",\n \"def test_augmentsXML(self):\\n fileName = self.mktemp()\\n fp = FilePath(fileName)\\n fp.setContent(oldAugmentsFormat)\\n upgradeAugmentsXML(fp)\\n self.assertEquals(fp.getContent(), newAugmentsFormat)\",\n \"def __set_xml():\\n if len(activity) == 0:\\n\\n OS = DRIVER.OS\\n xml_path = os.path.join(prjDir, \\\"config\\\", \\\"element_android.xml\\\")\\n if OS == \\\"iOS\\\":\\n xml_path = os.path.join(prjDir, \\\"config\\\", \\\"element_iOS.xml\\\")\\n\\n # open the xml file\\n per = elementTree.parse(xml_path)\\n all_element = per.findall('activity')\\n\\n for firstElement in all_element:\\n activity_name = firstElement.get(\\\"name\\\")\\n\\n element = {}\\n\\n for secondElement in firstElement.getchildren():\\n element_name = secondElement.get(\\\"name\\\")\\n\\n element_child = {}\\n for thirdElement in secondElement.getchildren():\\n\\n element_child[thirdElement.tag] = thirdElement.text\\n\\n element[element_name] = element_child\\n activity[activity_name] = element\",\n \"def get_test_resources():\\n with open(\\\"test_data/repo/data/textgroup/work/textgroup.work.version-lat1.xml\\\") as file:\\n text = Text(resource=file, urn=\\\"urn:cts:latinLit:textgroup.work.version-lat1\\\")\\n\\n with open(\\\"test_data/repo/full_inventory.xml\\\") as file:\\n inventory = TextInventory(resource=file)\\n work = inventory[\\\"urn:cts:latinLit:textgroup.work\\\"]\\n textgroup = inventory[\\\"urn:cts:latinLit:textgroup\\\"]\\n edition = inventory[\\\"urn:cts:latinLit:textgroup.work.version-lat1\\\"]\\n\\n return {\\n \\\"text\\\": text,\\n \\\"work\\\": work,\\n \\\"textgroup\\\": textgroup,\\n \\\"edition\\\": edition\\n }\",\n \"def main():\\n\\n print (f'Reading schema file {args.schemafile} and writing RST to directory {args.outdir}')\\n\\n schema = xmlschema.XMLSchema(args.schemafile)\\n\\n # create warning.rst file for deprectaion warnings\\n with open(\\\"warnings.rst\\\", \\\"w\\\") as warnfile:\\n print(\\\".. Put any comments here\\\\n\\\", file=warnfile)\\n print(\\\" Warning, this file is regenerated from the annotations in the schema file.\\\\n\\\", file=warnfile)\\n print(\\\" Any changes will be overwritten by convert_xsd_to_rst.py.\\\\n\\\\n\\\\n\\\", file=warnfile)\\n print(\\\"\\\\n\\\", file=warnfile)\\n print(\\\"The following are potential future changes, as tagged in the schema with <warning> elements in the documentation. They may result in modifications or deletions in future versions of StationXML.\\\\n\\\", file=warnfile)\\n print(\\\"\\\\n\\\\n\\\", file=warnfile)\\n\\n level_xpaths = ['fsx:FDSNStationXML',\\n 'fsx:FDSNStationXML/fsx:Network',\\n 'fsx:FDSNStationXML/fsx:Network/fsx:Station',\\n 'fsx:FDSNStationXML/fsx:Network/fsx:Station/fsx:Channel',\\n 'fsx:FDSNStationXML/fsx:Network/fsx:Station/fsx:Channel/fsx:Response']\\n\\n words = set()\\n for i, xpath in enumerate(level_xpaths):\\n xsd_element = schema.find(xpath)\\n\\n stop_element = None\\n this_element = os.path.basename(xpath).split(':')[1]\\n if i < 4:\\n stop_element = os.path.basename(level_xpaths[i+1]).split(':')[1]\\n\\n level_elem = walk_tree(xsd_element)\\n\\n # Use Preamble instead of root element name\\n if this_element==\\\"FDSNStationXML\\\":\\n this_element=\\\"Preamble\\\"\\n\\n # Generate output file name for this level\\n rst_file = os.path.join (args.outdir, f'level-{this_element.lower()}.rst')\\n\\n if args.verbose:\\n print (f'Writing to {rst_file}')\\n\\n with open(rst_file, 'w') as outfile:\\n print(\\\".. Put any comments here\\\\n\\\", file=outfile)\\n print(\\\" Warning, this file is regenerated from the annotations in the schema file.\\\\n\\\", file=outfile)\\n print(\\\" Any changes will be overwritten by convert_xsd_to_rst.py.\\\\n\\\", file=outfile)\\n\\n write_tree(level_elem, stop_element, outfile = outfile)\\n\\n recur_spelling(words, level_elem)\\n save_spelling(words)\",\n \"def addEntry(self, listDictions):\\n ## load xml\\n improvDoc = loadIMProvFile(self.argsFile)\\n entrname= 'Job'\\n for dictions in listDictions:\\n report = IMProvNode(entrname , None, **dictions)\\n improvDoc.addNode(report)\\n outfile = file( self.argsFile, 'w').write(str(improvDoc))\\n return\",\n \"def read_xml(self):\\n connection = urlopen(self.url)\\n in_xml = connection.read()\\n state = ElementTree.fromstring(in_xml)\\n records = []\\n record = []\\n\\n # Specific to CHP\\n # TODO(David) Nested for loops are bad. Change this to be more\\n # efficient, possibly use generators.\\n for center in state:\\n rec_center = center.attrib['ID']\\n\\n for dispatch in center:\\n rec_dispatch = dispatch.attrib['ID']\\n\\n for log in dispatch:\\n record = [rec_center, rec_dispatch]\\n\\n record.append(log.attrib['ID'])\\n\\n log_time = log.find('LogTime').text.strip('\\\"')\\n log_type = log.find('LogType').text.strip('\\\"')\\n location = log.find('Location').text.strip('\\\"')\\n loc_desc = log.find('LocationDesc').text.strip('\\\"')\\n area = log.find('Area').text.strip('\\\"')\\n\\n record.append(log_time)\\n record.append(log_type)\\n record.append(location)\\n record.append(loc_desc)\\n record.append(area)\\n\\n latlon = log.find('LATLON').text.strip('\\\"')\\n\\n (lat, lon) = latlon.split(':')\\n lat = str(lat[:2]) + '.' + str(lat[2:])\\n lon = '-' + str(lon[:3]) + '.' + str(lon[3:])\\n\\n record.append(lat)\\n record.append(lon)\\n\\n records.append(record)\\n\\n self.records = records\",\n \"def build_configs():\",\n \"def generate_xml_tree(self):\\n try:\\n tree = et.parse(self.file)\\n self.root = tree.getroot()\\n self.blast_output = self.root[8]\\n self.iteration = self.blast_output[0]\\n self.iteration_hit = self.iteration[4]\\n\\n for i in self.iteration_hit:\\n self.hits.append(i)\\n\\n for i in self.hits:\\n h = []\\n for j in i:\\n h.append(j)\\n\\n for hsp in h[5]:\\n procent = \\\"{0:.2f}\\\".format(int(hsp[10].text) / int(hsp[13].text) * 100)\\n procent = float(procent)\\n self.aligns.append(Alignment(h[2].text,\\n hsp[1].text,\\n procent,\\n hsp[12].text,\\n hsp[10].text,\\n hsp[13].text,\\n hsp[14].text,\\n hsp[15].text,\\n hsp[16].text))\\n self.main_alignments.append(MainAlignment(i[2].text,\\n self.aligns))\\n self.aligns = []\\n except IndexError:\\n \\\"Bad file.\\\"\",\n \"def main():\\n glob_pattern = \\\"{root}/{child}/*.xml\\\".format(root=MANCHESTER_ROOT, child=TARGET_CHILD)\\n corpus_files = glob(glob_pattern)\\n for filename in corpus_files:\\n print(filename)\\n to_csv(filtered_parent_freq_count([filename], 2))\",\n \"def main(src_xml, out='output.txt', sep='::'):\\n \\n soup = bs(open(src_xml).read(), 'lxml') \\n data = [(p[0].text, s_convert(p[1].text), p[2].text)\\n for p in zip(soup('weightedfrequency'),\\n soup('headword'),\\n soup('shortdefinition'))]\\n res = ''\\n words = []\\n for item in data:\\n try:\\n if item[1].replace('\\\\n', '') in words:\\n continue\\n else:\\n res += '{}{}{}{}{}\\\\n'.format(item[0],\\n sep,\\n item[1].replace('\\\\n', ''),\\n sep,\\n item[2].replace('\\\\n', ''))\\n words.append(item[1].replace('\\\\n', ''))\\n except:\\n continue\\n with open(out, 'w') as f:\\n f.write(res)\\n return res\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61072654","0.5717132","0.5615994","0.5543528","0.55028045","0.53621995","0.5347263","0.5297309","0.5269815","0.5254691","0.52032775","0.5177183","0.5130147","0.5118681","0.51131713","0.51111734","0.5094071","0.50852966","0.5085046","0.50843346","0.50589895","0.5041263","0.50376314","0.50374556","0.5014333","0.49962717","0.49937144","0.49916235","0.49897355","0.49828026","0.4973738","0.49674258","0.49440247","0.49363175","0.49211448","0.49160635","0.4913846","0.4903944","0.490373","0.49018025","0.4892479","0.4891718","0.48910236","0.48893228","0.4886891","0.48852265","0.48839623","0.48788133","0.48747247","0.48732892","0.48709875","0.48642775","0.4856655","0.48448792","0.48286662","0.48263744","0.4824608","0.48175403","0.47857016","0.47856194","0.47823343","0.47817886","0.47815093","0.47804773","0.47803736","0.4777209","0.47725597","0.4771328","0.47693968","0.47664157","0.47644585","0.4763028","0.47623613","0.47599238","0.47551224","0.4753274","0.47391096","0.4732845","0.47276014","0.47263637","0.47238025","0.47235912","0.4718478","0.47141662","0.4710987","0.4708887","0.4703245","0.46973857","0.46945626","0.46872616","0.46842992","0.46842057","0.46818307","0.46760923","0.46728203","0.46686438","0.46662655","0.46627524","0.46612573","0.46611884"],"string":"[\n \"0.61072654\",\n \"0.5717132\",\n \"0.5615994\",\n \"0.5543528\",\n \"0.55028045\",\n \"0.53621995\",\n \"0.5347263\",\n \"0.5297309\",\n \"0.5269815\",\n \"0.5254691\",\n \"0.52032775\",\n \"0.5177183\",\n \"0.5130147\",\n \"0.5118681\",\n \"0.51131713\",\n \"0.51111734\",\n \"0.5094071\",\n \"0.50852966\",\n \"0.5085046\",\n \"0.50843346\",\n \"0.50589895\",\n \"0.5041263\",\n \"0.50376314\",\n \"0.50374556\",\n \"0.5014333\",\n \"0.49962717\",\n \"0.49937144\",\n \"0.49916235\",\n \"0.49897355\",\n \"0.49828026\",\n \"0.4973738\",\n \"0.49674258\",\n \"0.49440247\",\n \"0.49363175\",\n \"0.49211448\",\n \"0.49160635\",\n \"0.4913846\",\n \"0.4903944\",\n \"0.490373\",\n \"0.49018025\",\n \"0.4892479\",\n \"0.4891718\",\n \"0.48910236\",\n \"0.48893228\",\n \"0.4886891\",\n \"0.48852265\",\n \"0.48839623\",\n \"0.48788133\",\n \"0.48747247\",\n \"0.48732892\",\n \"0.48709875\",\n \"0.48642775\",\n \"0.4856655\",\n \"0.48448792\",\n \"0.48286662\",\n \"0.48263744\",\n \"0.4824608\",\n \"0.48175403\",\n \"0.47857016\",\n \"0.47856194\",\n \"0.47823343\",\n \"0.47817886\",\n \"0.47815093\",\n \"0.47804773\",\n \"0.47803736\",\n \"0.4777209\",\n \"0.47725597\",\n \"0.4771328\",\n \"0.47693968\",\n \"0.47664157\",\n \"0.47644585\",\n \"0.4763028\",\n \"0.47623613\",\n \"0.47599238\",\n \"0.47551224\",\n \"0.4753274\",\n \"0.47391096\",\n \"0.4732845\",\n \"0.47276014\",\n \"0.47263637\",\n \"0.47238025\",\n \"0.47235912\",\n \"0.4718478\",\n \"0.47141662\",\n \"0.4710987\",\n \"0.4708887\",\n \"0.4703245\",\n \"0.46973857\",\n \"0.46945626\",\n \"0.46872616\",\n \"0.46842992\",\n \"0.46842057\",\n \"0.46818307\",\n \"0.46760923\",\n \"0.46728203\",\n \"0.46686438\",\n \"0.46662655\",\n \"0.46627524\",\n \"0.46612573\",\n \"0.46611884\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72865844"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":173,"cells":{"query":{"kind":"string","value":"r\"\"\"The constructor for Config class Initializes the Config class"},"document":{"kind":"string","value":"def __init__(self, config_file_name=\"config.json\"):\n with open(config_file_name, \"r\") as config:\n f = dict(json.load(config))\n for key, value in f.items():\n setattr(self, key, value)"},"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, *args, **kwargs):\r\n super().__init__()\r\n self._cfg = ConfigDict() # current configuration\r\n self._default_config = ConfigDict() # default configuration\r\n self._temp_config = OrderedDict() # temporary configuration\r\n self._path = Path() # current configuration path\r\n self._default_path = Path() # default configuration path\r\n self._conversion_dict = None\r\n self._auto_cast = None\r\n self._write_flags = None\r\n self._force_load = None\r\n self._load_empty = None\r\n self._ask_path = None\r\n self._search_in_default_config = None\r\n self._init_count = 0\r\n self._policies = defaultdict(bool) # by default every modification is forbidden # WIP\r\n if args or kwargs:\r\n self.init(*args, **kwargs)\r\n logger.debug(\"Config object created.\")","def __init__(self, config: Dict[str, Any]) -> None:\n self.config = config","def __init__(self, config_dict: dict):\n self._config = config_dict","def __init__(self):\n self.__parameters: ConfigParams = ConfigParams()","def __init__(self, config):\n\n self.config = config","def __init__(self, config: str) -> None:\n self.configuration = config","def __init__(self, config: str) -> None:\n self.configuration = config","def __init__(self, config: dict) -> None:\n super().__init__(config)","def __init__(self, config):\n self.config = config","def __init__(self, config):\n self.config = config","def __init__(self, config):\n self.config = config","def __init__(self, config=None):\n pass","def __init__(self):\n self.config = {}","def __init__(self, config, cfg):\n self.config = config\n self.cfg = cfg","def init_config(self):\n pass","def __init__(self, config: Optional[Config] = None):\n self.config = config or Config()","def __init__(self) -> None:\n self.config: dict[str, str | int] = {}","def __init__(self, configs):\n\n self.__configs = configs","def init_config() -> Config:\n ...","def __init__(self):\n # Read configuration into dictionary\n self.directories = general.config_directories()\n self.config = general.read_yaml_files(self.directories)","def initialize_from_config(self):","def __init__(self, *args, **kwargs):\n wrap = lambda v: Config(v) if type(v) is dict else v\n kvdict = {k: wrap(v) for k, v in dict(*args, **kwargs).items()}\n super(Config, self).__init__(kvdict)\n self.__dict__ = self","def __init__(self):\n\n if Config._instance:\n raise Exception('Config singleton is already instantiated. User Config.get_instance() obtain it.')\n\n parser = configparser.ConfigParser()\n parser.read('C:\\\\Users\\\\Akatosh\\\\PythonProjects\\\\note-it\\\\config\\\\config.ini')\n\n self.sections = {}\n\n for section in parser:\n self.sections[section] = _Section(parser[section])\n\n Config._instance = self","def __init__(self, config):\n raise NotImplementedError (\"This is just an abstract interface\")","def __init__(self, config):\n\n self.root = config.root\n self.pidfile = config.pidfile\n self.log_conf = config.logging","def _init_config_(self):\n self._config= {}","def __init__(self):\n\n self.path = os.path.dirname(os.path.realpath(__file__)) + '/config.ini'\n self.config = configparser.ConfigParser()\n self.config.read(self.path)","def __init__(self, config: Tuple):","def initialize(self, **kwargs):\n\n # Defining the configuration object\n self.config = kwargs.get('config')","def __init__(self, config_file_name=\"config.json\"):\n self.config_file_name = config_file_name\n self._config = self._open_config_file()","def __init__(self, config_path, normalize=False):\n self.config = {}\n _config_dict = {}\n self._config_path = Utils.expand_path(config_path)\n self.update = None\n self.normalize = normalize","def config_init(self):\n\n game_opts = [\n\n # Execution Options\n ('debug',False), # Toggle Debug Messaging\n ('log_path',False), # Turn on logging (w/path)\n ('log_lvl',logging.DEBUG), # Set log level\n\n # World Generation Options\n ('flex_limit',3) # Sets the maximum variance\n\n ]\n\n # Attempts to pull each value from the configuration\n # if not in config, the default value defined above\n # is set instead\n for opt in game_opts:\n try:\n setattr(self,opt[0],self.conf.conf_dict[opt[0]])\n except:\n setattr(self,opt[0],opt[1])\n continue","def Init(self, config):\r\n pass","def __init__(self):\n ConfigParser.RawConfigParser.OPTCRE = re.compile(r'(?P<option>[^=\\s][^=]*)\\s*(?P<vi>[=])\\s*(?P<value>.*)$')\n self.CONFIG = ConfigParser.ConfigParser()\n self.CONFIG.read(os.path.join(os.path.dirname(__file__)))\n self.IPS = []","def __init__(self, configuration):\n self._config = configuration","def __init__(self, cfg=None):\n if cfg is None:\n cfg = {}\n\n self.cfg = cfg","def __init__(self, config):\n super().__init__(config)\n self.collector_host = config.get(\"collector_host\")\n self.schedds = config.get(\"schedds\", [None])\n self.condor_config = config.get(\"condor_config\")\n self.constraint = config.get(\"constraint\", True)\n self.classad_attrs = config.get(\"classad_attrs\")\n self.correction_map = config.get(\"correction_map\")","def __init__(self, config):\n\n self.locations_hltv_starting_ = config[sC.BUCKET_LOCATIONS][sC.HLTV_STARTING]\n self.score_starting_ = config[sC.BUCKET_LOCATIONS][sC.SCORE_STARTING]\n self.logs_starting_ = config[sC.BUCKET_LOCATIONS][sC.LOGS_STARTING]\n self.temp = config[sC.FOLDER_LOCATIONS][sC.TEMP_APP_ENGINE_FOLDER]\n self.results_ = config[sC.FOLDER_LOCATIONS][sC.CONFIGS_RESULTS]\n self.amxmodx_logs_ = config[sC.FOLDER_LOCATIONS][sC.ADDONS_AMXMODX_LOGS]\n self.cstrike_logs_ = config[sC.FOLDER_LOCATIONS][sC.CSTRIKE_LOGS]\n self.hltv_demos_func_url = config[sC.CLOUD_FUNCTIONS_URLS][sC.HLTV_DEMOS_FUNC]\n self.ftp_logs_func_url = config[sC.CLOUD_FUNCTIONS_URLS][sC.FTP_LOGS_FUNC]\n\n print('{} - Initialized'.format(__name__))","def __init__(self, cfg=None, **kwargs):\n self.__dir = KITConfig.configDir\n self.__cfgFile = \"\"\n\n self.__cfg = {}\n self.__default = KITConfig.defaultConfig\n\n self.__setupLogger()\n\n if cfg is not None:\n self.__cfgFile = cfg\n self.load(cfg)","def __init__(self):\n parameters_list = []\n self.config_dict = self.open_config(parameters_list)\n\n # Define defaults\n self.disc_gt = 0.0\n self.disc_out = 0.0","def __init__(self, config_entry):\n self.config_entry = config_entry","def __init__(self, config_entry):\n self.config_entry = config_entry","def __init__(self):\n self.collectorName = COLLECTOR_NAME\n self.configCycleInterval = 20 # minutes\n self.cycleInterval = 5 * 60 # seconds\n\n # The configurationService attribute is the fully qualified class-name\n # of our configuration service that runs within ZenHub\n self.configurationService = 'NullConfig'\n\n # Will be filled in based on buildOptions\n self.options = None\n\n self.configCycleInterval = 20*60","def init(self, *args, **kwargs):\n try:\n self._init(*args, **kwargs)\n except (ValueError, TypeError, UnicodeError, ConfigParser.Error), exc:\n raise ConfigInvalidError, str(exc), sys.exc_info()[2]","def __init__(self, config_file, verbose):\r\n self.loadConfig(config_file)\r\n self.verbose = verbose","def __init__(self, config, logger):\n self.config = config\n self.logger = logger","def __init__(self, configs: Union[Config, Dict[str, Any]]):\n self.configs: Config = Config(configs, None, allow_new_hparam=True)","def __init__(self, conf=None):\n # set interpolation to None so you can supply filename template\n # that contain % to config.set\n conf = ConfigParser(strict=False,\n inline_comment_prefixes=(';',),\n interpolation=None) if (conf is None) else conf\n super().__init__(conf)\n self._cycle = None\n self._logger = logging.getLogger('metplus')\n # config.logger is called in wrappers, so set this name\n # so the code doesn't break\n self.logger = self._logger\n\n # get the OS environment and store it\n self.env = os.environ.copy()\n\n # add section to hold environment variables defined by the user\n self.add_section('user_env_vars')","def _init_config(self, configPath=None):\n # TODO: The SafeConfigParser class has been renamed to ConfigParser in Python 3.2.\n # This alias will be removed in future versions.\n # We still use SafeConfigParser for backwards compatibility with Python 2.\n self.config = SafeConfigParser()\n # Make option names case sensitive\n self.config.optionxform = str\n\n if configPath and os.path.isdir(configPath):\n configDir = configPath\n else:\n configDir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'conf')\n\n # List filenames in configDir alphabetically\n _, _, configFiles = next(os.walk(configDir))\n configFiles = sorted(configFiles, key=str.lower)\n\n # Read configuration pipeline\n for f in configFiles:\n with open(os.path.join(configDir, f)) as configFile:\n self.config.readfp(configFile)\n self._store_config_pass()\n\n if configPath and os.path.isfile(configPath):\n self.config.read(configPath)\n self._store_config_pass()\n\n appSection = 'application'\n self.appName = self._get_option_value(appSection, 'appName')\n self.appResource = self._get_option_value(appSection, 'appResource')\n self.appArgs = []\n appArgs = self._get_option_value(appSection, 'appArgs')\n if appArgs:\n self.appArgs = appArgs.split(' ')\n self.mainClass = self._get_option_value(appSection, 'mainClass')","def __init__(self, name=None):\n self.name = name or \"default\"\n config_path = os.path.join(get_config_directory(), self.name + JSON)\n try:\n with open(config_path, mode='r') as config_file:\n self.config_dict = json.load(config_file)\n except Exception as ex:\n raise ColinConfigException(\"Config file '{}' cannot be loaded.\".format(config_path))","def __init__(self, config_file):\n with open(config_file, 'r') as file:\n self.config = json.load(file)\n self.set_config(self.config)","def __new__(cls, *args, **kwargs):\n if not cls._instance:\n cls._instance = super(Config, cls).__new__(cls)\n return cls._instance","def __init__(self, filename=None):\n if filename:\n if not os.path.exists(filename):\n raise Exception(\"No configuration found at %s\" % filename)\n super(Configuration, self).__init__(filename)","def __init__(self, config_entry: config_entries.ConfigEntry) -> None:\n self.config_entry = config_entry","def __init__(self, settings):\n self._read_config(settings)","def create_config(self) -> None:\n pass","def create_config(self) -> None:\n pass","def __init__(self):\n\n self.config = load_config()\n self.set_env_var()","def __init__(self, config_file):\n \n self.log = logging.getLogger(__name__)\n\n self.parser = ConfigParser.ConfigParser()\n if os.path.exists(config_file) and os.path.isfile(config_file):\n self.parser.read(config_file)\n self.log.debug(\"opened configuration '%s'\" % config_file)\n else:\n raise ConfigError(\"Config file missing\", \"File '%s' doesn't exist.\" % (config_file))\n\n self.config_file = config_file\n self.check_config()","def __init__(self):\n\t\t\n\t\tsettings = configparser.SafeConfigParser(allow_no_value=True)\n\t\tlist=settings.read('data/settings.cfg')\n\t\tif not 'data/settings.cfg' in list:\n\t\t\tprint('no configuration file present.. making one')\n\t\t\tself.makeConfigFile(settings)\n\t\t\tshare = ['']\n\t\t\tself.nodes = []\n\t\telse:\n\t\t\tshare, nodes = self.openConfig(settings)\n\t\t\tself.nodes = nodes\n\t\t\n\t\t\n\t\tself.files = self.loadFiles(share)\t\t\n\t\tself.share = share\n\t\tself.kill= False\n\t\tself.downloads = {}\n\t\tself.currentVersion = (0,2,1)\n\t\tself.totalDownloads = 0\n\t\tself.current = 0\n\t\tself.config = settings","def __init__(self, userconfig=None):\n configspec = _get_configspec()\n self._configspec = ConfigObj(configspec, interpolation=False,\n list_values=False, _inspec=True)\n configs_default = ConfigObj(interpolation=False,\n configspec=self._configspec)\n self._config = self._validate(configs_default)\n if userconfig:\n self.read_userconfig(userconfig)","def __init__(self, config_file=None):\n\t\tself.options = {}\n\n\t\tif config_file:\n\t\t\tself.set_file(config_file)","def config():\n return Config()","def config():\n return Config()","def __init__(self):\n self.filename = pathlib.Path(__file__).parent.absolute().__str__() + '/../../data/config.ini'\n self.data = ConfigParser()\n self.data.read(self.filename)","def __init__(self, config_file):\n Config = ConfigParser.ConfigParser()\n Config.read(config_file)\n \n self.port_id = Config.get(\"SerialPortSection\", \"ComPort\")\n self.baud_rate = Config.get(\"SerialPortSection\", \"BaudRate\")\n self. timeout = Config.get(\"SerialPortSection\", \"TimeOut\")\n self.config_file = config_file","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, load_config):\n super().__init__()\n self._load_config = load_config","def init(cls, config, src):\n cls.config = config","def __init__(self):\n self.__default_config = ConfigParams.from_tuples(\n 'options.max_pool_size', 2,\n 'options.connect_timeout', 5000,\n 'options.auto_reconnect', True,\n 'options.max_page_size', 100,\n 'options.debug', True\n )\n\n # The logger\n self._logger: CompositeLogger = CompositeLogger()\n # The connection resolver\n self._connection_resolver: MongoDbConnectionResolver = MongoDbConnectionResolver()\n # The configuration options.\n self._options: ConfigParams = ConfigParams()\n # The MongoDB connection object.\n self._connection: pymongo.MongoClient = None\n # The MongoDB database name.\n self._database_name: str = None\n # The MongoDb database object.\n self._db: database.Database = None","def __init__(self, path_to_config_file):\n self.file_path = path_to_config_file","def _new():\n\treturn ConfigParser(\n\tdelimiters = ('=',),\n\tcomment_prefixes = ('#', ';'),\n\tdefault_section = 'default',\n\tallow_no_value = False,\n\tstrict = False,\n\tinterpolation = ExtendedInterpolation(),\n\tdefaults = {\n\t\t'debug': False,\n\t\t'datadir': path.join(path.expanduser('~'), '.local', 'rosshm'),\n\t\t'log.level': 'warn',\n\t\t'core.enable': True,\n\t\t'db.driver': 'sqlite',\n\t\t'db.name': 'rosshmdb',\n\t\t'db.config': '',\n\t\t'static.enable': True,\n\t\t'web.enable': True,\n\t},\n)","def __init__(self, config):\n self.conf = dict( timeout=60\n , logfile=''\n , ip_addr='192.168.0.220'\n , username='admin'\n , password='admin'\n , prompt=\"Cursor\"\n , init=False\n , debug=0\n , recv_pause=0.25\n , waitfor=300\n , pause=2\n , stdout=1\n , ping_timeout=10\n )\n self.conf.update(config)\n (self.exp_state, self.exp_output, self.exp_recv_cnt) = ('', '', 0)\n if self.conf['init']: self.initialize()","def __init__(self, config, well, directory):\n self.config = config\n self.well = well\n self.directory = directory","def __init__(self, **kwargs):\n cls = self.__class__\n\n # Initialize all configurables and input arguments\n for arg in cls.configurables():\n try: # Read from class constructor\n setattr(self, arg, kwargs[arg])\n except KeyError:\n try: # Set from default value defined in class\n default_value = getattr(self, arg).kwargs[\"default\"]\n setattr(self, arg, default_value)\n except KeyError: # if nothing is provided, fallbakcs to None\n setattr(self, arg, None)\n\n self.input_arguments = None\n if cls.input_configurables():\n self.input_arguments = [\n getattr(self, arg) for arg in cls.input_configurables()\n ]\n\n self.json_config = cfg.JsonConfig(self.config)\n self.output_objects = []\n self.file = None","def __init__(self, config_file=None):\n self.file = config_file\n self.parser = SafeConfigParser()\n if isinstance(self.file, (str, list)):\n self.parser.read(self.file)\n else: # assume file object was given instead\n self.parser.read_file(self.file)\n self._flask_cache = None\n self._assets_cache = None\n self._gridrealm_cache = None","def __init__(self, environment='develop'):\n\n cwd = path.dirname(path.abspath(__file__))\n config_dir = path.join(cwd, 'configs')\n\n config_files = []\n for (root, _, file_names) in walk(config_dir):\n for file_name in file_names:\n config_files.append(path.join(root, file_name))\n config_files = sorted(config_files)\n\n for config_file in config_files:\n config = anyconfig.load(config_file)\n for key in config:\n self[key] = config[key]\n\n if environment in config_file:\n break","def __init__(self, config, town):\n\t\tself.config = config","def __init__(self):\n\n # open json config file that reads in information\n config_path = open(\"config.json\", \"r\")\n config_json = config_path.read()\n config_dict = json.loads(config_json)\n\n # assign object variables\n self.project_id = config_dict[\"project-id\"]\n self.bucket_name = config_dict[\"bucket-name\"]\n self.location_id = config_dict[\"key-location\"]\n self.key_ring_id = config_dict[\"key-ring-id\"]\n self.crypto_key_id = config_dict[\"crypto-key-id\"]\n self.service_account_email = config_dict[\"service-account-email\"]\n\n # close the file\n config_path.close()","def __init__(self, config=None, broker=None):\n pass","def __init__(self, config_path=None):\n self.config_path = None\n\n config_path = config_path or CONF.api_paste_config\n if not os.path.isabs(config_path):\n self.config_path = CONF.find_file(config_path)\n elif os.path.exists(config_path):\n self.config_path = config_path\n\n if not self.config_path:\n raise exception.ConfigNotFound(path=config_path)","def __init__(self, ini_file):\n self.config = configparser.ConfigParser()\n self.config.read(ini_file)","def __init__(self, config_name: str, is_top_level_config: bool = False):\n self.config_name = config_name\n self.config_variable_name = to_snake_case(config_name) + \"_config\"\n self.is_top_level_config = is_top_level_config\n self.parameters: List[CppParameter] = list()\n self.configs: List[CppConfig] = list()","def __init__(self, config_path: str = \"config.json\"):\n # Change here if you want to relocate you config file\n self.config = {}\n self.load_configuration(config_path)\n self.app_name = self.config.get('app_name', self.APP_NAME)","def __init__(self):\n self.database = Database()\n self.load_config()","def __init__(self, config, loop):\n self.config = config\n self.loop = loop","def __init__(self, config_directory: Optional[pathlib.Path] = None):\n self._config_parser = configparser.ConfigParser()\n # Preserve case for keys.\n self._config_parser.optionxform = lambda x: x\n\n if config_directory is None:\n self._config_filepath = pathlib.Path(_KFP_CONFIG_FILE)\n else:\n self._config_filepath = config_directory / _KFP_CONFIG_FILE\n\n try:\n with open(str(self._config_filepath), 'r') as f:\n self._config_parser.read_file(f)\n except IOError:\n warnings.warn('No existing KFP Config file found')\n\n if not self._config_parser.has_section(_COMPONENTS_SECTION):\n self._config_parser.add_section(_COMPONENTS_SECTION)\n\n self._components = {}","def __init__(self, config_directory, scale_override=None):\n self._config_directory = config_directory\n\n self._config_detector = DetectorConfig(config_directory)\n self._config_align = AlignConfig(config_directory, scale_override=scale_override)\n self._config_crystal = CrystalMatchConfig(config_directory)","def __init__(self, ini_file):\n self.config = configparser.ConfigParser()\n self.config.read(ini_file)\n #print(self.config)","def __init__(self, config: str, wdir=os.getcwd()):\n\n self.config_path = config\n self.wdir = wdir\n\n with open(self.config_path) as fin:\n self.config_dic = yaml.load(fin, Loader=yaml.BaseLoader)\n\n # default is 00 for all interaction types\n self.config_parameters_dic = None\n\n # This parameter defines whether self_loops will be kept or not\n self.self_loops = True\n if 'self_loops' in self.config_dic:\n self.self_loops = bool(int(self.config_dic['self_loops']))","def __init__(self) -> None:\n\n self.config_keys = ['APPS_HOST', 'APPS_PORT']\n super().__init__()\n\n self.APPS_HOST = str(self.APPS_HOST)\n \"\"\"Host where the server will be served\"\"\"\n\n self.APPS_PORT = int(self.APPS_PORT)\n \"\"\"Port where the server will be served\"\"\"","def __init__(self, config_entry: config_entries.ConfigEntry) -> None:\n self.config_entry = config_entry\n self.options = dict(config_entry.options)","def __init__(self):\n self.storefn = Config.getConfigFnPath()\n\n # Load the configuration file file\n self.load()","def __init__(self):\n default_config = Config()\n query = Query(default_config)\n database = Database(default_config)\n common_util = CommonUtil(default_config, database)\n self.config = default_config\n self.query = query\n self.database = database\n self.common_util = common_util","def __init__(self, config_file, log_config_file):\n self._config = Config(config_file)\n if self._config.load() is None:\n print(\"Failed to load configuration.\\n\")\n sys.exit(-1)\n\n # Setup logging.\n self._logger = setup_logger('s3replicationmanager', log_config_file)\n if self._logger is None:\n print(\"Failed to configure logging.\\n\")\n sys.exit(-1)\n\n self._config.print_with(self._logger)\n\n self._jobs = Jobs(self._logger, \"all-jobs\")\n self._subscribers = Subscribers()","def __init__(self, **user_options):\n self.options = config.default_options.copy()\n self.configure(**user_options)","def config(self):\n pass","def config(self):\n pass","def __init__(self, config_file = 'config.yaml'):\n\n self.name = ''\n self.img_dir = ''\n self.out_dir = ''\n self.cam_file = ''\n self.options_file = ''\n self.output_xml_file = ''\n\n # If there is an options file, it will overwrite the defaults \n if config_file is not None:\n self.load(config_file)","def __initConfiguration(self):\n conf = configparser.ConfigParser()\n with open(self.configFile, \"r\") as f:\n conf.readfp(f)\n self.orgConf = conf\n # check additionalSection\n adSection = self.additionalSection\n if adSection in conf:\n adSection = conf[adSection]\n self.conf = {}\n for i in [self.CLIENT_ID, self.CLIENT_SECRET, self.AUTHZ_ENDPOINT,\n self.TOKEN_ENDPOINT, self.REDIRECT_URI, self.SCOPE]:\n if adSection != None and i in adSection:\n self.conf[i] = adSection[i]\n else:\n self.conf[i] = conf[\"DEFAULT\"][i]"],"string":"[\n \"def __init__(self, *args, **kwargs):\\r\\n super().__init__()\\r\\n self._cfg = ConfigDict() # current configuration\\r\\n self._default_config = ConfigDict() # default configuration\\r\\n self._temp_config = OrderedDict() # temporary configuration\\r\\n self._path = Path() # current configuration path\\r\\n self._default_path = Path() # default configuration path\\r\\n self._conversion_dict = None\\r\\n self._auto_cast = None\\r\\n self._write_flags = None\\r\\n self._force_load = None\\r\\n self._load_empty = None\\r\\n self._ask_path = None\\r\\n self._search_in_default_config = None\\r\\n self._init_count = 0\\r\\n self._policies = defaultdict(bool) # by default every modification is forbidden # WIP\\r\\n if args or kwargs:\\r\\n self.init(*args, **kwargs)\\r\\n logger.debug(\\\"Config object created.\\\")\",\n \"def __init__(self, config: Dict[str, Any]) -> None:\\n self.config = config\",\n \"def __init__(self, config_dict: dict):\\n self._config = config_dict\",\n \"def __init__(self):\\n self.__parameters: ConfigParams = ConfigParams()\",\n \"def __init__(self, config):\\n\\n self.config = config\",\n \"def __init__(self, config: str) -> None:\\n self.configuration = config\",\n \"def __init__(self, config: str) -> None:\\n self.configuration = config\",\n \"def __init__(self, config: dict) -> None:\\n super().__init__(config)\",\n \"def __init__(self, config):\\n self.config = config\",\n \"def __init__(self, config):\\n self.config = config\",\n \"def __init__(self, config):\\n self.config = config\",\n \"def __init__(self, config=None):\\n pass\",\n \"def __init__(self):\\n self.config = {}\",\n \"def __init__(self, config, cfg):\\n self.config = config\\n self.cfg = cfg\",\n \"def init_config(self):\\n pass\",\n \"def __init__(self, config: Optional[Config] = None):\\n self.config = config or Config()\",\n \"def __init__(self) -> None:\\n self.config: dict[str, str | int] = {}\",\n \"def __init__(self, configs):\\n\\n self.__configs = configs\",\n \"def init_config() -> Config:\\n ...\",\n \"def __init__(self):\\n # Read configuration into dictionary\\n self.directories = general.config_directories()\\n self.config = general.read_yaml_files(self.directories)\",\n \"def initialize_from_config(self):\",\n \"def __init__(self, *args, **kwargs):\\n wrap = lambda v: Config(v) if type(v) is dict else v\\n kvdict = {k: wrap(v) for k, v in dict(*args, **kwargs).items()}\\n super(Config, self).__init__(kvdict)\\n self.__dict__ = self\",\n \"def __init__(self):\\n\\n if Config._instance:\\n raise Exception('Config singleton is already instantiated. User Config.get_instance() obtain it.')\\n\\n parser = configparser.ConfigParser()\\n parser.read('C:\\\\\\\\Users\\\\\\\\Akatosh\\\\\\\\PythonProjects\\\\\\\\note-it\\\\\\\\config\\\\\\\\config.ini')\\n\\n self.sections = {}\\n\\n for section in parser:\\n self.sections[section] = _Section(parser[section])\\n\\n Config._instance = self\",\n \"def __init__(self, config):\\n raise NotImplementedError (\\\"This is just an abstract interface\\\")\",\n \"def __init__(self, config):\\n\\n self.root = config.root\\n self.pidfile = config.pidfile\\n self.log_conf = config.logging\",\n \"def _init_config_(self):\\n self._config= {}\",\n \"def __init__(self):\\n\\n self.path = os.path.dirname(os.path.realpath(__file__)) + '/config.ini'\\n self.config = configparser.ConfigParser()\\n self.config.read(self.path)\",\n \"def __init__(self, config: Tuple):\",\n \"def initialize(self, **kwargs):\\n\\n # Defining the configuration object\\n self.config = kwargs.get('config')\",\n \"def __init__(self, config_file_name=\\\"config.json\\\"):\\n self.config_file_name = config_file_name\\n self._config = self._open_config_file()\",\n \"def __init__(self, config_path, normalize=False):\\n self.config = {}\\n _config_dict = {}\\n self._config_path = Utils.expand_path(config_path)\\n self.update = None\\n self.normalize = normalize\",\n \"def config_init(self):\\n\\n game_opts = [\\n\\n # Execution Options\\n ('debug',False), # Toggle Debug Messaging\\n ('log_path',False), # Turn on logging (w/path)\\n ('log_lvl',logging.DEBUG), # Set log level\\n\\n # World Generation Options\\n ('flex_limit',3) # Sets the maximum variance\\n\\n ]\\n\\n # Attempts to pull each value from the configuration\\n # if not in config, the default value defined above\\n # is set instead\\n for opt in game_opts:\\n try:\\n setattr(self,opt[0],self.conf.conf_dict[opt[0]])\\n except:\\n setattr(self,opt[0],opt[1])\\n continue\",\n \"def Init(self, config):\\r\\n pass\",\n \"def __init__(self):\\n ConfigParser.RawConfigParser.OPTCRE = re.compile(r'(?P<option>[^=\\\\s][^=]*)\\\\s*(?P<vi>[=])\\\\s*(?P<value>.*)$')\\n self.CONFIG = ConfigParser.ConfigParser()\\n self.CONFIG.read(os.path.join(os.path.dirname(__file__)))\\n self.IPS = []\",\n \"def __init__(self, configuration):\\n self._config = configuration\",\n \"def __init__(self, cfg=None):\\n if cfg is None:\\n cfg = {}\\n\\n self.cfg = cfg\",\n \"def __init__(self, config):\\n super().__init__(config)\\n self.collector_host = config.get(\\\"collector_host\\\")\\n self.schedds = config.get(\\\"schedds\\\", [None])\\n self.condor_config = config.get(\\\"condor_config\\\")\\n self.constraint = config.get(\\\"constraint\\\", True)\\n self.classad_attrs = config.get(\\\"classad_attrs\\\")\\n self.correction_map = config.get(\\\"correction_map\\\")\",\n \"def __init__(self, config):\\n\\n self.locations_hltv_starting_ = config[sC.BUCKET_LOCATIONS][sC.HLTV_STARTING]\\n self.score_starting_ = config[sC.BUCKET_LOCATIONS][sC.SCORE_STARTING]\\n self.logs_starting_ = config[sC.BUCKET_LOCATIONS][sC.LOGS_STARTING]\\n self.temp = config[sC.FOLDER_LOCATIONS][sC.TEMP_APP_ENGINE_FOLDER]\\n self.results_ = config[sC.FOLDER_LOCATIONS][sC.CONFIGS_RESULTS]\\n self.amxmodx_logs_ = config[sC.FOLDER_LOCATIONS][sC.ADDONS_AMXMODX_LOGS]\\n self.cstrike_logs_ = config[sC.FOLDER_LOCATIONS][sC.CSTRIKE_LOGS]\\n self.hltv_demos_func_url = config[sC.CLOUD_FUNCTIONS_URLS][sC.HLTV_DEMOS_FUNC]\\n self.ftp_logs_func_url = config[sC.CLOUD_FUNCTIONS_URLS][sC.FTP_LOGS_FUNC]\\n\\n print('{} - Initialized'.format(__name__))\",\n \"def __init__(self, cfg=None, **kwargs):\\n self.__dir = KITConfig.configDir\\n self.__cfgFile = \\\"\\\"\\n\\n self.__cfg = {}\\n self.__default = KITConfig.defaultConfig\\n\\n self.__setupLogger()\\n\\n if cfg is not None:\\n self.__cfgFile = cfg\\n self.load(cfg)\",\n \"def __init__(self):\\n parameters_list = []\\n self.config_dict = self.open_config(parameters_list)\\n\\n # Define defaults\\n self.disc_gt = 0.0\\n self.disc_out = 0.0\",\n \"def __init__(self, config_entry):\\n self.config_entry = config_entry\",\n \"def __init__(self, config_entry):\\n self.config_entry = config_entry\",\n \"def __init__(self):\\n self.collectorName = COLLECTOR_NAME\\n self.configCycleInterval = 20 # minutes\\n self.cycleInterval = 5 * 60 # seconds\\n\\n # The configurationService attribute is the fully qualified class-name\\n # of our configuration service that runs within ZenHub\\n self.configurationService = 'NullConfig'\\n\\n # Will be filled in based on buildOptions\\n self.options = None\\n\\n self.configCycleInterval = 20*60\",\n \"def init(self, *args, **kwargs):\\n try:\\n self._init(*args, **kwargs)\\n except (ValueError, TypeError, UnicodeError, ConfigParser.Error), exc:\\n raise ConfigInvalidError, str(exc), sys.exc_info()[2]\",\n \"def __init__(self, config_file, verbose):\\r\\n self.loadConfig(config_file)\\r\\n self.verbose = verbose\",\n \"def __init__(self, config, logger):\\n self.config = config\\n self.logger = logger\",\n \"def __init__(self, configs: Union[Config, Dict[str, Any]]):\\n self.configs: Config = Config(configs, None, allow_new_hparam=True)\",\n \"def __init__(self, conf=None):\\n # set interpolation to None so you can supply filename template\\n # that contain % to config.set\\n conf = ConfigParser(strict=False,\\n inline_comment_prefixes=(';',),\\n interpolation=None) if (conf is None) else conf\\n super().__init__(conf)\\n self._cycle = None\\n self._logger = logging.getLogger('metplus')\\n # config.logger is called in wrappers, so set this name\\n # so the code doesn't break\\n self.logger = self._logger\\n\\n # get the OS environment and store it\\n self.env = os.environ.copy()\\n\\n # add section to hold environment variables defined by the user\\n self.add_section('user_env_vars')\",\n \"def _init_config(self, configPath=None):\\n # TODO: The SafeConfigParser class has been renamed to ConfigParser in Python 3.2.\\n # This alias will be removed in future versions.\\n # We still use SafeConfigParser for backwards compatibility with Python 2.\\n self.config = SafeConfigParser()\\n # Make option names case sensitive\\n self.config.optionxform = str\\n\\n if configPath and os.path.isdir(configPath):\\n configDir = configPath\\n else:\\n configDir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'conf')\\n\\n # List filenames in configDir alphabetically\\n _, _, configFiles = next(os.walk(configDir))\\n configFiles = sorted(configFiles, key=str.lower)\\n\\n # Read configuration pipeline\\n for f in configFiles:\\n with open(os.path.join(configDir, f)) as configFile:\\n self.config.readfp(configFile)\\n self._store_config_pass()\\n\\n if configPath and os.path.isfile(configPath):\\n self.config.read(configPath)\\n self._store_config_pass()\\n\\n appSection = 'application'\\n self.appName = self._get_option_value(appSection, 'appName')\\n self.appResource = self._get_option_value(appSection, 'appResource')\\n self.appArgs = []\\n appArgs = self._get_option_value(appSection, 'appArgs')\\n if appArgs:\\n self.appArgs = appArgs.split(' ')\\n self.mainClass = self._get_option_value(appSection, 'mainClass')\",\n \"def __init__(self, name=None):\\n self.name = name or \\\"default\\\"\\n config_path = os.path.join(get_config_directory(), self.name + JSON)\\n try:\\n with open(config_path, mode='r') as config_file:\\n self.config_dict = json.load(config_file)\\n except Exception as ex:\\n raise ColinConfigException(\\\"Config file '{}' cannot be loaded.\\\".format(config_path))\",\n \"def __init__(self, config_file):\\n with open(config_file, 'r') as file:\\n self.config = json.load(file)\\n self.set_config(self.config)\",\n \"def __new__(cls, *args, **kwargs):\\n if not cls._instance:\\n cls._instance = super(Config, cls).__new__(cls)\\n return cls._instance\",\n \"def __init__(self, filename=None):\\n if filename:\\n if not os.path.exists(filename):\\n raise Exception(\\\"No configuration found at %s\\\" % filename)\\n super(Configuration, self).__init__(filename)\",\n \"def __init__(self, config_entry: config_entries.ConfigEntry) -> None:\\n self.config_entry = config_entry\",\n \"def __init__(self, settings):\\n self._read_config(settings)\",\n \"def create_config(self) -> None:\\n pass\",\n \"def create_config(self) -> None:\\n pass\",\n \"def __init__(self):\\n\\n self.config = load_config()\\n self.set_env_var()\",\n \"def __init__(self, config_file):\\n \\n self.log = logging.getLogger(__name__)\\n\\n self.parser = ConfigParser.ConfigParser()\\n if os.path.exists(config_file) and os.path.isfile(config_file):\\n self.parser.read(config_file)\\n self.log.debug(\\\"opened configuration '%s'\\\" % config_file)\\n else:\\n raise ConfigError(\\\"Config file missing\\\", \\\"File '%s' doesn't exist.\\\" % (config_file))\\n\\n self.config_file = config_file\\n self.check_config()\",\n \"def __init__(self):\\n\\t\\t\\n\\t\\tsettings = configparser.SafeConfigParser(allow_no_value=True)\\n\\t\\tlist=settings.read('data/settings.cfg')\\n\\t\\tif not 'data/settings.cfg' in list:\\n\\t\\t\\tprint('no configuration file present.. making one')\\n\\t\\t\\tself.makeConfigFile(settings)\\n\\t\\t\\tshare = ['']\\n\\t\\t\\tself.nodes = []\\n\\t\\telse:\\n\\t\\t\\tshare, nodes = self.openConfig(settings)\\n\\t\\t\\tself.nodes = nodes\\n\\t\\t\\n\\t\\t\\n\\t\\tself.files = self.loadFiles(share)\\t\\t\\n\\t\\tself.share = share\\n\\t\\tself.kill= False\\n\\t\\tself.downloads = {}\\n\\t\\tself.currentVersion = (0,2,1)\\n\\t\\tself.totalDownloads = 0\\n\\t\\tself.current = 0\\n\\t\\tself.config = settings\",\n \"def __init__(self, userconfig=None):\\n configspec = _get_configspec()\\n self._configspec = ConfigObj(configspec, interpolation=False,\\n list_values=False, _inspec=True)\\n configs_default = ConfigObj(interpolation=False,\\n configspec=self._configspec)\\n self._config = self._validate(configs_default)\\n if userconfig:\\n self.read_userconfig(userconfig)\",\n \"def __init__(self, config_file=None):\\n\\t\\tself.options = {}\\n\\n\\t\\tif config_file:\\n\\t\\t\\tself.set_file(config_file)\",\n \"def config():\\n return Config()\",\n \"def config():\\n return Config()\",\n \"def __init__(self):\\n self.filename = pathlib.Path(__file__).parent.absolute().__str__() + '/../../data/config.ini'\\n self.data = ConfigParser()\\n self.data.read(self.filename)\",\n \"def __init__(self, config_file):\\n Config = ConfigParser.ConfigParser()\\n Config.read(config_file)\\n \\n self.port_id = Config.get(\\\"SerialPortSection\\\", \\\"ComPort\\\")\\n self.baud_rate = Config.get(\\\"SerialPortSection\\\", \\\"BaudRate\\\")\\n self. timeout = Config.get(\\\"SerialPortSection\\\", \\\"TimeOut\\\")\\n self.config_file = config_file\",\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, load_config):\\n super().__init__()\\n self._load_config = load_config\",\n \"def init(cls, config, src):\\n cls.config = config\",\n \"def __init__(self):\\n self.__default_config = ConfigParams.from_tuples(\\n 'options.max_pool_size', 2,\\n 'options.connect_timeout', 5000,\\n 'options.auto_reconnect', True,\\n 'options.max_page_size', 100,\\n 'options.debug', True\\n )\\n\\n # The logger\\n self._logger: CompositeLogger = CompositeLogger()\\n # The connection resolver\\n self._connection_resolver: MongoDbConnectionResolver = MongoDbConnectionResolver()\\n # The configuration options.\\n self._options: ConfigParams = ConfigParams()\\n # The MongoDB connection object.\\n self._connection: pymongo.MongoClient = None\\n # The MongoDB database name.\\n self._database_name: str = None\\n # The MongoDb database object.\\n self._db: database.Database = None\",\n \"def __init__(self, path_to_config_file):\\n self.file_path = path_to_config_file\",\n \"def _new():\\n\\treturn ConfigParser(\\n\\tdelimiters = ('=',),\\n\\tcomment_prefixes = ('#', ';'),\\n\\tdefault_section = 'default',\\n\\tallow_no_value = False,\\n\\tstrict = False,\\n\\tinterpolation = ExtendedInterpolation(),\\n\\tdefaults = {\\n\\t\\t'debug': False,\\n\\t\\t'datadir': path.join(path.expanduser('~'), '.local', 'rosshm'),\\n\\t\\t'log.level': 'warn',\\n\\t\\t'core.enable': True,\\n\\t\\t'db.driver': 'sqlite',\\n\\t\\t'db.name': 'rosshmdb',\\n\\t\\t'db.config': '',\\n\\t\\t'static.enable': True,\\n\\t\\t'web.enable': True,\\n\\t},\\n)\",\n \"def __init__(self, config):\\n self.conf = dict( timeout=60\\n , logfile=''\\n , ip_addr='192.168.0.220'\\n , username='admin'\\n , password='admin'\\n , prompt=\\\"Cursor\\\"\\n , init=False\\n , debug=0\\n , recv_pause=0.25\\n , waitfor=300\\n , pause=2\\n , stdout=1\\n , ping_timeout=10\\n )\\n self.conf.update(config)\\n (self.exp_state, self.exp_output, self.exp_recv_cnt) = ('', '', 0)\\n if self.conf['init']: self.initialize()\",\n \"def __init__(self, config, well, directory):\\n self.config = config\\n self.well = well\\n self.directory = directory\",\n \"def __init__(self, **kwargs):\\n cls = self.__class__\\n\\n # Initialize all configurables and input arguments\\n for arg in cls.configurables():\\n try: # Read from class constructor\\n setattr(self, arg, kwargs[arg])\\n except KeyError:\\n try: # Set from default value defined in class\\n default_value = getattr(self, arg).kwargs[\\\"default\\\"]\\n setattr(self, arg, default_value)\\n except KeyError: # if nothing is provided, fallbakcs to None\\n setattr(self, arg, None)\\n\\n self.input_arguments = None\\n if cls.input_configurables():\\n self.input_arguments = [\\n getattr(self, arg) for arg in cls.input_configurables()\\n ]\\n\\n self.json_config = cfg.JsonConfig(self.config)\\n self.output_objects = []\\n self.file = None\",\n \"def __init__(self, config_file=None):\\n self.file = config_file\\n self.parser = SafeConfigParser()\\n if isinstance(self.file, (str, list)):\\n self.parser.read(self.file)\\n else: # assume file object was given instead\\n self.parser.read_file(self.file)\\n self._flask_cache = None\\n self._assets_cache = None\\n self._gridrealm_cache = None\",\n \"def __init__(self, environment='develop'):\\n\\n cwd = path.dirname(path.abspath(__file__))\\n config_dir = path.join(cwd, 'configs')\\n\\n config_files = []\\n for (root, _, file_names) in walk(config_dir):\\n for file_name in file_names:\\n config_files.append(path.join(root, file_name))\\n config_files = sorted(config_files)\\n\\n for config_file in config_files:\\n config = anyconfig.load(config_file)\\n for key in config:\\n self[key] = config[key]\\n\\n if environment in config_file:\\n break\",\n \"def __init__(self, config, town):\\n\\t\\tself.config = config\",\n \"def __init__(self):\\n\\n # open json config file that reads in information\\n config_path = open(\\\"config.json\\\", \\\"r\\\")\\n config_json = config_path.read()\\n config_dict = json.loads(config_json)\\n\\n # assign object variables\\n self.project_id = config_dict[\\\"project-id\\\"]\\n self.bucket_name = config_dict[\\\"bucket-name\\\"]\\n self.location_id = config_dict[\\\"key-location\\\"]\\n self.key_ring_id = config_dict[\\\"key-ring-id\\\"]\\n self.crypto_key_id = config_dict[\\\"crypto-key-id\\\"]\\n self.service_account_email = config_dict[\\\"service-account-email\\\"]\\n\\n # close the file\\n config_path.close()\",\n \"def __init__(self, config=None, broker=None):\\n pass\",\n \"def __init__(self, config_path=None):\\n self.config_path = None\\n\\n config_path = config_path or CONF.api_paste_config\\n if not os.path.isabs(config_path):\\n self.config_path = CONF.find_file(config_path)\\n elif os.path.exists(config_path):\\n self.config_path = config_path\\n\\n if not self.config_path:\\n raise exception.ConfigNotFound(path=config_path)\",\n \"def __init__(self, ini_file):\\n self.config = configparser.ConfigParser()\\n self.config.read(ini_file)\",\n \"def __init__(self, config_name: str, is_top_level_config: bool = False):\\n self.config_name = config_name\\n self.config_variable_name = to_snake_case(config_name) + \\\"_config\\\"\\n self.is_top_level_config = is_top_level_config\\n self.parameters: List[CppParameter] = list()\\n self.configs: List[CppConfig] = list()\",\n \"def __init__(self, config_path: str = \\\"config.json\\\"):\\n # Change here if you want to relocate you config file\\n self.config = {}\\n self.load_configuration(config_path)\\n self.app_name = self.config.get('app_name', self.APP_NAME)\",\n \"def __init__(self):\\n self.database = Database()\\n self.load_config()\",\n \"def __init__(self, config, loop):\\n self.config = config\\n self.loop = loop\",\n \"def __init__(self, config_directory: Optional[pathlib.Path] = None):\\n self._config_parser = configparser.ConfigParser()\\n # Preserve case for keys.\\n self._config_parser.optionxform = lambda x: x\\n\\n if config_directory is None:\\n self._config_filepath = pathlib.Path(_KFP_CONFIG_FILE)\\n else:\\n self._config_filepath = config_directory / _KFP_CONFIG_FILE\\n\\n try:\\n with open(str(self._config_filepath), 'r') as f:\\n self._config_parser.read_file(f)\\n except IOError:\\n warnings.warn('No existing KFP Config file found')\\n\\n if not self._config_parser.has_section(_COMPONENTS_SECTION):\\n self._config_parser.add_section(_COMPONENTS_SECTION)\\n\\n self._components = {}\",\n \"def __init__(self, config_directory, scale_override=None):\\n self._config_directory = config_directory\\n\\n self._config_detector = DetectorConfig(config_directory)\\n self._config_align = AlignConfig(config_directory, scale_override=scale_override)\\n self._config_crystal = CrystalMatchConfig(config_directory)\",\n \"def __init__(self, ini_file):\\n self.config = configparser.ConfigParser()\\n self.config.read(ini_file)\\n #print(self.config)\",\n \"def __init__(self, config: str, wdir=os.getcwd()):\\n\\n self.config_path = config\\n self.wdir = wdir\\n\\n with open(self.config_path) as fin:\\n self.config_dic = yaml.load(fin, Loader=yaml.BaseLoader)\\n\\n # default is 00 for all interaction types\\n self.config_parameters_dic = None\\n\\n # This parameter defines whether self_loops will be kept or not\\n self.self_loops = True\\n if 'self_loops' in self.config_dic:\\n self.self_loops = bool(int(self.config_dic['self_loops']))\",\n \"def __init__(self) -> None:\\n\\n self.config_keys = ['APPS_HOST', 'APPS_PORT']\\n super().__init__()\\n\\n self.APPS_HOST = str(self.APPS_HOST)\\n \\\"\\\"\\\"Host where the server will be served\\\"\\\"\\\"\\n\\n self.APPS_PORT = int(self.APPS_PORT)\\n \\\"\\\"\\\"Port where the server will be served\\\"\\\"\\\"\",\n \"def __init__(self, config_entry: config_entries.ConfigEntry) -> None:\\n self.config_entry = config_entry\\n self.options = dict(config_entry.options)\",\n \"def __init__(self):\\n self.storefn = Config.getConfigFnPath()\\n\\n # Load the configuration file file\\n self.load()\",\n \"def __init__(self):\\n default_config = Config()\\n query = Query(default_config)\\n database = Database(default_config)\\n common_util = CommonUtil(default_config, database)\\n self.config = default_config\\n self.query = query\\n self.database = database\\n self.common_util = common_util\",\n \"def __init__(self, config_file, log_config_file):\\n self._config = Config(config_file)\\n if self._config.load() is None:\\n print(\\\"Failed to load configuration.\\\\n\\\")\\n sys.exit(-1)\\n\\n # Setup logging.\\n self._logger = setup_logger('s3replicationmanager', log_config_file)\\n if self._logger is None:\\n print(\\\"Failed to configure logging.\\\\n\\\")\\n sys.exit(-1)\\n\\n self._config.print_with(self._logger)\\n\\n self._jobs = Jobs(self._logger, \\\"all-jobs\\\")\\n self._subscribers = Subscribers()\",\n \"def __init__(self, **user_options):\\n self.options = config.default_options.copy()\\n self.configure(**user_options)\",\n \"def config(self):\\n pass\",\n \"def config(self):\\n pass\",\n \"def __init__(self, config_file = 'config.yaml'):\\n\\n self.name = ''\\n self.img_dir = ''\\n self.out_dir = ''\\n self.cam_file = ''\\n self.options_file = ''\\n self.output_xml_file = ''\\n\\n # If there is an options file, it will overwrite the defaults \\n if config_file is not None:\\n self.load(config_file)\",\n \"def __initConfiguration(self):\\n conf = configparser.ConfigParser()\\n with open(self.configFile, \\\"r\\\") as f:\\n conf.readfp(f)\\n self.orgConf = conf\\n # check additionalSection\\n adSection = self.additionalSection\\n if adSection in conf:\\n adSection = conf[adSection]\\n self.conf = {}\\n for i in [self.CLIENT_ID, self.CLIENT_SECRET, self.AUTHZ_ENDPOINT,\\n self.TOKEN_ENDPOINT, self.REDIRECT_URI, self.SCOPE]:\\n if adSection != None and i in adSection:\\n self.conf[i] = adSection[i]\\n else:\\n self.conf[i] = conf[\\\"DEFAULT\\\"][i]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8203434","0.7962474","0.78200513","0.77837414","0.77558804","0.77334917","0.77334917","0.7729926","0.7703412","0.7703412","0.7703412","0.7694449","0.7644489","0.7622834","0.75704795","0.7559002","0.754742","0.75234354","0.75190806","0.74873096","0.7462494","0.7439778","0.74078375","0.7365843","0.7317262","0.7299957","0.7277268","0.72679234","0.72675955","0.72636247","0.725348","0.7241625","0.7238692","0.714317","0.7140095","0.71238536","0.7117453","0.70930606","0.7080537","0.7079229","0.7068156","0.7068156","0.70346344","0.70273846","0.70235217","0.70089227","0.70030105","0.70023495","0.6960768","0.69591624","0.6955141","0.6936373","0.69220245","0.69189006","0.69123346","0.6906409","0.6906409","0.6901492","0.68945926","0.6893016","0.68837863","0.6878797","0.687846","0.687846","0.68779546","0.6872583","0.6839872","0.683661","0.6836073","0.6835405","0.68353206","0.68340117","0.6821051","0.6808765","0.68015224","0.68007","0.6785903","0.67739147","0.67595184","0.6758853","0.6757474","0.673611","0.6731681","0.67313457","0.67267287","0.6720677","0.67195946","0.67115957","0.6706078","0.66941845","0.6687704","0.6683256","0.6670862","0.6667564","0.6665597","0.66647226","0.6658989","0.6658989","0.6644963","0.6644274"],"string":"[\n \"0.8203434\",\n \"0.7962474\",\n \"0.78200513\",\n \"0.77837414\",\n \"0.77558804\",\n \"0.77334917\",\n \"0.77334917\",\n \"0.7729926\",\n \"0.7703412\",\n \"0.7703412\",\n \"0.7703412\",\n \"0.7694449\",\n \"0.7644489\",\n \"0.7622834\",\n \"0.75704795\",\n \"0.7559002\",\n \"0.754742\",\n \"0.75234354\",\n \"0.75190806\",\n \"0.74873096\",\n \"0.7462494\",\n \"0.7439778\",\n \"0.74078375\",\n \"0.7365843\",\n \"0.7317262\",\n \"0.7299957\",\n \"0.7277268\",\n \"0.72679234\",\n \"0.72675955\",\n \"0.72636247\",\n \"0.725348\",\n \"0.7241625\",\n \"0.7238692\",\n \"0.714317\",\n \"0.7140095\",\n \"0.71238536\",\n \"0.7117453\",\n \"0.70930606\",\n \"0.7080537\",\n \"0.7079229\",\n \"0.7068156\",\n \"0.7068156\",\n \"0.70346344\",\n \"0.70273846\",\n \"0.70235217\",\n \"0.70089227\",\n \"0.70030105\",\n \"0.70023495\",\n \"0.6960768\",\n \"0.69591624\",\n \"0.6955141\",\n \"0.6936373\",\n \"0.69220245\",\n \"0.69189006\",\n \"0.69123346\",\n \"0.6906409\",\n \"0.6906409\",\n \"0.6901492\",\n \"0.68945926\",\n \"0.6893016\",\n \"0.68837863\",\n \"0.6878797\",\n \"0.687846\",\n \"0.687846\",\n \"0.68779546\",\n \"0.6872583\",\n \"0.6839872\",\n \"0.683661\",\n \"0.6836073\",\n \"0.6835405\",\n \"0.68353206\",\n \"0.68340117\",\n \"0.6821051\",\n \"0.6808765\",\n \"0.68015224\",\n \"0.68007\",\n \"0.6785903\",\n \"0.67739147\",\n \"0.67595184\",\n \"0.6758853\",\n \"0.6757474\",\n \"0.673611\",\n \"0.6731681\",\n \"0.67313457\",\n \"0.67267287\",\n \"0.6720677\",\n \"0.67195946\",\n \"0.67115957\",\n \"0.6706078\",\n \"0.66941845\",\n \"0.6687704\",\n \"0.6683256\",\n \"0.6670862\",\n \"0.6667564\",\n \"0.6665597\",\n \"0.66647226\",\n \"0.6658989\",\n \"0.6658989\",\n \"0.6644963\",\n \"0.6644274\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69338214"},"document_rank":{"kind":"string","value":"52"}}},{"rowIdx":174,"cells":{"query":{"kind":"string","value":"r\"\"\"Class constructor for Config"},"document":{"kind":"string","value":"def __init__(self, config_file_name=\"config.json\"):\n self.config_file_name = config_file_name\n self._config = self._open_config_file()"},"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, config: Dict[str, Any]) -> None:\n self.config = config","def __init__(self, *args, **kwargs):\r\n super().__init__()\r\n self._cfg = ConfigDict() # current configuration\r\n self._default_config = ConfigDict() # default configuration\r\n self._temp_config = OrderedDict() # temporary configuration\r\n self._path = Path() # current configuration path\r\n self._default_path = Path() # default configuration path\r\n self._conversion_dict = None\r\n self._auto_cast = None\r\n self._write_flags = None\r\n self._force_load = None\r\n self._load_empty = None\r\n self._ask_path = None\r\n self._search_in_default_config = None\r\n self._init_count = 0\r\n self._policies = defaultdict(bool) # by default every modification is forbidden # WIP\r\n if args or kwargs:\r\n self.init(*args, **kwargs)\r\n logger.debug(\"Config object created.\")","def __init__(self):\n self.__parameters: ConfigParams = ConfigParams()","def __init__(self, config: str) -> None:\n self.configuration = config","def __init__(self, config: str) -> None:\n self.configuration = config","def __init__(self, config):\n\n self.config = config","def __init__(self, config=None):\n pass","def __init__(self) -> None:\n self.config: dict[str, str | int] = {}","def __init__(self, config_dict: dict):\n self._config = config_dict","def __init__(self, config):\n self.config = config","def __init__(self, config):\n self.config = config","def __init__(self, config):\n self.config = config","def __init__(self, config: dict) -> None:\n super().__init__(config)","def __init__(self, config, cfg):\n self.config = config\n self.cfg = cfg","def __init__(self, *args, **kwargs):\n wrap = lambda v: Config(v) if type(v) is dict else v\n kvdict = {k: wrap(v) for k, v in dict(*args, **kwargs).items()}\n super(Config, self).__init__(kvdict)\n self.__dict__ = self","def __init__(self):\n self.config = {}","def __init__(self, config: Optional[Config] = None):\n self.config = config or Config()","def __init__(self, config):\n raise NotImplementedError (\"This is just an abstract interface\")","def __init__(self, config: Tuple):","def __new__(cls, *args, **kwargs):\n if not cls._instance:\n cls._instance = super(Config, cls).__new__(cls)\n return cls._instance","def __init__(self, configs):\n\n self.__configs = configs","def initialize_from_config(self):","def __init__(self):\n\n if Config._instance:\n raise Exception('Config singleton is already instantiated. User Config.get_instance() obtain it.')\n\n parser = configparser.ConfigParser()\n parser.read('C:\\\\Users\\\\Akatosh\\\\PythonProjects\\\\note-it\\\\config\\\\config.ini')\n\n self.sections = {}\n\n for section in parser:\n self.sections[section] = _Section(parser[section])\n\n Config._instance = self","def __init__(self, configuration):\n self._config = configuration","def __init__(self):\n ConfigParser.RawConfigParser.OPTCRE = re.compile(r'(?P<option>[^=\\s][^=]*)\\s*(?P<vi>[=])\\s*(?P<value>.*)$')\n self.CONFIG = ConfigParser.ConfigParser()\n self.CONFIG.read(os.path.join(os.path.dirname(__file__)))\n self.IPS = []","def __init__(self):\n # Read configuration into dictionary\n self.directories = general.config_directories()\n self.config = general.read_yaml_files(self.directories)","def __init__(self, config_entry):\n self.config_entry = config_entry","def __init__(self, config_entry):\n self.config_entry = config_entry","def __init__(self, config):\n super().__init__(config)\n self.collector_host = config.get(\"collector_host\")\n self.schedds = config.get(\"schedds\", [None])\n self.condor_config = config.get(\"condor_config\")\n self.constraint = config.get(\"constraint\", True)\n self.classad_attrs = config.get(\"classad_attrs\")\n self.correction_map = config.get(\"correction_map\")","def __init__(self):\n\n self.path = os.path.dirname(os.path.realpath(__file__)) + '/config.ini'\n self.config = configparser.ConfigParser()\n self.config.read(self.path)","def __init__(self, config_file, verbose):\r\n self.loadConfig(config_file)\r\n self.verbose = verbose","def init_config() -> Config:\n ...","def __init__(self, config_path, normalize=False):\n self.config = {}\n _config_dict = {}\n self._config_path = Utils.expand_path(config_path)\n self.update = None\n self.normalize = normalize","def __init__(self, config):\n\n self.root = config.root\n self.pidfile = config.pidfile\n self.log_conf = config.logging","def _new():\n\treturn ConfigParser(\n\tdelimiters = ('=',),\n\tcomment_prefixes = ('#', ';'),\n\tdefault_section = 'default',\n\tallow_no_value = False,\n\tstrict = False,\n\tinterpolation = ExtendedInterpolation(),\n\tdefaults = {\n\t\t'debug': False,\n\t\t'datadir': path.join(path.expanduser('~'), '.local', 'rosshm'),\n\t\t'log.level': 'warn',\n\t\t'core.enable': True,\n\t\t'db.driver': 'sqlite',\n\t\t'db.name': 'rosshmdb',\n\t\t'db.config': '',\n\t\t'static.enable': True,\n\t\t'web.enable': True,\n\t},\n)","def __init__(self, cfg=None):\n if cfg is None:\n cfg = {}\n\n self.cfg = cfg","def __init__(self, config_file_name=\"config.json\"):\n with open(config_file_name, \"r\") as config:\n f = dict(json.load(config))\n for key, value in f.items():\n setattr(self, key, value)","def __init__(self, config_file=None):\n\t\tself.options = {}\n\n\t\tif config_file:\n\t\t\tself.set_file(config_file)","def __init__(self, path_to_config_file):\n self.file_path = path_to_config_file","def __init__(self, config_file):\n with open(config_file, 'r') as file:\n self.config = json.load(file)\n self.set_config(self.config)","def __init__(self, config, logger):\n self.config = config\n self.logger = logger","def __init__(self, configs: Union[Config, Dict[str, Any]]):\n self.configs: Config = Config(configs, None, allow_new_hparam=True)","def init_config(self):\n pass","def config():\n return Config()","def config():\n return Config()","def __init__(self, config_file):\n Config = ConfigParser.ConfigParser()\n Config.read(config_file)\n \n self.port_id = Config.get(\"SerialPortSection\", \"ComPort\")\n self.baud_rate = Config.get(\"SerialPortSection\", \"BaudRate\")\n self. timeout = Config.get(\"SerialPortSection\", \"TimeOut\")\n self.config_file = config_file","def __init__(self, filename=None):\n if filename:\n if not os.path.exists(filename):\n raise Exception(\"No configuration found at %s\" % filename)\n super(Configuration, self).__init__(filename)","def __init__(self, conf=None):\n # set interpolation to None so you can supply filename template\n # that contain % to config.set\n conf = ConfigParser(strict=False,\n inline_comment_prefixes=(';',),\n interpolation=None) if (conf is None) else conf\n super().__init__(conf)\n self._cycle = None\n self._logger = logging.getLogger('metplus')\n # config.logger is called in wrappers, so set this name\n # so the code doesn't break\n self.logger = self._logger\n\n # get the OS environment and store it\n self.env = os.environ.copy()\n\n # add section to hold environment variables defined by the user\n self.add_section('user_env_vars')","def __init__(self, config_entry: config_entries.ConfigEntry) -> None:\n self.config_entry = config_entry","def __init__(self, name=None):\n self.name = name or \"default\"\n config_path = os.path.join(get_config_directory(), self.name + JSON)\n try:\n with open(config_path, mode='r') as config_file:\n self.config_dict = json.load(config_file)\n except Exception as ex:\n raise ColinConfigException(\"Config file '{}' cannot be loaded.\".format(config_path))","def initialize(self, **kwargs):\n\n # Defining the configuration object\n self.config = kwargs.get('config')","def __init__(self, config_name: str, is_top_level_config: bool = False):\n self.config_name = config_name\n self.config_variable_name = to_snake_case(config_name) + \"_config\"\n self.is_top_level_config = is_top_level_config\n self.parameters: List[CppParameter] = list()\n self.configs: List[CppConfig] = list()","def __init__(self):\n parameters_list = []\n self.config_dict = self.open_config(parameters_list)\n\n # Define defaults\n self.disc_gt = 0.0\n self.disc_out = 0.0","def __init__(self, config, town):\n\t\tself.config = config","def __init__(self, name, config):\n self.name = name\n self.config = config\n self.values = []","def config_init(self):\n\n game_opts = [\n\n # Execution Options\n ('debug',False), # Toggle Debug Messaging\n ('log_path',False), # Turn on logging (w/path)\n ('log_lvl',logging.DEBUG), # Set log level\n\n # World Generation Options\n ('flex_limit',3) # Sets the maximum variance\n\n ]\n\n # Attempts to pull each value from the configuration\n # if not in config, the default value defined above\n # is set instead\n for opt in game_opts:\n try:\n setattr(self,opt[0],self.conf.conf_dict[opt[0]])\n except:\n setattr(self,opt[0],opt[1])\n continue","def __init__(self, **kwargs):\n cls = self.__class__\n\n # Initialize all configurables and input arguments\n for arg in cls.configurables():\n try: # Read from class constructor\n setattr(self, arg, kwargs[arg])\n except KeyError:\n try: # Set from default value defined in class\n default_value = getattr(self, arg).kwargs[\"default\"]\n setattr(self, arg, default_value)\n except KeyError: # if nothing is provided, fallbakcs to None\n setattr(self, arg, None)\n\n self.input_arguments = None\n if cls.input_configurables():\n self.input_arguments = [\n getattr(self, arg) for arg in cls.input_configurables()\n ]\n\n self.json_config = cfg.JsonConfig(self.config)\n self.output_objects = []\n self.file = None","def __init__(self):\n self.collectorName = COLLECTOR_NAME\n self.configCycleInterval = 20 # minutes\n self.cycleInterval = 5 * 60 # seconds\n\n # The configurationService attribute is the fully qualified class-name\n # of our configuration service that runs within ZenHub\n self.configurationService = 'NullConfig'\n\n # Will be filled in based on buildOptions\n self.options = None\n\n self.configCycleInterval = 20*60","def __init__(self, config_entry: config_entries.ConfigEntry) -> None:\n self.config_entry = config_entry\n self.options = dict(config_entry.options)","def __init__(self, config, well, directory):\n self.config = config\n self.well = well\n self.directory = directory","def create_config(self) -> None:\n pass","def create_config(self) -> None:\n pass","def __init__(self, userconfig=None):\n configspec = _get_configspec()\n self._configspec = ConfigObj(configspec, interpolation=False,\n list_values=False, _inspec=True)\n configs_default = ConfigObj(interpolation=False,\n configspec=self._configspec)\n self._config = self._validate(configs_default)\n if userconfig:\n self.read_userconfig(userconfig)","def __init__(self, cfg=None, **kwargs):\n self.__dir = KITConfig.configDir\n self.__cfgFile = \"\"\n\n self.__cfg = {}\n self.__default = KITConfig.defaultConfig\n\n self.__setupLogger()\n\n if cfg is not None:\n self.__cfgFile = cfg\n self.load(cfg)","def load(self):\n\n class Config(object):\n pass\n\n for key, val in self.kwargs.items():\n setattr(Config, key, val)\n return Config","def __init__(self, config_path=None):\n self.config_path = None\n\n config_path = config_path or CONF.api_paste_config\n if not os.path.isabs(config_path):\n self.config_path = CONF.find_file(config_path)\n elif os.path.exists(config_path):\n self.config_path = config_path\n\n if not self.config_path:\n raise exception.ConfigNotFound(path=config_path)","def __init__(self, config_file=None):\n self.file = config_file\n self.parser = SafeConfigParser()\n if isinstance(self.file, (str, list)):\n self.parser.read(self.file)\n else: # assume file object was given instead\n self.parser.read_file(self.file)\n self._flask_cache = None\n self._assets_cache = None\n self._gridrealm_cache = None","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, ini_file):\n self.config = configparser.ConfigParser()\n self.config.read(ini_file)","def __init__(self, config_path=None):\n config_path = config_path or CONF.api_paste_config\n if os.path.exists(config_path):\n self.config_path = config_path\n else:\n self.config_path = CONF.find_file(config_path)","def __init__(self, config=None, broker=None):\n pass","def __init__(self, config):\n\n self.locations_hltv_starting_ = config[sC.BUCKET_LOCATIONS][sC.HLTV_STARTING]\n self.score_starting_ = config[sC.BUCKET_LOCATIONS][sC.SCORE_STARTING]\n self.logs_starting_ = config[sC.BUCKET_LOCATIONS][sC.LOGS_STARTING]\n self.temp = config[sC.FOLDER_LOCATIONS][sC.TEMP_APP_ENGINE_FOLDER]\n self.results_ = config[sC.FOLDER_LOCATIONS][sC.CONFIGS_RESULTS]\n self.amxmodx_logs_ = config[sC.FOLDER_LOCATIONS][sC.ADDONS_AMXMODX_LOGS]\n self.cstrike_logs_ = config[sC.FOLDER_LOCATIONS][sC.CSTRIKE_LOGS]\n self.hltv_demos_func_url = config[sC.CLOUD_FUNCTIONS_URLS][sC.HLTV_DEMOS_FUNC]\n self.ftp_logs_func_url = config[sC.CLOUD_FUNCTIONS_URLS][sC.FTP_LOGS_FUNC]\n\n print('{} - Initialized'.format(__name__))","def from_config(cls, config: Dict[str, Any]) -> \"ClassyLoss\":\n raise NotImplementedError()","def __init__(self, **user_options):\n self.options = config.default_options.copy()\n self.configure(**user_options)","def __init__(self, load_config):\n super().__init__()\n self._load_config = load_config","def config(self):\n raise NotImplementedError","def _from_config(cls, config, **kwargs):\n return cls(config, **kwargs)","def __init__(self, config_file = 'config.yaml'):\n\n self.name = ''\n self.img_dir = ''\n self.out_dir = ''\n self.cam_file = ''\n self.options_file = ''\n self.output_xml_file = ''\n\n # If there is an options file, it will overwrite the defaults \n if config_file is not None:\n self.load(config_file)","def __init__(self):\n self.filename = pathlib.Path(__file__).parent.absolute().__str__() + '/../../data/config.ini'\n self.data = ConfigParser()\n self.data.read(self.filename)","def __init__(self):\n\n # open json config file that reads in information\n config_path = open(\"config.json\", \"r\")\n config_json = config_path.read()\n config_dict = json.loads(config_json)\n\n # assign object variables\n self.project_id = config_dict[\"project-id\"]\n self.bucket_name = config_dict[\"bucket-name\"]\n self.location_id = config_dict[\"key-location\"]\n self.key_ring_id = config_dict[\"key-ring-id\"]\n self.crypto_key_id = config_dict[\"crypto-key-id\"]\n self.service_account_email = config_dict[\"service-account-email\"]\n\n # close the file\n config_path.close()","def from_configuration(cls, **kwargs):\n return cls(**kwargs)","def Init(self, config):\r\n pass","def init(self, *args, **kwargs):\n try:\n self._init(*args, **kwargs)\n except (ValueError, TypeError, UnicodeError, ConfigParser.Error), exc:\n raise ConfigInvalidError, str(exc), sys.exc_info()[2]","def __init__(self, settings):\n self._read_config(settings)","def __init__(self, config, loop):\n self.config = config\n self.loop = loop","def __init__(self, config_file):\n \n self.log = logging.getLogger(__name__)\n\n self.parser = ConfigParser.ConfigParser()\n if os.path.exists(config_file) and os.path.isfile(config_file):\n self.parser.read(config_file)\n self.log.debug(\"opened configuration '%s'\" % config_file)\n else:\n raise ConfigError(\"Config file missing\", \"File '%s' doesn't exist.\" % (config_file))\n\n self.config_file = config_file\n self.check_config()","def __init__(self, config=None):\n config_dict = {}\n if config:\n config_dict = json.load(config)\n\n self.android = config_dict.get(\"android\")\n self.linux = config_dict.get(\"linux\")\n self.atf = config_dict.get(\"atf\")\n self.qemu = config_dict.get(\"qemu\", \"qemu-system-aarch64\")","def __init__(self, config_file: str = \"config.json\"):\n path_to_config = (Path(sys.modules[self.__module__].__file__).parent\n / config_file)\n with open(path_to_config, \"r\") as f:\n self.options = json.load(f)","def init(cls, config, src):\n cls.config = config","def __init__(self, config_path: str = \"config.json\"):\n # Change here if you want to relocate you config file\n self.config = {}\n self.load_configuration(config_path)\n self.app_name = self.config.get('app_name', self.APP_NAME)","def __init__(self, config: Dict[str, Any], data: Data, verbose: bool) -> None:\n self.__verbose = verbose\n self.__data = data\n self.__config = config","def __init__(self):\n\t\tConfigFile.__init__(self)\n\t\tself.created_by = None\n\t\tself.created_on = None\n\t\tself.definition = None\n\t\tself.note = None\n\t\tself.rejected_by = None\n\t\tself.rejected_on = None\n\t\tself.replaced_by = None\n\t\tself.status = 'elaboration'\n\t\tself.status_reason = None\n\t\tself.term = None\n\t\tself.todo = None\n\t\tself._valid_file_extension = 'def'","def _init_config_(self):\n self._config= {}","def __init__(self, config: str, wdir=os.getcwd()):\n\n self.config_path = config\n self.wdir = wdir\n\n with open(self.config_path) as fin:\n self.config_dic = yaml.load(fin, Loader=yaml.BaseLoader)\n\n # default is 00 for all interaction types\n self.config_parameters_dic = None\n\n # This parameter defines whether self_loops will be kept or not\n self.self_loops = True\n if 'self_loops' in self.config_dic:\n self.self_loops = bool(int(self.config_dic['self_loops']))","def __init__(self, ini_file):\n self.config = configparser.ConfigParser()\n self.config.read(ini_file)\n #print(self.config)","def __init__(self, config_directory, scale_override=None):\n self._config_directory = config_directory\n\n self._config_detector = DetectorConfig(config_directory)\n self._config_align = AlignConfig(config_directory, scale_override=scale_override)\n self._config_crystal = CrystalMatchConfig(config_directory)","def __init__(self):\n\t\t\n\t\tsettings = configparser.SafeConfigParser(allow_no_value=True)\n\t\tlist=settings.read('data/settings.cfg')\n\t\tif not 'data/settings.cfg' in list:\n\t\t\tprint('no configuration file present.. making one')\n\t\t\tself.makeConfigFile(settings)\n\t\t\tshare = ['']\n\t\t\tself.nodes = []\n\t\telse:\n\t\t\tshare, nodes = self.openConfig(settings)\n\t\t\tself.nodes = nodes\n\t\t\n\t\t\n\t\tself.files = self.loadFiles(share)\t\t\n\t\tself.share = share\n\t\tself.kill= False\n\t\tself.downloads = {}\n\t\tself.currentVersion = (0,2,1)\n\t\tself.totalDownloads = 0\n\t\tself.current = 0\n\t\tself.config = settings","def __init__(self):\n self.__default_config = ConfigParams.from_tuples(\n 'options.max_pool_size', 2,\n 'options.connect_timeout', 5000,\n 'options.auto_reconnect', True,\n 'options.max_page_size', 100,\n 'options.debug', True\n )\n\n # The logger\n self._logger: CompositeLogger = CompositeLogger()\n # The connection resolver\n self._connection_resolver: MongoDbConnectionResolver = MongoDbConnectionResolver()\n # The configuration options.\n self._options: ConfigParams = ConfigParams()\n # The MongoDB connection object.\n self._connection: pymongo.MongoClient = None\n # The MongoDB database name.\n self._database_name: str = None\n # The MongoDb database object.\n self._db: database.Database = None","def __init__(self):\n\n self.config = load_config()\n self.set_env_var()","def __init__(self) -> None:\n\n self.config_keys = ['APPS_HOST', 'APPS_PORT']\n super().__init__()\n\n self.APPS_HOST = str(self.APPS_HOST)\n \"\"\"Host where the server will be served\"\"\"\n\n self.APPS_PORT = int(self.APPS_PORT)\n \"\"\"Port where the server will be served\"\"\""],"string":"[\n \"def __init__(self, config: Dict[str, Any]) -> None:\\n self.config = config\",\n \"def __init__(self, *args, **kwargs):\\r\\n super().__init__()\\r\\n self._cfg = ConfigDict() # current configuration\\r\\n self._default_config = ConfigDict() # default configuration\\r\\n self._temp_config = OrderedDict() # temporary configuration\\r\\n self._path = Path() # current configuration path\\r\\n self._default_path = Path() # default configuration path\\r\\n self._conversion_dict = None\\r\\n self._auto_cast = None\\r\\n self._write_flags = None\\r\\n self._force_load = None\\r\\n self._load_empty = None\\r\\n self._ask_path = None\\r\\n self._search_in_default_config = None\\r\\n self._init_count = 0\\r\\n self._policies = defaultdict(bool) # by default every modification is forbidden # WIP\\r\\n if args or kwargs:\\r\\n self.init(*args, **kwargs)\\r\\n logger.debug(\\\"Config object created.\\\")\",\n \"def __init__(self):\\n self.__parameters: ConfigParams = ConfigParams()\",\n \"def __init__(self, config: str) -> None:\\n self.configuration = config\",\n \"def __init__(self, config: str) -> None:\\n self.configuration = config\",\n \"def __init__(self, config):\\n\\n self.config = config\",\n \"def __init__(self, config=None):\\n pass\",\n \"def __init__(self) -> None:\\n self.config: dict[str, str | int] = {}\",\n \"def __init__(self, config_dict: dict):\\n self._config = config_dict\",\n \"def __init__(self, config):\\n self.config = config\",\n \"def __init__(self, config):\\n self.config = config\",\n \"def __init__(self, config):\\n self.config = config\",\n \"def __init__(self, config: dict) -> None:\\n super().__init__(config)\",\n \"def __init__(self, config, cfg):\\n self.config = config\\n self.cfg = cfg\",\n \"def __init__(self, *args, **kwargs):\\n wrap = lambda v: Config(v) if type(v) is dict else v\\n kvdict = {k: wrap(v) for k, v in dict(*args, **kwargs).items()}\\n super(Config, self).__init__(kvdict)\\n self.__dict__ = self\",\n \"def __init__(self):\\n self.config = {}\",\n \"def __init__(self, config: Optional[Config] = None):\\n self.config = config or Config()\",\n \"def __init__(self, config):\\n raise NotImplementedError (\\\"This is just an abstract interface\\\")\",\n \"def __init__(self, config: Tuple):\",\n \"def __new__(cls, *args, **kwargs):\\n if not cls._instance:\\n cls._instance = super(Config, cls).__new__(cls)\\n return cls._instance\",\n \"def __init__(self, configs):\\n\\n self.__configs = configs\",\n \"def initialize_from_config(self):\",\n \"def __init__(self):\\n\\n if Config._instance:\\n raise Exception('Config singleton is already instantiated. User Config.get_instance() obtain it.')\\n\\n parser = configparser.ConfigParser()\\n parser.read('C:\\\\\\\\Users\\\\\\\\Akatosh\\\\\\\\PythonProjects\\\\\\\\note-it\\\\\\\\config\\\\\\\\config.ini')\\n\\n self.sections = {}\\n\\n for section in parser:\\n self.sections[section] = _Section(parser[section])\\n\\n Config._instance = self\",\n \"def __init__(self, configuration):\\n self._config = configuration\",\n \"def __init__(self):\\n ConfigParser.RawConfigParser.OPTCRE = re.compile(r'(?P<option>[^=\\\\s][^=]*)\\\\s*(?P<vi>[=])\\\\s*(?P<value>.*)$')\\n self.CONFIG = ConfigParser.ConfigParser()\\n self.CONFIG.read(os.path.join(os.path.dirname(__file__)))\\n self.IPS = []\",\n \"def __init__(self):\\n # Read configuration into dictionary\\n self.directories = general.config_directories()\\n self.config = general.read_yaml_files(self.directories)\",\n \"def __init__(self, config_entry):\\n self.config_entry = config_entry\",\n \"def __init__(self, config_entry):\\n self.config_entry = config_entry\",\n \"def __init__(self, config):\\n super().__init__(config)\\n self.collector_host = config.get(\\\"collector_host\\\")\\n self.schedds = config.get(\\\"schedds\\\", [None])\\n self.condor_config = config.get(\\\"condor_config\\\")\\n self.constraint = config.get(\\\"constraint\\\", True)\\n self.classad_attrs = config.get(\\\"classad_attrs\\\")\\n self.correction_map = config.get(\\\"correction_map\\\")\",\n \"def __init__(self):\\n\\n self.path = os.path.dirname(os.path.realpath(__file__)) + '/config.ini'\\n self.config = configparser.ConfigParser()\\n self.config.read(self.path)\",\n \"def __init__(self, config_file, verbose):\\r\\n self.loadConfig(config_file)\\r\\n self.verbose = verbose\",\n \"def init_config() -> Config:\\n ...\",\n \"def __init__(self, config_path, normalize=False):\\n self.config = {}\\n _config_dict = {}\\n self._config_path = Utils.expand_path(config_path)\\n self.update = None\\n self.normalize = normalize\",\n \"def __init__(self, config):\\n\\n self.root = config.root\\n self.pidfile = config.pidfile\\n self.log_conf = config.logging\",\n \"def _new():\\n\\treturn ConfigParser(\\n\\tdelimiters = ('=',),\\n\\tcomment_prefixes = ('#', ';'),\\n\\tdefault_section = 'default',\\n\\tallow_no_value = False,\\n\\tstrict = False,\\n\\tinterpolation = ExtendedInterpolation(),\\n\\tdefaults = {\\n\\t\\t'debug': False,\\n\\t\\t'datadir': path.join(path.expanduser('~'), '.local', 'rosshm'),\\n\\t\\t'log.level': 'warn',\\n\\t\\t'core.enable': True,\\n\\t\\t'db.driver': 'sqlite',\\n\\t\\t'db.name': 'rosshmdb',\\n\\t\\t'db.config': '',\\n\\t\\t'static.enable': True,\\n\\t\\t'web.enable': True,\\n\\t},\\n)\",\n \"def __init__(self, cfg=None):\\n if cfg is None:\\n cfg = {}\\n\\n self.cfg = cfg\",\n \"def __init__(self, config_file_name=\\\"config.json\\\"):\\n with open(config_file_name, \\\"r\\\") as config:\\n f = dict(json.load(config))\\n for key, value in f.items():\\n setattr(self, key, value)\",\n \"def __init__(self, config_file=None):\\n\\t\\tself.options = {}\\n\\n\\t\\tif config_file:\\n\\t\\t\\tself.set_file(config_file)\",\n \"def __init__(self, path_to_config_file):\\n self.file_path = path_to_config_file\",\n \"def __init__(self, config_file):\\n with open(config_file, 'r') as file:\\n self.config = json.load(file)\\n self.set_config(self.config)\",\n \"def __init__(self, config, logger):\\n self.config = config\\n self.logger = logger\",\n \"def __init__(self, configs: Union[Config, Dict[str, Any]]):\\n self.configs: Config = Config(configs, None, allow_new_hparam=True)\",\n \"def init_config(self):\\n pass\",\n \"def config():\\n return Config()\",\n \"def config():\\n return Config()\",\n \"def __init__(self, config_file):\\n Config = ConfigParser.ConfigParser()\\n Config.read(config_file)\\n \\n self.port_id = Config.get(\\\"SerialPortSection\\\", \\\"ComPort\\\")\\n self.baud_rate = Config.get(\\\"SerialPortSection\\\", \\\"BaudRate\\\")\\n self. timeout = Config.get(\\\"SerialPortSection\\\", \\\"TimeOut\\\")\\n self.config_file = config_file\",\n \"def __init__(self, filename=None):\\n if filename:\\n if not os.path.exists(filename):\\n raise Exception(\\\"No configuration found at %s\\\" % filename)\\n super(Configuration, self).__init__(filename)\",\n \"def __init__(self, conf=None):\\n # set interpolation to None so you can supply filename template\\n # that contain % to config.set\\n conf = ConfigParser(strict=False,\\n inline_comment_prefixes=(';',),\\n interpolation=None) if (conf is None) else conf\\n super().__init__(conf)\\n self._cycle = None\\n self._logger = logging.getLogger('metplus')\\n # config.logger is called in wrappers, so set this name\\n # so the code doesn't break\\n self.logger = self._logger\\n\\n # get the OS environment and store it\\n self.env = os.environ.copy()\\n\\n # add section to hold environment variables defined by the user\\n self.add_section('user_env_vars')\",\n \"def __init__(self, config_entry: config_entries.ConfigEntry) -> None:\\n self.config_entry = config_entry\",\n \"def __init__(self, name=None):\\n self.name = name or \\\"default\\\"\\n config_path = os.path.join(get_config_directory(), self.name + JSON)\\n try:\\n with open(config_path, mode='r') as config_file:\\n self.config_dict = json.load(config_file)\\n except Exception as ex:\\n raise ColinConfigException(\\\"Config file '{}' cannot be loaded.\\\".format(config_path))\",\n \"def initialize(self, **kwargs):\\n\\n # Defining the configuration object\\n self.config = kwargs.get('config')\",\n \"def __init__(self, config_name: str, is_top_level_config: bool = False):\\n self.config_name = config_name\\n self.config_variable_name = to_snake_case(config_name) + \\\"_config\\\"\\n self.is_top_level_config = is_top_level_config\\n self.parameters: List[CppParameter] = list()\\n self.configs: List[CppConfig] = list()\",\n \"def __init__(self):\\n parameters_list = []\\n self.config_dict = self.open_config(parameters_list)\\n\\n # Define defaults\\n self.disc_gt = 0.0\\n self.disc_out = 0.0\",\n \"def __init__(self, config, town):\\n\\t\\tself.config = config\",\n \"def __init__(self, name, config):\\n self.name = name\\n self.config = config\\n self.values = []\",\n \"def config_init(self):\\n\\n game_opts = [\\n\\n # Execution Options\\n ('debug',False), # Toggle Debug Messaging\\n ('log_path',False), # Turn on logging (w/path)\\n ('log_lvl',logging.DEBUG), # Set log level\\n\\n # World Generation Options\\n ('flex_limit',3) # Sets the maximum variance\\n\\n ]\\n\\n # Attempts to pull each value from the configuration\\n # if not in config, the default value defined above\\n # is set instead\\n for opt in game_opts:\\n try:\\n setattr(self,opt[0],self.conf.conf_dict[opt[0]])\\n except:\\n setattr(self,opt[0],opt[1])\\n continue\",\n \"def __init__(self, **kwargs):\\n cls = self.__class__\\n\\n # Initialize all configurables and input arguments\\n for arg in cls.configurables():\\n try: # Read from class constructor\\n setattr(self, arg, kwargs[arg])\\n except KeyError:\\n try: # Set from default value defined in class\\n default_value = getattr(self, arg).kwargs[\\\"default\\\"]\\n setattr(self, arg, default_value)\\n except KeyError: # if nothing is provided, fallbakcs to None\\n setattr(self, arg, None)\\n\\n self.input_arguments = None\\n if cls.input_configurables():\\n self.input_arguments = [\\n getattr(self, arg) for arg in cls.input_configurables()\\n ]\\n\\n self.json_config = cfg.JsonConfig(self.config)\\n self.output_objects = []\\n self.file = None\",\n \"def __init__(self):\\n self.collectorName = COLLECTOR_NAME\\n self.configCycleInterval = 20 # minutes\\n self.cycleInterval = 5 * 60 # seconds\\n\\n # The configurationService attribute is the fully qualified class-name\\n # of our configuration service that runs within ZenHub\\n self.configurationService = 'NullConfig'\\n\\n # Will be filled in based on buildOptions\\n self.options = None\\n\\n self.configCycleInterval = 20*60\",\n \"def __init__(self, config_entry: config_entries.ConfigEntry) -> None:\\n self.config_entry = config_entry\\n self.options = dict(config_entry.options)\",\n \"def __init__(self, config, well, directory):\\n self.config = config\\n self.well = well\\n self.directory = directory\",\n \"def create_config(self) -> None:\\n pass\",\n \"def create_config(self) -> None:\\n pass\",\n \"def __init__(self, userconfig=None):\\n configspec = _get_configspec()\\n self._configspec = ConfigObj(configspec, interpolation=False,\\n list_values=False, _inspec=True)\\n configs_default = ConfigObj(interpolation=False,\\n configspec=self._configspec)\\n self._config = self._validate(configs_default)\\n if userconfig:\\n self.read_userconfig(userconfig)\",\n \"def __init__(self, cfg=None, **kwargs):\\n self.__dir = KITConfig.configDir\\n self.__cfgFile = \\\"\\\"\\n\\n self.__cfg = {}\\n self.__default = KITConfig.defaultConfig\\n\\n self.__setupLogger()\\n\\n if cfg is not None:\\n self.__cfgFile = cfg\\n self.load(cfg)\",\n \"def load(self):\\n\\n class Config(object):\\n pass\\n\\n for key, val in self.kwargs.items():\\n setattr(Config, key, val)\\n return Config\",\n \"def __init__(self, config_path=None):\\n self.config_path = None\\n\\n config_path = config_path or CONF.api_paste_config\\n if not os.path.isabs(config_path):\\n self.config_path = CONF.find_file(config_path)\\n elif os.path.exists(config_path):\\n self.config_path = config_path\\n\\n if not self.config_path:\\n raise exception.ConfigNotFound(path=config_path)\",\n \"def __init__(self, config_file=None):\\n self.file = config_file\\n self.parser = SafeConfigParser()\\n if isinstance(self.file, (str, list)):\\n self.parser.read(self.file)\\n else: # assume file object was given instead\\n self.parser.read_file(self.file)\\n self._flask_cache = None\\n self._assets_cache = None\\n self._gridrealm_cache = None\",\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, ini_file):\\n self.config = configparser.ConfigParser()\\n self.config.read(ini_file)\",\n \"def __init__(self, config_path=None):\\n config_path = config_path or CONF.api_paste_config\\n if os.path.exists(config_path):\\n self.config_path = config_path\\n else:\\n self.config_path = CONF.find_file(config_path)\",\n \"def __init__(self, config=None, broker=None):\\n pass\",\n \"def __init__(self, config):\\n\\n self.locations_hltv_starting_ = config[sC.BUCKET_LOCATIONS][sC.HLTV_STARTING]\\n self.score_starting_ = config[sC.BUCKET_LOCATIONS][sC.SCORE_STARTING]\\n self.logs_starting_ = config[sC.BUCKET_LOCATIONS][sC.LOGS_STARTING]\\n self.temp = config[sC.FOLDER_LOCATIONS][sC.TEMP_APP_ENGINE_FOLDER]\\n self.results_ = config[sC.FOLDER_LOCATIONS][sC.CONFIGS_RESULTS]\\n self.amxmodx_logs_ = config[sC.FOLDER_LOCATIONS][sC.ADDONS_AMXMODX_LOGS]\\n self.cstrike_logs_ = config[sC.FOLDER_LOCATIONS][sC.CSTRIKE_LOGS]\\n self.hltv_demos_func_url = config[sC.CLOUD_FUNCTIONS_URLS][sC.HLTV_DEMOS_FUNC]\\n self.ftp_logs_func_url = config[sC.CLOUD_FUNCTIONS_URLS][sC.FTP_LOGS_FUNC]\\n\\n print('{} - Initialized'.format(__name__))\",\n \"def from_config(cls, config: Dict[str, Any]) -> \\\"ClassyLoss\\\":\\n raise NotImplementedError()\",\n \"def __init__(self, **user_options):\\n self.options = config.default_options.copy()\\n self.configure(**user_options)\",\n \"def __init__(self, load_config):\\n super().__init__()\\n self._load_config = load_config\",\n \"def config(self):\\n raise NotImplementedError\",\n \"def _from_config(cls, config, **kwargs):\\n return cls(config, **kwargs)\",\n \"def __init__(self, config_file = 'config.yaml'):\\n\\n self.name = ''\\n self.img_dir = ''\\n self.out_dir = ''\\n self.cam_file = ''\\n self.options_file = ''\\n self.output_xml_file = ''\\n\\n # If there is an options file, it will overwrite the defaults \\n if config_file is not None:\\n self.load(config_file)\",\n \"def __init__(self):\\n self.filename = pathlib.Path(__file__).parent.absolute().__str__() + '/../../data/config.ini'\\n self.data = ConfigParser()\\n self.data.read(self.filename)\",\n \"def __init__(self):\\n\\n # open json config file that reads in information\\n config_path = open(\\\"config.json\\\", \\\"r\\\")\\n config_json = config_path.read()\\n config_dict = json.loads(config_json)\\n\\n # assign object variables\\n self.project_id = config_dict[\\\"project-id\\\"]\\n self.bucket_name = config_dict[\\\"bucket-name\\\"]\\n self.location_id = config_dict[\\\"key-location\\\"]\\n self.key_ring_id = config_dict[\\\"key-ring-id\\\"]\\n self.crypto_key_id = config_dict[\\\"crypto-key-id\\\"]\\n self.service_account_email = config_dict[\\\"service-account-email\\\"]\\n\\n # close the file\\n config_path.close()\",\n \"def from_configuration(cls, **kwargs):\\n return cls(**kwargs)\",\n \"def Init(self, config):\\r\\n pass\",\n \"def init(self, *args, **kwargs):\\n try:\\n self._init(*args, **kwargs)\\n except (ValueError, TypeError, UnicodeError, ConfigParser.Error), exc:\\n raise ConfigInvalidError, str(exc), sys.exc_info()[2]\",\n \"def __init__(self, settings):\\n self._read_config(settings)\",\n \"def __init__(self, config, loop):\\n self.config = config\\n self.loop = loop\",\n \"def __init__(self, config_file):\\n \\n self.log = logging.getLogger(__name__)\\n\\n self.parser = ConfigParser.ConfigParser()\\n if os.path.exists(config_file) and os.path.isfile(config_file):\\n self.parser.read(config_file)\\n self.log.debug(\\\"opened configuration '%s'\\\" % config_file)\\n else:\\n raise ConfigError(\\\"Config file missing\\\", \\\"File '%s' doesn't exist.\\\" % (config_file))\\n\\n self.config_file = config_file\\n self.check_config()\",\n \"def __init__(self, config=None):\\n config_dict = {}\\n if config:\\n config_dict = json.load(config)\\n\\n self.android = config_dict.get(\\\"android\\\")\\n self.linux = config_dict.get(\\\"linux\\\")\\n self.atf = config_dict.get(\\\"atf\\\")\\n self.qemu = config_dict.get(\\\"qemu\\\", \\\"qemu-system-aarch64\\\")\",\n \"def __init__(self, config_file: str = \\\"config.json\\\"):\\n path_to_config = (Path(sys.modules[self.__module__].__file__).parent\\n / config_file)\\n with open(path_to_config, \\\"r\\\") as f:\\n self.options = json.load(f)\",\n \"def init(cls, config, src):\\n cls.config = config\",\n \"def __init__(self, config_path: str = \\\"config.json\\\"):\\n # Change here if you want to relocate you config file\\n self.config = {}\\n self.load_configuration(config_path)\\n self.app_name = self.config.get('app_name', self.APP_NAME)\",\n \"def __init__(self, config: Dict[str, Any], data: Data, verbose: bool) -> None:\\n self.__verbose = verbose\\n self.__data = data\\n self.__config = config\",\n \"def __init__(self):\\n\\t\\tConfigFile.__init__(self)\\n\\t\\tself.created_by = None\\n\\t\\tself.created_on = None\\n\\t\\tself.definition = None\\n\\t\\tself.note = None\\n\\t\\tself.rejected_by = None\\n\\t\\tself.rejected_on = None\\n\\t\\tself.replaced_by = None\\n\\t\\tself.status = 'elaboration'\\n\\t\\tself.status_reason = None\\n\\t\\tself.term = None\\n\\t\\tself.todo = None\\n\\t\\tself._valid_file_extension = 'def'\",\n \"def _init_config_(self):\\n self._config= {}\",\n \"def __init__(self, config: str, wdir=os.getcwd()):\\n\\n self.config_path = config\\n self.wdir = wdir\\n\\n with open(self.config_path) as fin:\\n self.config_dic = yaml.load(fin, Loader=yaml.BaseLoader)\\n\\n # default is 00 for all interaction types\\n self.config_parameters_dic = None\\n\\n # This parameter defines whether self_loops will be kept or not\\n self.self_loops = True\\n if 'self_loops' in self.config_dic:\\n self.self_loops = bool(int(self.config_dic['self_loops']))\",\n \"def __init__(self, ini_file):\\n self.config = configparser.ConfigParser()\\n self.config.read(ini_file)\\n #print(self.config)\",\n \"def __init__(self, config_directory, scale_override=None):\\n self._config_directory = config_directory\\n\\n self._config_detector = DetectorConfig(config_directory)\\n self._config_align = AlignConfig(config_directory, scale_override=scale_override)\\n self._config_crystal = CrystalMatchConfig(config_directory)\",\n \"def __init__(self):\\n\\t\\t\\n\\t\\tsettings = configparser.SafeConfigParser(allow_no_value=True)\\n\\t\\tlist=settings.read('data/settings.cfg')\\n\\t\\tif not 'data/settings.cfg' in list:\\n\\t\\t\\tprint('no configuration file present.. making one')\\n\\t\\t\\tself.makeConfigFile(settings)\\n\\t\\t\\tshare = ['']\\n\\t\\t\\tself.nodes = []\\n\\t\\telse:\\n\\t\\t\\tshare, nodes = self.openConfig(settings)\\n\\t\\t\\tself.nodes = nodes\\n\\t\\t\\n\\t\\t\\n\\t\\tself.files = self.loadFiles(share)\\t\\t\\n\\t\\tself.share = share\\n\\t\\tself.kill= False\\n\\t\\tself.downloads = {}\\n\\t\\tself.currentVersion = (0,2,1)\\n\\t\\tself.totalDownloads = 0\\n\\t\\tself.current = 0\\n\\t\\tself.config = settings\",\n \"def __init__(self):\\n self.__default_config = ConfigParams.from_tuples(\\n 'options.max_pool_size', 2,\\n 'options.connect_timeout', 5000,\\n 'options.auto_reconnect', True,\\n 'options.max_page_size', 100,\\n 'options.debug', True\\n )\\n\\n # The logger\\n self._logger: CompositeLogger = CompositeLogger()\\n # The connection resolver\\n self._connection_resolver: MongoDbConnectionResolver = MongoDbConnectionResolver()\\n # The configuration options.\\n self._options: ConfigParams = ConfigParams()\\n # The MongoDB connection object.\\n self._connection: pymongo.MongoClient = None\\n # The MongoDB database name.\\n self._database_name: str = None\\n # The MongoDb database object.\\n self._db: database.Database = None\",\n \"def __init__(self):\\n\\n self.config = load_config()\\n self.set_env_var()\",\n \"def __init__(self) -> None:\\n\\n self.config_keys = ['APPS_HOST', 'APPS_PORT']\\n super().__init__()\\n\\n self.APPS_HOST = str(self.APPS_HOST)\\n \\\"\\\"\\\"Host where the server will be served\\\"\\\"\\\"\\n\\n self.APPS_PORT = int(self.APPS_PORT)\\n \\\"\\\"\\\"Port where the server will be served\\\"\\\"\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8146151","0.81249666","0.7914005","0.7902959","0.7902959","0.78517556","0.7830942","0.78164166","0.7816199","0.78047544","0.78047544","0.78047544","0.7794701","0.7631528","0.7613544","0.76106983","0.7570277","0.7570083","0.7505082","0.7465383","0.7454133","0.7362795","0.72564214","0.7250131","0.7242494","0.7229574","0.72265446","0.72265446","0.7194435","0.7181348","0.7175195","0.71561235","0.7149797","0.7111156","0.7110856","0.71093625","0.7102539","0.71023625","0.706302","0.7062595","0.7056412","0.7047717","0.70417416","0.70386314","0.70386314","0.7030067","0.70222646","0.7019634","0.70142233","0.7012678","0.7009522","0.699475","0.6974509","0.69613636","0.69570494","0.694711","0.6944664","0.69441354","0.6930602","0.69067186","0.6901887","0.6901887","0.68925226","0.6889054","0.6877439","0.6876283","0.68661237","0.6857761","0.6853694","0.68463284","0.6845723","0.6843961","0.68405473","0.6840285","0.6833352","0.6829174","0.6823486","0.6802595","0.67933804","0.67912775","0.679085","0.6789616","0.6786914","0.67869127","0.6779256","0.6778579","0.67699254","0.6763202","0.67585015","0.6754568","0.67489636","0.6737121","0.67358637","0.6732636","0.6711185","0.67053986","0.6693244","0.6691935","0.66906476","0.6690254"],"string":"[\n \"0.8146151\",\n \"0.81249666\",\n \"0.7914005\",\n \"0.7902959\",\n \"0.7902959\",\n \"0.78517556\",\n \"0.7830942\",\n \"0.78164166\",\n \"0.7816199\",\n \"0.78047544\",\n \"0.78047544\",\n \"0.78047544\",\n \"0.7794701\",\n \"0.7631528\",\n \"0.7613544\",\n \"0.76106983\",\n \"0.7570277\",\n \"0.7570083\",\n \"0.7505082\",\n \"0.7465383\",\n \"0.7454133\",\n \"0.7362795\",\n \"0.72564214\",\n \"0.7250131\",\n \"0.7242494\",\n \"0.7229574\",\n \"0.72265446\",\n \"0.72265446\",\n \"0.7194435\",\n \"0.7181348\",\n \"0.7175195\",\n \"0.71561235\",\n \"0.7149797\",\n \"0.7111156\",\n \"0.7110856\",\n \"0.71093625\",\n \"0.7102539\",\n \"0.71023625\",\n \"0.706302\",\n \"0.7062595\",\n \"0.7056412\",\n \"0.7047717\",\n \"0.70417416\",\n \"0.70386314\",\n \"0.70386314\",\n \"0.7030067\",\n \"0.70222646\",\n \"0.7019634\",\n \"0.70142233\",\n \"0.7012678\",\n \"0.7009522\",\n \"0.699475\",\n \"0.6974509\",\n \"0.69613636\",\n \"0.69570494\",\n \"0.694711\",\n \"0.6944664\",\n \"0.69441354\",\n \"0.6930602\",\n \"0.69067186\",\n \"0.6901887\",\n \"0.6901887\",\n \"0.68925226\",\n \"0.6889054\",\n \"0.6877439\",\n \"0.6876283\",\n \"0.68661237\",\n \"0.6857761\",\n \"0.6853694\",\n \"0.68463284\",\n \"0.6845723\",\n \"0.6843961\",\n \"0.68405473\",\n \"0.6840285\",\n \"0.6833352\",\n \"0.6829174\",\n \"0.6823486\",\n \"0.6802595\",\n \"0.67933804\",\n \"0.67912775\",\n \"0.679085\",\n \"0.6789616\",\n \"0.6786914\",\n \"0.67869127\",\n \"0.6779256\",\n \"0.6778579\",\n \"0.67699254\",\n \"0.6763202\",\n \"0.67585015\",\n \"0.6754568\",\n \"0.67489636\",\n \"0.6737121\",\n \"0.67358637\",\n \"0.6732636\",\n \"0.6711185\",\n \"0.67053986\",\n \"0.6693244\",\n \"0.6691935\",\n \"0.66906476\",\n \"0.6690254\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7287139"},"document_rank":{"kind":"string","value":"22"}}},{"rowIdx":175,"cells":{"query":{"kind":"string","value":"Load the config file"},"document":{"kind":"string","value":"def _open_config_file(self):\n try:\n with open(self.config_file_name,encoding='utf-8') as json_data_file:\n conf = json.load(json_data_file)\n return conf\n except FileNotFoundError:\n with open(self.config_file_name, 'w',encoding='utf-8') as json_data_file:\n json.dump({},json_data_file,indent=2)\n return {}"},"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 load_config(self):\n pass","def load_config(self):\r\n with open('config.json', 'r') as f:\r\n self.config = json.load(f)","def load_config(self):\n if os.path.exists(self.config_file):\n with open(self.config_file) as f:\n conf = json.load(f)\n\n self.update_attributes_from_config(conf)","def load(file):\n _config.load(file)","def loadConf(self):\n\n with open(self.configFile) as f:\n self.config = json.load(f)","def load():\n # get (or create) config path\n p = initialize()\n return load_config(open(p['config']))","def read_config(self, config_filename):","def load_config(self, config_file):\n self.config = ConfigParser.ConfigParser()\n self.config.read(config_file)","def load_config(self):\n with open(self.TEMPERATURE_CONFIG_FILE_PATH, 'r') as file:\n self.config = json.load(file)","def load_config_file(self):\n\n conf_file = config.DEFAULT_CONFIGURATION_FILE\n\n if self.options and getattr(self.options, \"conf_file\"):\n conf_file = self.options.conf_file\n if (\n not os.path.exists(conf_file) and\n not os.path.exists(\"%s.d\" % conf_file)\n ):\n raise Exception(\n (\n \"The specified configuration file \"\n \"does not exist. File=(%s)\"\n ) % self.options.conf_file\n )\n\n self.from_file(conf_file)","def load_conf(self):\n self._read_uconf()","def load_config():\n\t\ttry:\n\t\t\tconf = ConfigParser()\n\n\t\t\tconfig_path = get_config_path()\n\t\t\tconf.read(config_path)\n\n\t\t\t# save references to conf, and config_path in class variables\n\t\t\tConfig.config_path = config_path\n\t\t\tConfig.conf = conf\n\n\t\t\tConfig.source_dir = conf.get('paths', 'source_dir')\n\t\t\tConfig.lyrics_dir = conf.get('paths', 'lyrics_dir')\n\n\t\t\tConfig.save_to_file = conf.getboolean('actions', 'save_to_file')\n\t\t\tConfig.save_to_tag = conf.getboolean('actions', 'save_to_tag')\n\n\t\t\tConfig.overwrite = conf.getboolean('actions', 'overwrite')\n\n\t\t\t# Load all the sources\n\t\t\tConfig.lyric_wikia = conf.getboolean('sources', 'lyric_wikia')\n\t\t\tConfig.musix_match = conf.getboolean('sources', 'musix_match')\n\t\t\tConfig.lyricsmode = conf.getboolean('sources', 'lyricsmode')\n\t\t\tConfig.az_lyrics = conf.getboolean('sources', 'az_lyrics')\n\n\t\t\t# Loading this with user config, we need to call the load_config only once at start.\n\t\t\tConfig.lyric_files_in_dir = glob2.glob(os.path.join(Config.lyrics_dir, '**/*.txt'))\n\n\n\t\t# Catch file handling errors\n\t\texcept IOError as e:\n\t\t\tprint('Unable to load config.')\n\t\t\tprint(e)","def init_config(self):\n with open(self.config_file, 'r') as fh:\n self.config = json.load(fh, object_pairs_hook=OrderedDict)\n logger.info('Config loaded: %s' % os.path.abspath(self.config_file))","def init_config(self):\n with open(self.config_file, 'r') as fh:\n self.config = json.load(fh, object_pairs_hook=OrderedDict)\n logger.info('Config loaded: %s' % os.path.abspath(self.config_file))","def load_config():\n global config\n\n with open(\"config.json\") as f:\n json_config = f.read()\n f.close()\n config = json.loads(json_config)","def _load_config():\n\tcfg = configparser.ConfigParser()\n\tcfg.read(join(get_current_path(), 'ib.config'))\n\treturn cfg","def read_configuration (self):\n\t\tself.config.read(self._configfile)","def load_config():\n config = ConfigParser()\n config.read(os.path.join(os.path.dirname(__file__), 'config.ini'))\n return config","def load_config():\n global config\n with open('config.yml', 'r') as file:\n config = yaml.load(file)","def load_config():\n here = os.path.dirname(os.path.abspath(__file__))\n config_path = os.path.join(here, 'config.json')\n with open(config_path, encoding='utf-8') as f:\n return json.load(f)","def load_config():\n config = configparser.ConfigParser()\n config.read('config.ini')\n return config","def load(self):\n with open(self.conf_fname, \"r\") as fd:\n config = json.load(fd)\n \n return config","def load(self):\n try:\n _config_file = open(self.config, 'r+')\n data = json.loads(_config_file.read())\n except (ValueError, IOError):\n data = {}\n\n self.update(data)","def load_config(filename):\n AS[\"config\"] = load_yaml_file(filename)","def loadConfig(self):\r\n self.config.read(self.CONFIG_FILE)\r\n try:\r\n assert \"Settings\" in self.config\r\n except AssertionError:\r\n print(\"Settings do not exist, creating new config file...\")\r\n self.saveConfig()\r\n settings = self.config[\"Settings\"]\r\n self.dataPath = settings.get(\"datapath\",fallback=\"\")\r\n self.videoPath = settings.get(\"videopath\",fallback=\"\")\r\n self.dataOffset = settings.getfloat(\"dataoffset\",fallback=0)\r\n self.colBlindMode = settings.getboolean(\"colblindmode\",False)\r\n if self.videoPath != \"\":\r\n self.loadVideo(self.videoPath,loadAudio=False)\r\n if self.dataPath != \"\":\r\n self.loadData(self.dataPath)","def _load_config():\n fname = _get_config_fname()\n if fname is None or not op.isfile(fname):\n return dict()\n with open(fname, 'r') as fid:\n config = json.load(fid)\n return config","def load_config(self):\n if not self.config_file_path:\n return False\n with open(self.config_file_path) as f:\n self.config = yaml.load(f)\n return True","def loadConfig(self, config_file):\r\n\r\n import json\r\n\r\n self.config = None\r\n\r\n try:\r\n with open(config_file) as f:\r\n self.config = json.load(f)\r\n except OSError as err:\r\n print(\"Unable to process {}, {}\".format(config_file, err))\r\n sys.exit(1)","def loadConfig():\n lines = []\n config = {}\n here = path.dirname(__file__)\n fn = path.join(here,'manatee.conf')\n try:\n with codecs.open(fn,'rU','utf-8') as conf:\n lines = conf.readlines()\n conf.close()\n except IOError as e:\n print \" Could not open configuration file: %s\" % e\n\n for line in lines:\n try:\n line = line.strip()\n if line:\n values = [x.strip() for x in line.split('=')]\n config[values[0]] = values[1]\n except Exception as e:\n print \"There was an error in the configuration file: %s\" % e\n # TODO: Any strings from the config file that might be displayed or passed into the SQL server need to be validated here.\n# config = validateConfig(config)\n return config","def _load_config():\n\tcfg = configparser.ConfigParser()\n\tcfg.read(os.path.join(get_current_directory(), 'citi.config'))\n\treturn cfg","def load ( self ):\n files = config.get_or_fail ( 'REPO.config_files' )\n for f in files:\n self.load_file ( f )","def load_conf(self, filename):\n\n path = \"./source/_0_time_series_class/configuration/\"\n filename = path + filename\n \n with open(filename) as file:\n self.conf = json.loads(file.read())","def cli_load_config(self, args) -> str:\n path = args.config_path\n if not os.path.isfile(path):\n return error(\"Path {} DNE\".format(path))\n\n try:\n self.config = config.from_file(path)\n return ok(\"Configuration loaded from {}\".format(path))\n except FileNotFoundError as err:\n return error(\"Could not load file: {}\".format(err))\n except json.JSONDecodeError as json_err:\n return error(\"Could not parse json file {}\".format(json_err))","def load_config( self, config_file=None ):\n if config_file is None:\n config_file = os.path.dirname(self.dbfile) + '/final.ini'\n config_parser = ConfigParser.ConfigParser()\n config_parser.read( config_file )\n self.config = config_parser\n return self.config","def load(self):\n config_dict = {}\n with open(\n os.path.join(\n os.path.dirname(\n os.path.abspath(\n inspect.stack()[0][1]\n )\n ),\n \"config.txt\"), 'r') as config_file:\n for line in config_file:\n if not line.startswith('#'):\n line = line.strip().split('=', 1)\n if len(line) == 2:\n config_dict[line[0]] = line[1]\n return config_dict","def load_config(path):\n # opens config file\n try:\n config = configparser.ConfigParser()\n config.read(path)\n return config\n except Exception as e:\n print(\"Error loading config file: \", e)\n sys.exit(1)","def load_from_conf(self):\r\n raise NotImplementedError","def __read_config(self):\n with open(self.config_file, 'r') as data_file:\n dict = json.load(data_file)\n self.ibooks_doc_root = dict[\"ibooks_doc_root\"]\n self.library_folder = dict[\"library_folder\"]\n self.annotation_folder = dict[\"annotation_folder\"]\n self.tmp_dir = dict[\"tmp_dir\"]","def load_config():\n proj_dir = os.path.dirname(os.path.abspath(__file__))\n config_path = os.path.join(proj_dir, \"config.yml\")\n conf = yaml.safe_load(open(config_path))\n return conf","def load_config():\n config_file = os.path.dirname(os.path.abspath(__file__)) + '/../config.json'\n with open(config_file, 'r') as f:\n config = json.load(f)\n\n return config","def load_from_conf(self):\n raise NotImplementedError","def load_config(self, filename: str=None):\n if not filename:\n filename = self.config_file\n with open(filename) as file_object:\n config = json.load(file_object)\n if isinstance(config, dict):\n for key, value in config.items():\n self.config[key] = value","def load_config():\n config_file = os.path.join(\n Path(os.path.dirname(os.path.realpath(__file__))).parent,\n \"config.ini\"\n )\n if not os.path.exists(config_file):\n raise FileNotFoundError(config_file)\n app_config = configparser.ConfigParser()\n app_config.read(config_file)\n return app_config['uberoo']","def load_config(self):\n h_config = configparser.ConfigParser()\n with self.config_file.open() as configfile:\n h_config.read_file(configfile)\n if not (\"general\" in h_config.keys() and \"unifi\" in h_config.keys() and \"hue\" in h_config.keys()):\n logging.warning(\"Configuration file {} is invalid.\".format(self.config_file))\n return\n if not self.configuration.interval:\n self.configuration.interval = int(h_config[\"general\"][\"interval\"])\n if not self.configuration.wifi_clients:\n self.configuration.wifi_clients = h_config[\"general\"][\"wifi_clients\"].split(\",\")\n if not self.configuration.schedules_names:\n self.configuration.schedules_names = h_config[\"general\"][\"schedules_name\"].split(\",\")\n if not self.configuration.unifi_host:\n self.configuration.unifi_host = h_config[\"unifi\"][\"host\"]\n if not self.configuration.unifi_port:\n self.configuration.unifi_port = int(h_config[\"unifi\"][\"port\"])\n if not self.configuration.unifi_username:\n self.configuration.unifi_username = h_config[\"unifi\"][\"username\"]\n if not self.configuration.unifi_password:\n self.configuration.unifi_password = h_config[\"unifi\"][\"password\"]\n if not self.configuration.hue_host:\n self.configuration.hue_host = h_config[\"hue\"][\"host\"]\n if not self.configuration.hue_port:\n self.configuration.hue_port = int(h_config[\"hue\"][\"port\"])\n if not self.configuration.hue_key:\n self.configuration.hue_key = h_config[\"hue\"][\"key\"]\n\n if \"general\" in h_config.keys():\n if not self.configuration.pub_host:\n self.configuration.pub_host = h_config[\"zmq\"][\"host\"]\n if not self.configuration.pub_port:\n self.configuration.pub_port = int(h_config[\"zmq\"][\"port\"])\n if \"no_pub\" not in self.configuration:\n self.configuration.no_pub = bool(int(h_config[\"zmq\"][\"disabled\"]))\n\n if \"logging\" in h_config.keys():\n if \"syslog_host\" in h_config[\"logging\"].keys() and not self.configuration.syslog_host:\n self.configuration.syslog_host = h_config[\"logging\"][\"syslog_host\"]\n if \"syslog_port\" in h_config[\"logging\"].keys():\n self.configuration.syslog_port = int(h_config[\"logging\"][\"syslog_port\"])\n if \"log_file\" in h_config[\"logging\"].keys() and not self.configuration.log_file:\n self.configuration.log_file = Path(h_config[\"logging\"][\"log_file\"])\n\n logging.info(\"Configuration loaded from {}\".format(str(self.config_file)))\n logging.debug(self.configuration)","def load_config(self, filename):\n # check if config file exists\n if not os.path.exists(filename):\n raise Exception(\"Can't find configuration {}.\".format(filename))\n # load config file\n config = configparser.ConfigParser()\n with open(filename, 'r') as config_file:\n config.read_file(config_file)\n return config","def load_config(self, path=\"\"):\n if not path:\n if not os.path.isdir(CONFIG_DIR):\n os.makedirs(CONFIG_DIR)\n file_path = QtGui.QFileDialog.getOpenFileName(self,\n \"Open Config\",\n CONFIG_DIR,\n \"Config Files (*.cfg)\")\n else:\n file_path = path\n self._load_state(file_path)\n #self.write_text(\"Loaded config @ {}\".format(file_path))","def _load_config_file(self, path: str) -> Dict[str, Any]:\n try:\n with open(path) as file:\n conf = json.load(file)\n except FileNotFoundError:\n raise OperationalException(\n f'Config file \"{path}\" not found!'\n ' Please create a config file or check whether it exists.')\n\n return conf","def __load_config(self) -> dict:\n file = open(\"config.json\")\n config_file = json.load(file)\n file.close()\n return config_file","def load(filepath):\n with open(filepath) as f:\n return Config(json.load(f))","def _load_config(file):\n try:\n return bb.parse.handle(os.path.join('conf', file), bb.data.init() )\n except IOError, e:\n return None","def load_config(self, filename):\n # read entire file for metadata\n fh = open(filename, 'r')\n self.file_contents = fh.read()\n\n # replace !include directives with content\n config_dir = os.path.split(filename)[0]\n include_re = re.compile('^!include\\s+(.*)$', re.MULTILINE)\n def include_repl(matchobj):\n fname = os.path.join(config_dir, matchobj.group(1))\n with open(fname) as f:\n return f.read()\n while re.search(include_re, self.file_contents): # for recursive !include\n self.file_contents = re.sub(include_re, include_repl, self.file_contents)\n\n # read in dictionary\n self.config = self.__ordered_load(self.file_contents)\n\n # convert functions of other params to true expressions\n for k in self.config.keys():\n self.config[k] = ExperimentConfig.__convert_key(self.config[k])\n\n # load core configuration\n return self.config","def load(filename):\n conf = CommonConfig.get()\n conf.update(toml.load(filename))\n return conf","def load( self ):\n ini = codecs.open(self.filename,\"r\",\"utf-8\",errors=\"replace\",buffering=0)\n for l in ini:\n l = l.strip()\n if l:\n (name,value) = l.split(\"=\",1)\n self.conf[name.strip()] = value.strip()\n ini.close()","def loadconfig(self, configfile=None):\n realconfig = configfile\n if configfile is None:\n realconfig = Infopage.DEFAULT_CFGFILE\n try:\n fh = io.open(realconfig, 'r')\n config = json.load(fh)\n self.config.update(config)\n except IOError as e:\n if configfile is None:\n # ignore if the default config does not exist\n pass\n else:\n raise e","def load_config(self) -> Dict[str, Any]:\n # Load all configs\n config: Dict[str, Any] = self.load_from_files(self.args.get(\"config\", []))\n\n return config","def load_config(cls, path: str) -> GlobalConfig:\n with open(path, \"r\") as config_file:\n config_dict = yaml.load(config_file)\n cls.config = GlobalConfig(config_dict)\n return cls.config","def loadConfig(fileName=None):\n if not fileName:\n fileName = Config.userDir + \"config.py\"\n try:\n config = literal_eval( (open(fileName).read()) )\n except Exception,e:\n print(e)\n return\n for c in Config.userConfig:\n if c in config:\n setattr(Config, c, config[c])\n Config.update()","def parse(self):\n try:\n with open(self.path, 'r') as ymlfile:\n self.__cfg = yaml.load(ymlfile)\n except IOError:\n self.log(\"File {0} not found -- aborting\".format(self.path))\n raise ConfigFileException","def load_config(config_file=None):\n if Config.CONFIG:\n return Config.CONFIG\n else:\n try:\n if not config_file:\n config_file = os.path.join('./config/', 'bcl2fastq.config.yaml')\n Config.CONFIG = Config._load_yaml_config(config_file)\n return Config.CONFIG\n except IOError:\n raise IOError((\"There was a problem loading the configuration file. \"\n \"Please make sure that {0} exists and that you have \"\n \"read permissions\".format(config_file)))","def load_conf():\n if os.path.exists(CONF_FILE):\n with open(CONF_FILE, 'r') as infile:\n return json.load(infile)\n else:\n return {}","def _get_config_from_file(self, filename):\n\n with open(filename, 'r') as f:\n config = load(f)\n return config","def _read_config_file(self):\r\n\r\n try:\r\n with open(self.config, 'r') as f:\r\n config_data = json.load(f)\r\n except FileNotFoundError:\r\n config_data = {}\r\n\r\n return config_data","def load_config(config_file_path):\n global config\n try:\n config_file_path = os.path.abspath(config_file_path)\n assert config_file_path\n with open(file=config_file_path) as yaml_data:\n loaded_config = yaml.safe_load(yaml_data)\n for k in config:\n if k in loaded_config:\n config[k] = loaded_config[k]\n except AssertionError:\n print(f\"Config file {config_file_path} not found or unreadable ! Exiting..\")\n quit(1)","def load_from_file(self, file_path):\n\n with open(file_path) as f:\n config_text = f.read()\n self.load_from_string(config_text)","def _load_config_log(self):\n config_path = os.path.join(self.runtime.working_dir, '.config')\n if not os.path.isfile(config_path):\n return {}\n with open(config_path, 'r') as f:\n data = yaml.load(f)\n return data","def load(self, file):\n self.namespace['workflow'].configfile(file)\n self.updateNamespace()","def load_configuration(self) -> None:\n config_file = self.default_config_file\n if self.config_file:\n config_file = self.config_file\n self.config = configparser.ConfigParser(delimiters=\"=\")\n # mypy is unhappy with us assigning to a method - (monkeypatching?)\n self.config.optionxform = lambda option: option # type: ignore\n self.config.read(config_file)","def load_config(self):\n DEFAULT_CONFIG = {\n \"test_times\": 30,\n \"perfherder_protocol\": \"http\",\n \"perfherder_host\": \"local.treeherder.mozilla.org\",\n \"perfherder_client_id\": \"\",\n \"perfherder_secret\": \"\",\n \"perfherder_repo\": \"mozilla-central\",\n \"dashboard_host\": \"\",\n \"dashboard_ssh\": \"\"\n }\n logger_hasal.info('Loading config file from {} ...'.format(self._config_path))\n if os.path.isfile(self._config_path):\n with open(self._config_path, 'r') as f:\n ret_obj = json.load(f)\n test_times = ret_obj.get('test_times', '')\n perf_protocol = ret_obj.get('perfherder_protocol', '')\n perf_host = ret_obj.get('perfherder_host', '')\n perf_repo = ret_obj.get('perfherder_repo', '')\n if test_times:\n logger_hasal.info('Test Times: {}'.format(test_times))\n if perf_protocol:\n logger_hasal.info('Perfherder Protocol: {}'.format(perf_protocol))\n if perf_host:\n logger_hasal.info('Perfherder Host: {}'.format(perf_host))\n if perf_repo:\n logger_hasal.info('Perfherder Repo: {}'.format(perf_repo))\n return ret_obj\n else:\n with open(self._config_path, 'w') as f:\n f.write(json.dumps(DEFAULT_CONFIG))\n logger_hasal.info('No config.json file {}. Generate default config.'.format(self._config_path))\n return DEFAULT_CONFIG","def load_config(config_path):\n global config\n with open(config_path) as config_file:\n config = munchify(yaml.safe_load(config_file))","def load_config(self):\n conf_file = os.path.join(self._conf_dir, \"dql.json\")\n if not os.path.exists(conf_file):\n return {}\n with open(conf_file, \"r\") as ifile:\n return json.load(ifile)","def load_config(self):\n logger.debug('loading config file: %s', self.config_file)\n if os.path.exists(self.config_file):\n with open(self.config_file) as file_handle:\n return json.load(file_handle)\n else:\n logger.error('configuration file is required for eventify')\n logger.error('unable to load configuration for service')\n raise EventifyConfigError(\n 'Configuration is required! Missing: %s' % self.config_file\n )","def load_config(self):\n try:\n self.config = yaml.load(open(roslib.packages.get_pkg_dir('human_activities') + '/config/config.ini', 'r'))\n print \"config loaded:\", self.config.keys()\n\n return True\n except:\n print \"no config file found in /human_activities/config/config.ini\"\n return False","def load_config(cls, config_file = None):\n config = ConfigParser()\n \n files = [\"/etc/imp.cfg\", os.path.expanduser(\"~/.imp.cfg\"), \".wm\", \".imp\"]\n if config_file is not None:\n files.append(config_file)\n \n config.read(files)\n cls.__instance = config","def load_config(self, config_file = None):\n if config_file:\n return ET.parse(config_file)\n else:\n return ET.parse(self.config_file)","def loadConfigs(self):\n self.onLoadConfig(urlopen(self.inipath))","def _load_config(path) -> dict:\n with open(path, \"r\") as F:\n return json.load(F)","def load_configuration(self, path):\n with open(path) as conf_file:\n if path.name not in self.configuration:\n self.configuration[path.name] = {}\n self.configuration[path.name] = json.load(conf_file)","def get_config(self):\n if self.config is None:\n self.config = Configuration()\n\n #Hard coded the file for now, will change with Django interface\n self.config.parse_file('config')","def _load(self):\n p = os.path.join(paths.setup_dir, 'system_health.yaml')\n if os.path.isfile(p):\n with open(p, 'r') as rfile:\n config = yaml.load(rfile)\n if config:\n self._values = config['values']\n self._conditionals = config['conditionals']\n\n general = config['general']\n self._limit = general['limit']","def load(self, file, config={}):\n if not os.path.exists(file):\n raise SystemExit('ERROR: config file at \"{f}\" does not exist'.format(f=file))\n config = config.copy()\n cp = ConfigParser.ConfigParser()\n cp.read(file)\n for sec in cp.sections():\n name = sec.lower()\n for opt in cp.options(sec):\n config[name + \".\" + opt.lower()] = cp.get(sec, opt).strip()\n return config","def load_configuration(self):\n config = ConfigParser.ConfigParser()\n config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'config.properties')\n config.read(config_file)\n return dict(config.defaults())","def init_config(cls, path):\n try:\n config_string = open(path).read()\n except EnvironmentError as ex:\n LOGGER.error('Could not load %s file, error: %s', path, ex)\n sys.exit()\n\n try:\n cls.config = json.loads(config_string)\n except ValueError as ex:\n LOGGER.error(' %s file is not valid json, error: %s', path, ex)\n sys.exit()","def load_config(self, cfg: ConfigParser):\n log.debug('loading configuration file')\n section = cfg['DEFAULT']\n # use host-specific configuration, if any\n if self.hostname in cfg:\n section = cfg[self.hostname]\n self.path = os.path.abspath(os.path.expanduser(section['repo_dir']))\n self.gpg_key_id = section['gpg_key_id']\n self.ignored_files = section['ignored_files'].split(',')\n self.ignored_files.append('.gitkeep')","def load(self, filename):\n config = AbstractConfig(config_file=filename)\n\n self.__idx(config)","def load_config(filename):\n with open(filename, \"r\") as stream:\n try:\n global CONFIG\n CONFIG = yaml.load(stream)\n except yaml.YAMLError as ex:\n print(ex)","def load_from_file(self, config_file):\n try:\n \n self.configParser = configparser.ConfigParser(allow_no_value=True)\n self.configParser.read(config_file)\n \n\n self.uri = self._readConfigOption(\"RepositoryConfiguration\", \"uri\").rstrip('/')\n self.db_driver = self._readConfigOption(\"Database\", \"db_driver\")\n self.db_user = self._readConfigOption(\"Database\", \"db_user\")\n self.db_password = self._readConfigOption(\"Database\", \"db_password\")\n self.db_database = self._readConfigOption(\"Database\", \"db_database\")\n self.db_hostname = self._readConfigOption(\"Database\", \"db_hostname\")\n self.db_port = int(self._readConfigOption(\"Database\", \"db_port\"))\n self.db_authentiacation = self._readConfigOption(\"Database\", \"db_authentication\")\n\n # Check if dirs are readable\n readable_dir(self.uri)\n\n \n except Exception as e:\n raise Exception('Failed in reading config file %s. Original message: %s' % (config_file, e))","def load_config(self, context: ResourceCommandContext, config_file_location: str) -> None:\n enqueue_keep_alive(context)\n self.handler.load_config(context, config_file_location)","def load_config():\n config_check()\n try:\n with open(os.path.abspath(CONFIG_PATH), 'rb') as config_file:\n config = pickle.load(config_file)\n except IOError:\n # Create new empty config file\n with open(os.path.abspath(CONFIG_PATH), 'wb') as config_file:\n config = {\n \"blogs\": [],\n \"active_blog\": None\n }\n pickle.dump(config, config_file)\n return config","def load():\n print(\"Loading Configuration file..\")\n\n def load_defaults():\n global _conf\n _conf = get_defaults()\n save()\n\n if not os.path.exists(__config_file):\n load_defaults()\n return\n\n global _conf\n with open(__config_file, 'r', encoding='utf-8') as stream:\n _conf = yaml.round_trip_load(stream)\n \n if _conf is None:\n load_defaults()\n return\n \n version = _conf.get('_conf', -1)\n if version != VERSION:\n migrate(version)\n _conf['_conf'] = VERSION\n save()\n\n def mergeDict(old: dict, new: dict, layer=1) -> dict:\n \"\"\"\n Merge a dictionary into another while prefering the old values over the new\n\n :param old: original dictionary\n :param new: new dictionary to merge\n \"\"\"\n \n from collections import Mapping\n changed = False\n for key, val in new.items():\n # print(\"{} ({})\".format(key, type(old.get(key))))\n if not key in old:\n print(\"{}Adding new value {}\".format(' ' * layer, key))\n changed = True\n old[key] = val\n elif issubclass(type(old[key]), Mapping) and issubclass(type(val), Mapping):\n print(\"{}Merging dict {}\".format(' ' * layer, key))\n changed = changed or mergeDict(old[key], val, layer + 1)\n\n return changed\n \n defaults = get_defaults()\n if mergeDict(_conf, defaults):\n save()","def load_config(self, filename, basedir = '.'):\n #find absolute path for config file\n (f, filepath) = self.find_file(filename, [basedir, __VALIDATA_ETC__])\n if filepath in self.include:\n raise ConfigError('Recursively include config file \"%s\"!' % filepath)\n self.include.add(filepath)\n cfg = yaml.load(f)\n f.close()\n\n #decide base directory for current config file\n basedir = dirname(filepath)\n\n #get log file path\n if '__logfile' in cfg:\n logfile = cfg['__logfile']\n if logfile[0] != '/':\n logfile = basedir + '/' + logfile\n self.logfile = logfile\n\n #check if there's any external reference\n for key in cfg:\n #ignore keywords\n if key[:2] == '__':\n continue\n elif key[:1] == '_':\n if isinstance(cfg[key], list):\n continue\n #load external reference\n refname = cfg[key]\n (f, filepath) = self.find_file(refname, [basedir, __VALIDATA_ETC__])\n cfg[key] = [x.rstrip('\\r\\n').decode('utf8') for x in f if x.rstrip('\\r\\n') != '']\n f.close()\n print 'Reference file \"%s\" loaded.' % refname\n\n #load include file(s)\n if '__include' in cfg:\n include = cfg['__include']\n del cfg['__include']\n if not isinstance(include, list):\n include = [include]\n tmp = {}\n for i in include:\n tmp.update(self.load_config(i, basedir))\n tmp.update(cfg)\n cfg = tmp\n\n print 'Config file \"%s\" loaded.' % filename\n return cfg","def load_config(config_file):\n try:\n with open('settings.json', 'r') as f:\n return json.loads(f.read())\n except (IOError, Exception) as e:\n print '%s' % e\n exit()","def read_config():\n with open(CONFIG_PATH) as config_file:\n return json.load(config_file)","def _set_config():\n\n\tdebug_msg = \"load default config yaml file\"\n\tlogger.debug(debug_msg)\n\n\tconfig_file_parser(paths.CONFIG_FILE, override_options=True)","def load_cfg(filepath=\"./config.yaml\"):\n with open(filepath, \"r\") as f:\n return yaml.load(f, Loader=yaml.FullLoader)","def load_conf(self):\n\n self.load_file(self.ini_file)\n self.files = []\n conf_file = open(self.ini_file, \"r\")\n for l in conf_file:\n self.files.append(l.strip())\n conf_file.close()","def _load_config(self):\n\n for p in self._paths:\n if p.exists():\n with p.open() as f:\n c = yaml.safe_load(f)\n if c:\n c['_config_file'] = str(p)\n return c\n else:\n raise ConfigurationError(f\"Didn't find a config file in paths: {self._paths}\")\n\n return {}","def parse_config(self):\n # TODO: parse config file\n pass","def readConfig(self):\n filename = self.cfg.get(\"CFG_FILE\")\n\n logging.info(\"Reading configuration file **{}**\".format(filename))\n try:\n # track previous MAP_FILE setting - map only needs to be redrawn if it's changed\n oldmap = self.cfg.get(\"MAP_FILE\") # may be None\n execfile(filename, self.cfg)\n\n # display setings\n out = '\\n'\n for a, b in self.cfg.iteritems():\n # exclude unprintables\n if a is not \"__builtins__\" and a is not \"MAPREF\":\n out = \"{} \\t {}: {}\\n\".format(out, a, b)\n # logging.info\n logging.info(\"Options read from configuration file: {}\".format(out))\n\n self.processMap()\n self.initAgent()\n logging.info(\"Starting agent pre-processing...\")\n self.processPrefs()\n self.setStart(self.cfg.get(\"START\"))\n self.setGoal(self.cfg.get(\"GOAL\"))\n\n if self.gui is not None: # reset has been called from the gui\n self.gui.setLmap(self.lmap)\n if not oldmap == self.cfg.get(\"MAP_FILE\"):\n self.gui.vmap.drawMap(self.lmap)\n self.hdlReset() # includes resetVars\n else:\n self.resetVars() # no attempt to update GUI\n\n\n except p4.BadMapException:\n self.updateStatus(\"Unable to load map: \" + self.cfg.get(\"MAP_FILE\"))\n except p4.BadAgentException:\n self.updateStatus(\"Unable to load agent: \" + self.cfg.get(\"AGENT_FILE\"))\n except:\n # unexpected error\n logging.error(\"Trace-back: \\n {}\".format(traceback.format_exc()))\n self.updateStatus(\"Problem reading config file!\")","def load(self, file, config={}):\n if not os.path.exists(file):\n err = 'ERROR: config file at \"{f}\" does not exist'\n err = err.format(f=file)\n raise SettingsError(err)\n config = config.copy()\n cp = GoulashConfigParser()\n cp.read(file)\n return cp._sections","def config():\n with open(config_path) as config_file:\n data = json.load(config_file)\n return data","def load_config(self):\n\n with open(os.path.expanduser(self.config_filename), 'r') as f:\n lines = f.readlines()\n\n _usable = lambda l: not(l.startswith('#') or l.strip() == '')\n lines = filter(_usable, lines)\n\n def _build_config(key, value, d):\n \"\"\" Called recursively to split up keys \"\"\"\n pieces = key.split('.', 1)\n if len(pieces) == 1:\n d[pieces[0]] = value.strip()\n else:\n d[pieces[0]] = _build_config(pieces[1], value, {})\n\n return d\n\n d = {}\n for line in lines:\n if '=' not in line:\n continue\n\n key, value = line.split('=')\n d = _build_config(key, value, d)\n\n return d"],"string":"[\n \"def load_config(self):\\n pass\",\n \"def load_config(self):\\r\\n with open('config.json', 'r') as f:\\r\\n self.config = json.load(f)\",\n \"def load_config(self):\\n if os.path.exists(self.config_file):\\n with open(self.config_file) as f:\\n conf = json.load(f)\\n\\n self.update_attributes_from_config(conf)\",\n \"def load(file):\\n _config.load(file)\",\n \"def loadConf(self):\\n\\n with open(self.configFile) as f:\\n self.config = json.load(f)\",\n \"def load():\\n # get (or create) config path\\n p = initialize()\\n return load_config(open(p['config']))\",\n \"def read_config(self, config_filename):\",\n \"def load_config(self, config_file):\\n self.config = ConfigParser.ConfigParser()\\n self.config.read(config_file)\",\n \"def load_config(self):\\n with open(self.TEMPERATURE_CONFIG_FILE_PATH, 'r') as file:\\n self.config = json.load(file)\",\n \"def load_config_file(self):\\n\\n conf_file = config.DEFAULT_CONFIGURATION_FILE\\n\\n if self.options and getattr(self.options, \\\"conf_file\\\"):\\n conf_file = self.options.conf_file\\n if (\\n not os.path.exists(conf_file) and\\n not os.path.exists(\\\"%s.d\\\" % conf_file)\\n ):\\n raise Exception(\\n (\\n \\\"The specified configuration file \\\"\\n \\\"does not exist. File=(%s)\\\"\\n ) % self.options.conf_file\\n )\\n\\n self.from_file(conf_file)\",\n \"def load_conf(self):\\n self._read_uconf()\",\n \"def load_config():\\n\\t\\ttry:\\n\\t\\t\\tconf = ConfigParser()\\n\\n\\t\\t\\tconfig_path = get_config_path()\\n\\t\\t\\tconf.read(config_path)\\n\\n\\t\\t\\t# save references to conf, and config_path in class variables\\n\\t\\t\\tConfig.config_path = config_path\\n\\t\\t\\tConfig.conf = conf\\n\\n\\t\\t\\tConfig.source_dir = conf.get('paths', 'source_dir')\\n\\t\\t\\tConfig.lyrics_dir = conf.get('paths', 'lyrics_dir')\\n\\n\\t\\t\\tConfig.save_to_file = conf.getboolean('actions', 'save_to_file')\\n\\t\\t\\tConfig.save_to_tag = conf.getboolean('actions', 'save_to_tag')\\n\\n\\t\\t\\tConfig.overwrite = conf.getboolean('actions', 'overwrite')\\n\\n\\t\\t\\t# Load all the sources\\n\\t\\t\\tConfig.lyric_wikia = conf.getboolean('sources', 'lyric_wikia')\\n\\t\\t\\tConfig.musix_match = conf.getboolean('sources', 'musix_match')\\n\\t\\t\\tConfig.lyricsmode = conf.getboolean('sources', 'lyricsmode')\\n\\t\\t\\tConfig.az_lyrics = conf.getboolean('sources', 'az_lyrics')\\n\\n\\t\\t\\t# Loading this with user config, we need to call the load_config only once at start.\\n\\t\\t\\tConfig.lyric_files_in_dir = glob2.glob(os.path.join(Config.lyrics_dir, '**/*.txt'))\\n\\n\\n\\t\\t# Catch file handling errors\\n\\t\\texcept IOError as e:\\n\\t\\t\\tprint('Unable to load config.')\\n\\t\\t\\tprint(e)\",\n \"def init_config(self):\\n with open(self.config_file, 'r') as fh:\\n self.config = json.load(fh, object_pairs_hook=OrderedDict)\\n logger.info('Config loaded: %s' % os.path.abspath(self.config_file))\",\n \"def init_config(self):\\n with open(self.config_file, 'r') as fh:\\n self.config = json.load(fh, object_pairs_hook=OrderedDict)\\n logger.info('Config loaded: %s' % os.path.abspath(self.config_file))\",\n \"def load_config():\\n global config\\n\\n with open(\\\"config.json\\\") as f:\\n json_config = f.read()\\n f.close()\\n config = json.loads(json_config)\",\n \"def _load_config():\\n\\tcfg = configparser.ConfigParser()\\n\\tcfg.read(join(get_current_path(), 'ib.config'))\\n\\treturn cfg\",\n \"def read_configuration (self):\\n\\t\\tself.config.read(self._configfile)\",\n \"def load_config():\\n config = ConfigParser()\\n config.read(os.path.join(os.path.dirname(__file__), 'config.ini'))\\n return config\",\n \"def load_config():\\n global config\\n with open('config.yml', 'r') as file:\\n config = yaml.load(file)\",\n \"def load_config():\\n here = os.path.dirname(os.path.abspath(__file__))\\n config_path = os.path.join(here, 'config.json')\\n with open(config_path, encoding='utf-8') as f:\\n return json.load(f)\",\n \"def load_config():\\n config = configparser.ConfigParser()\\n config.read('config.ini')\\n return config\",\n \"def load(self):\\n with open(self.conf_fname, \\\"r\\\") as fd:\\n config = json.load(fd)\\n \\n return config\",\n \"def load(self):\\n try:\\n _config_file = open(self.config, 'r+')\\n data = json.loads(_config_file.read())\\n except (ValueError, IOError):\\n data = {}\\n\\n self.update(data)\",\n \"def load_config(filename):\\n AS[\\\"config\\\"] = load_yaml_file(filename)\",\n \"def loadConfig(self):\\r\\n self.config.read(self.CONFIG_FILE)\\r\\n try:\\r\\n assert \\\"Settings\\\" in self.config\\r\\n except AssertionError:\\r\\n print(\\\"Settings do not exist, creating new config file...\\\")\\r\\n self.saveConfig()\\r\\n settings = self.config[\\\"Settings\\\"]\\r\\n self.dataPath = settings.get(\\\"datapath\\\",fallback=\\\"\\\")\\r\\n self.videoPath = settings.get(\\\"videopath\\\",fallback=\\\"\\\")\\r\\n self.dataOffset = settings.getfloat(\\\"dataoffset\\\",fallback=0)\\r\\n self.colBlindMode = settings.getboolean(\\\"colblindmode\\\",False)\\r\\n if self.videoPath != \\\"\\\":\\r\\n self.loadVideo(self.videoPath,loadAudio=False)\\r\\n if self.dataPath != \\\"\\\":\\r\\n self.loadData(self.dataPath)\",\n \"def _load_config():\\n fname = _get_config_fname()\\n if fname is None or not op.isfile(fname):\\n return dict()\\n with open(fname, 'r') as fid:\\n config = json.load(fid)\\n return config\",\n \"def load_config(self):\\n if not self.config_file_path:\\n return False\\n with open(self.config_file_path) as f:\\n self.config = yaml.load(f)\\n return True\",\n \"def loadConfig(self, config_file):\\r\\n\\r\\n import json\\r\\n\\r\\n self.config = None\\r\\n\\r\\n try:\\r\\n with open(config_file) as f:\\r\\n self.config = json.load(f)\\r\\n except OSError as err:\\r\\n print(\\\"Unable to process {}, {}\\\".format(config_file, err))\\r\\n sys.exit(1)\",\n \"def loadConfig():\\n lines = []\\n config = {}\\n here = path.dirname(__file__)\\n fn = path.join(here,'manatee.conf')\\n try:\\n with codecs.open(fn,'rU','utf-8') as conf:\\n lines = conf.readlines()\\n conf.close()\\n except IOError as e:\\n print \\\" Could not open configuration file: %s\\\" % e\\n\\n for line in lines:\\n try:\\n line = line.strip()\\n if line:\\n values = [x.strip() for x in line.split('=')]\\n config[values[0]] = values[1]\\n except Exception as e:\\n print \\\"There was an error in the configuration file: %s\\\" % e\\n # TODO: Any strings from the config file that might be displayed or passed into the SQL server need to be validated here.\\n# config = validateConfig(config)\\n return config\",\n \"def _load_config():\\n\\tcfg = configparser.ConfigParser()\\n\\tcfg.read(os.path.join(get_current_directory(), 'citi.config'))\\n\\treturn cfg\",\n \"def load ( self ):\\n files = config.get_or_fail ( 'REPO.config_files' )\\n for f in files:\\n self.load_file ( f )\",\n \"def load_conf(self, filename):\\n\\n path = \\\"./source/_0_time_series_class/configuration/\\\"\\n filename = path + filename\\n \\n with open(filename) as file:\\n self.conf = json.loads(file.read())\",\n \"def cli_load_config(self, args) -> str:\\n path = args.config_path\\n if not os.path.isfile(path):\\n return error(\\\"Path {} DNE\\\".format(path))\\n\\n try:\\n self.config = config.from_file(path)\\n return ok(\\\"Configuration loaded from {}\\\".format(path))\\n except FileNotFoundError as err:\\n return error(\\\"Could not load file: {}\\\".format(err))\\n except json.JSONDecodeError as json_err:\\n return error(\\\"Could not parse json file {}\\\".format(json_err))\",\n \"def load_config( self, config_file=None ):\\n if config_file is None:\\n config_file = os.path.dirname(self.dbfile) + '/final.ini'\\n config_parser = ConfigParser.ConfigParser()\\n config_parser.read( config_file )\\n self.config = config_parser\\n return self.config\",\n \"def load(self):\\n config_dict = {}\\n with open(\\n os.path.join(\\n os.path.dirname(\\n os.path.abspath(\\n inspect.stack()[0][1]\\n )\\n ),\\n \\\"config.txt\\\"), 'r') as config_file:\\n for line in config_file:\\n if not line.startswith('#'):\\n line = line.strip().split('=', 1)\\n if len(line) == 2:\\n config_dict[line[0]] = line[1]\\n return config_dict\",\n \"def load_config(path):\\n # opens config file\\n try:\\n config = configparser.ConfigParser()\\n config.read(path)\\n return config\\n except Exception as e:\\n print(\\\"Error loading config file: \\\", e)\\n sys.exit(1)\",\n \"def load_from_conf(self):\\r\\n raise NotImplementedError\",\n \"def __read_config(self):\\n with open(self.config_file, 'r') as data_file:\\n dict = json.load(data_file)\\n self.ibooks_doc_root = dict[\\\"ibooks_doc_root\\\"]\\n self.library_folder = dict[\\\"library_folder\\\"]\\n self.annotation_folder = dict[\\\"annotation_folder\\\"]\\n self.tmp_dir = dict[\\\"tmp_dir\\\"]\",\n \"def load_config():\\n proj_dir = os.path.dirname(os.path.abspath(__file__))\\n config_path = os.path.join(proj_dir, \\\"config.yml\\\")\\n conf = yaml.safe_load(open(config_path))\\n return conf\",\n \"def load_config():\\n config_file = os.path.dirname(os.path.abspath(__file__)) + '/../config.json'\\n with open(config_file, 'r') as f:\\n config = json.load(f)\\n\\n return config\",\n \"def load_from_conf(self):\\n raise NotImplementedError\",\n \"def load_config(self, filename: str=None):\\n if not filename:\\n filename = self.config_file\\n with open(filename) as file_object:\\n config = json.load(file_object)\\n if isinstance(config, dict):\\n for key, value in config.items():\\n self.config[key] = value\",\n \"def load_config():\\n config_file = os.path.join(\\n Path(os.path.dirname(os.path.realpath(__file__))).parent,\\n \\\"config.ini\\\"\\n )\\n if not os.path.exists(config_file):\\n raise FileNotFoundError(config_file)\\n app_config = configparser.ConfigParser()\\n app_config.read(config_file)\\n return app_config['uberoo']\",\n \"def load_config(self):\\n h_config = configparser.ConfigParser()\\n with self.config_file.open() as configfile:\\n h_config.read_file(configfile)\\n if not (\\\"general\\\" in h_config.keys() and \\\"unifi\\\" in h_config.keys() and \\\"hue\\\" in h_config.keys()):\\n logging.warning(\\\"Configuration file {} is invalid.\\\".format(self.config_file))\\n return\\n if not self.configuration.interval:\\n self.configuration.interval = int(h_config[\\\"general\\\"][\\\"interval\\\"])\\n if not self.configuration.wifi_clients:\\n self.configuration.wifi_clients = h_config[\\\"general\\\"][\\\"wifi_clients\\\"].split(\\\",\\\")\\n if not self.configuration.schedules_names:\\n self.configuration.schedules_names = h_config[\\\"general\\\"][\\\"schedules_name\\\"].split(\\\",\\\")\\n if not self.configuration.unifi_host:\\n self.configuration.unifi_host = h_config[\\\"unifi\\\"][\\\"host\\\"]\\n if not self.configuration.unifi_port:\\n self.configuration.unifi_port = int(h_config[\\\"unifi\\\"][\\\"port\\\"])\\n if not self.configuration.unifi_username:\\n self.configuration.unifi_username = h_config[\\\"unifi\\\"][\\\"username\\\"]\\n if not self.configuration.unifi_password:\\n self.configuration.unifi_password = h_config[\\\"unifi\\\"][\\\"password\\\"]\\n if not self.configuration.hue_host:\\n self.configuration.hue_host = h_config[\\\"hue\\\"][\\\"host\\\"]\\n if not self.configuration.hue_port:\\n self.configuration.hue_port = int(h_config[\\\"hue\\\"][\\\"port\\\"])\\n if not self.configuration.hue_key:\\n self.configuration.hue_key = h_config[\\\"hue\\\"][\\\"key\\\"]\\n\\n if \\\"general\\\" in h_config.keys():\\n if not self.configuration.pub_host:\\n self.configuration.pub_host = h_config[\\\"zmq\\\"][\\\"host\\\"]\\n if not self.configuration.pub_port:\\n self.configuration.pub_port = int(h_config[\\\"zmq\\\"][\\\"port\\\"])\\n if \\\"no_pub\\\" not in self.configuration:\\n self.configuration.no_pub = bool(int(h_config[\\\"zmq\\\"][\\\"disabled\\\"]))\\n\\n if \\\"logging\\\" in h_config.keys():\\n if \\\"syslog_host\\\" in h_config[\\\"logging\\\"].keys() and not self.configuration.syslog_host:\\n self.configuration.syslog_host = h_config[\\\"logging\\\"][\\\"syslog_host\\\"]\\n if \\\"syslog_port\\\" in h_config[\\\"logging\\\"].keys():\\n self.configuration.syslog_port = int(h_config[\\\"logging\\\"][\\\"syslog_port\\\"])\\n if \\\"log_file\\\" in h_config[\\\"logging\\\"].keys() and not self.configuration.log_file:\\n self.configuration.log_file = Path(h_config[\\\"logging\\\"][\\\"log_file\\\"])\\n\\n logging.info(\\\"Configuration loaded from {}\\\".format(str(self.config_file)))\\n logging.debug(self.configuration)\",\n \"def load_config(self, filename):\\n # check if config file exists\\n if not os.path.exists(filename):\\n raise Exception(\\\"Can't find configuration {}.\\\".format(filename))\\n # load config file\\n config = configparser.ConfigParser()\\n with open(filename, 'r') as config_file:\\n config.read_file(config_file)\\n return config\",\n \"def load_config(self, path=\\\"\\\"):\\n if not path:\\n if not os.path.isdir(CONFIG_DIR):\\n os.makedirs(CONFIG_DIR)\\n file_path = QtGui.QFileDialog.getOpenFileName(self,\\n \\\"Open Config\\\",\\n CONFIG_DIR,\\n \\\"Config Files (*.cfg)\\\")\\n else:\\n file_path = path\\n self._load_state(file_path)\\n #self.write_text(\\\"Loaded config @ {}\\\".format(file_path))\",\n \"def _load_config_file(self, path: str) -> Dict[str, Any]:\\n try:\\n with open(path) as file:\\n conf = json.load(file)\\n except FileNotFoundError:\\n raise OperationalException(\\n f'Config file \\\"{path}\\\" not found!'\\n ' Please create a config file or check whether it exists.')\\n\\n return conf\",\n \"def __load_config(self) -> dict:\\n file = open(\\\"config.json\\\")\\n config_file = json.load(file)\\n file.close()\\n return config_file\",\n \"def load(filepath):\\n with open(filepath) as f:\\n return Config(json.load(f))\",\n \"def _load_config(file):\\n try:\\n return bb.parse.handle(os.path.join('conf', file), bb.data.init() )\\n except IOError, e:\\n return None\",\n \"def load_config(self, filename):\\n # read entire file for metadata\\n fh = open(filename, 'r')\\n self.file_contents = fh.read()\\n\\n # replace !include directives with content\\n config_dir = os.path.split(filename)[0]\\n include_re = re.compile('^!include\\\\s+(.*)$', re.MULTILINE)\\n def include_repl(matchobj):\\n fname = os.path.join(config_dir, matchobj.group(1))\\n with open(fname) as f:\\n return f.read()\\n while re.search(include_re, self.file_contents): # for recursive !include\\n self.file_contents = re.sub(include_re, include_repl, self.file_contents)\\n\\n # read in dictionary\\n self.config = self.__ordered_load(self.file_contents)\\n\\n # convert functions of other params to true expressions\\n for k in self.config.keys():\\n self.config[k] = ExperimentConfig.__convert_key(self.config[k])\\n\\n # load core configuration\\n return self.config\",\n \"def load(filename):\\n conf = CommonConfig.get()\\n conf.update(toml.load(filename))\\n return conf\",\n \"def load( self ):\\n ini = codecs.open(self.filename,\\\"r\\\",\\\"utf-8\\\",errors=\\\"replace\\\",buffering=0)\\n for l in ini:\\n l = l.strip()\\n if l:\\n (name,value) = l.split(\\\"=\\\",1)\\n self.conf[name.strip()] = value.strip()\\n ini.close()\",\n \"def loadconfig(self, configfile=None):\\n realconfig = configfile\\n if configfile is None:\\n realconfig = Infopage.DEFAULT_CFGFILE\\n try:\\n fh = io.open(realconfig, 'r')\\n config = json.load(fh)\\n self.config.update(config)\\n except IOError as e:\\n if configfile is None:\\n # ignore if the default config does not exist\\n pass\\n else:\\n raise e\",\n \"def load_config(self) -> Dict[str, Any]:\\n # Load all configs\\n config: Dict[str, Any] = self.load_from_files(self.args.get(\\\"config\\\", []))\\n\\n return config\",\n \"def load_config(cls, path: str) -> GlobalConfig:\\n with open(path, \\\"r\\\") as config_file:\\n config_dict = yaml.load(config_file)\\n cls.config = GlobalConfig(config_dict)\\n return cls.config\",\n \"def loadConfig(fileName=None):\\n if not fileName:\\n fileName = Config.userDir + \\\"config.py\\\"\\n try:\\n config = literal_eval( (open(fileName).read()) )\\n except Exception,e:\\n print(e)\\n return\\n for c in Config.userConfig:\\n if c in config:\\n setattr(Config, c, config[c])\\n Config.update()\",\n \"def parse(self):\\n try:\\n with open(self.path, 'r') as ymlfile:\\n self.__cfg = yaml.load(ymlfile)\\n except IOError:\\n self.log(\\\"File {0} not found -- aborting\\\".format(self.path))\\n raise ConfigFileException\",\n \"def load_config(config_file=None):\\n if Config.CONFIG:\\n return Config.CONFIG\\n else:\\n try:\\n if not config_file:\\n config_file = os.path.join('./config/', 'bcl2fastq.config.yaml')\\n Config.CONFIG = Config._load_yaml_config(config_file)\\n return Config.CONFIG\\n except IOError:\\n raise IOError((\\\"There was a problem loading the configuration file. \\\"\\n \\\"Please make sure that {0} exists and that you have \\\"\\n \\\"read permissions\\\".format(config_file)))\",\n \"def load_conf():\\n if os.path.exists(CONF_FILE):\\n with open(CONF_FILE, 'r') as infile:\\n return json.load(infile)\\n else:\\n return {}\",\n \"def _get_config_from_file(self, filename):\\n\\n with open(filename, 'r') as f:\\n config = load(f)\\n return config\",\n \"def _read_config_file(self):\\r\\n\\r\\n try:\\r\\n with open(self.config, 'r') as f:\\r\\n config_data = json.load(f)\\r\\n except FileNotFoundError:\\r\\n config_data = {}\\r\\n\\r\\n return config_data\",\n \"def load_config(config_file_path):\\n global config\\n try:\\n config_file_path = os.path.abspath(config_file_path)\\n assert config_file_path\\n with open(file=config_file_path) as yaml_data:\\n loaded_config = yaml.safe_load(yaml_data)\\n for k in config:\\n if k in loaded_config:\\n config[k] = loaded_config[k]\\n except AssertionError:\\n print(f\\\"Config file {config_file_path} not found or unreadable ! Exiting..\\\")\\n quit(1)\",\n \"def load_from_file(self, file_path):\\n\\n with open(file_path) as f:\\n config_text = f.read()\\n self.load_from_string(config_text)\",\n \"def _load_config_log(self):\\n config_path = os.path.join(self.runtime.working_dir, '.config')\\n if not os.path.isfile(config_path):\\n return {}\\n with open(config_path, 'r') as f:\\n data = yaml.load(f)\\n return data\",\n \"def load(self, file):\\n self.namespace['workflow'].configfile(file)\\n self.updateNamespace()\",\n \"def load_configuration(self) -> None:\\n config_file = self.default_config_file\\n if self.config_file:\\n config_file = self.config_file\\n self.config = configparser.ConfigParser(delimiters=\\\"=\\\")\\n # mypy is unhappy with us assigning to a method - (monkeypatching?)\\n self.config.optionxform = lambda option: option # type: ignore\\n self.config.read(config_file)\",\n \"def load_config(self):\\n DEFAULT_CONFIG = {\\n \\\"test_times\\\": 30,\\n \\\"perfherder_protocol\\\": \\\"http\\\",\\n \\\"perfherder_host\\\": \\\"local.treeherder.mozilla.org\\\",\\n \\\"perfherder_client_id\\\": \\\"\\\",\\n \\\"perfherder_secret\\\": \\\"\\\",\\n \\\"perfherder_repo\\\": \\\"mozilla-central\\\",\\n \\\"dashboard_host\\\": \\\"\\\",\\n \\\"dashboard_ssh\\\": \\\"\\\"\\n }\\n logger_hasal.info('Loading config file from {} ...'.format(self._config_path))\\n if os.path.isfile(self._config_path):\\n with open(self._config_path, 'r') as f:\\n ret_obj = json.load(f)\\n test_times = ret_obj.get('test_times', '')\\n perf_protocol = ret_obj.get('perfherder_protocol', '')\\n perf_host = ret_obj.get('perfherder_host', '')\\n perf_repo = ret_obj.get('perfherder_repo', '')\\n if test_times:\\n logger_hasal.info('Test Times: {}'.format(test_times))\\n if perf_protocol:\\n logger_hasal.info('Perfherder Protocol: {}'.format(perf_protocol))\\n if perf_host:\\n logger_hasal.info('Perfherder Host: {}'.format(perf_host))\\n if perf_repo:\\n logger_hasal.info('Perfherder Repo: {}'.format(perf_repo))\\n return ret_obj\\n else:\\n with open(self._config_path, 'w') as f:\\n f.write(json.dumps(DEFAULT_CONFIG))\\n logger_hasal.info('No config.json file {}. Generate default config.'.format(self._config_path))\\n return DEFAULT_CONFIG\",\n \"def load_config(config_path):\\n global config\\n with open(config_path) as config_file:\\n config = munchify(yaml.safe_load(config_file))\",\n \"def load_config(self):\\n conf_file = os.path.join(self._conf_dir, \\\"dql.json\\\")\\n if not os.path.exists(conf_file):\\n return {}\\n with open(conf_file, \\\"r\\\") as ifile:\\n return json.load(ifile)\",\n \"def load_config(self):\\n logger.debug('loading config file: %s', self.config_file)\\n if os.path.exists(self.config_file):\\n with open(self.config_file) as file_handle:\\n return json.load(file_handle)\\n else:\\n logger.error('configuration file is required for eventify')\\n logger.error('unable to load configuration for service')\\n raise EventifyConfigError(\\n 'Configuration is required! Missing: %s' % self.config_file\\n )\",\n \"def load_config(self):\\n try:\\n self.config = yaml.load(open(roslib.packages.get_pkg_dir('human_activities') + '/config/config.ini', 'r'))\\n print \\\"config loaded:\\\", self.config.keys()\\n\\n return True\\n except:\\n print \\\"no config file found in /human_activities/config/config.ini\\\"\\n return False\",\n \"def load_config(cls, config_file = None):\\n config = ConfigParser()\\n \\n files = [\\\"/etc/imp.cfg\\\", os.path.expanduser(\\\"~/.imp.cfg\\\"), \\\".wm\\\", \\\".imp\\\"]\\n if config_file is not None:\\n files.append(config_file)\\n \\n config.read(files)\\n cls.__instance = config\",\n \"def load_config(self, config_file = None):\\n if config_file:\\n return ET.parse(config_file)\\n else:\\n return ET.parse(self.config_file)\",\n \"def loadConfigs(self):\\n self.onLoadConfig(urlopen(self.inipath))\",\n \"def _load_config(path) -> dict:\\n with open(path, \\\"r\\\") as F:\\n return json.load(F)\",\n \"def load_configuration(self, path):\\n with open(path) as conf_file:\\n if path.name not in self.configuration:\\n self.configuration[path.name] = {}\\n self.configuration[path.name] = json.load(conf_file)\",\n \"def get_config(self):\\n if self.config is None:\\n self.config = Configuration()\\n\\n #Hard coded the file for now, will change with Django interface\\n self.config.parse_file('config')\",\n \"def _load(self):\\n p = os.path.join(paths.setup_dir, 'system_health.yaml')\\n if os.path.isfile(p):\\n with open(p, 'r') as rfile:\\n config = yaml.load(rfile)\\n if config:\\n self._values = config['values']\\n self._conditionals = config['conditionals']\\n\\n general = config['general']\\n self._limit = general['limit']\",\n \"def load(self, file, config={}):\\n if not os.path.exists(file):\\n raise SystemExit('ERROR: config file at \\\"{f}\\\" does not exist'.format(f=file))\\n config = config.copy()\\n cp = ConfigParser.ConfigParser()\\n cp.read(file)\\n for sec in cp.sections():\\n name = sec.lower()\\n for opt in cp.options(sec):\\n config[name + \\\".\\\" + opt.lower()] = cp.get(sec, opt).strip()\\n return config\",\n \"def load_configuration(self):\\n config = ConfigParser.ConfigParser()\\n config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'config.properties')\\n config.read(config_file)\\n return dict(config.defaults())\",\n \"def init_config(cls, path):\\n try:\\n config_string = open(path).read()\\n except EnvironmentError as ex:\\n LOGGER.error('Could not load %s file, error: %s', path, ex)\\n sys.exit()\\n\\n try:\\n cls.config = json.loads(config_string)\\n except ValueError as ex:\\n LOGGER.error(' %s file is not valid json, error: %s', path, ex)\\n sys.exit()\",\n \"def load_config(self, cfg: ConfigParser):\\n log.debug('loading configuration file')\\n section = cfg['DEFAULT']\\n # use host-specific configuration, if any\\n if self.hostname in cfg:\\n section = cfg[self.hostname]\\n self.path = os.path.abspath(os.path.expanduser(section['repo_dir']))\\n self.gpg_key_id = section['gpg_key_id']\\n self.ignored_files = section['ignored_files'].split(',')\\n self.ignored_files.append('.gitkeep')\",\n \"def load(self, filename):\\n config = AbstractConfig(config_file=filename)\\n\\n self.__idx(config)\",\n \"def load_config(filename):\\n with open(filename, \\\"r\\\") as stream:\\n try:\\n global CONFIG\\n CONFIG = yaml.load(stream)\\n except yaml.YAMLError as ex:\\n print(ex)\",\n \"def load_from_file(self, config_file):\\n try:\\n \\n self.configParser = configparser.ConfigParser(allow_no_value=True)\\n self.configParser.read(config_file)\\n \\n\\n self.uri = self._readConfigOption(\\\"RepositoryConfiguration\\\", \\\"uri\\\").rstrip('/')\\n self.db_driver = self._readConfigOption(\\\"Database\\\", \\\"db_driver\\\")\\n self.db_user = self._readConfigOption(\\\"Database\\\", \\\"db_user\\\")\\n self.db_password = self._readConfigOption(\\\"Database\\\", \\\"db_password\\\")\\n self.db_database = self._readConfigOption(\\\"Database\\\", \\\"db_database\\\")\\n self.db_hostname = self._readConfigOption(\\\"Database\\\", \\\"db_hostname\\\")\\n self.db_port = int(self._readConfigOption(\\\"Database\\\", \\\"db_port\\\"))\\n self.db_authentiacation = self._readConfigOption(\\\"Database\\\", \\\"db_authentication\\\")\\n\\n # Check if dirs are readable\\n readable_dir(self.uri)\\n\\n \\n except Exception as e:\\n raise Exception('Failed in reading config file %s. Original message: %s' % (config_file, e))\",\n \"def load_config(self, context: ResourceCommandContext, config_file_location: str) -> None:\\n enqueue_keep_alive(context)\\n self.handler.load_config(context, config_file_location)\",\n \"def load_config():\\n config_check()\\n try:\\n with open(os.path.abspath(CONFIG_PATH), 'rb') as config_file:\\n config = pickle.load(config_file)\\n except IOError:\\n # Create new empty config file\\n with open(os.path.abspath(CONFIG_PATH), 'wb') as config_file:\\n config = {\\n \\\"blogs\\\": [],\\n \\\"active_blog\\\": None\\n }\\n pickle.dump(config, config_file)\\n return config\",\n \"def load():\\n print(\\\"Loading Configuration file..\\\")\\n\\n def load_defaults():\\n global _conf\\n _conf = get_defaults()\\n save()\\n\\n if not os.path.exists(__config_file):\\n load_defaults()\\n return\\n\\n global _conf\\n with open(__config_file, 'r', encoding='utf-8') as stream:\\n _conf = yaml.round_trip_load(stream)\\n \\n if _conf is None:\\n load_defaults()\\n return\\n \\n version = _conf.get('_conf', -1)\\n if version != VERSION:\\n migrate(version)\\n _conf['_conf'] = VERSION\\n save()\\n\\n def mergeDict(old: dict, new: dict, layer=1) -> dict:\\n \\\"\\\"\\\"\\n Merge a dictionary into another while prefering the old values over the new\\n\\n :param old: original dictionary\\n :param new: new dictionary to merge\\n \\\"\\\"\\\"\\n \\n from collections import Mapping\\n changed = False\\n for key, val in new.items():\\n # print(\\\"{} ({})\\\".format(key, type(old.get(key))))\\n if not key in old:\\n print(\\\"{}Adding new value {}\\\".format(' ' * layer, key))\\n changed = True\\n old[key] = val\\n elif issubclass(type(old[key]), Mapping) and issubclass(type(val), Mapping):\\n print(\\\"{}Merging dict {}\\\".format(' ' * layer, key))\\n changed = changed or mergeDict(old[key], val, layer + 1)\\n\\n return changed\\n \\n defaults = get_defaults()\\n if mergeDict(_conf, defaults):\\n save()\",\n \"def load_config(self, filename, basedir = '.'):\\n #find absolute path for config file\\n (f, filepath) = self.find_file(filename, [basedir, __VALIDATA_ETC__])\\n if filepath in self.include:\\n raise ConfigError('Recursively include config file \\\"%s\\\"!' % filepath)\\n self.include.add(filepath)\\n cfg = yaml.load(f)\\n f.close()\\n\\n #decide base directory for current config file\\n basedir = dirname(filepath)\\n\\n #get log file path\\n if '__logfile' in cfg:\\n logfile = cfg['__logfile']\\n if logfile[0] != '/':\\n logfile = basedir + '/' + logfile\\n self.logfile = logfile\\n\\n #check if there's any external reference\\n for key in cfg:\\n #ignore keywords\\n if key[:2] == '__':\\n continue\\n elif key[:1] == '_':\\n if isinstance(cfg[key], list):\\n continue\\n #load external reference\\n refname = cfg[key]\\n (f, filepath) = self.find_file(refname, [basedir, __VALIDATA_ETC__])\\n cfg[key] = [x.rstrip('\\\\r\\\\n').decode('utf8') for x in f if x.rstrip('\\\\r\\\\n') != '']\\n f.close()\\n print 'Reference file \\\"%s\\\" loaded.' % refname\\n\\n #load include file(s)\\n if '__include' in cfg:\\n include = cfg['__include']\\n del cfg['__include']\\n if not isinstance(include, list):\\n include = [include]\\n tmp = {}\\n for i in include:\\n tmp.update(self.load_config(i, basedir))\\n tmp.update(cfg)\\n cfg = tmp\\n\\n print 'Config file \\\"%s\\\" loaded.' % filename\\n return cfg\",\n \"def load_config(config_file):\\n try:\\n with open('settings.json', 'r') as f:\\n return json.loads(f.read())\\n except (IOError, Exception) as e:\\n print '%s' % e\\n exit()\",\n \"def read_config():\\n with open(CONFIG_PATH) as config_file:\\n return json.load(config_file)\",\n \"def _set_config():\\n\\n\\tdebug_msg = \\\"load default config yaml file\\\"\\n\\tlogger.debug(debug_msg)\\n\\n\\tconfig_file_parser(paths.CONFIG_FILE, override_options=True)\",\n \"def load_cfg(filepath=\\\"./config.yaml\\\"):\\n with open(filepath, \\\"r\\\") as f:\\n return yaml.load(f, Loader=yaml.FullLoader)\",\n \"def load_conf(self):\\n\\n self.load_file(self.ini_file)\\n self.files = []\\n conf_file = open(self.ini_file, \\\"r\\\")\\n for l in conf_file:\\n self.files.append(l.strip())\\n conf_file.close()\",\n \"def _load_config(self):\\n\\n for p in self._paths:\\n if p.exists():\\n with p.open() as f:\\n c = yaml.safe_load(f)\\n if c:\\n c['_config_file'] = str(p)\\n return c\\n else:\\n raise ConfigurationError(f\\\"Didn't find a config file in paths: {self._paths}\\\")\\n\\n return {}\",\n \"def parse_config(self):\\n # TODO: parse config file\\n pass\",\n \"def readConfig(self):\\n filename = self.cfg.get(\\\"CFG_FILE\\\")\\n\\n logging.info(\\\"Reading configuration file **{}**\\\".format(filename))\\n try:\\n # track previous MAP_FILE setting - map only needs to be redrawn if it's changed\\n oldmap = self.cfg.get(\\\"MAP_FILE\\\") # may be None\\n execfile(filename, self.cfg)\\n\\n # display setings\\n out = '\\\\n'\\n for a, b in self.cfg.iteritems():\\n # exclude unprintables\\n if a is not \\\"__builtins__\\\" and a is not \\\"MAPREF\\\":\\n out = \\\"{} \\\\t {}: {}\\\\n\\\".format(out, a, b)\\n # logging.info\\n logging.info(\\\"Options read from configuration file: {}\\\".format(out))\\n\\n self.processMap()\\n self.initAgent()\\n logging.info(\\\"Starting agent pre-processing...\\\")\\n self.processPrefs()\\n self.setStart(self.cfg.get(\\\"START\\\"))\\n self.setGoal(self.cfg.get(\\\"GOAL\\\"))\\n\\n if self.gui is not None: # reset has been called from the gui\\n self.gui.setLmap(self.lmap)\\n if not oldmap == self.cfg.get(\\\"MAP_FILE\\\"):\\n self.gui.vmap.drawMap(self.lmap)\\n self.hdlReset() # includes resetVars\\n else:\\n self.resetVars() # no attempt to update GUI\\n\\n\\n except p4.BadMapException:\\n self.updateStatus(\\\"Unable to load map: \\\" + self.cfg.get(\\\"MAP_FILE\\\"))\\n except p4.BadAgentException:\\n self.updateStatus(\\\"Unable to load agent: \\\" + self.cfg.get(\\\"AGENT_FILE\\\"))\\n except:\\n # unexpected error\\n logging.error(\\\"Trace-back: \\\\n {}\\\".format(traceback.format_exc()))\\n self.updateStatus(\\\"Problem reading config file!\\\")\",\n \"def load(self, file, config={}):\\n if not os.path.exists(file):\\n err = 'ERROR: config file at \\\"{f}\\\" does not exist'\\n err = err.format(f=file)\\n raise SettingsError(err)\\n config = config.copy()\\n cp = GoulashConfigParser()\\n cp.read(file)\\n return cp._sections\",\n \"def config():\\n with open(config_path) as config_file:\\n data = json.load(config_file)\\n return data\",\n \"def load_config(self):\\n\\n with open(os.path.expanduser(self.config_filename), 'r') as f:\\n lines = f.readlines()\\n\\n _usable = lambda l: not(l.startswith('#') or l.strip() == '')\\n lines = filter(_usable, lines)\\n\\n def _build_config(key, value, d):\\n \\\"\\\"\\\" Called recursively to split up keys \\\"\\\"\\\"\\n pieces = key.split('.', 1)\\n if len(pieces) == 1:\\n d[pieces[0]] = value.strip()\\n else:\\n d[pieces[0]] = _build_config(pieces[1], value, {})\\n\\n return d\\n\\n d = {}\\n for line in lines:\\n if '=' not in line:\\n continue\\n\\n key, value = line.split('=')\\n d = _build_config(key, value, d)\\n\\n return d\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8379018","0.8353927","0.8132022","0.8111965","0.8104528","0.79837865","0.7953077","0.78238404","0.7770456","0.77264285","0.77023524","0.7679735","0.7665702","0.7665702","0.76194495","0.76163685","0.7611368","0.75783414","0.7574488","0.7554147","0.752987","0.75162137","0.7503696","0.74936754","0.7470804","0.7467447","0.7466623","0.74653757","0.74632823","0.74539894","0.7429376","0.7421454","0.7407486","0.74065197","0.7400068","0.7380263","0.73612833","0.73517627","0.73487437","0.7342034","0.73260874","0.7297708","0.72916794","0.72827816","0.7282646","0.72805446","0.72768736","0.726665","0.7260592","0.72448766","0.72423935","0.7233299","0.7190436","0.71866673","0.71820235","0.7162534","0.71461856","0.7135165","0.71240366","0.7113913","0.7107502","0.7100857","0.7100783","0.7090044","0.7071489","0.70660836","0.70641524","0.70618796","0.7053403","0.7053185","0.7045926","0.7045669","0.7034596","0.7034403","0.703184","0.70280665","0.7027885","0.70165664","0.701145","0.70002097","0.69975114","0.6994143","0.6986454","0.698299","0.69791204","0.69726515","0.6972059","0.69709504","0.6967259","0.6957323","0.6957137","0.6950377","0.6935683","0.69317657","0.6926174","0.6922323","0.692064","0.69203484","0.6914944","0.69078416","0.69035274"],"string":"[\n \"0.8379018\",\n \"0.8353927\",\n \"0.8132022\",\n \"0.8111965\",\n \"0.8104528\",\n \"0.79837865\",\n \"0.7953077\",\n \"0.78238404\",\n \"0.7770456\",\n \"0.77264285\",\n \"0.77023524\",\n \"0.7679735\",\n \"0.7665702\",\n \"0.7665702\",\n \"0.76194495\",\n \"0.76163685\",\n \"0.7611368\",\n \"0.75783414\",\n \"0.7574488\",\n \"0.7554147\",\n \"0.752987\",\n \"0.75162137\",\n \"0.7503696\",\n \"0.74936754\",\n \"0.7470804\",\n \"0.7467447\",\n \"0.7466623\",\n \"0.74653757\",\n \"0.74632823\",\n \"0.74539894\",\n \"0.7429376\",\n \"0.7421454\",\n \"0.7407486\",\n \"0.74065197\",\n \"0.7400068\",\n \"0.7380263\",\n \"0.73612833\",\n \"0.73517627\",\n \"0.73487437\",\n \"0.7342034\",\n \"0.73260874\",\n \"0.7297708\",\n \"0.72916794\",\n \"0.72827816\",\n \"0.7282646\",\n \"0.72805446\",\n \"0.72768736\",\n \"0.726665\",\n \"0.7260592\",\n \"0.72448766\",\n \"0.72423935\",\n \"0.7233299\",\n \"0.7190436\",\n \"0.71866673\",\n \"0.71820235\",\n \"0.7162534\",\n \"0.71461856\",\n \"0.7135165\",\n \"0.71240366\",\n \"0.7113913\",\n \"0.7107502\",\n \"0.7100857\",\n \"0.7100783\",\n \"0.7090044\",\n \"0.7071489\",\n \"0.70660836\",\n \"0.70641524\",\n \"0.70618796\",\n \"0.7053403\",\n \"0.7053185\",\n \"0.7045926\",\n \"0.7045669\",\n \"0.7034596\",\n \"0.7034403\",\n \"0.703184\",\n \"0.70280665\",\n \"0.7027885\",\n \"0.70165664\",\n \"0.701145\",\n \"0.70002097\",\n \"0.69975114\",\n \"0.6994143\",\n \"0.6986454\",\n \"0.698299\",\n \"0.69791204\",\n \"0.69726515\",\n \"0.6972059\",\n \"0.69709504\",\n \"0.6967259\",\n \"0.6957323\",\n \"0.6957137\",\n \"0.6950377\",\n \"0.6935683\",\n \"0.69317657\",\n \"0.6926174\",\n \"0.6922323\",\n \"0.692064\",\n \"0.69203484\",\n \"0.6914944\",\n \"0.69078416\",\n \"0.69035274\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":176,"cells":{"query":{"kind":"string","value":"Saves the config file"},"document":{"kind":"string","value":"def save_config_file(self):\n with open(self.config_file_name, 'w',encoding='utf-8') as outfile:\n json.dump(self._config, outfile,indent=2)"},"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 save(self):\n file = open(self.path, 'w')\n self.config.write(file)\n file.close()","def save(self):\r\n with open(self.filename, 'wb') as configfile:\r\n self.write(configfile)","def save_config(self):\n config.save_config(self.config, self.config_file)","def save():\n\n env.config.save(env.config_file)","def save():\n\t\ttry:\n\t\t\t#paths\n\t\t\tConfig.conf.set('paths', 'source_dir', Config.source_dir)\n\t\t\tConfig.conf.set('paths', 'lyrics_dir', Config.lyrics_dir)\n\n\t\t\t#actions\n\t\t\tConfig.setBool('actions', 'save_to_file', Config.save_to_file)\n\t\t\tConfig.setBool('actions', 'save_to_tag', Config.save_to_tag)\n\n\t\t\t#sources\n\t\t\tConfig.setBool('sources', 'lyric_wikia', Config.lyric_wikia)\n\t\t\tConfig.setBool('sources', 'musix_match', Config.musix_match)\n\t\t\tConfig.setBool('sources', 'lyricsmode', Config.lyricsmode)\n\t\t\tConfig.setBool('sources', 'az_lyrics', Config.az_lyrics)\n\n\t\t\twith open(Config.config_path, 'w') as configfile:\n\t\t\t\tConfig.conf.write(configfile)\n\t\t\treturn True\n\n\t\t# Catch all config parser errors\n\t\texcept BaseConfigParserError as e:\n\t\t\tprint('Unable to save settings to config.')\n\t\t\tprint(e)\n\t\t\treturn False\n\n\t\t# Catch file handling errors\n\t\texcept IOError as e:\n\t\t\tprint('Unable to save settings to config.')\n\t\t\tprint(e)\n\t\t\treturn False","def saveConfig(self):\n newPath = self.newFolderPath.text()\n config.set(\"saveLocation\", str(newPath))\n config.save()\n self.reloadSettings()","def save(self):\n self.__config.sync()\n self.__saved = True\n Logger().debug(\"Configuration saved\")","def save():\n with open(CONFIG_FILE, 'w') as f:\n json.dump(config, f, indent=4, sort_keys=True)","def save(self):\r\n with open(self.filename, 'w') as f:\r\n if self.pretty:\r\n json.dump(self.__config, f, sort_keys=False,\r\n indent=4, separators=(',', ': '))\r\n else:\r\n json.dump(self.__config, f)","def save(self):\n try:\n with open(self._filename, 'w') as conf_file:\n conf_file.write(json.dumps(self._data))\n except OSError:\n _LOGGER.exception(\"Can't store config in %s\", self._filename)","def save():\n print(\"Saving config file..\")\n\n res = yaml.round_trip_dump(_conf, indent=2, block_seq_indent=1)\n\n with open(__config_file, 'w', encoding='utf-8') as stream:\n stream.write(res)","def saveConfig():\n with open(_CONFIG_FNM, 'w') as configfile:\n CONFIG_DICT.write(configfile,\n space_around_delimiters=True)","def save(self, config_path):\n raise NotImplementedError()","def save_config_file(self):\n wkdir = Path(self.config_dict[\"outputdir\"])\n config_filename = str(wkdir / f\"{self.config_dict['name']}.json\")\n save_config(self.config_dict, config_filename)","def save_config(self):\n data = json.dumps(self.cfg)\n\n try:\n file = open(self.cfg_file_name, 'w')\n file.write(data)\n except OSError as err:\n print(\"can't save property: {0}\".format(err))\n else:\n file.close()","def save(self) -> None:\n logger.info(\"Saving to config...\")\n yml.save(self._config, self.configpath)","def save(self):\n with open(self._config, 'w') as f:\n json.dump(self.data, f, indent=2, sort_keys=True)","def saveExitConfig(self):\n newPath = self.newFolderPath.text()\n config.set(\"saveLocation\", str(newPath))\n config.save()\n self.reloadSettings()\n self.close()","def save(self):\n for p, c in self.configs_:\n c.write(p)","def save_config() -> None:\n with open(_config_file, \"w\", newline=\"\") as config_file:\n json.dump(_config, config_file, indent=4)\n config_file.truncate()","def save(self) -> None:\n self._client.save_config()","def save(self):\n\t\tself.CONFIG.save()\n\t\tself.temp_files.save()","def save(self):\n with open(self._CONFIG_FILE_PATH, 'w') as config_file:\n json.dump(vars(self), config_file)\n return self._CONFIG_FILE_PATH","def save_to_file(self):\n check_path(self.config_path)\n\n with open(self.settings_file, 'w') as settings_file:\n options = self._get_options()\n json.dump(options,\n \t settings_file,\n \t indent=4,\n \t separators=(',', ': '))","def save_config(self):\n with open(self.config_file, 'w') as fout:\n json.dump({'name_dict': self._name_dict, 'metric_dict': self._metric_dict, 'credential_path': self.credential_path, 'path_for_worksheet_name': self.path_for_worksheet_name}, fout)","def save_config(self):\n\n if not self.__conf.has_section(self.section):\n self.__conf.add_section(self.section)\n\n for key in self._params:\n val = self._params[key]\n self.__conf.set(self.section, key, val)\n\n with open(self.conf_path, 'w') as f:\n self.__conf.write(f)","def save(self):\n Registry.SetKey(self.CONFIG_NAME, self.config, True)\n self.load() # for validation","def save(self):\n # Always write out components in alphabetical order for determinism,\n # especially in tests.\n for function_name in sorted(self._components.keys()):\n self._config_parser[_COMPONENTS_SECTION][\n function_name] = self._components[function_name]\n\n with open(str(self._config_filepath), 'w') as f:\n self._config_parser.write(f)","def saveConfig(self):\r\n self.config[\"Settings\"] = {}\r\n settings = self.config[\"Settings\"]\r\n settings[\"datapath\"] = self.dataPath\r\n settings[\"videopath\"] = self.videoPath\r\n settings[\"dataoffset\"] = str(self.dataOffset)\r\n settings[\"colblindmode\"] = str(self.colBlindMode)\r\n with open(self.CONFIG_FILE,\"w\") as file:\r\n self.config.write(file)","def _save_changes(self):\n copy2(self._cfg_filename, self._cfg_filename + \".bak\")\n with open(self._cfg_filename, \"w\", encoding=\"utf-8\") as self._cfg_file:\n self.write(self._cfg_file)","def save_config(self, new_config, filename=None):\n self.cfg.update(new_config)\n if filename is None:\n self.cfg.filename = self.cfg_filename\n else:\n self.cfg.filename = filename\n self.cfg.write()\n logger.info(\"Config file %s written out\" % self.cfg.filename)","def save(self) -> bool:\n config_file = self.DEFAULT_CONFIG_LOCAL\n for filename in self.CONFIG_LOCAL:\n if os.path.isfile(filename):\n config_file = filename\n break\n\n with open(config_file, \"w\") as f:\n try:\n stream = yaml.dump(self.to_dict(), indent=2, default_flow_style=False)\n f.write(stream)\n\n except Exception as e:\n raise click.ClickException(\n f\"Error while saving config in {config_file}:\\n{str(e)}\"\n )\n return True","def SaveConfig(self):\n config_value = getattr(self, APPDATA)\n path_value = config_value.AbsolutePaths[0]\n default_cfg_file = os.path.join(path_value, CONFIG_FILE_NAME)\n temp_file = default_cfg_file + '.TEMP'\n if os.path.exists(default_cfg_file):\n json.dump(type(self)._CURRENT_CONFIG,\n open(temp_file.lower(),\n mode='w'),\n cls=ConfigEncoder,\n sort_keys=False,\n indent=4)\n EnsureBackup(temp_file, default_cfg_file)\n else:\n if not os.path.isdir(path_value):\n os.mkdir(path_value)\n json.dump(type(self)._CURRENT_CONFIG,\n open(default_cfg_file.lower(),\n mode='w'),\n cls=ConfigEncoder,\n sort_keys=False,\n indent=4)","def save_config(self):\n\n return self.perform_action('/mgmtd/db/save')","def save_config(self, filename: str=None):\n if not filename:\n filename = self.config_file\n with open(filename, \"w\") as file_object:\n json.dump(self.config, file_object, indent=4, sort_keys=True)","def saveConfig(config):\n global SW_CONFIG\n cf = ConfigParser.ConfigParser()\n cf.add_section(\"dir_config\")\n cf.set(\"dir_config\", \"7zpath\", config['7zpath'])\n cf.set(\"dir_config\", \"sharefolder\", config['sharefolder'])\n cf.set(\"dir_config\", \"distpath\", config['distpath'])\n cf.add_section(\"sw_config\")\n cf.set(\"sw_config\", \"version\", config['sw_version'])\n cf.set(\"sw_config\", \"startup\", config['startup'])\n cf.add_section(\"run_config\")\n cf.set(\"run_config\", \"pop\", False)\n cf.set(\"run_config\", \"backup\", False)\n fp = open(CONFIG_FILE, \"w\")\n cf.write(fp)\n fp.close()\n SW_CONFIG = config","def save_config(self, path):\n if os.path.isdir(path):\n path = os.path.join(path, 'config.json')\n print('Save config to {}'.format(path))\n with open(path, 'w', encoding='utf-8') as w:\n w.write(json.dumps(self.to_dict(), indent=2,\n sort_keys=True))","def save(self, savedir='.', fname=None):\n # Build up the file path to write to.\n dirpath = os.path.abspath(savedir)\n if fname is None:\n fname = os.path.basename(self.fname)\n\n name = os.path.splitext(fname)[0]\n path = os.path.join(dirpath, name + '.conf')\n\n # Put all comments and attributes into string formats.\n lines = ['# %s' % comment for comment in self.comments]\n lines.append('')\n for letter, section in self.config_guide.items():\n names = getattr(self, section)\n if names:\n if isinstance(names, basestring):\n line = '%s: %s;' % (letter, names)\n else:\n line = '%s: %s;' % (letter, ', '.join(names))\n lines.append(line)\n\n # Write the config.\n with open(path, 'w') as f:\n f.write('\\n'.join(lines))","def save_to_conf(self):\n raise NotImplementedError","def save_config(self, *args, **kwargs):\n raise NotImplementedError","def save(self):\n try:\n self.write(open(self._cfg_path, 'w'))\n return True\n except PermissionError as err:\n if err.errno == 13:\n return False\n raise err","def save_to_conf(self):\r\n raise NotImplementedError","def save_configuration(config):\n with open(cwd + '/configuration.pickle', 'wb') as handle:\n pickle.dump(config, handle, protocol=pickle.HIGHEST_PROTOCOL)","def save_config(self):\n if not os.path.exists(self._conf_dir):\n os.makedirs(self._conf_dir)\n conf_file = os.path.join(self._conf_dir, \"dql.json\")\n with open(conf_file, \"w\") as ofile:\n json.dump(self.conf, ofile, indent=2)","def save_config(self, path=\"\"):\n if not path:\n if not os.path.isdir(CONFIG_DIR):\n os.makedirs(CONFIG_DIR)\n file_path = QtGui.QFileDialog.getSaveFileName(self,\n \"Save Config\",\n CONFIG_DIR,\n \"Config File (*.cfg)\")\n else:\n file_path = path\n self._save_state(file_path)\n self.write_text(\"Saved config @ {}\".format(file_path))","def save_config():\n # Order the load flags using load_keys...\n od_load_flags = OrderedDict()\n for k in load_keys:\n od_load_flags[k] = load_flags[k]\n pawstools.save_cfg(od_load_flags,cfg_file)","def save_config(config_path: str, data: dict):\n with open(config_path, 'w') as j:\n dump(data,j)","def write_config_file():\n\tif not config_parser:\n\t\tprint \"Config module not loaded. I don't save anything.\"\n\t\treturn\n\n\tf = file(config_file, \"w\")\n\tconfig_parser.write(f)\n\tf.close()","def save( self ):\n ini = codecs.open(self.filename,\"w\",\"utf-8\",errors=\"replace\",buffering=0)\n for (name,value) in self.conf.items():\n print >>ini, name, \"=\", value\n ini.close()","def save_configurations(self):\n # Get the file path\n self.data_path = self.data_path_entry.get()\n # Open the file\n with open(self.data_path, 'rb') as file:\n self.log('Opened ' + str(self.data_path))\n # Un-serialize\n info = pickle.load(file)\n # Write the new properties\n self.main_window.overwrite_properties(info)\n\n self.exit()","def save(self):\r\n if not self.filename:\r\n raise IOError(errors['NoConfigFileYet'])\r\n self.onSave()\r\n stuff = dict()\r\n for thing in ['aliases', 'triggers']:\r\n stuff[thing] = [] # Populate with (args, kwargs) pairs.\r\n if self.config.get('saving', thing):\r\n for c, o in getattr(self, thing).iteritems():\r\n stuff[thing].append(o.serialise())\r\n stuff['variables'] = dict()\r\n if self.config.get('saving', 'variables'):\r\n for v in self.variables:\r\n if hasattr(self, v):\r\n var = getattr(self, v)\r\n if type(var) in self.basicTypes:\r\n stuff['variables'][v] = var\r\n stuff['config'] = self.config.get_dump()\r\n with open(self.filename, 'w') as f:\r\n json.dump(stuff, f, indent = 1, sort_keys = True) # Finally write the completed dictionary.\r","def save_conf(self):\r\n self.sendAndRecv(\"SAVECONF\\r\\n\")","def save_settings(self):\n with open(self.settings_path, \"w\") as f:\n json.dump(self.settings, f, indent=4)","def save_config(self, save_path: str) -> None:\n os.makedirs(save_path, exist_ok=True)\n model_hyperparameters_path = os.path.join(save_path, MODEL_HYPERPARAMETERS_FILE_NAME)\n save_json(model_hyperparameters_path, self.config_obj.to_dict())","def _save(self):\n file = open(\"settings.ini\", \"w\")\n self._parser.write(file)\n file.close()","def _save_cfg_to_file(self, server_id, cfg):\n\t\tfile = self.SettingsFolder + '{}.yml'.format(server_id)\n\t\twith open(file, 'w') as f:\n\t\t\tyaml.dump(cfg, f, default_flow_style=False)","def saveSettings(self):\n helpers.saveFile(self.dataDir, self.settingsFilename, json.dumps(self.settings))","def save_configuration(self):\n dom = self.vistrailsStartup.startup_dom()\n doc = dom.documentElement\n configuration_element = enter_named_element(doc, 'configuration')\n doc.removeChild(configuration_element)\n self.configuration.write_to_dom(dom, doc)\n self.vistrailsStartup.write_startup_dom(dom)\n dom.unlink()","def update(self):\n self.save_config_file()","def save(config, filename=None):\n filename = add_directory(filename or 'configure.json')\n directory = os.path.dirname(filename)\n if not os.path.exists(directory):\n os.makedirs(directory, 0o700)\n with open(filename, \"w\") as f:\n json.dump(config, f, indent=2, sort_keys=True)","def save_config(config):\n with open(os.path.abspath(CONFIG_PATH), 'wb') as config_file:\n pickle.dump(config, config_file)\n return config","def saveConfig(self, name=None):\n\n configDir = self.mwGlob['configDir']\n\n if self.config.get('profileName', '') == 'config':\n if 'reference' in self.config:\n del self.config['reference']\n\n # default saving for reference\n if name is None:\n name = self.config.get('reference', 'config')\n\n fileName = configDir + '/' + name + '.cfg'\n with open(fileName, 'w') as outfile:\n json.dump(self.config,\n outfile,\n sort_keys=True,\n indent=4)\n # if we save a reference first, we have to save the config as well\n if name != 'config':\n fileName = configDir + '/config.cfg'\n with open(fileName, 'w') as outfile:\n json.dump(self.config,\n outfile,\n sort_keys=True,\n indent=4)\n return True","def save_config(conf, default):\n print()\n if yes_no('Would you like to save your configuration?'):\n name = simple_response(\n 'What would you like to name your configuration?')\n path = ask_path(\n 'Please enter the path you would like your configuration saved to',\n default=default)\n file_path = os.path.join(path, name)\n if file_path.find('.json') == -1:\n file_path += '.json'\n with open(file_path, 'w+') as f:\n json.dump(conf, f, indent=4)","def saveNewConfiguration(self):\n selection = tk.filedialog. \\\n asksaveasfilename(title=\"Save CHUM configuration\")\n if selection:\n self._currentConfiguration = selection\n self._saveToFilePath(selection)","def saveCurrentConfig():\n cf = ConfigParser.ConfigParser()\n cf.add_section(\"dir_config\")\n cf.set(\"dir_config\", \"7zpath\", SW_CONFIG['7zpath'])\n cf.set(\"dir_config\", \"sharefolder\", SW_CONFIG['sharefolder'])\n cf.set(\"dir_config\", \"distpath\", SW_CONFIG['distpath'])\n cf.add_section(\"sw_config\")\n cf.set(\"sw_config\", \"version\", SW_CONFIG['sw_version'])\n cf.set(\"sw_config\", \"startup\", SW_CONFIG['startup'])\n cf.add_section(\"run_config\")\n cf.set(\"run_config\", \"pop\", RUN_CONFIG['pop'])\n cf.set(\"run_config\", \"backup\", RUN_CONFIG['backup'])\n cf.add_section(\"hook_config'\")\n for k, v in HOOK_CONFIG:\n cf.set(\"hook_config\", k, v)\n fp = open(CONFIG_FILE, \"w\")\n cf.write(fp)\n fp.close()","def save(self, config_file: typing.TextIO):\n json.dump(self.to_dict(), config_file, indent=4)","def write_config(self, filename):\n self.config.filename = filename\n self.config.write()","def save_config(**kwargs):\n if kwargs == {}:\n kwargs = config._config\n current_config = _load_config()\n current_config.update(**kwargs)\n # write to disk\n fname = _get_config_fname()\n if fname is None:\n raise RuntimeError('config filename could not be determined')\n if not op.isdir(op.dirname(fname)):\n os.mkdir(op.dirname(fname))\n with open(fname, 'w') as fid:\n json.dump(current_config, fid, sort_keys=True, indent=0)","def writeShREEKConfig(self, filename):\n self._ShREEKConfig.save(filename)\n return","async def save_config(self):\n\n # Display info message\n log.info(\"save_config\")\n\n # Send command to ask for saving config. Wait till the question to overwrite\n # the startup file (\"Overwrite file [startup-config].... (Y/N)[N] ?\")\n output = await self.send_command(self.cmd_save_config, pattern=\"?\")\n\n # Confirm to save the config\n output += await self.send_command(\"Y\")\n\n # Return the commands of the configuration saving process\n return output","def save_config(conf, save_path):\n with open(os.path.join(save_path), \"w\") as f:\n f.write(yaml.dump({'param': conf}, default_flow_style=False))","def saveSettings():\t\n\tglobal settings\n\tfout = open(config_file,'w')\n\tfout.write(json.dumps(settings, sort_keys=True, indent=4))\n\tfout.close()","def save(self):\n # TODO: save the file","def saveConfig(config, filepath=None):\n result = False\n if filepath is None:\n filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), \"res/\", \"config.ini\")\n try:\n with open(filepath, 'wb') as configfile:\n config.write(configfile)\n result = True\n except Exception, e:\n print \"*** Caught Exception: %r ***\" % e\n return result","def save(self):\n sublime.save_settings(self.file_name)","def save(data, section): # save a config\n\tglobal _timesSaved\n\tif dynConfig['logConfigActions']:\n\t\tlogger.info( f'saving {section}: {data}' )\n\t# save\n\tif section != 'placeholderForSaving':\n\t\tcurrentConfigData[section] = data\n\t\tlogger.debug( f'saved {section}' )\n\telse:\n\t\t_timesSaved = 2\n\t# save to disk if this is the third save\n\tif _timesSaved == 0 or _timesSaved == 1:\n\t\t_timesSaved += 1\n\telse:\n\t\t_timesSaved = 0\n\t\ttry:\n\t\t\t# save to disk\n\t\t\twith open( configPath, 'w', encoding='utf-8' ) as file:\n\t\t\t\tjson.dump( currentConfigData, file, indent=4 )\n\t\texcept:\n\t\t\tlogger.error( f'failed to save config to disk!' )\n\t\t\traise ConfigError( 'error while saving the config file' )","def save_file(self, force=False): # type: (bool) -> bool\n if self._modified or force:\n logging.info('Cyra is writing your config to %s' % self._file)\n\n with open(self._file, 'w') as f:\n f.write(self.export_toml())\n\n self._modified = False\n return True\n return False","def save(self):\n \n f = file(self.conf_file, \"w\")\n f.write(header + \"\\n\".join(map(str, self.db)) + \"\\n\")\n f.close()","def save(config, path=None):\n if path is None:\n path = settings.HOST_CONFIG_PATH\n\n with open(path, 'w') as output:\n output.write(yaml.safe_dump(config, default_flow_style=False))","def save_conf(self, name=None):\n \n if name:\n filename = name\n \n else:\n filename = \"conf_\" + str(self.conf[\"device\"]) + \"_\" + datetime.today().strftime('%Y-%m-%d') + \".txt\"\n \n path = \"./source/_0_time_series_class/configuration/\"\n filename = path + filename\n \n with open(filename, \"w\") as file:\n json.dump(self.conf, file)","def saveConfigFileDlg( self ):\n fileName = QtGui.QFileDialog.getSaveFileName( self, \"Save Full Config As...\", self.rsrc.lastFolder, \"Config files (*.cfg)\" )\n if ( fileName ):\n self.saveConfigFile( fileName )\n path, fName = os.path.split( str( fileName ) )\n self.rsrc.lastFolder = path","def save(self):\n if self.location is None:\n logger.debug(\"Save requested but not saving settings, \"\n \"location is None\")\n return\n\n if self._saving or not self._dirty:\n return\n\n self._saving = True\n\n logger.debug(\"Saving settings...\")\n\n with open(self.location + \".new\", 'w') as f:\n self.write(f)\n\n try:\n # make it readable by current user only, to protect private data\n os.fchmod(f.fileno(), 384)\n except:\n pass # fail gracefully, eg if on windows\n\n f.flush()\n\n try:\n os.rename(self.location, self.location + \".old\")\n except:\n pass # if it doesn'texist we don't care\n\n os.rename(self.location + \".new\", self.location)\n\n try:\n os.remove(self.location + \".old\")\n except:\n pass\n\n self._saving = False\n self._dirty = False","def __write_config(self):\n with open(self.config_file, 'w') as data_file:\n config = {\"ibooks_doc_root\":self.ibooks_doc_root,\n \"library_folder\":self.library_folder,\n \"annotation_folder\":self.annotation_folder,\n \"tmp_dir\":self.tmp_dir\n } \n data = json.dumps(config, ensure_ascii=False)\n data_file.write(data)","def write_config(self):\n logging.debug(\"Writing configuration file: %s\" % self.config_file)\n f = open(self.config_file, \"w\")\n self.config.write(f)\n f.close()","def save_config(self):\n if not os.path.exists(USER_CONFIG_PATH):\n os.makedirs(USER_CONFIG_PATH)\n\n # obtener el config actual\n config = self.get_config()\n\n # obtener el cliente\n client = self._args.get('client')\n\n # ciertos parametros no se tienen que salvar\n args = self._args.copy()\n for item in ['doc', 'command', 'client']:\n if item in args:\n args.pop(item)\n\n # actualizar el cliente default\n config['client'] = client\n\n # actualizar el resto de los parametros para ese cliente\n for item in args:\n if client in config:\n config[client][item] = args.get(item)\n else:\n config[client] = {item: args.get(item)}\n\n with open(USER_CONFIG_FILE, 'w') as config_file:\n yaml.dump(config, config_file, default_flow_style=False,\n allow_unicode=True)","def save(self,filename=None,defaults=False):\n # Check filename or use default filename\n if not filename:\n if self.__configfile:\n filename=self.__configfile\n else:\n raise Exception(_('EVOGTK: Need a filename for saving preferences'))\n # Set widget values on config parser\n for section in self.__optionstruct:\n for option in self.__optionstruct[section]:\n widgets=self.__optionstruct[section][option][1]\n # Get default value\n value=vars(self)[section].get_option(option)\n if not defaults and widgets:\n # Use widget value\n val=self.__guidata.__getattr__(widgets[0])\n if val:\n value=val\n # Create section in file if not exists\n if not self.__config.has_section(section):\n self.__config.add_section(section)\n value=vars(self)[section].set_option(option,value)\n # Write config to file\n fd=open(filename,'wb')\n self.__config.write(fd)\n fd.close()","async def save_config(self):\n\n # Display info message\n log.info(\"save_config\")\n\n # Send command\n output = await self.send_command(self.cmd_save_config)\n\n # Return the commands of the configuration saving process\n return output","def save_config(self, cfg):\n filename = self.get_filename(\"config\", ext=\".txt\")\n if filename is None:\n return\n\n if not isinstance(cfg, XFasterConfig):\n cfg = XFasterConfig(cfg)\n\n try:\n creator = os.getlogin()\n except OSError:\n creator = \"unknown\"\n with open(filename, \"w\") as f:\n f.write(\n \"# Created by {} on {:%Y-%m-%d %H:%M:%S}\\n\\n\".format(\n creator, datetime.datetime.now()\n )\n )\n cfg.write(f)\n\n return filename","def save():\n log.info(\"Saving settings file\")\n with open(SETTINGS_FILE, \"w\") as file:\n json.dump(_names, file)","def write(self):\n cfgpath = os.path.join(self.config_dir, CONFIG_FILENAME)\n ofile = open(cfgpath, 'w')\n if ofile:\n log.debug( \"Write config: %s\" % cfgpath )\n cfg = yaml.dump(self.yaml, default_flow_style=False)\n log.debug( \"Config:\\n%s\" % cfg)\n ofile.write(cfg)\n ofile.close()","def save(self, filename=\"startup-config\"):\n command = f\"copy running-config {filename}\"\n # Changed to send_command_timing to not require a direct prompt return.\n self.native.send_command_timing(command)\n # If the user has enabled 'file prompt quiet' which dose not require any confirmation or feedback.\n # This will send return without requiring an OK.\n # Send a return to pass the [OK]? message - Increase delay_factor for looking for response.\n self.native.send_command_timing(\"\\n\", delay_factor=2)\n # Confirm that we have a valid prompt again before returning.\n self.native.find_prompt()\n log.debug(\"Host %s: Configuration saved.\", self.host)\n return True","def _save_configuration_to_yml(self):\n data = self.get_configuration_data()\n timestamp = self.model.timestamp\n with open(os.path.join(CHECKPOINTS_DIR, timestamp, 'config_{}.yml'.format(timestamp)), 'w') as outfile:\n yaml.dump(dict(data), outfile, default_flow_style=False)","def save_settings(self):\n settings = {'camera': self.comboCamera.currentIndex(),\n 'rotation': self.comboRotation.currentIndex(),\n 'colors': {\n 'min_hue': self.spinMinHue.value(),\n 'max_hue': self.spinMaxHue.value(),\n 'min_saturation': self.spinMinSaturation.value(),\n 'max_saturation': self.spinMaxSaturation.value(),\n 'min_value': self.spinMinValue.value(),\n 'max_value': self.spinMaxValue.value(),\n }, 'diameter': self.spinDiameter.value(),\n 'lifter': self.lineEditLifter.text(),\n 'save_video': self.checkSaveVideo.isChecked()\n }\n settings_file = open('./resources/settings.json', 'w')\n json.dump(settings, settings_file, indent=4)\n settings_file.close()\n self.statusbar.clearMessage()\n self.statusbar.showMessage('Settings saved.', 5000)","def save_to_config(self) -> None:\n config_path = os.path.join(self.base_path, \"config.json\")\n\n with open(config_path, \"r\") as _json:\n c_dict = json.load(_json)\n\n c_dict[\"mean_similarity_error\"] = self.ME\n c_dict[\"similarity_correlation\"] = self.pearson_corr\n c_dict[\"similarity_spearman_correlation\"] = self.spearman_corr\n\n with open(config_path, \"w\") as _json:\n json.dump(c_dict, _json)","def save_cfg(self, output_dir):\n output_path = os.path.join(output_dir, 'level_config.cfg')\n shutil.copy(self.cfg_path, output_path)","def save(config: dict, out_dir: str, filename: str = \"config.yaml\"):\n assert filename.endswith(\".yaml\")\n with open(os.path.join(out_dir, filename), \"w+\") as f:\n f.write(yaml.dump(config))","def save(self, file_name):\n saved_data = { \"start_config\" : self.start_config, \"action_storage\" : self.action_storage } \n with open(file_name, 'wb') as fh:\n pickle.dump(saved_data, fh)","def save_options(self,config,options_file):\n \n config.set('manager-editable','media_offset',self.media_offset)\n config.set('manager-editable','profiles_offset',self.pp_profiles_offset)\n config.set('manager-editable','use_sudo',self.use_sudo)\n config.set('manager-editable','options',self.options)\n\n config.set('manager-editable','autostart_path',self.autostart_path) \n config.set('manager-editable','autostart_use_sudo',self.autostart_use_sudo)\n config.set('manager-editable','autostart_options',self.autostart_options)\n \n with open(options_file, 'wb') as config_file:\n config.write(config_file)","def onExportConfig(self, evt):\n dlg = wx.FileDialog(self.view, \"Save As Configuration File\", wildcard = \"*.ini\" ,\n style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)\n if dlg.ShowModal() == wx.ID_OK:\n fileName=dlg.GetPath()\n self.config.exportConfig(fileName=fileName, e=None)","def save(self):\n Preferences.setVCS(\n \"AutoClose\",\n self.vcsAutoCloseCheckBox.isChecked())\n Preferences.setVCS(\n \"AutoSaveFiles\",\n self.vcsAutoSaveCheckBox.isChecked())\n Preferences.setVCS(\n \"AutoSaveProject\",\n self.vcsAutoSaveProjectCheckBox.isChecked())\n Preferences.setVCS(\n \"StatusMonitorInterval\",\n self.vcsStatusMonitorIntervalSpinBox.value())\n Preferences.setVCS(\n \"MonitorLocalStatus\",\n self.vcsMonitorLocalStatusCheckBox.isChecked())\n Preferences.setVCS(\n \"AutoUpdate\",\n self.autoUpdateCheckBox.isChecked())\n \n self.saveColours(Preferences.setProjectBrowserColour)"],"string":"[\n \"def save(self):\\n file = open(self.path, 'w')\\n self.config.write(file)\\n file.close()\",\n \"def save(self):\\r\\n with open(self.filename, 'wb') as configfile:\\r\\n self.write(configfile)\",\n \"def save_config(self):\\n config.save_config(self.config, self.config_file)\",\n \"def save():\\n\\n env.config.save(env.config_file)\",\n \"def save():\\n\\t\\ttry:\\n\\t\\t\\t#paths\\n\\t\\t\\tConfig.conf.set('paths', 'source_dir', Config.source_dir)\\n\\t\\t\\tConfig.conf.set('paths', 'lyrics_dir', Config.lyrics_dir)\\n\\n\\t\\t\\t#actions\\n\\t\\t\\tConfig.setBool('actions', 'save_to_file', Config.save_to_file)\\n\\t\\t\\tConfig.setBool('actions', 'save_to_tag', Config.save_to_tag)\\n\\n\\t\\t\\t#sources\\n\\t\\t\\tConfig.setBool('sources', 'lyric_wikia', Config.lyric_wikia)\\n\\t\\t\\tConfig.setBool('sources', 'musix_match', Config.musix_match)\\n\\t\\t\\tConfig.setBool('sources', 'lyricsmode', Config.lyricsmode)\\n\\t\\t\\tConfig.setBool('sources', 'az_lyrics', Config.az_lyrics)\\n\\n\\t\\t\\twith open(Config.config_path, 'w') as configfile:\\n\\t\\t\\t\\tConfig.conf.write(configfile)\\n\\t\\t\\treturn True\\n\\n\\t\\t# Catch all config parser errors\\n\\t\\texcept BaseConfigParserError as e:\\n\\t\\t\\tprint('Unable to save settings to config.')\\n\\t\\t\\tprint(e)\\n\\t\\t\\treturn False\\n\\n\\t\\t# Catch file handling errors\\n\\t\\texcept IOError as e:\\n\\t\\t\\tprint('Unable to save settings to config.')\\n\\t\\t\\tprint(e)\\n\\t\\t\\treturn False\",\n \"def saveConfig(self):\\n newPath = self.newFolderPath.text()\\n config.set(\\\"saveLocation\\\", str(newPath))\\n config.save()\\n self.reloadSettings()\",\n \"def save(self):\\n self.__config.sync()\\n self.__saved = True\\n Logger().debug(\\\"Configuration saved\\\")\",\n \"def save():\\n with open(CONFIG_FILE, 'w') as f:\\n json.dump(config, f, indent=4, sort_keys=True)\",\n \"def save(self):\\r\\n with open(self.filename, 'w') as f:\\r\\n if self.pretty:\\r\\n json.dump(self.__config, f, sort_keys=False,\\r\\n indent=4, separators=(',', ': '))\\r\\n else:\\r\\n json.dump(self.__config, f)\",\n \"def save(self):\\n try:\\n with open(self._filename, 'w') as conf_file:\\n conf_file.write(json.dumps(self._data))\\n except OSError:\\n _LOGGER.exception(\\\"Can't store config in %s\\\", self._filename)\",\n \"def save():\\n print(\\\"Saving config file..\\\")\\n\\n res = yaml.round_trip_dump(_conf, indent=2, block_seq_indent=1)\\n\\n with open(__config_file, 'w', encoding='utf-8') as stream:\\n stream.write(res)\",\n \"def saveConfig():\\n with open(_CONFIG_FNM, 'w') as configfile:\\n CONFIG_DICT.write(configfile,\\n space_around_delimiters=True)\",\n \"def save(self, config_path):\\n raise NotImplementedError()\",\n \"def save_config_file(self):\\n wkdir = Path(self.config_dict[\\\"outputdir\\\"])\\n config_filename = str(wkdir / f\\\"{self.config_dict['name']}.json\\\")\\n save_config(self.config_dict, config_filename)\",\n \"def save_config(self):\\n data = json.dumps(self.cfg)\\n\\n try:\\n file = open(self.cfg_file_name, 'w')\\n file.write(data)\\n except OSError as err:\\n print(\\\"can't save property: {0}\\\".format(err))\\n else:\\n file.close()\",\n \"def save(self) -> None:\\n logger.info(\\\"Saving to config...\\\")\\n yml.save(self._config, self.configpath)\",\n \"def save(self):\\n with open(self._config, 'w') as f:\\n json.dump(self.data, f, indent=2, sort_keys=True)\",\n \"def saveExitConfig(self):\\n newPath = self.newFolderPath.text()\\n config.set(\\\"saveLocation\\\", str(newPath))\\n config.save()\\n self.reloadSettings()\\n self.close()\",\n \"def save(self):\\n for p, c in self.configs_:\\n c.write(p)\",\n \"def save_config() -> None:\\n with open(_config_file, \\\"w\\\", newline=\\\"\\\") as config_file:\\n json.dump(_config, config_file, indent=4)\\n config_file.truncate()\",\n \"def save(self) -> None:\\n self._client.save_config()\",\n \"def save(self):\\n\\t\\tself.CONFIG.save()\\n\\t\\tself.temp_files.save()\",\n \"def save(self):\\n with open(self._CONFIG_FILE_PATH, 'w') as config_file:\\n json.dump(vars(self), config_file)\\n return self._CONFIG_FILE_PATH\",\n \"def save_to_file(self):\\n check_path(self.config_path)\\n\\n with open(self.settings_file, 'w') as settings_file:\\n options = self._get_options()\\n json.dump(options,\\n \\t settings_file,\\n \\t indent=4,\\n \\t separators=(',', ': '))\",\n \"def save_config(self):\\n with open(self.config_file, 'w') as fout:\\n json.dump({'name_dict': self._name_dict, 'metric_dict': self._metric_dict, 'credential_path': self.credential_path, 'path_for_worksheet_name': self.path_for_worksheet_name}, fout)\",\n \"def save_config(self):\\n\\n if not self.__conf.has_section(self.section):\\n self.__conf.add_section(self.section)\\n\\n for key in self._params:\\n val = self._params[key]\\n self.__conf.set(self.section, key, val)\\n\\n with open(self.conf_path, 'w') as f:\\n self.__conf.write(f)\",\n \"def save(self):\\n Registry.SetKey(self.CONFIG_NAME, self.config, True)\\n self.load() # for validation\",\n \"def save(self):\\n # Always write out components in alphabetical order for determinism,\\n # especially in tests.\\n for function_name in sorted(self._components.keys()):\\n self._config_parser[_COMPONENTS_SECTION][\\n function_name] = self._components[function_name]\\n\\n with open(str(self._config_filepath), 'w') as f:\\n self._config_parser.write(f)\",\n \"def saveConfig(self):\\r\\n self.config[\\\"Settings\\\"] = {}\\r\\n settings = self.config[\\\"Settings\\\"]\\r\\n settings[\\\"datapath\\\"] = self.dataPath\\r\\n settings[\\\"videopath\\\"] = self.videoPath\\r\\n settings[\\\"dataoffset\\\"] = str(self.dataOffset)\\r\\n settings[\\\"colblindmode\\\"] = str(self.colBlindMode)\\r\\n with open(self.CONFIG_FILE,\\\"w\\\") as file:\\r\\n self.config.write(file)\",\n \"def _save_changes(self):\\n copy2(self._cfg_filename, self._cfg_filename + \\\".bak\\\")\\n with open(self._cfg_filename, \\\"w\\\", encoding=\\\"utf-8\\\") as self._cfg_file:\\n self.write(self._cfg_file)\",\n \"def save_config(self, new_config, filename=None):\\n self.cfg.update(new_config)\\n if filename is None:\\n self.cfg.filename = self.cfg_filename\\n else:\\n self.cfg.filename = filename\\n self.cfg.write()\\n logger.info(\\\"Config file %s written out\\\" % self.cfg.filename)\",\n \"def save(self) -> bool:\\n config_file = self.DEFAULT_CONFIG_LOCAL\\n for filename in self.CONFIG_LOCAL:\\n if os.path.isfile(filename):\\n config_file = filename\\n break\\n\\n with open(config_file, \\\"w\\\") as f:\\n try:\\n stream = yaml.dump(self.to_dict(), indent=2, default_flow_style=False)\\n f.write(stream)\\n\\n except Exception as e:\\n raise click.ClickException(\\n f\\\"Error while saving config in {config_file}:\\\\n{str(e)}\\\"\\n )\\n return True\",\n \"def SaveConfig(self):\\n config_value = getattr(self, APPDATA)\\n path_value = config_value.AbsolutePaths[0]\\n default_cfg_file = os.path.join(path_value, CONFIG_FILE_NAME)\\n temp_file = default_cfg_file + '.TEMP'\\n if os.path.exists(default_cfg_file):\\n json.dump(type(self)._CURRENT_CONFIG,\\n open(temp_file.lower(),\\n mode='w'),\\n cls=ConfigEncoder,\\n sort_keys=False,\\n indent=4)\\n EnsureBackup(temp_file, default_cfg_file)\\n else:\\n if not os.path.isdir(path_value):\\n os.mkdir(path_value)\\n json.dump(type(self)._CURRENT_CONFIG,\\n open(default_cfg_file.lower(),\\n mode='w'),\\n cls=ConfigEncoder,\\n sort_keys=False,\\n indent=4)\",\n \"def save_config(self):\\n\\n return self.perform_action('/mgmtd/db/save')\",\n \"def save_config(self, filename: str=None):\\n if not filename:\\n filename = self.config_file\\n with open(filename, \\\"w\\\") as file_object:\\n json.dump(self.config, file_object, indent=4, sort_keys=True)\",\n \"def saveConfig(config):\\n global SW_CONFIG\\n cf = ConfigParser.ConfigParser()\\n cf.add_section(\\\"dir_config\\\")\\n cf.set(\\\"dir_config\\\", \\\"7zpath\\\", config['7zpath'])\\n cf.set(\\\"dir_config\\\", \\\"sharefolder\\\", config['sharefolder'])\\n cf.set(\\\"dir_config\\\", \\\"distpath\\\", config['distpath'])\\n cf.add_section(\\\"sw_config\\\")\\n cf.set(\\\"sw_config\\\", \\\"version\\\", config['sw_version'])\\n cf.set(\\\"sw_config\\\", \\\"startup\\\", config['startup'])\\n cf.add_section(\\\"run_config\\\")\\n cf.set(\\\"run_config\\\", \\\"pop\\\", False)\\n cf.set(\\\"run_config\\\", \\\"backup\\\", False)\\n fp = open(CONFIG_FILE, \\\"w\\\")\\n cf.write(fp)\\n fp.close()\\n SW_CONFIG = config\",\n \"def save_config(self, path):\\n if os.path.isdir(path):\\n path = os.path.join(path, 'config.json')\\n print('Save config to {}'.format(path))\\n with open(path, 'w', encoding='utf-8') as w:\\n w.write(json.dumps(self.to_dict(), indent=2,\\n sort_keys=True))\",\n \"def save(self, savedir='.', fname=None):\\n # Build up the file path to write to.\\n dirpath = os.path.abspath(savedir)\\n if fname is None:\\n fname = os.path.basename(self.fname)\\n\\n name = os.path.splitext(fname)[0]\\n path = os.path.join(dirpath, name + '.conf')\\n\\n # Put all comments and attributes into string formats.\\n lines = ['# %s' % comment for comment in self.comments]\\n lines.append('')\\n for letter, section in self.config_guide.items():\\n names = getattr(self, section)\\n if names:\\n if isinstance(names, basestring):\\n line = '%s: %s;' % (letter, names)\\n else:\\n line = '%s: %s;' % (letter, ', '.join(names))\\n lines.append(line)\\n\\n # Write the config.\\n with open(path, 'w') as f:\\n f.write('\\\\n'.join(lines))\",\n \"def save_to_conf(self):\\n raise NotImplementedError\",\n \"def save_config(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def save(self):\\n try:\\n self.write(open(self._cfg_path, 'w'))\\n return True\\n except PermissionError as err:\\n if err.errno == 13:\\n return False\\n raise err\",\n \"def save_to_conf(self):\\r\\n raise NotImplementedError\",\n \"def save_configuration(config):\\n with open(cwd + '/configuration.pickle', 'wb') as handle:\\n pickle.dump(config, handle, protocol=pickle.HIGHEST_PROTOCOL)\",\n \"def save_config(self):\\n if not os.path.exists(self._conf_dir):\\n os.makedirs(self._conf_dir)\\n conf_file = os.path.join(self._conf_dir, \\\"dql.json\\\")\\n with open(conf_file, \\\"w\\\") as ofile:\\n json.dump(self.conf, ofile, indent=2)\",\n \"def save_config(self, path=\\\"\\\"):\\n if not path:\\n if not os.path.isdir(CONFIG_DIR):\\n os.makedirs(CONFIG_DIR)\\n file_path = QtGui.QFileDialog.getSaveFileName(self,\\n \\\"Save Config\\\",\\n CONFIG_DIR,\\n \\\"Config File (*.cfg)\\\")\\n else:\\n file_path = path\\n self._save_state(file_path)\\n self.write_text(\\\"Saved config @ {}\\\".format(file_path))\",\n \"def save_config():\\n # Order the load flags using load_keys...\\n od_load_flags = OrderedDict()\\n for k in load_keys:\\n od_load_flags[k] = load_flags[k]\\n pawstools.save_cfg(od_load_flags,cfg_file)\",\n \"def save_config(config_path: str, data: dict):\\n with open(config_path, 'w') as j:\\n dump(data,j)\",\n \"def write_config_file():\\n\\tif not config_parser:\\n\\t\\tprint \\\"Config module not loaded. I don't save anything.\\\"\\n\\t\\treturn\\n\\n\\tf = file(config_file, \\\"w\\\")\\n\\tconfig_parser.write(f)\\n\\tf.close()\",\n \"def save( self ):\\n ini = codecs.open(self.filename,\\\"w\\\",\\\"utf-8\\\",errors=\\\"replace\\\",buffering=0)\\n for (name,value) in self.conf.items():\\n print >>ini, name, \\\"=\\\", value\\n ini.close()\",\n \"def save_configurations(self):\\n # Get the file path\\n self.data_path = self.data_path_entry.get()\\n # Open the file\\n with open(self.data_path, 'rb') as file:\\n self.log('Opened ' + str(self.data_path))\\n # Un-serialize\\n info = pickle.load(file)\\n # Write the new properties\\n self.main_window.overwrite_properties(info)\\n\\n self.exit()\",\n \"def save(self):\\r\\n if not self.filename:\\r\\n raise IOError(errors['NoConfigFileYet'])\\r\\n self.onSave()\\r\\n stuff = dict()\\r\\n for thing in ['aliases', 'triggers']:\\r\\n stuff[thing] = [] # Populate with (args, kwargs) pairs.\\r\\n if self.config.get('saving', thing):\\r\\n for c, o in getattr(self, thing).iteritems():\\r\\n stuff[thing].append(o.serialise())\\r\\n stuff['variables'] = dict()\\r\\n if self.config.get('saving', 'variables'):\\r\\n for v in self.variables:\\r\\n if hasattr(self, v):\\r\\n var = getattr(self, v)\\r\\n if type(var) in self.basicTypes:\\r\\n stuff['variables'][v] = var\\r\\n stuff['config'] = self.config.get_dump()\\r\\n with open(self.filename, 'w') as f:\\r\\n json.dump(stuff, f, indent = 1, sort_keys = True) # Finally write the completed dictionary.\\r\",\n \"def save_conf(self):\\r\\n self.sendAndRecv(\\\"SAVECONF\\\\r\\\\n\\\")\",\n \"def save_settings(self):\\n with open(self.settings_path, \\\"w\\\") as f:\\n json.dump(self.settings, f, indent=4)\",\n \"def save_config(self, save_path: str) -> None:\\n os.makedirs(save_path, exist_ok=True)\\n model_hyperparameters_path = os.path.join(save_path, MODEL_HYPERPARAMETERS_FILE_NAME)\\n save_json(model_hyperparameters_path, self.config_obj.to_dict())\",\n \"def _save(self):\\n file = open(\\\"settings.ini\\\", \\\"w\\\")\\n self._parser.write(file)\\n file.close()\",\n \"def _save_cfg_to_file(self, server_id, cfg):\\n\\t\\tfile = self.SettingsFolder + '{}.yml'.format(server_id)\\n\\t\\twith open(file, 'w') as f:\\n\\t\\t\\tyaml.dump(cfg, f, default_flow_style=False)\",\n \"def saveSettings(self):\\n helpers.saveFile(self.dataDir, self.settingsFilename, json.dumps(self.settings))\",\n \"def save_configuration(self):\\n dom = self.vistrailsStartup.startup_dom()\\n doc = dom.documentElement\\n configuration_element = enter_named_element(doc, 'configuration')\\n doc.removeChild(configuration_element)\\n self.configuration.write_to_dom(dom, doc)\\n self.vistrailsStartup.write_startup_dom(dom)\\n dom.unlink()\",\n \"def update(self):\\n self.save_config_file()\",\n \"def save(config, filename=None):\\n filename = add_directory(filename or 'configure.json')\\n directory = os.path.dirname(filename)\\n if not os.path.exists(directory):\\n os.makedirs(directory, 0o700)\\n with open(filename, \\\"w\\\") as f:\\n json.dump(config, f, indent=2, sort_keys=True)\",\n \"def save_config(config):\\n with open(os.path.abspath(CONFIG_PATH), 'wb') as config_file:\\n pickle.dump(config, config_file)\\n return config\",\n \"def saveConfig(self, name=None):\\n\\n configDir = self.mwGlob['configDir']\\n\\n if self.config.get('profileName', '') == 'config':\\n if 'reference' in self.config:\\n del self.config['reference']\\n\\n # default saving for reference\\n if name is None:\\n name = self.config.get('reference', 'config')\\n\\n fileName = configDir + '/' + name + '.cfg'\\n with open(fileName, 'w') as outfile:\\n json.dump(self.config,\\n outfile,\\n sort_keys=True,\\n indent=4)\\n # if we save a reference first, we have to save the config as well\\n if name != 'config':\\n fileName = configDir + '/config.cfg'\\n with open(fileName, 'w') as outfile:\\n json.dump(self.config,\\n outfile,\\n sort_keys=True,\\n indent=4)\\n return True\",\n \"def save_config(conf, default):\\n print()\\n if yes_no('Would you like to save your configuration?'):\\n name = simple_response(\\n 'What would you like to name your configuration?')\\n path = ask_path(\\n 'Please enter the path you would like your configuration saved to',\\n default=default)\\n file_path = os.path.join(path, name)\\n if file_path.find('.json') == -1:\\n file_path += '.json'\\n with open(file_path, 'w+') as f:\\n json.dump(conf, f, indent=4)\",\n \"def saveNewConfiguration(self):\\n selection = tk.filedialog. \\\\\\n asksaveasfilename(title=\\\"Save CHUM configuration\\\")\\n if selection:\\n self._currentConfiguration = selection\\n self._saveToFilePath(selection)\",\n \"def saveCurrentConfig():\\n cf = ConfigParser.ConfigParser()\\n cf.add_section(\\\"dir_config\\\")\\n cf.set(\\\"dir_config\\\", \\\"7zpath\\\", SW_CONFIG['7zpath'])\\n cf.set(\\\"dir_config\\\", \\\"sharefolder\\\", SW_CONFIG['sharefolder'])\\n cf.set(\\\"dir_config\\\", \\\"distpath\\\", SW_CONFIG['distpath'])\\n cf.add_section(\\\"sw_config\\\")\\n cf.set(\\\"sw_config\\\", \\\"version\\\", SW_CONFIG['sw_version'])\\n cf.set(\\\"sw_config\\\", \\\"startup\\\", SW_CONFIG['startup'])\\n cf.add_section(\\\"run_config\\\")\\n cf.set(\\\"run_config\\\", \\\"pop\\\", RUN_CONFIG['pop'])\\n cf.set(\\\"run_config\\\", \\\"backup\\\", RUN_CONFIG['backup'])\\n cf.add_section(\\\"hook_config'\\\")\\n for k, v in HOOK_CONFIG:\\n cf.set(\\\"hook_config\\\", k, v)\\n fp = open(CONFIG_FILE, \\\"w\\\")\\n cf.write(fp)\\n fp.close()\",\n \"def save(self, config_file: typing.TextIO):\\n json.dump(self.to_dict(), config_file, indent=4)\",\n \"def write_config(self, filename):\\n self.config.filename = filename\\n self.config.write()\",\n \"def save_config(**kwargs):\\n if kwargs == {}:\\n kwargs = config._config\\n current_config = _load_config()\\n current_config.update(**kwargs)\\n # write to disk\\n fname = _get_config_fname()\\n if fname is None:\\n raise RuntimeError('config filename could not be determined')\\n if not op.isdir(op.dirname(fname)):\\n os.mkdir(op.dirname(fname))\\n with open(fname, 'w') as fid:\\n json.dump(current_config, fid, sort_keys=True, indent=0)\",\n \"def writeShREEKConfig(self, filename):\\n self._ShREEKConfig.save(filename)\\n return\",\n \"async def save_config(self):\\n\\n # Display info message\\n log.info(\\\"save_config\\\")\\n\\n # Send command to ask for saving config. Wait till the question to overwrite\\n # the startup file (\\\"Overwrite file [startup-config].... (Y/N)[N] ?\\\")\\n output = await self.send_command(self.cmd_save_config, pattern=\\\"?\\\")\\n\\n # Confirm to save the config\\n output += await self.send_command(\\\"Y\\\")\\n\\n # Return the commands of the configuration saving process\\n return output\",\n \"def save_config(conf, save_path):\\n with open(os.path.join(save_path), \\\"w\\\") as f:\\n f.write(yaml.dump({'param': conf}, default_flow_style=False))\",\n \"def saveSettings():\\t\\n\\tglobal settings\\n\\tfout = open(config_file,'w')\\n\\tfout.write(json.dumps(settings, sort_keys=True, indent=4))\\n\\tfout.close()\",\n \"def save(self):\\n # TODO: save the file\",\n \"def saveConfig(config, filepath=None):\\n result = False\\n if filepath is None:\\n filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), \\\"res/\\\", \\\"config.ini\\\")\\n try:\\n with open(filepath, 'wb') as configfile:\\n config.write(configfile)\\n result = True\\n except Exception, e:\\n print \\\"*** Caught Exception: %r ***\\\" % e\\n return result\",\n \"def save(self):\\n sublime.save_settings(self.file_name)\",\n \"def save(data, section): # save a config\\n\\tglobal _timesSaved\\n\\tif dynConfig['logConfigActions']:\\n\\t\\tlogger.info( f'saving {section}: {data}' )\\n\\t# save\\n\\tif section != 'placeholderForSaving':\\n\\t\\tcurrentConfigData[section] = data\\n\\t\\tlogger.debug( f'saved {section}' )\\n\\telse:\\n\\t\\t_timesSaved = 2\\n\\t# save to disk if this is the third save\\n\\tif _timesSaved == 0 or _timesSaved == 1:\\n\\t\\t_timesSaved += 1\\n\\telse:\\n\\t\\t_timesSaved = 0\\n\\t\\ttry:\\n\\t\\t\\t# save to disk\\n\\t\\t\\twith open( configPath, 'w', encoding='utf-8' ) as file:\\n\\t\\t\\t\\tjson.dump( currentConfigData, file, indent=4 )\\n\\t\\texcept:\\n\\t\\t\\tlogger.error( f'failed to save config to disk!' )\\n\\t\\t\\traise ConfigError( 'error while saving the config file' )\",\n \"def save_file(self, force=False): # type: (bool) -> bool\\n if self._modified or force:\\n logging.info('Cyra is writing your config to %s' % self._file)\\n\\n with open(self._file, 'w') as f:\\n f.write(self.export_toml())\\n\\n self._modified = False\\n return True\\n return False\",\n \"def save(self):\\n \\n f = file(self.conf_file, \\\"w\\\")\\n f.write(header + \\\"\\\\n\\\".join(map(str, self.db)) + \\\"\\\\n\\\")\\n f.close()\",\n \"def save(config, path=None):\\n if path is None:\\n path = settings.HOST_CONFIG_PATH\\n\\n with open(path, 'w') as output:\\n output.write(yaml.safe_dump(config, default_flow_style=False))\",\n \"def save_conf(self, name=None):\\n \\n if name:\\n filename = name\\n \\n else:\\n filename = \\\"conf_\\\" + str(self.conf[\\\"device\\\"]) + \\\"_\\\" + datetime.today().strftime('%Y-%m-%d') + \\\".txt\\\"\\n \\n path = \\\"./source/_0_time_series_class/configuration/\\\"\\n filename = path + filename\\n \\n with open(filename, \\\"w\\\") as file:\\n json.dump(self.conf, file)\",\n \"def saveConfigFileDlg( self ):\\n fileName = QtGui.QFileDialog.getSaveFileName( self, \\\"Save Full Config As...\\\", self.rsrc.lastFolder, \\\"Config files (*.cfg)\\\" )\\n if ( fileName ):\\n self.saveConfigFile( fileName )\\n path, fName = os.path.split( str( fileName ) )\\n self.rsrc.lastFolder = path\",\n \"def save(self):\\n if self.location is None:\\n logger.debug(\\\"Save requested but not saving settings, \\\"\\n \\\"location is None\\\")\\n return\\n\\n if self._saving or not self._dirty:\\n return\\n\\n self._saving = True\\n\\n logger.debug(\\\"Saving settings...\\\")\\n\\n with open(self.location + \\\".new\\\", 'w') as f:\\n self.write(f)\\n\\n try:\\n # make it readable by current user only, to protect private data\\n os.fchmod(f.fileno(), 384)\\n except:\\n pass # fail gracefully, eg if on windows\\n\\n f.flush()\\n\\n try:\\n os.rename(self.location, self.location + \\\".old\\\")\\n except:\\n pass # if it doesn'texist we don't care\\n\\n os.rename(self.location + \\\".new\\\", self.location)\\n\\n try:\\n os.remove(self.location + \\\".old\\\")\\n except:\\n pass\\n\\n self._saving = False\\n self._dirty = False\",\n \"def __write_config(self):\\n with open(self.config_file, 'w') as data_file:\\n config = {\\\"ibooks_doc_root\\\":self.ibooks_doc_root,\\n \\\"library_folder\\\":self.library_folder,\\n \\\"annotation_folder\\\":self.annotation_folder,\\n \\\"tmp_dir\\\":self.tmp_dir\\n } \\n data = json.dumps(config, ensure_ascii=False)\\n data_file.write(data)\",\n \"def write_config(self):\\n logging.debug(\\\"Writing configuration file: %s\\\" % self.config_file)\\n f = open(self.config_file, \\\"w\\\")\\n self.config.write(f)\\n f.close()\",\n \"def save_config(self):\\n if not os.path.exists(USER_CONFIG_PATH):\\n os.makedirs(USER_CONFIG_PATH)\\n\\n # obtener el config actual\\n config = self.get_config()\\n\\n # obtener el cliente\\n client = self._args.get('client')\\n\\n # ciertos parametros no se tienen que salvar\\n args = self._args.copy()\\n for item in ['doc', 'command', 'client']:\\n if item in args:\\n args.pop(item)\\n\\n # actualizar el cliente default\\n config['client'] = client\\n\\n # actualizar el resto de los parametros para ese cliente\\n for item in args:\\n if client in config:\\n config[client][item] = args.get(item)\\n else:\\n config[client] = {item: args.get(item)}\\n\\n with open(USER_CONFIG_FILE, 'w') as config_file:\\n yaml.dump(config, config_file, default_flow_style=False,\\n allow_unicode=True)\",\n \"def save(self,filename=None,defaults=False):\\n # Check filename or use default filename\\n if not filename:\\n if self.__configfile:\\n filename=self.__configfile\\n else:\\n raise Exception(_('EVOGTK: Need a filename for saving preferences'))\\n # Set widget values on config parser\\n for section in self.__optionstruct:\\n for option in self.__optionstruct[section]:\\n widgets=self.__optionstruct[section][option][1]\\n # Get default value\\n value=vars(self)[section].get_option(option)\\n if not defaults and widgets:\\n # Use widget value\\n val=self.__guidata.__getattr__(widgets[0])\\n if val:\\n value=val\\n # Create section in file if not exists\\n if not self.__config.has_section(section):\\n self.__config.add_section(section)\\n value=vars(self)[section].set_option(option,value)\\n # Write config to file\\n fd=open(filename,'wb')\\n self.__config.write(fd)\\n fd.close()\",\n \"async def save_config(self):\\n\\n # Display info message\\n log.info(\\\"save_config\\\")\\n\\n # Send command\\n output = await self.send_command(self.cmd_save_config)\\n\\n # Return the commands of the configuration saving process\\n return output\",\n \"def save_config(self, cfg):\\n filename = self.get_filename(\\\"config\\\", ext=\\\".txt\\\")\\n if filename is None:\\n return\\n\\n if not isinstance(cfg, XFasterConfig):\\n cfg = XFasterConfig(cfg)\\n\\n try:\\n creator = os.getlogin()\\n except OSError:\\n creator = \\\"unknown\\\"\\n with open(filename, \\\"w\\\") as f:\\n f.write(\\n \\\"# Created by {} on {:%Y-%m-%d %H:%M:%S}\\\\n\\\\n\\\".format(\\n creator, datetime.datetime.now()\\n )\\n )\\n cfg.write(f)\\n\\n return filename\",\n \"def save():\\n log.info(\\\"Saving settings file\\\")\\n with open(SETTINGS_FILE, \\\"w\\\") as file:\\n json.dump(_names, file)\",\n \"def write(self):\\n cfgpath = os.path.join(self.config_dir, CONFIG_FILENAME)\\n ofile = open(cfgpath, 'w')\\n if ofile:\\n log.debug( \\\"Write config: %s\\\" % cfgpath )\\n cfg = yaml.dump(self.yaml, default_flow_style=False)\\n log.debug( \\\"Config:\\\\n%s\\\" % cfg)\\n ofile.write(cfg)\\n ofile.close()\",\n \"def save(self, filename=\\\"startup-config\\\"):\\n command = f\\\"copy running-config {filename}\\\"\\n # Changed to send_command_timing to not require a direct prompt return.\\n self.native.send_command_timing(command)\\n # If the user has enabled 'file prompt quiet' which dose not require any confirmation or feedback.\\n # This will send return without requiring an OK.\\n # Send a return to pass the [OK]? message - Increase delay_factor for looking for response.\\n self.native.send_command_timing(\\\"\\\\n\\\", delay_factor=2)\\n # Confirm that we have a valid prompt again before returning.\\n self.native.find_prompt()\\n log.debug(\\\"Host %s: Configuration saved.\\\", self.host)\\n return True\",\n \"def _save_configuration_to_yml(self):\\n data = self.get_configuration_data()\\n timestamp = self.model.timestamp\\n with open(os.path.join(CHECKPOINTS_DIR, timestamp, 'config_{}.yml'.format(timestamp)), 'w') as outfile:\\n yaml.dump(dict(data), outfile, default_flow_style=False)\",\n \"def save_settings(self):\\n settings = {'camera': self.comboCamera.currentIndex(),\\n 'rotation': self.comboRotation.currentIndex(),\\n 'colors': {\\n 'min_hue': self.spinMinHue.value(),\\n 'max_hue': self.spinMaxHue.value(),\\n 'min_saturation': self.spinMinSaturation.value(),\\n 'max_saturation': self.spinMaxSaturation.value(),\\n 'min_value': self.spinMinValue.value(),\\n 'max_value': self.spinMaxValue.value(),\\n }, 'diameter': self.spinDiameter.value(),\\n 'lifter': self.lineEditLifter.text(),\\n 'save_video': self.checkSaveVideo.isChecked()\\n }\\n settings_file = open('./resources/settings.json', 'w')\\n json.dump(settings, settings_file, indent=4)\\n settings_file.close()\\n self.statusbar.clearMessage()\\n self.statusbar.showMessage('Settings saved.', 5000)\",\n \"def save_to_config(self) -> None:\\n config_path = os.path.join(self.base_path, \\\"config.json\\\")\\n\\n with open(config_path, \\\"r\\\") as _json:\\n c_dict = json.load(_json)\\n\\n c_dict[\\\"mean_similarity_error\\\"] = self.ME\\n c_dict[\\\"similarity_correlation\\\"] = self.pearson_corr\\n c_dict[\\\"similarity_spearman_correlation\\\"] = self.spearman_corr\\n\\n with open(config_path, \\\"w\\\") as _json:\\n json.dump(c_dict, _json)\",\n \"def save_cfg(self, output_dir):\\n output_path = os.path.join(output_dir, 'level_config.cfg')\\n shutil.copy(self.cfg_path, output_path)\",\n \"def save(config: dict, out_dir: str, filename: str = \\\"config.yaml\\\"):\\n assert filename.endswith(\\\".yaml\\\")\\n with open(os.path.join(out_dir, filename), \\\"w+\\\") as f:\\n f.write(yaml.dump(config))\",\n \"def save(self, file_name):\\n saved_data = { \\\"start_config\\\" : self.start_config, \\\"action_storage\\\" : self.action_storage } \\n with open(file_name, 'wb') as fh:\\n pickle.dump(saved_data, fh)\",\n \"def save_options(self,config,options_file):\\n \\n config.set('manager-editable','media_offset',self.media_offset)\\n config.set('manager-editable','profiles_offset',self.pp_profiles_offset)\\n config.set('manager-editable','use_sudo',self.use_sudo)\\n config.set('manager-editable','options',self.options)\\n\\n config.set('manager-editable','autostart_path',self.autostart_path) \\n config.set('manager-editable','autostart_use_sudo',self.autostart_use_sudo)\\n config.set('manager-editable','autostart_options',self.autostart_options)\\n \\n with open(options_file, 'wb') as config_file:\\n config.write(config_file)\",\n \"def onExportConfig(self, evt):\\n dlg = wx.FileDialog(self.view, \\\"Save As Configuration File\\\", wildcard = \\\"*.ini\\\" ,\\n style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)\\n if dlg.ShowModal() == wx.ID_OK:\\n fileName=dlg.GetPath()\\n self.config.exportConfig(fileName=fileName, e=None)\",\n \"def save(self):\\n Preferences.setVCS(\\n \\\"AutoClose\\\",\\n self.vcsAutoCloseCheckBox.isChecked())\\n Preferences.setVCS(\\n \\\"AutoSaveFiles\\\",\\n self.vcsAutoSaveCheckBox.isChecked())\\n Preferences.setVCS(\\n \\\"AutoSaveProject\\\",\\n self.vcsAutoSaveProjectCheckBox.isChecked())\\n Preferences.setVCS(\\n \\\"StatusMonitorInterval\\\",\\n self.vcsStatusMonitorIntervalSpinBox.value())\\n Preferences.setVCS(\\n \\\"MonitorLocalStatus\\\",\\n self.vcsMonitorLocalStatusCheckBox.isChecked())\\n Preferences.setVCS(\\n \\\"AutoUpdate\\\",\\n self.autoUpdateCheckBox.isChecked())\\n \\n self.saveColours(Preferences.setProjectBrowserColour)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.9018369","0.89983326","0.87025833","0.8437155","0.83241445","0.8323876","0.8261388","0.82597125","0.8157242","0.8059971","0.80546784","0.805303","0.7990608","0.79761726","0.79709685","0.79246825","0.7923481","0.7910758","0.7910608","0.78848404","0.7884696","0.78810245","0.78804606","0.786675","0.78557724","0.7831463","0.78197193","0.78163725","0.7814579","0.7752738","0.7747439","0.7745395","0.7720092","0.76957107","0.76787686","0.7631607","0.76250196","0.7610422","0.76009536","0.75982755","0.75957185","0.7571225","0.7548178","0.7542437","0.75124896","0.7488222","0.74820966","0.7479538","0.7477034","0.747386","0.7464519","0.7395819","0.7380424","0.7380073","0.7372492","0.73685724","0.7366541","0.73460734","0.734535","0.73405105","0.73395145","0.7335472","0.7331998","0.732765","0.7327125","0.7319074","0.73185754","0.73104215","0.7309882","0.7288159","0.7286821","0.72695917","0.7253319","0.72455","0.72414684","0.7234386","0.72338676","0.7201672","0.7192053","0.71385455","0.71380025","0.713022","0.7116065","0.7115737","0.71143585","0.7112588","0.7106298","0.70921206","0.70854926","0.7071014","0.705838","0.7053607","0.7041643","0.704047","0.7028983","0.70217574","0.701391","0.6997121","0.6987919","0.6986385"],"string":"[\n \"0.9018369\",\n \"0.89983326\",\n \"0.87025833\",\n \"0.8437155\",\n \"0.83241445\",\n \"0.8323876\",\n \"0.8261388\",\n \"0.82597125\",\n \"0.8157242\",\n \"0.8059971\",\n \"0.80546784\",\n \"0.805303\",\n \"0.7990608\",\n \"0.79761726\",\n \"0.79709685\",\n \"0.79246825\",\n \"0.7923481\",\n \"0.7910758\",\n \"0.7910608\",\n \"0.78848404\",\n \"0.7884696\",\n \"0.78810245\",\n \"0.78804606\",\n \"0.786675\",\n \"0.78557724\",\n \"0.7831463\",\n \"0.78197193\",\n \"0.78163725\",\n \"0.7814579\",\n \"0.7752738\",\n \"0.7747439\",\n \"0.7745395\",\n \"0.7720092\",\n \"0.76957107\",\n \"0.76787686\",\n \"0.7631607\",\n \"0.76250196\",\n \"0.7610422\",\n \"0.76009536\",\n \"0.75982755\",\n \"0.75957185\",\n \"0.7571225\",\n \"0.7548178\",\n \"0.7542437\",\n \"0.75124896\",\n \"0.7488222\",\n \"0.74820966\",\n \"0.7479538\",\n \"0.7477034\",\n \"0.747386\",\n \"0.7464519\",\n \"0.7395819\",\n \"0.7380424\",\n \"0.7380073\",\n \"0.7372492\",\n \"0.73685724\",\n \"0.7366541\",\n \"0.73460734\",\n \"0.734535\",\n \"0.73405105\",\n \"0.73395145\",\n \"0.7335472\",\n \"0.7331998\",\n \"0.732765\",\n \"0.7327125\",\n \"0.7319074\",\n \"0.73185754\",\n \"0.73104215\",\n \"0.7309882\",\n \"0.7288159\",\n \"0.7286821\",\n \"0.72695917\",\n \"0.7253319\",\n \"0.72455\",\n \"0.72414684\",\n \"0.7234386\",\n \"0.72338676\",\n \"0.7201672\",\n \"0.7192053\",\n \"0.71385455\",\n \"0.71380025\",\n \"0.713022\",\n \"0.7116065\",\n \"0.7115737\",\n \"0.71143585\",\n \"0.7112588\",\n \"0.7106298\",\n \"0.70921206\",\n \"0.70854926\",\n \"0.7071014\",\n \"0.705838\",\n \"0.7053607\",\n \"0.7041643\",\n \"0.704047\",\n \"0.7028983\",\n \"0.70217574\",\n \"0.701391\",\n \"0.6997121\",\n \"0.6987919\",\n \"0.6986385\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8239592"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":177,"cells":{"query":{"kind":"string","value":"Return value stored in config"},"document":{"kind":"string","value":"def get(self, key, default_val=None):\n if key not in self._config.keys(): # we don't want KeyError\n return default_val # just return None if not found\n return self._config[key]"},"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_config_value(self, name):\r\n if name in self.config_values:\r\n return self.config_values[name]","def _get_config_value(self, section, key):\n return config.get(section, key)","def value(self) -> str:\n return self._config.get('value')","def get(self, key):\n return self.config.get(key)","def config_value(name):\n def get():\n try:\n return config.get('yourls', name)\n except (NoOptionError, NoSectionError):\n return None\n return get","def get_system_value(name: str):\n return Config.objects.first().__dict__[name]","def get_config(self):\n return {'value': self.value}","def config(self):\n return self[CONFIG_KEY]","def getconfig(self, key):\n return self.config[key]","def get_config(self, key):\n return self.data[key]","def get_value(self, key):\n if key not in self._config:\n raise ValueError(\"%s not in self.config\"%key)\n return self._config[key][\"value\"]","def get_config(self, name):\n return self.configs[name][0]","def get_config_value(keyword):\n if g_configs and keyword in g_configs:\n return g_configs[keyword]\n return \"\"","def get_config_value(self, key):\n try:\n self.logger.write_to_log('config data requested', 'model')\n\n return self.db_handler.get_config_value(key)[0]\n except Exception as err:\n method_name = sys._getframe().f_code.co_name\n\n self.logger.write_to_log('exception', 'model')\n self.logger.write_to_err_log(f'exception in method {method_name} - {err}', 'model')","def __getitem__(self, name):\n return self.config[name]","def getvalue(self,num,name):\n return self.M.conf(num)[name]","def get_config():\n return CONFIG","def get_value(key: str) -> str:\n Config.__get()\n assert Config.__config is not None\n return Config.__config.get(\"wsgi\", key)","def __getitem__(self, key):\n return self.config[key]","def get_config(self,config):\n return self.parser.get(\"main\", config)","def __getitem__(self, name : str) -> Any:\n return self._client.get_config()[name]","def value(self):\n\n memcached_items = memcache_services.get_multi([self.name])\n if self.name in memcached_items:\n return memcached_items[self.name]\n\n datastore_item = config_models.ConfigPropertyModel.get(\n self.name, strict=False)\n if datastore_item is not None:\n memcache_services.set_multi({\n datastore_item.id: datastore_item.value})\n return datastore_item.value\n\n return self.default_value","def get_configval(self, keyname, defaultval=None):\n return self.cfghelper.get_value(keyname,defaultval)","def _getConfigParam(self, name, default=None):\n return self.config.get(self._configPrefix + name.lower(), default)","def get_config(self, key):\n return getattr(self.args, 'conf.{}'.format(key))","def get_config_var(name):\n return get_config_vars().get(name)","def setting(self, config, name, default=None):\n\n return config.get(name, default) if config else default","def config(self):\n return CurrentProject().config.config[self.key]","def get(self) -> dict:\n return Config.get()","def get(self, key):\n self._check(key)\n return unicode(self.__config.value(key).toString())","def get(query):\n global INITIALIZED\n global CONFIG\n global GLOBAL_CONFIG\n\n if not INITIALIZED:\n raise Exception('[XOS-Config] Module has not been initialized')\n\n val = Config.get_param(query, CONFIG)\n if not val:\n val = Config.get_param(query, GLOBAL_CONFIG)\n if not val:\n val = Config.get_param(query, default.DEFAULT_VALUES)\n if not val:\n # TODO if no val return none\n # raise Exception('[XOS-Config] Config does not have a value (or a default) parameter %s' % query)\n return None\n return val","def config(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"config\")","def getValue(self, valueName):\n\t\treturn self.settings[valueName][0]","def get_config(item: str) -> Union[str, int]:\n file = load_config_file(\"config.json\")\n\n value = file.get(item)\n\n if value is None:\n raise Exception(f\"Your config is out of date! Missing a value for {item}\")\n return value","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config"],"string":"[\n \"def get_config_value(self, name):\\r\\n if name in self.config_values:\\r\\n return self.config_values[name]\",\n \"def _get_config_value(self, section, key):\\n return config.get(section, key)\",\n \"def value(self) -> str:\\n return self._config.get('value')\",\n \"def get(self, key):\\n return self.config.get(key)\",\n \"def config_value(name):\\n def get():\\n try:\\n return config.get('yourls', name)\\n except (NoOptionError, NoSectionError):\\n return None\\n return get\",\n \"def get_system_value(name: str):\\n return Config.objects.first().__dict__[name]\",\n \"def get_config(self):\\n return {'value': self.value}\",\n \"def config(self):\\n return self[CONFIG_KEY]\",\n \"def getconfig(self, key):\\n return self.config[key]\",\n \"def get_config(self, key):\\n return self.data[key]\",\n \"def get_value(self, key):\\n if key not in self._config:\\n raise ValueError(\\\"%s not in self.config\\\"%key)\\n return self._config[key][\\\"value\\\"]\",\n \"def get_config(self, name):\\n return self.configs[name][0]\",\n \"def get_config_value(keyword):\\n if g_configs and keyword in g_configs:\\n return g_configs[keyword]\\n return \\\"\\\"\",\n \"def get_config_value(self, key):\\n try:\\n self.logger.write_to_log('config data requested', 'model')\\n\\n return self.db_handler.get_config_value(key)[0]\\n except Exception as err:\\n method_name = sys._getframe().f_code.co_name\\n\\n self.logger.write_to_log('exception', 'model')\\n self.logger.write_to_err_log(f'exception in method {method_name} - {err}', 'model')\",\n \"def __getitem__(self, name):\\n return self.config[name]\",\n \"def getvalue(self,num,name):\\n return self.M.conf(num)[name]\",\n \"def get_config():\\n return CONFIG\",\n \"def get_value(key: str) -> str:\\n Config.__get()\\n assert Config.__config is not None\\n return Config.__config.get(\\\"wsgi\\\", key)\",\n \"def __getitem__(self, key):\\n return self.config[key]\",\n \"def get_config(self,config):\\n return self.parser.get(\\\"main\\\", config)\",\n \"def __getitem__(self, name : str) -> Any:\\n return self._client.get_config()[name]\",\n \"def value(self):\\n\\n memcached_items = memcache_services.get_multi([self.name])\\n if self.name in memcached_items:\\n return memcached_items[self.name]\\n\\n datastore_item = config_models.ConfigPropertyModel.get(\\n self.name, strict=False)\\n if datastore_item is not None:\\n memcache_services.set_multi({\\n datastore_item.id: datastore_item.value})\\n return datastore_item.value\\n\\n return self.default_value\",\n \"def get_configval(self, keyname, defaultval=None):\\n return self.cfghelper.get_value(keyname,defaultval)\",\n \"def _getConfigParam(self, name, default=None):\\n return self.config.get(self._configPrefix + name.lower(), default)\",\n \"def get_config(self, key):\\n return getattr(self.args, 'conf.{}'.format(key))\",\n \"def get_config_var(name):\\n return get_config_vars().get(name)\",\n \"def setting(self, config, name, default=None):\\n\\n return config.get(name, default) if config else default\",\n \"def config(self):\\n return CurrentProject().config.config[self.key]\",\n \"def get(self) -> dict:\\n return Config.get()\",\n \"def get(self, key):\\n self._check(key)\\n return unicode(self.__config.value(key).toString())\",\n \"def get(query):\\n global INITIALIZED\\n global CONFIG\\n global GLOBAL_CONFIG\\n\\n if not INITIALIZED:\\n raise Exception('[XOS-Config] Module has not been initialized')\\n\\n val = Config.get_param(query, CONFIG)\\n if not val:\\n val = Config.get_param(query, GLOBAL_CONFIG)\\n if not val:\\n val = Config.get_param(query, default.DEFAULT_VALUES)\\n if not val:\\n # TODO if no val return none\\n # raise Exception('[XOS-Config] Config does not have a value (or a default) parameter %s' % query)\\n return None\\n return val\",\n \"def config(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"config\\\")\",\n \"def getValue(self, valueName):\\n\\t\\treturn self.settings[valueName][0]\",\n \"def get_config(item: str) -> Union[str, int]:\\n file = load_config_file(\\\"config.json\\\")\\n\\n value = file.get(item)\\n\\n if value is None:\\n raise Exception(f\\\"Your config is out of date! Missing a value for {item}\\\")\\n return value\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8236148","0.78571916","0.78411025","0.77996963","0.7762611","0.7640735","0.7605088","0.7578148","0.7571694","0.7504212","0.7446086","0.7428434","0.7364911","0.7358118","0.7330266","0.73145777","0.7290636","0.72804093","0.7263993","0.7168558","0.7160482","0.71520907","0.71280974","0.7100109","0.7096089","0.70873976","0.70827675","0.7059195","0.7049757","0.703598","0.7030822","0.7022724","0.6986693","0.6973593","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343","0.6938343"],"string":"[\n \"0.8236148\",\n \"0.78571916\",\n \"0.78411025\",\n \"0.77996963\",\n \"0.7762611\",\n \"0.7640735\",\n \"0.7605088\",\n \"0.7578148\",\n \"0.7571694\",\n \"0.7504212\",\n \"0.7446086\",\n \"0.7428434\",\n \"0.7364911\",\n \"0.7358118\",\n \"0.7330266\",\n \"0.73145777\",\n \"0.7290636\",\n \"0.72804093\",\n \"0.7263993\",\n \"0.7168558\",\n \"0.7160482\",\n \"0.71520907\",\n \"0.71280974\",\n \"0.7100109\",\n \"0.7096089\",\n \"0.70873976\",\n \"0.70827675\",\n \"0.7059195\",\n \"0.7049757\",\n \"0.703598\",\n \"0.7030822\",\n \"0.7022724\",\n \"0.6986693\",\n \"0.6973593\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\",\n \"0.6938343\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":178,"cells":{"query":{"kind":"string","value":"Update the config file"},"document":{"kind":"string","value":"def update(self):\n self.save_config_file()"},"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 conf_update(self):\n pass","def updateConfig(self):\n # Make sure to keep the default values in place.\n if self.newConfig['sensor'] == 0:\n self.newConfig['sensor'] = self.config['sensor']\n if self.newConfig['camera'] == 0:\n self.newConfig['camera'] = self.config['camera']\n if not self.newConfig['auto']['times']:\n self.newConfig['auto']['times'] = self.config['auto']['times']\n if not self.newConfig['auto']['days']:\n self.newConfig['auto']['days'] = self.config['auto']['days']\n\n # Show the changes.\n if self.verbosity >= 1:\n print('%s: Updating configuration file...' % self.feederName)\n try:\n for key in self.config.keys():\n if type(self.config[key]) is dict:\n for subkey in self.config[key].keys():\n if self.config[key][subkey] != self.newConfig[key][subkey]:\n print('%s: Updating %s from %s to %s.' % (self.feederName, subkey, self.config[key][subkey], self.newConfig[key][subkey]))\n elif self.config[key] != self.newConfig[key]:\n print('%s: Updating %s from %s to %s.' % (self.feederName, key, self.config[key], self.newConfig[key]))\n except ValueError:\n if self.verbosity >= 1:\n print('%s: Configuration file does not contain a valid JSON object.' % self.feederName)\n if self.verbosity == 2:\n print('%s: Overwriting configuration file to: %s.' % (self.feederName, self.config))\n\n # Change the configuration file.\n self.config = self.newConfig\n self.writeConfig()","def updateconfig(self):\n\n # Initialize the yaml data\n ydata = {\"metadata\": self._metadata, \"nodes\": self._nodes}\n\n # Write the system config file\n filename = self._rootdir + self._metadata[\"system_config_file\"]\n with open(filename, \"w\") as yamlfile:\n yaml.dump(ydata, yamlfile)","def __update(self):\n if self.__file:\n target_file = open(self.__file)\n for attr in dir(self):\n if not attr.startswith(\"_\") and \\\n (self.__overwrite or (attr not in self.__exclude)) \\\n and not self.__is_attr_callable(attr):\n try:\n delattr(self, attr)\n except AttributeError:\n pass\n pool = yaml.load(target_file)\n target_file.close()\n if pool: # could be None\n for key, val in pool.iteritems():\n if not key.startswith(\"_\") and \\\n (self.__overwrite or (key not in self.__exclude)) \\\n and not self.__is_attr_callable(key):\n setattr(self, key, val)\n if hasattr(self, 'log_config_file_changes')\\\n and self.log_config_file_changes:\n logging.getLogger(__name__).info(\"Config file has updated.\")","def update_config(self, data):\n self.config.data = dict_merge(self.config.data, data)\n self.config.save()","def config_update(self, update: io.BytesIO) -> None:\n self.__logger.debug('Eva.config_update called')\n return self.__http_client.config_update(update)","def update_config(self, config):\n return self._update_config(\"config\", config)","def refresh_config(self):\n with open(config_name, 'rb') as f:\n self.CONFIG = simplejson.load(f)\n\n return self","def _auto_update_configuration(self) -> None:\n self.config = rasa.utils.train_utils.update_confidence_type(self.config)\n rasa.utils.train_utils.validate_configuration_settings(self.config)\n self.config = rasa.utils.train_utils.update_similarity_type(self.config)\n self.config = rasa.utils.train_utils.update_evaluation_parameters(self.config)","def update_conf_file():\n filepath = remote_dir + \"/apache2/conf/httpd.conf\"\n fabric.contrib.files.sed(filepath, 'myproject', project_name)","def reload_config(self):\n pass","def update_config(self, kv: dict):\n self._configs.update(kv)\n self._save()","def _refreshconfig(self):\n self.config = ConfigGenerator(os.path.join(self.rundir, const.CONFIG_FILE))","def refresh_configuration(self):\n pass","def setup_configuration_file(self):\n\n with open(self.config_path, \"w+\") as f_config:\n\n f_config.write(get_configuration_file_form())","def update_config_file(**kwargs):\n config_file = try_read_file()\n config_file.update(kwargs)\n config_file = {key: value for key, value in config_file.items() if value is not None}\n logging.info('open config file %s', config_file_path)\n with open(config_file_path, 'w') as f:\n logging.info('begin io %s', config_file_path)\n json.dump(config_file, f, indent=4)\n logging.info('end io %s', config_file_path)","def use_config_file(self):\n self.config_file = self.find_config_file()\n if self.config_file:\n self.apply_config_file(self.config_file)","def reload(self):\n self.read(self._cfg_path)","def testUpdateConfigFile(self):\n # Test update project field.\n gcp_setup_runner.UpdateConfigFile(self.cfg_path, \"project\",\n \"test_project\")\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\n open(self.cfg_path, \"r\"), user_config_pb2.UserConfig)\n self.assertEqual(cfg.project, \"test_project\")\n self.assertEqual(cfg.ssh_private_key_path, \"\")\n # Test add ssh key path in config.\n gcp_setup_runner.UpdateConfigFile(self.cfg_path,\n \"ssh_private_key_path\", \"test_path\")\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\n open(self.cfg_path, \"r\"), user_config_pb2.UserConfig)\n self.assertEqual(cfg.project, \"test_project\")\n self.assertEqual(cfg.ssh_private_key_path, \"test_path\")\n # Test config is not a file\n with mock.patch(\"os.path.isfile\") as chkfile:\n chkfile.return_value = False\n gcp_setup_runner.UpdateConfigFile(self.cfg_path, \"project\",\n \"test_project\")\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\n open(self.cfg_path, \"r\"), user_config_pb2.UserConfig)\n self.assertEqual(cfg.project, \"test_project\")","def update(self, config_dict):\r\n self._update(config_dict, allow_new_keys=True)","def update_config(config_file, config_base=None):\n if config_base is None:\n config_base = def_config_file\n assert(os.path.isfile(config_base))\n if not os.path.isfile(config_file):\n shutil.copy(config_base, config_file)\n cp = CisConfigParser()\n cp.read(config_file)\n miss = []\n if platform._is_win: # pragma: windows\n miss += update_config_windows(cp)\n with open(config_file, 'w') as fd:\n cp.write(fd)\n for sect, opt, desc in miss: # pragma: windows\n warnings.warn((\"Could not locate option %s in section %s.\"\n + \"Please set this in %s to: %s\")\n % (opt, sect, config_file, desc))","def update_packages(self, config_file):\n entries = yacman.load_yaml(config_file)\n self.update(entries)\n return True","def update_config(self, update_dict):\n self.config = recursive_merge_dicts(self.config, update_dict)","def config_edits(configfile):\n try:\n\n # Read in the file\n filedata = None\n with open(configfile, 'r') as file:\n filedata = file.read()\n\n # Replace the target string\n filedata = filedata.replace(\n '/home/scratch01/sradanov/A2C2/NCEP/', '').replace('/home/estimr2/sradanov/Operational/', '')\n\n # Write the file out again\n with open(configfile, 'w') as file:\n file.write(filedata)\n\n LOGGER.info('configfile modified')\n except Exception:\n LOGGER.exeption('Failed to modify configfile:')\n\n return configfile","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_from_file(self):\n config_path = os.environ.get('MINDINSIGHT_CONFIG', '')\n if not config_path:\n return\n\n config_module = None\n\n # python:full.path.for.config.module\n if config_path.startswith('python:'):\n config_module = import_module(config_path[len('python:'):])\n\n # file:full/path/for/config.py\n elif config_path.startswith('file:'):\n config_path = config_path[len('file:'):]\n module_name = '__mindinsightconfig__'\n config_module = types.ModuleType(module_name)\n machinery = import_module('importlib.machinery')\n loader = machinery.SourceFileLoader(module_name, config_path)\n loader.exec_module(config_module)\n\n if config_module is None:\n return\n\n for setting in dir(config_module):\n if setting.isupper() and setting in self._default_settings:\n setting_value = getattr(config_module, setting)\n setattr(self, setting, setting_value)\n self._explicit_settings.add(setting)","def save_config(self, new_config, filename=None):\n self.cfg.update(new_config)\n if filename is None:\n self.cfg.filename = self.cfg_filename\n else:\n self.cfg.filename = filename\n self.cfg.write()\n logger.info(\"Config file %s written out\" % self.cfg.filename)","def write_config(self, filename):\n self.config.filename = filename\n self.config.write()","def update_shed_config(self, shed_conf):\n for index, my_shed_tool_conf in enumerate(self._dynamic_tool_confs):\n if shed_conf['config_filename'] == my_shed_tool_conf['config_filename']:\n self._dynamic_tool_confs[index] = shed_conf\n self._save_integrated_tool_panel()","def config_updated(self):\n if callable(self.on_config_updated):\n self.on_config_updated(self.config())","def update_feature(selfs, k, v, cfg_path):\n with open(cfg_path, 'r') as cfg:\n file_dict = yaml.safe_load(cfg)\n # overprint the entries with the new config_dict\n file_dict['{}'.format(k)] = v\n with open(cfg_path, 'w') as w_file:\n w_file.write(yaml.dump(file_dict))","def edit_cfg(config_file):\n\n GUI().cfgEditor(config_file)","def load_config(self):\n if os.path.exists(self.config_file):\n with open(self.config_file) as f:\n conf = json.load(f)\n\n self.update_attributes_from_config(conf)","def _update_auto_config(self):\n\n # Initialize the yaml data\n nodes = {}\n with open(self._autoconfig_filename, \"r\") as stream:\n try:\n ydata = yaml.load(stream)\n if \"nodes\" in ydata:\n nodes = ydata[\"nodes\"]\n except yaml.YAMLError as exc:\n print(exc)\n return\n\n for i in nodes.items():\n key = i[0]\n node = i[1]\n\n # Interfaces\n node[\"interfaces\"] = {}\n for item in self._nodes[key][\"interfaces\"].items():\n port = item[0]\n interface = item[1]\n\n node[\"interfaces\"][port] = {}\n addr = \"{}\".format(interface[\"pci_address\"])\n node[\"interfaces\"][port][\"pci_address\"] = addr\n if \"mac_address\" in interface:\n node[\"interfaces\"][port][\"mac_address\"] = interface[\"mac_address\"]\n\n if \"total_other_cpus\" in self._nodes[key][\"cpu\"]:\n node[\"cpu\"][\"total_other_cpus\"] = self._nodes[key][\"cpu\"][\n \"total_other_cpus\"\n ]\n if \"total_vpp_cpus\" in self._nodes[key][\"cpu\"]:\n node[\"cpu\"][\"total_vpp_cpus\"] = self._nodes[key][\"cpu\"][\n \"total_vpp_cpus\"\n ]\n if \"reserve_vpp_main_core\" in self._nodes[key][\"cpu\"]:\n node[\"cpu\"][\"reserve_vpp_main_core\"] = self._nodes[key][\"cpu\"][\n \"reserve_vpp_main_core\"\n ]\n\n # TCP\n if \"active_open_sessions\" in self._nodes[key][\"tcp\"]:\n node[\"tcp\"][\"active_open_sessions\"] = self._nodes[key][\"tcp\"][\n \"active_open_sessions\"\n ]\n if \"passive_open_sessions\" in self._nodes[key][\"tcp\"]:\n node[\"tcp\"][\"passive_open_sessions\"] = self._nodes[key][\"tcp\"][\n \"passive_open_sessions\"\n ]\n\n # Huge pages\n node[\"hugepages\"][\"total\"] = self._nodes[key][\"hugepages\"][\"total\"]\n\n # Write the auto config config file\n with open(self._autoconfig_filename, \"w\") as yamlfile:\n yaml.dump(ydata, yamlfile)","def update(self, obj):\n\n self.cfg.update(obj)","def refresh(self):\n self.config.read(self.filename)\n self.loadRecentFiles()","def update_global_config(self, config, **kwargs):\n pass","def update_config(update):\n global _config\n new_config = copy.deepcopy(_config)\n _update_dict_recursive(new_config, update)\n logging.config.dictConfig(new_config)\n _configure_ulog_bridge()\n _config = new_config","def _overwrite_with_config(self, new_cfg):\n for section in new_cfg.sections():\n for key, val in new_cfg.items(section):\n self.config.set(section, key, val)","def config_update_from_file(cls, config_file: str = None) -> None:\n if config_file is None:\n config_file = cls._config[\"graph_app_config\"]\n\n if config_file != \"\":\n cls._logger.debug(\n \"[%s]: Update config from file: %s\", cls.__name__, config_file\n )\n\n cls._config[\"graph_app_config\"] = config_file\n\n config_yaml: Dict = {}\n with open(config_file, \"r\") as f:\n try:\n config_yaml = safe_load(f)\n except YAMLError:\n cls._logger.exception(\n \"Exception loading config file '%s'\", config_file\n )\n\n if config_yaml:\n config_update = {\n \"graph_{}\".format(k): config_yaml.get(k, None)\n for k in config_yaml.keys()\n }\n\n cls._config.update(config_update)\n\n cls._logger.debug(\"[%s]: Final config: %s\", cls.__name__, cls._config)","def overwrite(cls, config_file_overwrite: str):\n conf_overwrite: dict = GC.read_conf(config_file_overwrite)\n for sec, attr in conf_overwrite.items():\n for key, val in attr.items():\n try:\n _ = GC.conf[sec][key]\n GC.conf[sec][key] = val\n except KeyError:\n print(\"Overwrite config file has section/key that \"\n \"don't exist in base config!!! Abort!!!\")\n sys.exit(1)","def update(self, config_dict):\n self._update(config_dict, allow_new_keys=True)","def reload(self):\n with open(self._config) as f:\n self.data = json.load(f)","def write_config(self):\n logging.debug(\"Writing configuration file: %s\" % self.config_file)\n f = open(self.config_file, \"w\")\n self.config.write(f)\n f.close()","def _add_db_in_config(self):\n logger.info(f\"Updating configuration file in {self.configfile}\")\n with open(self.configfile, \"a\") as fp:\n print(self.ref_name + \".genome : \" + self.ref_name, file=fp)","def updated(self, newConfiguration):\n log.debug('ConfigListener: configuration %s updated' % newConfiguration)","def update_configs(self, config):\n for what in self.plugins: # backend, repo etc.\n for key in self.plugins[what]: # s3, filesystem etc.\n # print(\"Updating configuration of\", what, key)\n self.plugins[what][key].config(what='set', params=config)\n return","def with_config_update(self):\n original_config = self.load_config()\n\n config_data = original_config.json\n if str(self.ITEM_PUBLIC_ID) in config_data[f\"{self.ITEM_TYPE}s\"]:\n config_data[f\"{self.ITEM_TYPE}s\"].remove(str(self.ITEM_PUBLIC_ID))\n config_data[f\"{self.ITEM_TYPE}s\"].append(\n f\"{self.ITEM_PUBLIC_ID.author}/{self.ITEM_PUBLIC_ID.name}:0.0.1\"\n )\n self.dump_config(AgentConfig.from_json(config_data))\n try:\n yield\n finally:\n self.dump_config(original_config)","def check_update(self):\r\n with open('new_config.json', 'rt') as jsonfile:\r\n configuration = jsonfile.read()\r\n configuration_data = json.loads(configuration)\r\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:\r\n try:\r\n sock.settimeout(2)\r\n sock.bind(('', 8080))\r\n sock.listen(1)\r\n conn, addr = sock.accept()\r\n except socket.timeout:\r\n return False\r\n sock.settimeout(None)\r\n with conn:\r\n conn.send(configuration)\r\n data = conn.recv(1024)\r\n with open('new_config.json', 'wt') as jsonfile:\r\n json.dump(data, jsonfile)\r\n self.set_new_configuration()","def update_config(self, config):\n self.config = {\n \"display_name\": \"\",\n \"description\": \"\",\n \"required\": 1,\n \"type\": \"string\"\n }\n self.config.update(config)\n self.API_KEY = self.config['key']","def update_config(self, config):\n self.config = {\n \"display_name\": \"\",\n \"description\": \"\",\n \"required\": 1,\n \"type\": \"string\"\n }\n self.config.update(config)\n self.API_KEY = self.config['key']","def on_save(self):\r\n #new_config = ConfigParser.RawConfigParser()\r\n cur_config = self.config.dict_config\r\n #\r\n # update the dict_config\r\n cur_config[\"access_restriction\"][\"ips\"] = self.text_ips.get(1.0, tk.END).strip()\r\n cur_config[\"access_restriction\"][\"ar_url\"] = self.entry_url.get().strip()\r\n #\r\n cur_config[\"email\"][\"relay_server_host\"] = self.entry_server_host.get().strip()\r\n cur_config[\"email\"][\"relay_server_port\"] = self.entry_server_port.get().strip()\r\n cur_config[\"email\"][\"email_from\"] = self.entry_from.get().strip()\r\n cur_config[\"email\"][\"recipients\"] = self.text_recipients.get(1.0, tk.END).strip()\r\n cur_config[\"email\"][\"ar_enabled_subject\"] = self.entry_enabled_subject.get().strip()\r\n cur_config[\"email\"][\"ar_enabled_body\"] = self.text_enabled_body.get(1.0, tk.END).strip()\r\n cur_config[\"email\"][\"ar_disabled_subject\"] = self.entry_disabled_subject.get()\r\n cur_config[\"email\"][\"ar_disabled_body\"] = self.text_disabled_body.get(1.0, tk.END).strip()\r\n\r\n #self.action.save_config()\r\n # # sync dict_config to the gui\r\n # for section in self.config.dict_config:\r\n # new_config.add_section(section)\r\n # for item in self.config.dict_config[section]:\r\n # new_config.set(section, item, self.config.dict_config[section][item])\r\n # #\r\n # # saving to a file\r\n # with open(self.config.file_path, 'w') as newconfigfile:\r\n # new_config.write(newconfigfile)\r\n #\r\n # # mbox.showinfo(\"Information\",\r\n # # \"Current configuration has been successfully saved to '%s'\" % os.path.basename(self.configfile))\r\n # self.console.debug(\"Configuration has been saved to '%s'\" % self.config.file_path)\r","def load_file(self, update=True): # type: (bool) -> None\n if os.path.isfile(self._file):\n logging.info('Cyra is reading your config from %s' % self._file)\n\n with open(self._file, 'r') as f:\n toml_str = f.read()\n self.load_toml(toml_str)\n else:\n self._modified = True\n\n # Write file if non existent or modified\n if update:\n self.save_file()","def refresh(self):\n self.update_from_file()\n self.update_from_env()","def apply_config(filename):\n with open(filename) as config_file:\n config = json.load(config_file)\n for setting, value in config.items():\n CoreConfig.__dict__[setting] = value","def update_config_file(invoker: AirflowInvoker) -> None:\n airflow_cfg_path = invoker.files[\"config\"]\n logging.debug(f\"Generated default '{str(airflow_cfg_path)}'\")\n\n # open the configuration and update it\n # now we let's update the config to use our stubs\n airflow_cfg = configparser.ConfigParser()\n\n with airflow_cfg_path.open() as cfg:\n airflow_cfg.read_file(cfg)\n logging.debug(f\"Loaded '{str(airflow_cfg_path)}'\")\n\n config = invoker.plugin_config_processed\n for section, cfg in config.items():\n airflow_cfg[section].update(cfg)\n logging.debug(f\"\\tUpdated section [{section}] with {cfg}\")\n\n with airflow_cfg_path.open(\"w\") as cfg:\n airflow_cfg.write(cfg)\n logging.debug(f\"Saved '{str(airflow_cfg_path)}'\")","def update(name, value, config_dir=None):\n if name not in Config.__ALLOWED:\n msg = f'Cannot update configuration; value \"{name}\" is not allowed.'\n raise ConfigurationError(msg)\n config_dir = Config.resolve_config_dir(config_dir)\n config_dat, config_file = Config.get_config_file(\n config_dir,\n round_trip_load=True,\n quiet=True,\n )\n config_dat.update({name: value})\n Config.write_config_file(config_dat, config_file)\n if Config.is_set:\n Config.__conf[name] = value","def update_validation_section(self):\n rconfig = configparser.RawConfigParser()\n rconfig.read(self.conf_file)\n if not rconfig.has_section('validation'):\n rconfig.add_section('validation')\n rconfig.set(\n 'validation', 'connect_method',\n 'floating' if self.ext_net else 'fixed')\n rconfig.set(\n 'validation', 'network_for_ssh',\n self.network.name if self.network else env.get(\"EXTERNAL_NETWORK\"))\n with open(self.conf_file, 'w', encoding='utf-8') as config_file:\n rconfig.write(config_file)","def update(self):\n \n dbpath, config = self._start()\n \n self.config.obo = check_file(config.obo, dbpath, \"obo\") \n desc_file = check_file(config.model_descriptions, dbpath,\n \"model_descriptions\", allow_none=True) \n phen_file = check_file(config.model_phenotypes, dbpath,\n \"model_phenotypes\", allow_none=True)\n \n summary = self._update(desc_file, phen_file) \n if len(summary[\"incorrect_ids\"]) == 0 and not config.skip_compute:\n self._compute(models=summary[\"new_phenotypes\"])\n \n self._end()","def _update_config_from_file(config, cfg_file):\n config.defrost()\n with open(cfg_file, 'r') as infile:\n yaml_cfg = yaml.load(infile, Loader=yaml.FullLoader)\n for cfg in yaml_cfg.setdefault('BASE', ['']):\n if cfg:\n _update_config_from_file(\n config, os.path.join(os.path.dirname(cfg_file), cfg)\n )\n config.merge_from_file(cfg_file)\n config.freeze()","def test_config_update(get_config):\n cfg = get_config(Config, {'test': 'main'})\n update_from = {\"name\": \"new_name\"}\n cfg.update(update_from)\n\n assert cfg.data.get('name') == \"new_name\", \"config was not updated\"","def __write_config(self):\n with open(self.config_file, 'w') as data_file:\n config = {\"ibooks_doc_root\":self.ibooks_doc_root,\n \"library_folder\":self.library_folder,\n \"annotation_folder\":self.annotation_folder,\n \"tmp_dir\":self.tmp_dir\n } \n data = json.dumps(config, ensure_ascii=False)\n data_file.write(data)","def updateSettings(self):\n self.parser.read(self.file)\n self.showTicker = self.parser.getboolean('Settings', 'showTicker')\n self.verbose = self.parser.getboolean('Settings', 'verbose')\n self.sleepTime = self.parser.getint('Settings', 'sleeptime')\n self.saveGraph = self.parser.getboolean('Settings', 'saveGraph')\n self.graphDPI = self.parser.getint('Settings', 'graphDPI')","def update(d):\n # get (or create) config path\n p= initialize()['config']\n\n with lockfile.LockFile(p):\n # load current configuration\n cnf = load_config(open(p))\n\n # merge \n def dict_merge(a, b):\n '''recursively merges dict's. not just simple a['key'] = b['key'], if\n both a and bhave a key who's value is a dict then dict_merge is called\n on both values and the result stored in the returned dictionary.\n from https://www.xormedia.com/recursively-merge-dictionaries-in-python/\n '''\n if not isinstance(b, dict):\n return b\n result = copy.deepcopy(a)\n for k, v in b.items():\n if k in result and isinstance(result[k], dict):\n result[k] = dict_merge(result[k], v)\n else:\n result[k] = copy.deepcopy(v)\n return result\n cnf = dict_merge(cnf, d)\n\n # save \n dump_config(cnf, open(p,'w'))","def update_compute_section(self):\n rconfig = configparser.RawConfigParser()\n rconfig.read(self.conf_file)\n if not rconfig.has_section('compute'):\n rconfig.add_section('compute')\n rconfig.set(\n 'compute', 'fixed_network_name',\n self.network.name if self.network else env.get(\"EXTERNAL_NETWORK\"))\n with open(self.conf_file, 'w', encoding='utf-8') as config_file:\n rconfig.write(config_file)","def update_settings(self):\n\n param = \"settings.py\"\n self._check_path_availability([\"get_settings_dir\", \"get_settings_dir_to\"])\n self.updater.update_files(\n self.analizer.get_settings_dir(),\n self.analizer.get_settings_dir_to(),\n param,\n )\n return self.write_debug_message(\"Settings upgrade is done!\\n\")","def save_config(self):\n\n if not self.__conf.has_section(self.section):\n self.__conf.add_section(self.section)\n\n for key in self._params:\n val = self._params[key]\n self.__conf.set(self.section, key, val)\n\n with open(self.conf_path, 'w') as f:\n self.__conf.write(f)","def update_config(self):\n self.channel_count = self.config_global['channel_count']\n self.pixel_count = self.config_global['pixel_count']\n self.pixel_index_max = self.pixel_count - 1\n self.repeat_count = self.config_global['repeat_count']\n self.repeat_snake = self.config_global['repeat_snake']\n\n self.update_interval = self.config_global['update_interval']\n self.mode_16bit = self.config_global['mode_16bit']\n\n self.color_channels = self.config_global['color_channels']\n # self.color_channels = collections.namedtuple(\n # 'color_channels',\n # **self.color_channels_dict\n # )\n self.color_channels_count = len(self.color_channels)\n if self.mode_16bit:\n self.color_channels_count = self.color_channels_count * 2\n\n self.total_channel_count = (\n self.pixel_count *\n self.color_channels_count\n )\n if self.repeat_count > 0:\n self.total_channel_count *= self.repeat_count","def upgrade_config(configFile:str, oldSampleFile:str, newSampleFile:str, unsafeAttributesFile:str, filetype:str):\n\n #If config file is not present then abort merging.\n if not os.path.isfile(configFile):\n Log.error(f'config file {configFile} does not exist')\n raise Exception(f'ERROR: config file {configFile} does not exist')\n\n Log.info(f'config file {str(configFile)} upgrade started.')\n\n # old sample file\n conf_old_sample = filetype + oldSampleFile\n cs_conf_old_sample = S3CortxConfStore(config=conf_old_sample, index=conf_old_sample)\n\n # new sample file\n conf_new_sample = filetype + newSampleFile\n cs_conf_new_sample = S3CortxConfStore(config=conf_new_sample, index=conf_new_sample)\n conf_new_sample_keys = cs_conf_new_sample.get_all_keys()\n\n # unsafe attribute file\n conf_unsafe_file = filetype + unsafeAttributesFile\n cs_conf_unsafe_file = S3CortxConfStore(config=conf_unsafe_file, index=conf_unsafe_file)\n conf_unsafe_file_keys = cs_conf_unsafe_file.get_all_keys()\n\n # active config file\n conf_file = filetype + configFile\n cs_conf_file = S3CortxConfStore(config=conf_file, index=conf_file)\n conf_file_keys = cs_conf_file.get_all_keys()\n\n #logic to determine which keys to merge.\n keys_to_overwrite = []\n for key in conf_new_sample_keys:\n #If key is marked for unsafe then do not modify/overwrite.\n if key in conf_unsafe_file_keys:\n continue\n #if key not present active config file then add it\n # (this will also add and hence effectively overwrite keys removed in above [] handing\n # and hence will always result in overwrite for these keys from the new sample file).\n if key not in conf_file_keys:\n keys_to_overwrite.append(key)\n #if key is not unsafe and value is not changed by user then overwrite it.\n elif cs_conf_file.get_config(key) == cs_conf_old_sample.get_config(key):\n keys_to_overwrite.append(key)\n #if user has changed the value of the key then skip it.\n else:\n continue\n\n cs_conf_file.merge_config(source_index=conf_new_sample, keys_to_include=keys_to_overwrite)\n cs_conf_file.save_config()\n Log.info(f'config file {str(configFile)} upgrade completed')","def update_tempest_conf_file(conf_file, rconfig):\n with open(TempestCommon.tempest_conf_yaml, encoding='utf-8') as yfile:\n conf_yaml = yaml.safe_load(yfile)\n if conf_yaml:\n sections = rconfig.sections()\n for section in conf_yaml:\n if section not in sections:\n rconfig.add_section(section)\n sub_conf = conf_yaml.get(section)\n for key, value in sub_conf.items():\n rconfig.set(section, key, value)\n\n with open(conf_file, 'w', encoding='utf-8') as config_file:\n rconfig.write(config_file)","def update_cfg_file(cfg, scoring, logr):\n cfg[SCORER][SCORER_PATH] = SCORING_PATHS.get(scoring)\n cfg[SCORER][SCORER_OPTIONS] = SCORING_ATTRS.get(scoring).get(logr)\n return cfg","async def setconfigfile(self, ctx, *, config_file):\n self.settings.setConfigFile(config_file)\n await ctx.send(inline('Done'))","def load(self):\n try:\n _config_file = open(self.config, 'r+')\n data = json.loads(_config_file.read())\n except (ValueError, IOError):\n data = {}\n\n self.update(data)","def save(self):\n file = open(self.path, 'w')\n self.config.write(file)\n file.close()","def update_config(self, config):\n self.config = {\n \"key\": \"\",\n \"display_name\": \"\",\n \"description\": \"\",\n \"required\": 1,\n \"type\": \"string\"\n }\n self.config.update(config)\n self.API_KEY = self.config['github_api_key']","def modify_config_file(config_file, search_config, replace_config):\n with open(config_file, 'r+') as f:\n content = f.read()\n f.seek(0)\n f.write(content.replace(search_config, replace_config))\n f.truncate()\n f.close()","def update_config(self, config):\n # add follower public folder to the CKAN's list of public folders\n here = os.path.dirname(__file__)\n public_dir = os.path.join(here, 'public')\n if config.get('extra_public_paths'):\n config['extra_public_paths'] += ',' + public_dir\n else:\n config['extra_public_paths'] = public_dir\n # add follower template folder to the CKAN's list of template folders\n template_dir = os.path.join(here, 'templates')\n if config.get('extra_template_paths'):\n config['extra_template_paths'] += ',' + template_dir\n else:\n config['extra_template_paths'] = template_dir","def _update_cfg_from_files(self, files):\n\t\tfor file in files:\n\t\t\twith open(self.SettingsFolder + file) as f:\n\t\t\t\tself._add_cfg_to_list(file[:-4], yaml.load(f))","def _update_cloudwatch_config(self, config_type):\n param_name = self._get_ssm_param_name(config_type)\n cw_config_ssm = self._set_cloudwatch_ssm_config_param(\n param_name, config_type)\n cur_cw_config_crc = self._sha1_hash_file(config_type)\n ssm_cw_config_crc = self._sha1_hash_json(cw_config_ssm)\n # check if user updated cloudwatch related config files.\n # if so, perform corresponding actions.\n if cur_cw_config_crc != ssm_cw_config_crc:\n logger.info(\n \"Cloudwatch {} config file has changed.\".format(config_type))\n self.CLOUDWATCH_CONFIG_TYPE_TO_UPDATE_CONFIG_FUNC.get(\n config_type)()","def change_pwds(config):\n if not config:\n click.echo(help_msg)\n return\n try:\n user_config = imp.load_source('config', config)\n except IOError as e:\n click.echo(\"File %s not found.\" % config)\n logger.error(\"Invalid path to config file: %s\" % e)\n except Exception as e:\n click.echo(\"Ooups. Something went wrong.\")\n click.echo(e)\n logger.critical(\"%s\" % e)\n else:\n for i in dir(config_f):\n if not i.startswith(\"__\"):\n try:\n user_config.__dict__[i]\n except KeyError:\n user_config.__dict__[i] = config_f.__dict__[i]\n handle_exceptions(main, user_config)","def reload_ini(self):\n while True:\n\n if round(os.path.getmtime(self.config_file)) > self.config_last_modified:\n print('Config Changes Detected, Reloading .ini File')\n config = configparser.ConfigParser()\n config.read(self.config_file)\n self._set_ini_options(config)\n self.config_last_modified = round(os.path.getmtime(self.config_file))\n\n time.sleep(3)","def _save_changes(self):\n copy2(self._cfg_filename, self._cfg_filename + \".bak\")\n with open(self._cfg_filename, \"w\", encoding=\"utf-8\") as self._cfg_file:\n self.write(self._cfg_file)","def update_dashboard_section(self):\n rconfig = configparser.RawConfigParser()\n rconfig.read(self.conf_file)\n if env.get('DASHBOARD_URL'):\n if not rconfig.has_section('dashboard'):\n rconfig.add_section('dashboard')\n rconfig.set('dashboard', 'dashboard_url', env.get('DASHBOARD_URL'))\n else:\n rconfig.set('service_available', 'horizon', False)\n with open(self.conf_file, 'w', encoding='utf-8') as config_file:\n rconfig.write(config_file)","def _on_config_changed(self, _):\n self._configure_pod()","def update_local(self, name, file=None):\n self._recent_caller = name\n self._local = {}\n if file is None:\n file = self._findConfigPath(name)\n\n if file and os.path.exists(file):\n config = CustomConfigObj(file,\n encoding='UTF8',\n parent_config=self._main_config)\n\n self._update(self._local, config)\n return True","def configure(self, config: dict):\n self.config.update(config)","def update(self, config):\n # find keys are in config but not in self.config\n extra_keys = set(config.keys()) - set(self.config.keys())\n if len(extra_keys) > 0:\n raise ValueError(\"keys {} in config are not in Config.config\".format(extra_keys))\n # update self.config by config\n else:\n self.config.update(config)","def update(self):\n # TO DO for updating urls if changed\n pass","def save(self):\n if self.changed:\n logger.info(\"Overwriting Redis config\")\n self.client.config_rewrite()\n self.changed = False","def save_config(self):\n config.save_config(self.config, self.config_file)","def updateConfig(self, conf=None):\r\n if conf is not None:\r\n self.config.update(conf)\r\n if self.visprotocol is not None:\r\n self.visprotocol.updateSettings(self.getConfigData())\r\n # else:\r\n # _LOGGER.warning(\"Visonic link is not set\")\r\n # make the changes to the platform parameters (used in alarm_control_panel)\r\n # the original idea was to keep these separate for multiple partitions but now i'm not so sure its necessary\r\n\r\n self.hass.data[DOMAIN][\"arm_without_code\"] = self.toBool(self.config.get(CONF_ARM_CODE_AUTO, False))\r\n self.hass.data[DOMAIN][\"force_keypad\"] = self.toBool(self.config.get(CONF_FORCE_KEYPAD, False))\r\n self.hass.data[DOMAIN][\"arm_away_instant\"] = self.toBool(self.config.get(CONF_INSTANT_ARM_AWAY, False))\r\n self.hass.data[DOMAIN][\"arm_home_instant\"] = self.toBool(self.config.get(CONF_INSTANT_ARM_HOME, False))\r\n\r\n _LOGGER.debug(\"[Settings] Log Max Entries %s\", self.config.get(CONF_LOG_MAX_ENTRIES))\r\n _LOGGER.debug(\"[Settings] Log Reverse %s\", self.config.get(CONF_LOG_REVERSE))\r\n _LOGGER.debug(\"[Settings] Log Create Event %s\", self.config.get(CONF_LOG_EVENT))\r\n _LOGGER.debug(\"[Settings] Log Final Event %s\", self.config.get(CONF_LOG_DONE))\r\n _LOGGER.debug(\"[Settings] Log XML Filename %s\", self.config.get(CONF_LOG_XML_FN))\r\n _LOGGER.debug(\"[Settings] Log CSV Filename %s\", self.config.get(CONF_LOG_CSV_FN))\r\n _LOGGER.debug(\"[Settings] Log CSV title Row %s\", self.config.get(CONF_LOG_CSV_TITLE))","def update_config_file(commands_to_add, commands_to_remove):\r\n\r\n # Parse the config.txt file contents\r\n config_file_contents = {}\r\n if os.path.exists(utils.CONFIG_FILE_PATH):\r\n config_file_string = utils.get_config_file()\r\n first_line = True\r\n for line in config_file_string.split('\\n'):\r\n if first_line:\r\n first_line = False\r\n continue\r\n if not line.strip(): continue\r\n if not line.startswith('#'):\r\n line = line.split('\\t')\r\n config_file_contents[line[0]] = line\r\n\r\n # Remove the specified contents\r\n for cmd in commands_to_remove:\r\n config_file_contents.pop(cmd, None)\r\n\r\n # Add the specified contents\r\n for cmd in commands_to_add:\r\n config_file_contents[cmd] = [cmd] + ['none']*3\r\n\r\n # Archive old config.txt\r\n if os.path.exists(utils.CONFIG_FILE_PATH):\r\n current_time = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')\r\n obs_ending = '-obsolete-{0}.txt'.format(current_time)\r\n obs_path = obs_ending.join(utils.CONFIG_FILE_PATH.rsplit('.txt',1))\r\n os.rename(utils.CONFIG_FILE_PATH, obs_path)\r\n\r\n # Print new sorted config.txt\r\n out_handle = open(utils.CONFIG_FILE_PATH, 'w')\r\n out_handle.write('cmd_name\\texecute\\tload_module\\tunload_module')\r\n out_handle.write('\\n')\r\n for cmd, line in sorted(config_file_contents.iteritems()):\r\n out_handle.write('\\t'.join(line))\r\n out_handle.write('\\n')\r\n out_handle.close()","def update_config(doc, signum):\n log = logging.getLogger(__name__)\n log.info('Caught signal %d (%s). Reloading configuration.', signum, '/'.join(SIGNALS_INT_TO_NAME[signum]))\n if not GLOBAL_MUTABLE_CONFIG['--config']:\n log.warning('No previously defined configuration file. Nothing to read.')\n return\n\n # Read config.\n try:\n config = _get_arguments(doc)\n except DocoptcfgFileError as exc:\n logging.getLogger(__name__).error('Config file specified but invalid: %s', exc.message)\n return\n\n # Resolve relative paths.\n _real_paths(config)\n\n # Validate.\n try:\n _validate_config(config)\n except ConfigError:\n return\n\n # Update.\n GLOBAL_MUTABLE_CONFIG.update(config)\n\n # Re-setup logging.\n setup_logging(GLOBAL_MUTABLE_CONFIG)\n log.info('Done reloading configuration.')","def _update(self):\n # clear group before rebuild\n self.clear()\n\n # build configuration groups\n self._config_names = []\n for i in range(self._n_configs):\n config_name = f\"config{i+1:02}\"\n self._config_names.append(config_name)\n self._build_config_group(config_name)\n\n # reset active configuration if necessary\n if not all(cname in self._config_names for cname in self._active_config):\n self._active_config = (self._config_names[0],)\n\n # build datasets\n self._build_datasets()","def init_config(self):\n # self.config.read(self.cnfgfile)\n if not self.config.has_section(VERSION_SECTION):\n self.config.add_section(VERSION_SECTION)","def configfile(self, fp):\n if not self.modifier.skip_configfile:\n if os.path.exists(fp):\n self.configfiles.append(fp)\n c = snakemake.io.load_configfile(fp)\n update_config(self.config, c)\n if self.overwrite_config:\n logger.info(\n \"Config file {} is extended by additional config specified via the command line.\".format(\n fp\n )\n )\n update_config(self.config, self.overwrite_config)\n elif not self.overwrite_configfiles:\n fp_full = os.path.abspath(fp)\n raise WorkflowError(\n f\"Workflow defines configfile {fp} but it is not present or accessible (full checked path: {fp_full}).\"\n )\n else:\n # CLI configfiles have been specified, do not throw an error but update with their values\n update_config(self.config, self.overwrite_config)","def reload(self):\n self.load_config()\n # Seems we need to explicitly refresh this\n if self.main_instance:\n self.main_instance.config = self.config","def _load_conf(self, conf):\n f = open(self.file, \"w\")\n f.write(conf)\n f.close()","def config(self, config_dict):\r\n self._cfg.config = config_dict","def saveConfig(self):\r\n self.config[\"Settings\"] = {}\r\n settings = self.config[\"Settings\"]\r\n settings[\"datapath\"] = self.dataPath\r\n settings[\"videopath\"] = self.videoPath\r\n settings[\"dataoffset\"] = str(self.dataOffset)\r\n settings[\"colblindmode\"] = str(self.colBlindMode)\r\n with open(self.CONFIG_FILE,\"w\") as file:\r\n self.config.write(file)"],"string":"[\n \"def conf_update(self):\\n pass\",\n \"def updateConfig(self):\\n # Make sure to keep the default values in place.\\n if self.newConfig['sensor'] == 0:\\n self.newConfig['sensor'] = self.config['sensor']\\n if self.newConfig['camera'] == 0:\\n self.newConfig['camera'] = self.config['camera']\\n if not self.newConfig['auto']['times']:\\n self.newConfig['auto']['times'] = self.config['auto']['times']\\n if not self.newConfig['auto']['days']:\\n self.newConfig['auto']['days'] = self.config['auto']['days']\\n\\n # Show the changes.\\n if self.verbosity >= 1:\\n print('%s: Updating configuration file...' % self.feederName)\\n try:\\n for key in self.config.keys():\\n if type(self.config[key]) is dict:\\n for subkey in self.config[key].keys():\\n if self.config[key][subkey] != self.newConfig[key][subkey]:\\n print('%s: Updating %s from %s to %s.' % (self.feederName, subkey, self.config[key][subkey], self.newConfig[key][subkey]))\\n elif self.config[key] != self.newConfig[key]:\\n print('%s: Updating %s from %s to %s.' % (self.feederName, key, self.config[key], self.newConfig[key]))\\n except ValueError:\\n if self.verbosity >= 1:\\n print('%s: Configuration file does not contain a valid JSON object.' % self.feederName)\\n if self.verbosity == 2:\\n print('%s: Overwriting configuration file to: %s.' % (self.feederName, self.config))\\n\\n # Change the configuration file.\\n self.config = self.newConfig\\n self.writeConfig()\",\n \"def updateconfig(self):\\n\\n # Initialize the yaml data\\n ydata = {\\\"metadata\\\": self._metadata, \\\"nodes\\\": self._nodes}\\n\\n # Write the system config file\\n filename = self._rootdir + self._metadata[\\\"system_config_file\\\"]\\n with open(filename, \\\"w\\\") as yamlfile:\\n yaml.dump(ydata, yamlfile)\",\n \"def __update(self):\\n if self.__file:\\n target_file = open(self.__file)\\n for attr in dir(self):\\n if not attr.startswith(\\\"_\\\") and \\\\\\n (self.__overwrite or (attr not in self.__exclude)) \\\\\\n and not self.__is_attr_callable(attr):\\n try:\\n delattr(self, attr)\\n except AttributeError:\\n pass\\n pool = yaml.load(target_file)\\n target_file.close()\\n if pool: # could be None\\n for key, val in pool.iteritems():\\n if not key.startswith(\\\"_\\\") and \\\\\\n (self.__overwrite or (key not in self.__exclude)) \\\\\\n and not self.__is_attr_callable(key):\\n setattr(self, key, val)\\n if hasattr(self, 'log_config_file_changes')\\\\\\n and self.log_config_file_changes:\\n logging.getLogger(__name__).info(\\\"Config file has updated.\\\")\",\n \"def update_config(self, data):\\n self.config.data = dict_merge(self.config.data, data)\\n self.config.save()\",\n \"def config_update(self, update: io.BytesIO) -> None:\\n self.__logger.debug('Eva.config_update called')\\n return self.__http_client.config_update(update)\",\n \"def update_config(self, config):\\n return self._update_config(\\\"config\\\", config)\",\n \"def refresh_config(self):\\n with open(config_name, 'rb') as f:\\n self.CONFIG = simplejson.load(f)\\n\\n return self\",\n \"def _auto_update_configuration(self) -> None:\\n self.config = rasa.utils.train_utils.update_confidence_type(self.config)\\n rasa.utils.train_utils.validate_configuration_settings(self.config)\\n self.config = rasa.utils.train_utils.update_similarity_type(self.config)\\n self.config = rasa.utils.train_utils.update_evaluation_parameters(self.config)\",\n \"def update_conf_file():\\n filepath = remote_dir + \\\"/apache2/conf/httpd.conf\\\"\\n fabric.contrib.files.sed(filepath, 'myproject', project_name)\",\n \"def reload_config(self):\\n pass\",\n \"def update_config(self, kv: dict):\\n self._configs.update(kv)\\n self._save()\",\n \"def _refreshconfig(self):\\n self.config = ConfigGenerator(os.path.join(self.rundir, const.CONFIG_FILE))\",\n \"def refresh_configuration(self):\\n pass\",\n \"def setup_configuration_file(self):\\n\\n with open(self.config_path, \\\"w+\\\") as f_config:\\n\\n f_config.write(get_configuration_file_form())\",\n \"def update_config_file(**kwargs):\\n config_file = try_read_file()\\n config_file.update(kwargs)\\n config_file = {key: value for key, value in config_file.items() if value is not None}\\n logging.info('open config file %s', config_file_path)\\n with open(config_file_path, 'w') as f:\\n logging.info('begin io %s', config_file_path)\\n json.dump(config_file, f, indent=4)\\n logging.info('end io %s', config_file_path)\",\n \"def use_config_file(self):\\n self.config_file = self.find_config_file()\\n if self.config_file:\\n self.apply_config_file(self.config_file)\",\n \"def reload(self):\\n self.read(self._cfg_path)\",\n \"def testUpdateConfigFile(self):\\n # Test update project field.\\n gcp_setup_runner.UpdateConfigFile(self.cfg_path, \\\"project\\\",\\n \\\"test_project\\\")\\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\\n open(self.cfg_path, \\\"r\\\"), user_config_pb2.UserConfig)\\n self.assertEqual(cfg.project, \\\"test_project\\\")\\n self.assertEqual(cfg.ssh_private_key_path, \\\"\\\")\\n # Test add ssh key path in config.\\n gcp_setup_runner.UpdateConfigFile(self.cfg_path,\\n \\\"ssh_private_key_path\\\", \\\"test_path\\\")\\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\\n open(self.cfg_path, \\\"r\\\"), user_config_pb2.UserConfig)\\n self.assertEqual(cfg.project, \\\"test_project\\\")\\n self.assertEqual(cfg.ssh_private_key_path, \\\"test_path\\\")\\n # Test config is not a file\\n with mock.patch(\\\"os.path.isfile\\\") as chkfile:\\n chkfile.return_value = False\\n gcp_setup_runner.UpdateConfigFile(self.cfg_path, \\\"project\\\",\\n \\\"test_project\\\")\\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\\n open(self.cfg_path, \\\"r\\\"), user_config_pb2.UserConfig)\\n self.assertEqual(cfg.project, \\\"test_project\\\")\",\n \"def update(self, config_dict):\\r\\n self._update(config_dict, allow_new_keys=True)\",\n \"def update_config(config_file, config_base=None):\\n if config_base is None:\\n config_base = def_config_file\\n assert(os.path.isfile(config_base))\\n if not os.path.isfile(config_file):\\n shutil.copy(config_base, config_file)\\n cp = CisConfigParser()\\n cp.read(config_file)\\n miss = []\\n if platform._is_win: # pragma: windows\\n miss += update_config_windows(cp)\\n with open(config_file, 'w') as fd:\\n cp.write(fd)\\n for sect, opt, desc in miss: # pragma: windows\\n warnings.warn((\\\"Could not locate option %s in section %s.\\\"\\n + \\\"Please set this in %s to: %s\\\")\\n % (opt, sect, config_file, desc))\",\n \"def update_packages(self, config_file):\\n entries = yacman.load_yaml(config_file)\\n self.update(entries)\\n return True\",\n \"def update_config(self, update_dict):\\n self.config = recursive_merge_dicts(self.config, update_dict)\",\n \"def config_edits(configfile):\\n try:\\n\\n # Read in the file\\n filedata = None\\n with open(configfile, 'r') as file:\\n filedata = file.read()\\n\\n # Replace the target string\\n filedata = filedata.replace(\\n '/home/scratch01/sradanov/A2C2/NCEP/', '').replace('/home/estimr2/sradanov/Operational/', '')\\n\\n # Write the file out again\\n with open(configfile, 'w') as file:\\n file.write(filedata)\\n\\n LOGGER.info('configfile modified')\\n except Exception:\\n LOGGER.exeption('Failed to modify configfile:')\\n\\n return configfile\",\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_from_file(self):\\n config_path = os.environ.get('MINDINSIGHT_CONFIG', '')\\n if not config_path:\\n return\\n\\n config_module = None\\n\\n # python:full.path.for.config.module\\n if config_path.startswith('python:'):\\n config_module = import_module(config_path[len('python:'):])\\n\\n # file:full/path/for/config.py\\n elif config_path.startswith('file:'):\\n config_path = config_path[len('file:'):]\\n module_name = '__mindinsightconfig__'\\n config_module = types.ModuleType(module_name)\\n machinery = import_module('importlib.machinery')\\n loader = machinery.SourceFileLoader(module_name, config_path)\\n loader.exec_module(config_module)\\n\\n if config_module is None:\\n return\\n\\n for setting in dir(config_module):\\n if setting.isupper() and setting in self._default_settings:\\n setting_value = getattr(config_module, setting)\\n setattr(self, setting, setting_value)\\n self._explicit_settings.add(setting)\",\n \"def save_config(self, new_config, filename=None):\\n self.cfg.update(new_config)\\n if filename is None:\\n self.cfg.filename = self.cfg_filename\\n else:\\n self.cfg.filename = filename\\n self.cfg.write()\\n logger.info(\\\"Config file %s written out\\\" % self.cfg.filename)\",\n \"def write_config(self, filename):\\n self.config.filename = filename\\n self.config.write()\",\n \"def update_shed_config(self, shed_conf):\\n for index, my_shed_tool_conf in enumerate(self._dynamic_tool_confs):\\n if shed_conf['config_filename'] == my_shed_tool_conf['config_filename']:\\n self._dynamic_tool_confs[index] = shed_conf\\n self._save_integrated_tool_panel()\",\n \"def config_updated(self):\\n if callable(self.on_config_updated):\\n self.on_config_updated(self.config())\",\n \"def update_feature(selfs, k, v, cfg_path):\\n with open(cfg_path, 'r') as cfg:\\n file_dict = yaml.safe_load(cfg)\\n # overprint the entries with the new config_dict\\n file_dict['{}'.format(k)] = v\\n with open(cfg_path, 'w') as w_file:\\n w_file.write(yaml.dump(file_dict))\",\n \"def edit_cfg(config_file):\\n\\n GUI().cfgEditor(config_file)\",\n \"def load_config(self):\\n if os.path.exists(self.config_file):\\n with open(self.config_file) as f:\\n conf = json.load(f)\\n\\n self.update_attributes_from_config(conf)\",\n \"def _update_auto_config(self):\\n\\n # Initialize the yaml data\\n nodes = {}\\n with open(self._autoconfig_filename, \\\"r\\\") as stream:\\n try:\\n ydata = yaml.load(stream)\\n if \\\"nodes\\\" in ydata:\\n nodes = ydata[\\\"nodes\\\"]\\n except yaml.YAMLError as exc:\\n print(exc)\\n return\\n\\n for i in nodes.items():\\n key = i[0]\\n node = i[1]\\n\\n # Interfaces\\n node[\\\"interfaces\\\"] = {}\\n for item in self._nodes[key][\\\"interfaces\\\"].items():\\n port = item[0]\\n interface = item[1]\\n\\n node[\\\"interfaces\\\"][port] = {}\\n addr = \\\"{}\\\".format(interface[\\\"pci_address\\\"])\\n node[\\\"interfaces\\\"][port][\\\"pci_address\\\"] = addr\\n if \\\"mac_address\\\" in interface:\\n node[\\\"interfaces\\\"][port][\\\"mac_address\\\"] = interface[\\\"mac_address\\\"]\\n\\n if \\\"total_other_cpus\\\" in self._nodes[key][\\\"cpu\\\"]:\\n node[\\\"cpu\\\"][\\\"total_other_cpus\\\"] = self._nodes[key][\\\"cpu\\\"][\\n \\\"total_other_cpus\\\"\\n ]\\n if \\\"total_vpp_cpus\\\" in self._nodes[key][\\\"cpu\\\"]:\\n node[\\\"cpu\\\"][\\\"total_vpp_cpus\\\"] = self._nodes[key][\\\"cpu\\\"][\\n \\\"total_vpp_cpus\\\"\\n ]\\n if \\\"reserve_vpp_main_core\\\" in self._nodes[key][\\\"cpu\\\"]:\\n node[\\\"cpu\\\"][\\\"reserve_vpp_main_core\\\"] = self._nodes[key][\\\"cpu\\\"][\\n \\\"reserve_vpp_main_core\\\"\\n ]\\n\\n # TCP\\n if \\\"active_open_sessions\\\" in self._nodes[key][\\\"tcp\\\"]:\\n node[\\\"tcp\\\"][\\\"active_open_sessions\\\"] = self._nodes[key][\\\"tcp\\\"][\\n \\\"active_open_sessions\\\"\\n ]\\n if \\\"passive_open_sessions\\\" in self._nodes[key][\\\"tcp\\\"]:\\n node[\\\"tcp\\\"][\\\"passive_open_sessions\\\"] = self._nodes[key][\\\"tcp\\\"][\\n \\\"passive_open_sessions\\\"\\n ]\\n\\n # Huge pages\\n node[\\\"hugepages\\\"][\\\"total\\\"] = self._nodes[key][\\\"hugepages\\\"][\\\"total\\\"]\\n\\n # Write the auto config config file\\n with open(self._autoconfig_filename, \\\"w\\\") as yamlfile:\\n yaml.dump(ydata, yamlfile)\",\n \"def update(self, obj):\\n\\n self.cfg.update(obj)\",\n \"def refresh(self):\\n self.config.read(self.filename)\\n self.loadRecentFiles()\",\n \"def update_global_config(self, config, **kwargs):\\n pass\",\n \"def update_config(update):\\n global _config\\n new_config = copy.deepcopy(_config)\\n _update_dict_recursive(new_config, update)\\n logging.config.dictConfig(new_config)\\n _configure_ulog_bridge()\\n _config = new_config\",\n \"def _overwrite_with_config(self, new_cfg):\\n for section in new_cfg.sections():\\n for key, val in new_cfg.items(section):\\n self.config.set(section, key, val)\",\n \"def config_update_from_file(cls, config_file: str = None) -> None:\\n if config_file is None:\\n config_file = cls._config[\\\"graph_app_config\\\"]\\n\\n if config_file != \\\"\\\":\\n cls._logger.debug(\\n \\\"[%s]: Update config from file: %s\\\", cls.__name__, config_file\\n )\\n\\n cls._config[\\\"graph_app_config\\\"] = config_file\\n\\n config_yaml: Dict = {}\\n with open(config_file, \\\"r\\\") as f:\\n try:\\n config_yaml = safe_load(f)\\n except YAMLError:\\n cls._logger.exception(\\n \\\"Exception loading config file '%s'\\\", config_file\\n )\\n\\n if config_yaml:\\n config_update = {\\n \\\"graph_{}\\\".format(k): config_yaml.get(k, None)\\n for k in config_yaml.keys()\\n }\\n\\n cls._config.update(config_update)\\n\\n cls._logger.debug(\\\"[%s]: Final config: %s\\\", cls.__name__, cls._config)\",\n \"def overwrite(cls, config_file_overwrite: str):\\n conf_overwrite: dict = GC.read_conf(config_file_overwrite)\\n for sec, attr in conf_overwrite.items():\\n for key, val in attr.items():\\n try:\\n _ = GC.conf[sec][key]\\n GC.conf[sec][key] = val\\n except KeyError:\\n print(\\\"Overwrite config file has section/key that \\\"\\n \\\"don't exist in base config!!! Abort!!!\\\")\\n sys.exit(1)\",\n \"def update(self, config_dict):\\n self._update(config_dict, allow_new_keys=True)\",\n \"def reload(self):\\n with open(self._config) as f:\\n self.data = json.load(f)\",\n \"def write_config(self):\\n logging.debug(\\\"Writing configuration file: %s\\\" % self.config_file)\\n f = open(self.config_file, \\\"w\\\")\\n self.config.write(f)\\n f.close()\",\n \"def _add_db_in_config(self):\\n logger.info(f\\\"Updating configuration file in {self.configfile}\\\")\\n with open(self.configfile, \\\"a\\\") as fp:\\n print(self.ref_name + \\\".genome : \\\" + self.ref_name, file=fp)\",\n \"def updated(self, newConfiguration):\\n log.debug('ConfigListener: configuration %s updated' % newConfiguration)\",\n \"def update_configs(self, config):\\n for what in self.plugins: # backend, repo etc.\\n for key in self.plugins[what]: # s3, filesystem etc.\\n # print(\\\"Updating configuration of\\\", what, key)\\n self.plugins[what][key].config(what='set', params=config)\\n return\",\n \"def with_config_update(self):\\n original_config = self.load_config()\\n\\n config_data = original_config.json\\n if str(self.ITEM_PUBLIC_ID) in config_data[f\\\"{self.ITEM_TYPE}s\\\"]:\\n config_data[f\\\"{self.ITEM_TYPE}s\\\"].remove(str(self.ITEM_PUBLIC_ID))\\n config_data[f\\\"{self.ITEM_TYPE}s\\\"].append(\\n f\\\"{self.ITEM_PUBLIC_ID.author}/{self.ITEM_PUBLIC_ID.name}:0.0.1\\\"\\n )\\n self.dump_config(AgentConfig.from_json(config_data))\\n try:\\n yield\\n finally:\\n self.dump_config(original_config)\",\n \"def check_update(self):\\r\\n with open('new_config.json', 'rt') as jsonfile:\\r\\n configuration = jsonfile.read()\\r\\n configuration_data = json.loads(configuration)\\r\\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:\\r\\n try:\\r\\n sock.settimeout(2)\\r\\n sock.bind(('', 8080))\\r\\n sock.listen(1)\\r\\n conn, addr = sock.accept()\\r\\n except socket.timeout:\\r\\n return False\\r\\n sock.settimeout(None)\\r\\n with conn:\\r\\n conn.send(configuration)\\r\\n data = conn.recv(1024)\\r\\n with open('new_config.json', 'wt') as jsonfile:\\r\\n json.dump(data, jsonfile)\\r\\n self.set_new_configuration()\",\n \"def update_config(self, config):\\n self.config = {\\n \\\"display_name\\\": \\\"\\\",\\n \\\"description\\\": \\\"\\\",\\n \\\"required\\\": 1,\\n \\\"type\\\": \\\"string\\\"\\n }\\n self.config.update(config)\\n self.API_KEY = self.config['key']\",\n \"def update_config(self, config):\\n self.config = {\\n \\\"display_name\\\": \\\"\\\",\\n \\\"description\\\": \\\"\\\",\\n \\\"required\\\": 1,\\n \\\"type\\\": \\\"string\\\"\\n }\\n self.config.update(config)\\n self.API_KEY = self.config['key']\",\n \"def on_save(self):\\r\\n #new_config = ConfigParser.RawConfigParser()\\r\\n cur_config = self.config.dict_config\\r\\n #\\r\\n # update the dict_config\\r\\n cur_config[\\\"access_restriction\\\"][\\\"ips\\\"] = self.text_ips.get(1.0, tk.END).strip()\\r\\n cur_config[\\\"access_restriction\\\"][\\\"ar_url\\\"] = self.entry_url.get().strip()\\r\\n #\\r\\n cur_config[\\\"email\\\"][\\\"relay_server_host\\\"] = self.entry_server_host.get().strip()\\r\\n cur_config[\\\"email\\\"][\\\"relay_server_port\\\"] = self.entry_server_port.get().strip()\\r\\n cur_config[\\\"email\\\"][\\\"email_from\\\"] = self.entry_from.get().strip()\\r\\n cur_config[\\\"email\\\"][\\\"recipients\\\"] = self.text_recipients.get(1.0, tk.END).strip()\\r\\n cur_config[\\\"email\\\"][\\\"ar_enabled_subject\\\"] = self.entry_enabled_subject.get().strip()\\r\\n cur_config[\\\"email\\\"][\\\"ar_enabled_body\\\"] = self.text_enabled_body.get(1.0, tk.END).strip()\\r\\n cur_config[\\\"email\\\"][\\\"ar_disabled_subject\\\"] = self.entry_disabled_subject.get()\\r\\n cur_config[\\\"email\\\"][\\\"ar_disabled_body\\\"] = self.text_disabled_body.get(1.0, tk.END).strip()\\r\\n\\r\\n #self.action.save_config()\\r\\n # # sync dict_config to the gui\\r\\n # for section in self.config.dict_config:\\r\\n # new_config.add_section(section)\\r\\n # for item in self.config.dict_config[section]:\\r\\n # new_config.set(section, item, self.config.dict_config[section][item])\\r\\n # #\\r\\n # # saving to a file\\r\\n # with open(self.config.file_path, 'w') as newconfigfile:\\r\\n # new_config.write(newconfigfile)\\r\\n #\\r\\n # # mbox.showinfo(\\\"Information\\\",\\r\\n # # \\\"Current configuration has been successfully saved to '%s'\\\" % os.path.basename(self.configfile))\\r\\n # self.console.debug(\\\"Configuration has been saved to '%s'\\\" % self.config.file_path)\\r\",\n \"def load_file(self, update=True): # type: (bool) -> None\\n if os.path.isfile(self._file):\\n logging.info('Cyra is reading your config from %s' % self._file)\\n\\n with open(self._file, 'r') as f:\\n toml_str = f.read()\\n self.load_toml(toml_str)\\n else:\\n self._modified = True\\n\\n # Write file if non existent or modified\\n if update:\\n self.save_file()\",\n \"def refresh(self):\\n self.update_from_file()\\n self.update_from_env()\",\n \"def apply_config(filename):\\n with open(filename) as config_file:\\n config = json.load(config_file)\\n for setting, value in config.items():\\n CoreConfig.__dict__[setting] = value\",\n \"def update_config_file(invoker: AirflowInvoker) -> None:\\n airflow_cfg_path = invoker.files[\\\"config\\\"]\\n logging.debug(f\\\"Generated default '{str(airflow_cfg_path)}'\\\")\\n\\n # open the configuration and update it\\n # now we let's update the config to use our stubs\\n airflow_cfg = configparser.ConfigParser()\\n\\n with airflow_cfg_path.open() as cfg:\\n airflow_cfg.read_file(cfg)\\n logging.debug(f\\\"Loaded '{str(airflow_cfg_path)}'\\\")\\n\\n config = invoker.plugin_config_processed\\n for section, cfg in config.items():\\n airflow_cfg[section].update(cfg)\\n logging.debug(f\\\"\\\\tUpdated section [{section}] with {cfg}\\\")\\n\\n with airflow_cfg_path.open(\\\"w\\\") as cfg:\\n airflow_cfg.write(cfg)\\n logging.debug(f\\\"Saved '{str(airflow_cfg_path)}'\\\")\",\n \"def update(name, value, config_dir=None):\\n if name not in Config.__ALLOWED:\\n msg = f'Cannot update configuration; value \\\"{name}\\\" is not allowed.'\\n raise ConfigurationError(msg)\\n config_dir = Config.resolve_config_dir(config_dir)\\n config_dat, config_file = Config.get_config_file(\\n config_dir,\\n round_trip_load=True,\\n quiet=True,\\n )\\n config_dat.update({name: value})\\n Config.write_config_file(config_dat, config_file)\\n if Config.is_set:\\n Config.__conf[name] = value\",\n \"def update_validation_section(self):\\n rconfig = configparser.RawConfigParser()\\n rconfig.read(self.conf_file)\\n if not rconfig.has_section('validation'):\\n rconfig.add_section('validation')\\n rconfig.set(\\n 'validation', 'connect_method',\\n 'floating' if self.ext_net else 'fixed')\\n rconfig.set(\\n 'validation', 'network_for_ssh',\\n self.network.name if self.network else env.get(\\\"EXTERNAL_NETWORK\\\"))\\n with open(self.conf_file, 'w', encoding='utf-8') as config_file:\\n rconfig.write(config_file)\",\n \"def update(self):\\n \\n dbpath, config = self._start()\\n \\n self.config.obo = check_file(config.obo, dbpath, \\\"obo\\\") \\n desc_file = check_file(config.model_descriptions, dbpath,\\n \\\"model_descriptions\\\", allow_none=True) \\n phen_file = check_file(config.model_phenotypes, dbpath,\\n \\\"model_phenotypes\\\", allow_none=True)\\n \\n summary = self._update(desc_file, phen_file) \\n if len(summary[\\\"incorrect_ids\\\"]) == 0 and not config.skip_compute:\\n self._compute(models=summary[\\\"new_phenotypes\\\"])\\n \\n self._end()\",\n \"def _update_config_from_file(config, cfg_file):\\n config.defrost()\\n with open(cfg_file, 'r') as infile:\\n yaml_cfg = yaml.load(infile, Loader=yaml.FullLoader)\\n for cfg in yaml_cfg.setdefault('BASE', ['']):\\n if cfg:\\n _update_config_from_file(\\n config, os.path.join(os.path.dirname(cfg_file), cfg)\\n )\\n config.merge_from_file(cfg_file)\\n config.freeze()\",\n \"def test_config_update(get_config):\\n cfg = get_config(Config, {'test': 'main'})\\n update_from = {\\\"name\\\": \\\"new_name\\\"}\\n cfg.update(update_from)\\n\\n assert cfg.data.get('name') == \\\"new_name\\\", \\\"config was not updated\\\"\",\n \"def __write_config(self):\\n with open(self.config_file, 'w') as data_file:\\n config = {\\\"ibooks_doc_root\\\":self.ibooks_doc_root,\\n \\\"library_folder\\\":self.library_folder,\\n \\\"annotation_folder\\\":self.annotation_folder,\\n \\\"tmp_dir\\\":self.tmp_dir\\n } \\n data = json.dumps(config, ensure_ascii=False)\\n data_file.write(data)\",\n \"def updateSettings(self):\\n self.parser.read(self.file)\\n self.showTicker = self.parser.getboolean('Settings', 'showTicker')\\n self.verbose = self.parser.getboolean('Settings', 'verbose')\\n self.sleepTime = self.parser.getint('Settings', 'sleeptime')\\n self.saveGraph = self.parser.getboolean('Settings', 'saveGraph')\\n self.graphDPI = self.parser.getint('Settings', 'graphDPI')\",\n \"def update(d):\\n # get (or create) config path\\n p= initialize()['config']\\n\\n with lockfile.LockFile(p):\\n # load current configuration\\n cnf = load_config(open(p))\\n\\n # merge \\n def dict_merge(a, b):\\n '''recursively merges dict's. not just simple a['key'] = b['key'], if\\n both a and bhave a key who's value is a dict then dict_merge is called\\n on both values and the result stored in the returned dictionary.\\n from https://www.xormedia.com/recursively-merge-dictionaries-in-python/\\n '''\\n if not isinstance(b, dict):\\n return b\\n result = copy.deepcopy(a)\\n for k, v in b.items():\\n if k in result and isinstance(result[k], dict):\\n result[k] = dict_merge(result[k], v)\\n else:\\n result[k] = copy.deepcopy(v)\\n return result\\n cnf = dict_merge(cnf, d)\\n\\n # save \\n dump_config(cnf, open(p,'w'))\",\n \"def update_compute_section(self):\\n rconfig = configparser.RawConfigParser()\\n rconfig.read(self.conf_file)\\n if not rconfig.has_section('compute'):\\n rconfig.add_section('compute')\\n rconfig.set(\\n 'compute', 'fixed_network_name',\\n self.network.name if self.network else env.get(\\\"EXTERNAL_NETWORK\\\"))\\n with open(self.conf_file, 'w', encoding='utf-8') as config_file:\\n rconfig.write(config_file)\",\n \"def update_settings(self):\\n\\n param = \\\"settings.py\\\"\\n self._check_path_availability([\\\"get_settings_dir\\\", \\\"get_settings_dir_to\\\"])\\n self.updater.update_files(\\n self.analizer.get_settings_dir(),\\n self.analizer.get_settings_dir_to(),\\n param,\\n )\\n return self.write_debug_message(\\\"Settings upgrade is done!\\\\n\\\")\",\n \"def save_config(self):\\n\\n if not self.__conf.has_section(self.section):\\n self.__conf.add_section(self.section)\\n\\n for key in self._params:\\n val = self._params[key]\\n self.__conf.set(self.section, key, val)\\n\\n with open(self.conf_path, 'w') as f:\\n self.__conf.write(f)\",\n \"def update_config(self):\\n self.channel_count = self.config_global['channel_count']\\n self.pixel_count = self.config_global['pixel_count']\\n self.pixel_index_max = self.pixel_count - 1\\n self.repeat_count = self.config_global['repeat_count']\\n self.repeat_snake = self.config_global['repeat_snake']\\n\\n self.update_interval = self.config_global['update_interval']\\n self.mode_16bit = self.config_global['mode_16bit']\\n\\n self.color_channels = self.config_global['color_channels']\\n # self.color_channels = collections.namedtuple(\\n # 'color_channels',\\n # **self.color_channels_dict\\n # )\\n self.color_channels_count = len(self.color_channels)\\n if self.mode_16bit:\\n self.color_channels_count = self.color_channels_count * 2\\n\\n self.total_channel_count = (\\n self.pixel_count *\\n self.color_channels_count\\n )\\n if self.repeat_count > 0:\\n self.total_channel_count *= self.repeat_count\",\n \"def upgrade_config(configFile:str, oldSampleFile:str, newSampleFile:str, unsafeAttributesFile:str, filetype:str):\\n\\n #If config file is not present then abort merging.\\n if not os.path.isfile(configFile):\\n Log.error(f'config file {configFile} does not exist')\\n raise Exception(f'ERROR: config file {configFile} does not exist')\\n\\n Log.info(f'config file {str(configFile)} upgrade started.')\\n\\n # old sample file\\n conf_old_sample = filetype + oldSampleFile\\n cs_conf_old_sample = S3CortxConfStore(config=conf_old_sample, index=conf_old_sample)\\n\\n # new sample file\\n conf_new_sample = filetype + newSampleFile\\n cs_conf_new_sample = S3CortxConfStore(config=conf_new_sample, index=conf_new_sample)\\n conf_new_sample_keys = cs_conf_new_sample.get_all_keys()\\n\\n # unsafe attribute file\\n conf_unsafe_file = filetype + unsafeAttributesFile\\n cs_conf_unsafe_file = S3CortxConfStore(config=conf_unsafe_file, index=conf_unsafe_file)\\n conf_unsafe_file_keys = cs_conf_unsafe_file.get_all_keys()\\n\\n # active config file\\n conf_file = filetype + configFile\\n cs_conf_file = S3CortxConfStore(config=conf_file, index=conf_file)\\n conf_file_keys = cs_conf_file.get_all_keys()\\n\\n #logic to determine which keys to merge.\\n keys_to_overwrite = []\\n for key in conf_new_sample_keys:\\n #If key is marked for unsafe then do not modify/overwrite.\\n if key in conf_unsafe_file_keys:\\n continue\\n #if key not present active config file then add it\\n # (this will also add and hence effectively overwrite keys removed in above [] handing\\n # and hence will always result in overwrite for these keys from the new sample file).\\n if key not in conf_file_keys:\\n keys_to_overwrite.append(key)\\n #if key is not unsafe and value is not changed by user then overwrite it.\\n elif cs_conf_file.get_config(key) == cs_conf_old_sample.get_config(key):\\n keys_to_overwrite.append(key)\\n #if user has changed the value of the key then skip it.\\n else:\\n continue\\n\\n cs_conf_file.merge_config(source_index=conf_new_sample, keys_to_include=keys_to_overwrite)\\n cs_conf_file.save_config()\\n Log.info(f'config file {str(configFile)} upgrade completed')\",\n \"def update_tempest_conf_file(conf_file, rconfig):\\n with open(TempestCommon.tempest_conf_yaml, encoding='utf-8') as yfile:\\n conf_yaml = yaml.safe_load(yfile)\\n if conf_yaml:\\n sections = rconfig.sections()\\n for section in conf_yaml:\\n if section not in sections:\\n rconfig.add_section(section)\\n sub_conf = conf_yaml.get(section)\\n for key, value in sub_conf.items():\\n rconfig.set(section, key, value)\\n\\n with open(conf_file, 'w', encoding='utf-8') as config_file:\\n rconfig.write(config_file)\",\n \"def update_cfg_file(cfg, scoring, logr):\\n cfg[SCORER][SCORER_PATH] = SCORING_PATHS.get(scoring)\\n cfg[SCORER][SCORER_OPTIONS] = SCORING_ATTRS.get(scoring).get(logr)\\n return cfg\",\n \"async def setconfigfile(self, ctx, *, config_file):\\n self.settings.setConfigFile(config_file)\\n await ctx.send(inline('Done'))\",\n \"def load(self):\\n try:\\n _config_file = open(self.config, 'r+')\\n data = json.loads(_config_file.read())\\n except (ValueError, IOError):\\n data = {}\\n\\n self.update(data)\",\n \"def save(self):\\n file = open(self.path, 'w')\\n self.config.write(file)\\n file.close()\",\n \"def update_config(self, config):\\n self.config = {\\n \\\"key\\\": \\\"\\\",\\n \\\"display_name\\\": \\\"\\\",\\n \\\"description\\\": \\\"\\\",\\n \\\"required\\\": 1,\\n \\\"type\\\": \\\"string\\\"\\n }\\n self.config.update(config)\\n self.API_KEY = self.config['github_api_key']\",\n \"def modify_config_file(config_file, search_config, replace_config):\\n with open(config_file, 'r+') as f:\\n content = f.read()\\n f.seek(0)\\n f.write(content.replace(search_config, replace_config))\\n f.truncate()\\n f.close()\",\n \"def update_config(self, config):\\n # add follower public folder to the CKAN's list of public folders\\n here = os.path.dirname(__file__)\\n public_dir = os.path.join(here, 'public')\\n if config.get('extra_public_paths'):\\n config['extra_public_paths'] += ',' + public_dir\\n else:\\n config['extra_public_paths'] = public_dir\\n # add follower template folder to the CKAN's list of template folders\\n template_dir = os.path.join(here, 'templates')\\n if config.get('extra_template_paths'):\\n config['extra_template_paths'] += ',' + template_dir\\n else:\\n config['extra_template_paths'] = template_dir\",\n \"def _update_cfg_from_files(self, files):\\n\\t\\tfor file in files:\\n\\t\\t\\twith open(self.SettingsFolder + file) as f:\\n\\t\\t\\t\\tself._add_cfg_to_list(file[:-4], yaml.load(f))\",\n \"def _update_cloudwatch_config(self, config_type):\\n param_name = self._get_ssm_param_name(config_type)\\n cw_config_ssm = self._set_cloudwatch_ssm_config_param(\\n param_name, config_type)\\n cur_cw_config_crc = self._sha1_hash_file(config_type)\\n ssm_cw_config_crc = self._sha1_hash_json(cw_config_ssm)\\n # check if user updated cloudwatch related config files.\\n # if so, perform corresponding actions.\\n if cur_cw_config_crc != ssm_cw_config_crc:\\n logger.info(\\n \\\"Cloudwatch {} config file has changed.\\\".format(config_type))\\n self.CLOUDWATCH_CONFIG_TYPE_TO_UPDATE_CONFIG_FUNC.get(\\n config_type)()\",\n \"def change_pwds(config):\\n if not config:\\n click.echo(help_msg)\\n return\\n try:\\n user_config = imp.load_source('config', config)\\n except IOError as e:\\n click.echo(\\\"File %s not found.\\\" % config)\\n logger.error(\\\"Invalid path to config file: %s\\\" % e)\\n except Exception as e:\\n click.echo(\\\"Ooups. Something went wrong.\\\")\\n click.echo(e)\\n logger.critical(\\\"%s\\\" % e)\\n else:\\n for i in dir(config_f):\\n if not i.startswith(\\\"__\\\"):\\n try:\\n user_config.__dict__[i]\\n except KeyError:\\n user_config.__dict__[i] = config_f.__dict__[i]\\n handle_exceptions(main, user_config)\",\n \"def reload_ini(self):\\n while True:\\n\\n if round(os.path.getmtime(self.config_file)) > self.config_last_modified:\\n print('Config Changes Detected, Reloading .ini File')\\n config = configparser.ConfigParser()\\n config.read(self.config_file)\\n self._set_ini_options(config)\\n self.config_last_modified = round(os.path.getmtime(self.config_file))\\n\\n time.sleep(3)\",\n \"def _save_changes(self):\\n copy2(self._cfg_filename, self._cfg_filename + \\\".bak\\\")\\n with open(self._cfg_filename, \\\"w\\\", encoding=\\\"utf-8\\\") as self._cfg_file:\\n self.write(self._cfg_file)\",\n \"def update_dashboard_section(self):\\n rconfig = configparser.RawConfigParser()\\n rconfig.read(self.conf_file)\\n if env.get('DASHBOARD_URL'):\\n if not rconfig.has_section('dashboard'):\\n rconfig.add_section('dashboard')\\n rconfig.set('dashboard', 'dashboard_url', env.get('DASHBOARD_URL'))\\n else:\\n rconfig.set('service_available', 'horizon', False)\\n with open(self.conf_file, 'w', encoding='utf-8') as config_file:\\n rconfig.write(config_file)\",\n \"def _on_config_changed(self, _):\\n self._configure_pod()\",\n \"def update_local(self, name, file=None):\\n self._recent_caller = name\\n self._local = {}\\n if file is None:\\n file = self._findConfigPath(name)\\n\\n if file and os.path.exists(file):\\n config = CustomConfigObj(file,\\n encoding='UTF8',\\n parent_config=self._main_config)\\n\\n self._update(self._local, config)\\n return True\",\n \"def configure(self, config: dict):\\n self.config.update(config)\",\n \"def update(self, config):\\n # find keys are in config but not in self.config\\n extra_keys = set(config.keys()) - set(self.config.keys())\\n if len(extra_keys) > 0:\\n raise ValueError(\\\"keys {} in config are not in Config.config\\\".format(extra_keys))\\n # update self.config by config\\n else:\\n self.config.update(config)\",\n \"def update(self):\\n # TO DO for updating urls if changed\\n pass\",\n \"def save(self):\\n if self.changed:\\n logger.info(\\\"Overwriting Redis config\\\")\\n self.client.config_rewrite()\\n self.changed = False\",\n \"def save_config(self):\\n config.save_config(self.config, self.config_file)\",\n \"def updateConfig(self, conf=None):\\r\\n if conf is not None:\\r\\n self.config.update(conf)\\r\\n if self.visprotocol is not None:\\r\\n self.visprotocol.updateSettings(self.getConfigData())\\r\\n # else:\\r\\n # _LOGGER.warning(\\\"Visonic link is not set\\\")\\r\\n # make the changes to the platform parameters (used in alarm_control_panel)\\r\\n # the original idea was to keep these separate for multiple partitions but now i'm not so sure its necessary\\r\\n\\r\\n self.hass.data[DOMAIN][\\\"arm_without_code\\\"] = self.toBool(self.config.get(CONF_ARM_CODE_AUTO, False))\\r\\n self.hass.data[DOMAIN][\\\"force_keypad\\\"] = self.toBool(self.config.get(CONF_FORCE_KEYPAD, False))\\r\\n self.hass.data[DOMAIN][\\\"arm_away_instant\\\"] = self.toBool(self.config.get(CONF_INSTANT_ARM_AWAY, False))\\r\\n self.hass.data[DOMAIN][\\\"arm_home_instant\\\"] = self.toBool(self.config.get(CONF_INSTANT_ARM_HOME, False))\\r\\n\\r\\n _LOGGER.debug(\\\"[Settings] Log Max Entries %s\\\", self.config.get(CONF_LOG_MAX_ENTRIES))\\r\\n _LOGGER.debug(\\\"[Settings] Log Reverse %s\\\", self.config.get(CONF_LOG_REVERSE))\\r\\n _LOGGER.debug(\\\"[Settings] Log Create Event %s\\\", self.config.get(CONF_LOG_EVENT))\\r\\n _LOGGER.debug(\\\"[Settings] Log Final Event %s\\\", self.config.get(CONF_LOG_DONE))\\r\\n _LOGGER.debug(\\\"[Settings] Log XML Filename %s\\\", self.config.get(CONF_LOG_XML_FN))\\r\\n _LOGGER.debug(\\\"[Settings] Log CSV Filename %s\\\", self.config.get(CONF_LOG_CSV_FN))\\r\\n _LOGGER.debug(\\\"[Settings] Log CSV title Row %s\\\", self.config.get(CONF_LOG_CSV_TITLE))\",\n \"def update_config_file(commands_to_add, commands_to_remove):\\r\\n\\r\\n # Parse the config.txt file contents\\r\\n config_file_contents = {}\\r\\n if os.path.exists(utils.CONFIG_FILE_PATH):\\r\\n config_file_string = utils.get_config_file()\\r\\n first_line = True\\r\\n for line in config_file_string.split('\\\\n'):\\r\\n if first_line:\\r\\n first_line = False\\r\\n continue\\r\\n if not line.strip(): continue\\r\\n if not line.startswith('#'):\\r\\n line = line.split('\\\\t')\\r\\n config_file_contents[line[0]] = line\\r\\n\\r\\n # Remove the specified contents\\r\\n for cmd in commands_to_remove:\\r\\n config_file_contents.pop(cmd, None)\\r\\n\\r\\n # Add the specified contents\\r\\n for cmd in commands_to_add:\\r\\n config_file_contents[cmd] = [cmd] + ['none']*3\\r\\n\\r\\n # Archive old config.txt\\r\\n if os.path.exists(utils.CONFIG_FILE_PATH):\\r\\n current_time = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')\\r\\n obs_ending = '-obsolete-{0}.txt'.format(current_time)\\r\\n obs_path = obs_ending.join(utils.CONFIG_FILE_PATH.rsplit('.txt',1))\\r\\n os.rename(utils.CONFIG_FILE_PATH, obs_path)\\r\\n\\r\\n # Print new sorted config.txt\\r\\n out_handle = open(utils.CONFIG_FILE_PATH, 'w')\\r\\n out_handle.write('cmd_name\\\\texecute\\\\tload_module\\\\tunload_module')\\r\\n out_handle.write('\\\\n')\\r\\n for cmd, line in sorted(config_file_contents.iteritems()):\\r\\n out_handle.write('\\\\t'.join(line))\\r\\n out_handle.write('\\\\n')\\r\\n out_handle.close()\",\n \"def update_config(doc, signum):\\n log = logging.getLogger(__name__)\\n log.info('Caught signal %d (%s). Reloading configuration.', signum, '/'.join(SIGNALS_INT_TO_NAME[signum]))\\n if not GLOBAL_MUTABLE_CONFIG['--config']:\\n log.warning('No previously defined configuration file. Nothing to read.')\\n return\\n\\n # Read config.\\n try:\\n config = _get_arguments(doc)\\n except DocoptcfgFileError as exc:\\n logging.getLogger(__name__).error('Config file specified but invalid: %s', exc.message)\\n return\\n\\n # Resolve relative paths.\\n _real_paths(config)\\n\\n # Validate.\\n try:\\n _validate_config(config)\\n except ConfigError:\\n return\\n\\n # Update.\\n GLOBAL_MUTABLE_CONFIG.update(config)\\n\\n # Re-setup logging.\\n setup_logging(GLOBAL_MUTABLE_CONFIG)\\n log.info('Done reloading configuration.')\",\n \"def _update(self):\\n # clear group before rebuild\\n self.clear()\\n\\n # build configuration groups\\n self._config_names = []\\n for i in range(self._n_configs):\\n config_name = f\\\"config{i+1:02}\\\"\\n self._config_names.append(config_name)\\n self._build_config_group(config_name)\\n\\n # reset active configuration if necessary\\n if not all(cname in self._config_names for cname in self._active_config):\\n self._active_config = (self._config_names[0],)\\n\\n # build datasets\\n self._build_datasets()\",\n \"def init_config(self):\\n # self.config.read(self.cnfgfile)\\n if not self.config.has_section(VERSION_SECTION):\\n self.config.add_section(VERSION_SECTION)\",\n \"def configfile(self, fp):\\n if not self.modifier.skip_configfile:\\n if os.path.exists(fp):\\n self.configfiles.append(fp)\\n c = snakemake.io.load_configfile(fp)\\n update_config(self.config, c)\\n if self.overwrite_config:\\n logger.info(\\n \\\"Config file {} is extended by additional config specified via the command line.\\\".format(\\n fp\\n )\\n )\\n update_config(self.config, self.overwrite_config)\\n elif not self.overwrite_configfiles:\\n fp_full = os.path.abspath(fp)\\n raise WorkflowError(\\n f\\\"Workflow defines configfile {fp} but it is not present or accessible (full checked path: {fp_full}).\\\"\\n )\\n else:\\n # CLI configfiles have been specified, do not throw an error but update with their values\\n update_config(self.config, self.overwrite_config)\",\n \"def reload(self):\\n self.load_config()\\n # Seems we need to explicitly refresh this\\n if self.main_instance:\\n self.main_instance.config = self.config\",\n \"def _load_conf(self, conf):\\n f = open(self.file, \\\"w\\\")\\n f.write(conf)\\n f.close()\",\n \"def config(self, config_dict):\\r\\n self._cfg.config = config_dict\",\n \"def saveConfig(self):\\r\\n self.config[\\\"Settings\\\"] = {}\\r\\n settings = self.config[\\\"Settings\\\"]\\r\\n settings[\\\"datapath\\\"] = self.dataPath\\r\\n settings[\\\"videopath\\\"] = self.videoPath\\r\\n settings[\\\"dataoffset\\\"] = str(self.dataOffset)\\r\\n settings[\\\"colblindmode\\\"] = str(self.colBlindMode)\\r\\n with open(self.CONFIG_FILE,\\\"w\\\") as file:\\r\\n self.config.write(file)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8264877","0.7606795","0.74441475","0.726482","0.7236753","0.72217864","0.7091417","0.7060331","0.70171785","0.70084494","0.6937647","0.69036394","0.6887495","0.68652135","0.6852088","0.6795112","0.679408","0.67330885","0.6727831","0.6705917","0.66979545","0.6675949","0.66608924","0.66542983","0.6618892","0.65922624","0.6573851","0.6571257","0.6559911","0.65597725","0.65567434","0.6554245","0.6543328","0.6535085","0.6530818","0.64974326","0.64898056","0.6485235","0.64847267","0.64548755","0.6454667","0.6451614","0.6450422","0.64390045","0.64377356","0.6428822","0.6420591","0.6417948","0.6410888","0.6397023","0.6397023","0.63952154","0.63882166","0.6377484","0.63772804","0.6377112","0.6373792","0.637171","0.6366796","0.63563544","0.6341555","0.63331044","0.63302946","0.6325132","0.6317451","0.63149947","0.6299498","0.6295931","0.6295813","0.6282219","0.6272947","0.6271646","0.62679833","0.62666065","0.62409","0.6239175","0.6238545","0.6224374","0.62176615","0.6215808","0.6214888","0.6210739","0.62070346","0.6193919","0.61893666","0.6187311","0.618511","0.6181811","0.6173924","0.61705506","0.6170119","0.6159923","0.61452854","0.61448556","0.6143913","0.6135089","0.61108994","0.6107523","0.61063075","0.60997254"],"string":"[\n \"0.8264877\",\n \"0.7606795\",\n \"0.74441475\",\n \"0.726482\",\n \"0.7236753\",\n \"0.72217864\",\n \"0.7091417\",\n \"0.7060331\",\n \"0.70171785\",\n \"0.70084494\",\n \"0.6937647\",\n \"0.69036394\",\n \"0.6887495\",\n \"0.68652135\",\n \"0.6852088\",\n \"0.6795112\",\n \"0.679408\",\n \"0.67330885\",\n \"0.6727831\",\n \"0.6705917\",\n \"0.66979545\",\n \"0.6675949\",\n \"0.66608924\",\n \"0.66542983\",\n \"0.6618892\",\n \"0.65922624\",\n \"0.6573851\",\n \"0.6571257\",\n \"0.6559911\",\n \"0.65597725\",\n \"0.65567434\",\n \"0.6554245\",\n \"0.6543328\",\n \"0.6535085\",\n \"0.6530818\",\n \"0.64974326\",\n \"0.64898056\",\n \"0.6485235\",\n \"0.64847267\",\n \"0.64548755\",\n \"0.6454667\",\n \"0.6451614\",\n \"0.6450422\",\n \"0.64390045\",\n \"0.64377356\",\n \"0.6428822\",\n \"0.6420591\",\n \"0.6417948\",\n \"0.6410888\",\n \"0.6397023\",\n \"0.6397023\",\n \"0.63952154\",\n \"0.63882166\",\n \"0.6377484\",\n \"0.63772804\",\n \"0.6377112\",\n \"0.6373792\",\n \"0.637171\",\n \"0.6366796\",\n \"0.63563544\",\n \"0.6341555\",\n \"0.63331044\",\n \"0.63302946\",\n \"0.6325132\",\n \"0.6317451\",\n \"0.63149947\",\n \"0.6299498\",\n \"0.6295931\",\n \"0.6295813\",\n \"0.6282219\",\n \"0.6272947\",\n \"0.6271646\",\n \"0.62679833\",\n \"0.62666065\",\n \"0.62409\",\n \"0.6239175\",\n \"0.6238545\",\n \"0.6224374\",\n \"0.62176615\",\n \"0.6215808\",\n \"0.6214888\",\n \"0.6210739\",\n \"0.62070346\",\n \"0.6193919\",\n \"0.61893666\",\n \"0.6187311\",\n \"0.618511\",\n \"0.6181811\",\n \"0.6173924\",\n \"0.61705506\",\n \"0.6170119\",\n \"0.6159923\",\n \"0.61452854\",\n \"0.61448556\",\n \"0.6143913\",\n \"0.6135089\",\n \"0.61108994\",\n \"0.6107523\",\n \"0.61063075\",\n \"0.60997254\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.88768095"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":179,"cells":{"query":{"kind":"string","value":"FILL COLUMN2 WITH MOST LIKELY VALUES BASED ON COLUMN1"},"document":{"kind":"string","value":"def fillgaps(column1,column2,train,test):\n ddict={}\n d1=test[[column1,column2]].dropna().values\n d2=train[[column1,column2]].dropna().values\n c1=np.array(d1[:,0].tolist()+d2[:,0].tolist())\n c2=np.array(d1[:,1].tolist()+d2[:,1].tolist())\n for ic1 in np.unique(c1):\n ddict[ic1]=(c2[c1==ic1].mean(),c2[c1==ic1].std())\n full_data = [train, test]\n for dataset in full_data:\n for missing in np.where(np.isnan(dataset[column2]))[0]:\n m,s=ddict[dataset[column1][missing]]\n if s<=0:\n dataset[column2][missing]=m\n else:\n dataset[column2][missing]=np.random.normal(loc=m,scale=s,size=1)\n return (train,test)"},"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 _fill_col1_val_where_col2_notna(col1, col2, val):\n fill_ser = col1.copy()\n fill_ser[col2.notna()] = val\n return col1.fillna(fill_ser)","def fill_col(col, x):\n col.append(x)\n return col","def merge(line):\n #Step1. Putting 0 to the end of the list.\n result = []\n for cell in line:\n if cell != 0:\n result.append(cell)\n for cell in range(line.count(0)):\n result.append(0)\n #Step2. Replaced with a tile of twice the value and a zero tile\n for cell in range(len(result)-1):\n if result[cell] == result[cell+1] and len(result) != 1:\n result[cell] += result[cell]\n result[cell+1] = 0\n #Step3. Repeat step1\n final_result = []\n for cell in result:\n if cell != 0:\n final_result.append(cell)\n for cell in range(result.count(0)):\n final_result.append(0)\n return final_result","def fill_cells_to_the_right(nonogram, row, col):\n sth_changed = False\n\n # leeway stores a number of fillable cells to the left\n # -1 at the end returns length of line, when there is no true empty cell\n left_cells = nonogram.data.get_row(row)[:col]\n leeway = (left_cells[::-1]+[-1]).index(-1)\n\n block_length = find_min_block_length(nonogram, row, col)\n\n # filling cells enforced by minimal block length\n for position in range(col + 1, col + block_length - leeway):\n nonogram.fill_cell(row, position, 1)\n sth_changed = True\n\n return sth_changed","def modify_d2(d1, d2):\n val_list = [i for i in d2.keys()]\n \n for key in val_list:\n for i in range(len(d2[key])):\n try:\n val = d1[d2[key][i][2]]\n d2[key][i][2] = val\n if None in d2[key][i]:\n d2[key][i].remove(None)\n except:\n pass\n return d2","def fill_cells_to_the_left(nonogram, row, col):\n sth_changed = False\n\n # leeway stores a number of fillable cells to the right\n # -1 at the end returns length of line, when there is no true empty cell\n right_cells = nonogram.data.get_row(row)[col+1:]\n leeway = (right_cells + [-1]).index(-1)\n\n block_length = find_min_block_length(nonogram, row, col)\n\n # filling cells enforced by minimal block length\n for position in range(col + leeway + 1 - block_length, col):\n nonogram.fill_cell(row, position, 1)\n sth_changed = True\n\n return sth_changed","def normalize(column):\n value_set = set(column)\n unique_count = len(value_set)\n if unique_count == 1:\n # skip everything in this column. \n return []\n elif unique_count == 2:\n zero = list(value_set)[0]\n one = list(value_set)[1]\n normalized_column = []\n for value in column:\n normalized_column.append(1 if value == one else 0)\n return [normalized_column]\n else: \n all_values = list(value_set)\n normalized_column = []\n\n # expand into multiple columns \n for index in range(len(all_values)):\n normalized_column.append([])\n\n for value in column:\n for index in range(len(all_values)):\n normalized_column[index].append(1 if value == all_values[index] else 0)\n \n return normalized_column","def merge(line):\r\n # Create a copy of the input list line\r\n list_copy=[]\r\n #adding the none zero elements of line to list_copy\r\n for dummy_i in range(len(line)):\r\n if line[dummy_i] != 0:\r\n list_copy.append(line[dummy_i])\r\n # adding the appropriate number of zeros to match the length of list_copy and line\r\n for dummy_j in range(len(list_copy),len(line)):\r\n list_copy.append(0)\r\n \r\n # merging the tiles that have the same value\r\n for dummy_k in range(len(list_copy)-1):\r\n # checking for equal values of the adjacent tiles \r\n if list_copy[dummy_k]!=0 and list_copy[dummy_k]==list_copy[dummy_k+1]:\r\n # if equal double the value of the first tile and assign zero to second tile\r\n list_copy[dummy_k]=2*list_copy[dummy_k]\r\n list_copy[dummy_k+1]=0\r\n \r\n #shifting the rest of the values ot the tiles by one place\r\n for dummy_p in range(dummy_k+1,len(list_copy)-1):\r\n list_copy[dummy_p]=list_copy[dummy_p+1]\r\n if (len(line)>3):\r\n list_copy[-2]=list_copy[-1]\r\n list_copy[-1]=0\r\n # returning list_copy which is the answer\r\n return list_copy","def fill_hom(patient, gene):\n\n first = 'HR_' + patient + '_First_' + gene + '_Split'\n second = 'HR_' + patient + '_Second_' + gene + '_Split'\n\n for column in data.columns:\n f = re.match(second, column)\n if f:\n data[second] = data[second].fillna(data[first])\n else:\n pass","def fill_data(column, data):\n data[column].fillna(data[column].value_counts().index[0], inplace=True)","def backfill(arr, arr1):\n \n arr = np.where(arr < 0.01, np.NaN, arr)\n # FIXME:\n # RuntimeWarning: invalid value encountered in less\n # arr = np.where(arr < 0.01, np.NaN, arr)\n\n x = np.isnan(arr1)\n arr1[x] = arr[x]\n return arr1","def _update_context_no_unique_values(metadata, column, unique_values):\r\n\r\n return None","def merge(line):\n line2=[]\n line3=[]\n line4=[]\n pair=0\n shift=0\n line1=[0]*len(line)\n if(len(line)==1):\n for iota in line:\n line1[0]=iota\n return line1\n \n for iota in xrange(len(line)):\n line4.append(line[iota])\n \n for iota in xrange(len(line)):\n line3.append(line[iota])\n \n \n \n for xinn in xrange(len(line3)):\n for iota in xrange(len(line3)-1):\n if(line3[iota]==0):\n if((line3[iota+1])>0):\n temp=line3[iota];\n line3[iota]=line3[iota+1];\n line3[iota+1]=temp\n shift=1\n xinn=xinn+1\n \n \n if(shift==1):\n for iota in xrange(len(line3)):\n line2.append(line3[iota])\n else:\n for iota in xrange(len(line4)):\n line2.append(line4[iota])\n \n \n \n \n \n \n \n for olay in range(len(line2)-1):\n \n \n if(line2[olay]==line2[olay+1]):\n line1[olay]=2*line2[olay];\n line2[olay+1]=0\n line1[olay+1]=line2[olay+1]\n pair=1;\n olay=olay+2\n else:\n line1[olay]=line2[olay]\n line1[olay+1]=line2[olay+1]\n \n \n \n \n \n \n \n \n \n \n if(pair==0):\n for lonn in xrange(len(line3)):\n line1[lonn]=line3[lonn]\n return line1\n \n \n \n for xinn in xrange(len(line1)):\n for iota in xrange(len(line1)-1):\n if(line1[iota]==0):\n if((line1[iota+1])>0):\n temp=line1[iota];\n line1[iota]=line1[iota+1];\n line1[iota+1]=temp\n \n xinn=xinn+1\n \n return line1","def switchColumn(data_file, column1, column2):\n\tdata = []\n\tfor dataLine in readData(data_file):\n\t\ttmp = dataLine[column1-1]\n\t\tdataLine[column1-1] = dataLine[column2-1]\n\t\tdataLine[column2-1] = tmp\n\t\tdata.append(dataLine)\n\twriteData(data_file, data)","def fillna(df, col: str, forward: bool):\n na_prev = len(df)\n report = f'fillna(\"{col}\") ' + ('forward' if forward else 'backward') + ' NA count:'\n while True:\n na = df[col].isna().sum()\n report += f' {na}'\n if na == na_prev or na == 0: break\n na_prev = na\n # df must to be sorted by (ABI, YEAR)\n df.loc[df[col].isna(), col] = df.groupby('ABI')[col].shift(1 if forward else -1)","def fillna_negtive1(df, target=None):\n if not target:\n target = ['price', 'image_top_1']\n for col in target:\n df[col] = df[col].fillna(-1)\n return None","def _exch(self, ix_1, ix_2):\n tmp = self._vals[ix_1]\n self._vals[ix_1] = self._vals[ix_2]\n self._vals[ix_2] = tmp","def addColumnValues(self, column):\n nr1 = self.data.shape[1]\n nr = len(column)\n if nr1 == 0:\n # case 1: empty table\n if nr == 0:\n # case 1a: we're just adding a name\n self.data = numpy.reshape(self.data, (1, 0))\n pass\n else:\n # case 1b: we're adding a column of values\n self.data = numpy.reshape(numpy.array(column), (1, nr))\n pass\n pass\n else:\n # case 2: non-empty table\n if nr1 > 0 and nr != nr1:\n raise Exception(\"New column must have the same length as existing ones %s %s\"%(nr1,nr))\n new_column = numpy.reshape(numpy.array(column), (1, nr))\n self.data = numpy.concatenate((self.data, new_column))\n pass\n return","def _merge_row(self, row1, row2):\n\n duprow = list(row1)\n duprow.extend(list(row2))\n row1.clear()\n overlap_map = {}\n\n for body, overlap in duprow:\n if body not in overlap_map:\n overlap_map[body] = 0\n overlap_map[body] += overlap\n\n for body, overlap in overlap_map.items():\n row1.add((body, overlap))","def fill_forward(df):\n df = df.fillna(method='ffill')\n df = df.fillna(method='bfill').fillna(0)\n return df","def assemble_col(c1, c2):\n c1.extend(c2)\n return c1","def fill_row(row, x):\n row.append(x)\n return row","def merge(line):\r\n setup_line = line[:]\r\n new_line = []\r\n for num in setup_line:\r\n if num == 0:\r\n setup_line.remove(0)\r\n setup_line.append(0)\r\n \r\n setup_line.append(0)\r\n setup_line.append(0)\r\n setup_line.append(0)\r\n setup_line.append(0)\r\n \r\n for itr in range(len(line)):\r\n if setup_line[0] == setup_line[1] and setup_line[0] != 0:\r\n new_line.append(setup_line[0] * 2)\r\n setup_line.remove(setup_line[0])\r\n setup_line.remove(setup_line[0])\r\n else:\r\n new_line.append(setup_line[0])\r\n setup_line.remove(setup_line[0])\r\n new_line.append(0)\r\n \r\n for itr in range(len(new_line)):\r\n for num in new_line[len(line):]:\r\n if num == 0:\r\n new_line.remove(0)\r\n \r\n return new_line","def merge(line):\n lst = [0] * len(line) # we start with a 0-filled list.\n pos = 0 # index position in the new list\n pvl = 0 # we keep the previous value\n for val in line:\n if val: # we only care about the non zero values.\n if not pvl: # this tile is empty\n lst[pos] = val # let's fill with val\n pvl = val\n elif pvl - val: # different non zero values?\n pos += 1\n lst[pos] = val # tiles don't merge\n pvl = val\n else: # same values!\n lst[pos] <<= 1 # it merges!\n pos += 1\n pvl = 0 # next value is 0\n return lst","def merge(line):\n # replace with your code\n result = []\n for index in range(len(line)):\n result.append(0)\n result = shift_down(line, result)\n for index in range(len(result) - 1):\n if result[index] == result[index + 1]:\n result[index] *= 2\n result[index + 1] = 0\n result = shift_down(result, result)\n return result","def merge_right(row):\r\n row1 = reverse(row)\r\n row2 = add_tiles(row1)\r\n row3 = reverse(row2)\r\n row = row3\r\n\r\n return row","def merge(line):\r\n origin_len = len(line)\r\n new_line = list(line)\r\n empty_space = 0\r\n # remove zero\r\n while empty_space in new_line:\r\n new_line.remove(0)\r\n # merge\r\n tile_cursor = 0\r\n for dummy_count in range(len(new_line) - 1):\r\n if tile_cursor >= (len(new_line) - 1):\r\n break\r\n elif new_line[tile_cursor] == new_line[tile_cursor + 1]:\r\n new_line[tile_cursor] = 2 * new_line[tile_cursor]\r\n new_line[tile_cursor + 1] = 0\r\n tile_cursor = tile_cursor + 2\r\n else:\r\n tile_cursor += 1\r\n \r\n #remove zero\r\n while empty_space in new_line:\r\n new_line.remove(0)\r\n list_zero = [0] * (origin_len - len(new_line))\r\n new_line.extend(list_zero)\r\n \r\n return new_line","def fill_league_currency(self, df, latest_currency_list):\n league_currency_list = [currency[0] for currency in df.columns]\n for lastest_currency in latest_currency_list:\n if lastest_currency not in league_currency_list:\n df[lastest_currency, df.columns[0][1]] = np.nan\n df = df.sort_index(axis=1)\n return df","def merge(line):\n # create a list of non zero values from input\n input_size = len(line)\n line = [dummy_value for dummy_value in line if dummy_value > 0]\n \n # create an output list of same length as input with zero values\n line2 = [0] * input_size\n \n #update the output list with the non zero input list based on certain conditions\n line2[0:len(line)] = line\n \n pos = [dummy_no for dummy_no in range(0, len(line2))]\n \n for jos in pos[0:input_size -1]:\n if line2[jos] == line2[pos[jos+1]]:\n line2[jos] = line2[jos] + line2[pos[jos+1]]\n line2[jos+1] = 0\n \n # repeat last two steps above\n # create an output list of same length as input with zero values\n line2 = [dummy_val for dummy_val in line2 if dummy_val > 0]\n \n # create an output list of same length as input with zero values\n line3 = [0] * input_size\n \n #update the output list with the non zero input list \n line3[0:len(line2)] = line2\n \n return line3","def fill_missing_admission_type(df):\n for admit_type in df[\"admission_type\"].unique():\n type_facilities = df[df[\"admission_type\"] == admit_type][\"facility\"].unique()\n\n df[\"admission_type\"] = np.where(\n (df[\"admission_type\"].isnull() & df[\"facility\"].isin(type_facilities)),\n admit_type,\n df[\"admission_type\"],\n )\n\n return df","def merge(line):\r\n result_list = [0] * len(line)\r\n medium_list = []\r\n zero = 0\r\n \r\n for non_zero in range(len(line)):\r\n if line[non_zero] > 0:\r\n medium_list.append(line[non_zero])\r\n \r\n for position in range(len(medium_list)):\r\n result_list.pop(position)\r\n result_list.insert(position, medium_list[position])\r\n \r\n \r\n for tile in range(len(result_list)):\r\n if tile + 1 > len(result_list) -1:\r\n break\r\n if result_list[tile] == result_list[tile + 1]:\r\n result_list[tile] *= 2\r\n result_list[tile+1] = 0\r\n \r\n \r\n while zero in result_list:\r\n result_list.remove(zero) \r\n \r\n \r\n while len(result_list) != len(line):\r\n result_list.append(zero)\r\n \r\n \r\n return result_list","def _rebuild_compareset(self, result, rewrapped_columns, columns):\n normalize = lambda x: x if (isinstance(x, str) or not x) else tuple(x)\n rewrapped_columns = normalize(rewrapped_columns)\n columns = normalize(columns)\n\n if rewrapped_columns == columns:\n return result # <- EXIT!\n\n missing = self._missing\n def rebuild(x):\n lookup_dict = dict(zip(rewrapped_columns, x))\n return tuple(lookup_dict.get(c, missing) for c in columns)\n return CompareSet(rebuild(x) for x in result)","def merge(self, nums1, m, nums2, n):\n nums1.extend([0]*n)\n j=0\n for i in range(len(nums1)):\n if nums2[j]<nums1[i]:\n nums1.remove(0)\n nums1.insert(i,nums2[j])\n j=j+1","def expand_df(df, column):\n expanded2 = pd.DataFrame({\n col: np.repeat(df[col].values, df[column].str.len())\n for col in df.columns.drop(column)}\n ).assign(**{column: list(np.concatenate(df[column].values))})\n return expanded2","def right_to_left(data, key, col_tuple, col_tuples, re_tuples,\n re_triple, cnt):\n first_col = col_tuples[0]\n second_col = col_tuples[1]\n if col_tuple == first_col or col_tuple == second_col:\n if col_tuple == first_col:\n data[\"tmp_0\"] = data[col_tuple[1]].astype(str).str.extract(re_triple[cnt][0].format(key),\n expand=True)\n else:\n data[\"tmp_0\"] = data[col_tuple[1]].astype(str).str.extract(re_triple[cnt][0],\n expand=True)\n data[\"tmp_1\"] = data[\"tmp_0\"].str.extract(re_triple[cnt][1],\n expand=True)\n if col_tuple == first_col:\n regex = re_triple[cnt][2].format(key)\n data[\"tmp_0\"] = data[\"tmp_0\"].str.extract(regex, expand=True)\n else:\n regex = re_triple[cnt][2]\n data[\"tmp_0\"] = data[\"tmp_0\"].str.extract(regex, expand=True)\n tmp_0_clean = data[\"tmp_0\"].str.strip()\n data[col_tuple[0]] = data[col_tuple[0]].fillna(tmp_0_clean)\n if col_tuple == first_col:\n data[col_tuple[1]] = data[col_tuple[1]].replace(re_triple[cnt][0].format(key),\n np.NaN, regex=True)\n else:\n data[col_tuple[1]] = data[col_tuple[1]].replace(re_triple[cnt][0][:-15]+\")\",\n np.NaN, regex=True)\n data[col_tuple[1]] = data[col_tuple[1]].replace(re_triple[cnt][0],\n np.NaN, regex=True)\n tmp_1_clean = data[\"tmp_1\"].str.strip()\n data[col_tuple[1]] = data[col_tuple[1]].fillna(tmp_1_clean)\n data = data.drop(columns=\"tmp_0\")\n data = data.drop(columns=\"tmp_1\")\n return data","def map (a_data,a_column,a_old,a_new) :\n loc_new_data = a_data\n a_data[a_column].replace(a_old,a_new,inplace=True)","def fix_null_vals(dataset):\n\tprint(\"\\tFixing null values\")\n\n\tif not dataset.isnull().any().any():\n\t\treturn dataset\n\telse:\n\t\treturn dataset.fillna(method=\"ffill\")","def combine_columns(allowed_columns):\n\n v_columns = [v for v in allowed_columns if v in df.columns]\n v_columns.sort()\n for i in range(1, len(v_columns)):\n df[v_columns[0]] = df[v_columns[0]].fillna(df[v_columns[i]])\n df.drop(v_columns[i], 1, inplace=True)\n return v_columns[0]","def merge(self, nums1, m, nums2, n):\n n=len(nums1)\n j=0\n for i in range(n):\n if nums2[j]<nums1[i] and nums2[j]<len(nums2):\n nums1.remove(0)\n nums1.insert(i,nums2[j])\n j=j+1\n if nums1[i]==0 and nums2[j]<len(nums2):\n nums1[i]=nums2[j]","def fill_end_of_the_row(nono, row):\n ending = nono.limits.get_row_endings(row, -1)\n sth_changed = fill_range_in_row(nono, row,\n range(ending + 1, nono.meta_data.n_cols),\n -1)\n return sth_changed","def _propagate_duplicate_cols(self, duplicate_cols):\n for duplicate in duplicate_cols:\n no_suffix = \"_\".join(duplicate.split(\"_\")[:-1])\n null_idx = self._hybrid_meta[no_suffix].isnull()\n non_null_vals = self._hybrid_meta.loc[null_idx, duplicate].values\n self._hybrid_meta.loc[null_idx, no_suffix] = non_null_vals","def merge(line):\n result = [0 for idx in range(len(line))]\n count = 0\n # push all non-zero values to the left of the tile\n for num in line:\n if num != 0:\n result[count] = num\n count += 1\n # merge adjacent values only once left to right\n for idx in range(len(list(result))-1):\n if result[idx] == result[idx+1]:\n result[idx] = result[idx] + result[idx+1]\n result.pop(idx+1)\n result.append(0)\n return result","def map_value(self, df, from_column, to_column, value = None,\n values_map_column = None, values_map = None):\n if from_column not in df.columns:\n return df\n\n if value:\n df[to_column] = np.where(df[from_column].notnull(), value, None)\n elif values_map_column and values_map:\n #add unit value regardless if there is a measure value\n df[to_column] = df[values_map_column].map(values_map)\n #reset all unit values where there's no corresponding measure\n df[to_column] = df[to_column].mask(df[from_column].isnull(), None)\n\n return df","def _prepare_data_to_aug(\n self, col: pd.Series, freq=0.2\n ) -> Tuple[pd.Series, pd.Series]:","def reduce_possibilities_by_column(self):\n y = self.targetCell.y\n for i in range(1,10): #content\n for n in range(9): #x-coord adjacent cells\n neighbour_cell = self.puzzleGrid.grid[n][y]\n if self.targetCell != neighbour_cell:\n self.targetCell.column_neighbour_possibilities.append( neighbour_cell.possibilities)\n if str(i) == neighbour_cell.finalNumber:\n self.RemovePossiblityFromTargetCell(i)\n self.targetCell.column_neighbour_possibilities = flatten_list(self.targetCell.column_neighbour_possibilities)","def acumula_x2(self, x2, rodada):\n self.x2[rodada].append(x2)","def fill_with_mode(filename, column):\r\n df=None\r\n df=pd.read_csv(filename)\r\n df[column].fillna(df[column].mode()[0], inplace=True)\r\n return df","def concat(column_based_table_1: dict[str, list[str]], column_based_table_2: dict[str, list[str]]) -> dict[str, list[str]]:\n combined_data_table: dict[str, list[str]] = {}\n for column in column_based_table_1:\n combined_data_table[column] = column_based_table_1[column]\n keys_list = list(combined_data_table.keys())\n for column in column_based_table_2:\n if column in keys_list:\n column_data = combined_data_table[column]\n column_data_2 = column_based_table_2[column]\n # append to list\n for item in column_data_2:\n column_data.append(item)\n combined_data_table[column] = column_data\n else:\n combined_data_table[column] = column_based_table_2[column]\n return combined_data_table","def merge(line):\n length = len(line)\n merge_line = [element for element in line if element != 0]\n \n for index in range(0, len(merge_line)-1):\n if merge_line[index] == merge_line[index+1]:\n merge_line[index] *= 2\n merge_line[index+1] = 0\n merge_line = [element for element in merge_line if element != 0]\n while len(merge_line) != length:\n merge_line.append(0)\n \n return merge_line","def ffill(data):\n last = data[0]\n new = []\n for line in data:\n if line:\n new.append(line)\n last = line\n else:\n new.append(last)\n return new","def fill_beggining_of_the_row(nonogram, row):\n origin = nonogram.limits.get_row_origins(row, 0)\n sth_changed = fill_range_in_row(nonogram, row, range(origin), -1)\n return sth_changed","def fill(self, value):\n if self.fragmented:\n (self[self._begin:].view(ndarray)).fill(value)\n (self[:self._end].view(ndarray)).fill(value)\n else:\n if self._begin < self._end:\n part = self[self._begin:self._end]\n elif self._end == 0:\n part = self[self._begin:]\n\n (part.view(ndarray)).fill(value)","def augment_column(self, col: pd.Series,) -> pd.Series:","def merge(self, nums1, m, nums2, n):\n nums1.extend([0]*len(nums2))\n j=0\n for i in range(len(nums2)):\n if nums2[i]<nums1[j]:\n nums1.pop()\n print(nums1)\n nums1.insert(j,nums2[i])\n j=j+1","def fix_values(df, col):\n broken_values = [value for value in df[col]]\n fixed_values = []\n for value in broken_values:\n fixed_values.append(int(value.replace(',','')\n .replace('$','')))\n df[col] = fixed_values","def fill_range_in_row(nonogram, row, cols, value):\n sth_changed = False\n\n for col in cols:\n change = nonogram.fill_cell(row, col, value)\n sth_changed = sth_changed or change\n\n return sth_changed","def fill(self, recoValue, l1Value, weight=1.):\n self._total.fill(recoValue, weight)\n self._dist.fill(l1Value, weight)\n if l1Value > self._threshold:\n self._pass.fill(recoValue, weight)","def island_fill(i: int, j: int, islandMatrix: List[List[int]]) -> List[List[int]]:\n q = [(i, j)]\n while q:\n element = q.pop()\n if islandMatrix[element[0]][element[1]] == 1:\n for e in neighbourhood(element[0], element[1], islandMatrix):\n q.append(e)\n islandMatrix[element[0]][element[1]] = 2\n return islandMatrix","def merge(self, nums1, m, nums2, n):\n n0=len(nums1)-n\n j=0\n for i in range(n0):\n while nums2[j]<nums1[i]:\n nums1.remove(0)\n nums1.insert(i,nums2[j])\n j=j+1","def _switch_column_values(self, row, column_target):\n cols = row.index.tolist()\n column_target_index = cols.index(column_target)\n\n if column_target_index == 0:\n column_source_index = 1\n elif column_target_index == len(cols) - 1:\n column_source_index = column_target_index - 1\n else:\n column_source_index = column_target_index - 1\n\n column_source = cols[column_source_index]\n replace_value = row[column_source]\n if self.log:\n print(\">>> Replacing values between {}: {} and {}: {}\".format(column_target, row[column_target]\n , column_source, replace_value))\n row[column_source] = row[column_target]\n row[column_target] = replace_value\n return row","def DealWithMissingValues(data_set: pd.DataFrame):\n data_set.fillna(method=\"pad\", inplace=True)","def set_cell_by_index(self, column_index, cell):\n while len(self) <= column_index:\n self.append(None)\n self[column_index] = cell","def fill_between_the_blocks(nonogram, row):\n hints = nonogram.data.get_row_hints(row)\n endings = nonogram.limits.get_row_endings(row)\n origins = nonogram.limits.get_row_origins(row)\n\n sth_changed = False\n\n for i in range(len(hints) - 1):\n cols = range(endings[i] + 1, origins[i+1])\n changed = fill_range_in_row(nonogram, row, cols, -1)\n sth_changed = sth_changed or changed\n\n return sth_changed","def fill_valid2(df):\n for idx, row in df.iterrows():\n if pd.isnull(row['cid']) &\n (pd.isnull(row['byr']) |\n pd.isnull(row['iyr']) |\n pd.isnull(row['hgt']) |\n pd.isnull(row['hcl']) |\n pd.isnull(row['ecl']) |\n pd.isnull(row['pid']) |\n pd.isnull(row['hgt'])):\n df['valid'][idx] = 0","def generate_column(values, previous_table):\n\n # result = []\n\n for i in range(0, len(previous_table)):\n # current_item = previous_table[i] + values[i]\n # result.append(current_item)\n values[i][0:0] = previous_table[i]\n\n # return result\n print \"Column(s) attached to result\"\n return values","def merge(self, nums1, m, nums2, n):\n n0=len(nums1)-n\n j=0\n for i in range(n0):\n if nums2[j]<nums1[i]:\n nums1.remove(0)\n nums1.insert(i,nums2[j])\n j=j+1","def fill_missing(self):\n df = self.df\n # Filling with default values\n logger.debug(\"Filling from distributions...\")\n for field in HeatStrokeDataFiller.default_map or field in HeatStrokeDataFiller.positive_default:\n if field not in df.columns:\n logger.warning(\"(%s) missing from data-frame columns\" % field)\n continue\n logger.debug(\"Setting missing in \\\"%s\\\" to default: %s\" % (field, HeatStrokeDataFiller.default_map[field]))\n default_value = HeatStrokeDataFiller.default_map[field]\n\n where = HeatStrokeDataFiller.find_where_missing(df, field, find_nan=True, find_str=False)\n how_many_to_fill = np.sum(where)\n if field in HeatStrokeDataFiller.positive_default:\n # Use default positive dietributions\n distribution = HeatStrokeDataFiller.positive_default[field]\n df[field].loc[where] = distribution(how_many_to_fill)\n else:\n logger.debug(\"Using default %s for field: %s\" % (default_value, field))\n # Use default values\n df[field].loc[where] = np.array([default_value] * how_many_to_fill)\n\n # Filling with Zeros\n logger.debug(\"Fillling with zeros...\")\n for field in HeatStrokeDataFiller.fields_to_fill_with_zero:\n if field not in df.columns:\n logger.warning(\"\\\"%s\\\" missing from columns\" % field)\n continue\n logger.debug(\"Setting missing in \\\"%s\\\" to 0\" % field)\n\n where = HeatStrokeDataFiller.find_where_missing(df, field, find_nan=True, find_str=True)\n how_many_to_fill = np.sum(where)\n df[field].loc[where] = np.zeros(how_many_to_fill)\n\n # Filling in columns with the average from the rest of the column\n logger.debug(\"Filling with agerages...\")\n for field in HeatStrokeDataFiller.fields_to_fill_with_average:\n if field not in df.columns:\n logger.warning(\"\\\"%s\\\" missing from data-frame columns\" % field)\n continue\n\n where = HeatStrokeDataFiller.find_where_missing(df, field, find_nan=True, find_str=True)\n data = df[field][np.invert(where)]\n mean = np.mean(data)\n std = np.std(data)\n if mean == np.nan or std == np.nan:\n mean, std = (0, 0)\n logger.debug(\"Setting missing in \\\"%s\\\" with: %.3f +/- %.3f\" % (field, mean, std))\n how_many_to_fill = np.sum(where)\n df[field].loc[where] = mean + std * np.random.random(how_many_to_fill)\n\n fields_not_modified = set(df.columns) - set(HeatStrokeDataFiller.default_map.keys()) - HeatStrokeDataFiller.fields_to_fill_with_zero - HeatStrokeDataFiller.fields_to_fill_with_zero\n logger.debug(\"Fields not modified: %s\" % fields_not_modified.__str__())\n return df","def mode_impute(self, column_val):\n mode = column_val.mode()[0]\n column_val = column_val.fillna(mode)\n return column_val","def __init__(self, v1, v2):\n mergedData = []\n list(map(mergedData.extend, list(zip_longest(v1, v2))))\n self.data = list(filter(lambda x: x is not None, mergedData))\n self.index = 0","def compress_dups(data, column):\n idx = defaultdict(list)\n for row in data:\n idx[row[column]].append(row)\n\n dedup = []\n\n for idx_row in sorted(idx.items()):\n dedup.append(avg_rows(idx_row[1]))\n return dedup","def same_as(self, rows: List[Row], column: Column) -> List[Row]:\n return_list: List[Row] = []\n if not rows:\n return return_list\n cell_value = rows[0].values[column.name]\n for table_row in self.table_data:\n new_cell_value = table_row.values[column.name]\n if new_cell_value is None or not isinstance(new_cell_value, type(cell_value)):\n continue\n if new_cell_value == cell_value:\n return_list.append(table_row)\n return return_list","def order_links_end_points(in_file,links_columns,links_columns_all_details,out_file):\n\n df = pd.read_csv(in_file)#.iloc[:,1:]\n # links_columns = [41,45,51,55]\n links_node_swapped_columns = links_columns[math.floor(len(links_columns)/2):] + links_columns[0:math.floor(len(links_columns)/2)]\n\n\n # links_columns_all_details = list(np.arange(41,61))\n links_node_swapped_columns_all_details = links_columns_all_details[math.floor(len(links_columns_all_details)/2):] + links_columns_all_details[0:math.floor(len(links_columns_all_details)/2)]\n\n\n for ix1, (Index, row1) in tqdm(enumerate(df.iterrows())):\n for ix2, (Index, row2) in enumerate(df[ix1+1:].iterrows()):\n\n\n if (row1[links_columns].as_matrix() == row2[links_node_swapped_columns].as_matrix()).all():\n # print('swapping',ix1,ix1 + 1 +ix2)\n # import ipdb; ipdb.set_trace()\n # print('Row2',row2)\n temp = []\n for i in range(len(links_columns_all_details)):\n\n if i < math.floor(len(links_columns_all_details)/2):\n temp.append(df.iat[ix1 + 1 + ix2, links_columns_all_details[i]])\n df.iat[ix1 + 1 + ix2, links_columns_all_details[i]] = df.iat[ix1 + 1 + ix2, links_node_swapped_columns_all_details[i]]\n else:\n df.iat[ix1 + 1 + ix2, links_columns_all_details[i]] = temp[i - math.floor(len(links_columns_all_details)/2)]\n\n # print('swapped',ix1,ix1 + 1 +ix2)\n # print('Row1', row1,'Row2', row2)\n # import ipdb; ipdb.set_trace()\n\n\n\n df.to_csv(out_file, index=False)\n\n return df","def _apply_array_spatial12_lowfilling(self, h1e: 'Nparray',\n h2e: 'Nparray') -> 'Nparray':\n if fqe.settings.use_accelerated_code:\n return self._apply_array_spatial12_lowfilling_fast(h1e, h2e)\n else:\n return self._apply_array_spatial12_lowfilling_python(h1e, h2e)","def clean_df(self, df, column_name):\r\n \r\n df[column_name] = df[column_name].fillna('').str.replace('\\n', ' ')\r\n return df","def appforth(df, line):\n df.loc[-1]=line\n df.index = df.index + 1 # shifting index\n df = df.sort_index() # sorting by index\n return df","def __clean_repeated_columns(self, df, column_type):\n for column in df.columns:\n if column_type in column.lower():\n # Fill main column with data from \"prefix + _\" type column names.\n df[column_type[:-1]].fillna(df[column], inplace=True)\n # Drop the \"prefix + _\" type column names.\n df.drop(column, axis=1, inplace=True)","def fix_date_year(df, col_1, col_2):\n\n for idx, date in enumerate(df[col_1]):\n year1 = date.year\n year2 = df.loc[idx, col_2]\n if np.abs(year1-year2)>95:\n year1 -=100\n df.loc[idx, col_1]=df.loc[idx, col_1].replace(year=year1)\n return df","def merge2(self, nums1, m, nums2, n): \n # 从nums1的第m个数字开始，用nums2的值来替换\n for i in range(n):\n nums1[m+i] = nums2[i]\n nums1.sort()","def expand(table):\n t = []\n for r in table:\n for _ in range(r[1]):\n try:\n t.append((r[0], r[2]))\n except IndexError:\n t.append((r[0], None))\n return t","def merge(line):\n # Iterate over input and create output with non-zeros slid to the left.\n slid = []\n for num in line:\n if num == 0:\n continue\n else:\n slid.append(num)\n for dummy_slot in range(len(line) - len(slid)):\n slid.append(0)\n\n # Iterate over slid_left and create output with tile pairs replaced with\n # a tile of twice the value and a zero tile.\n paired = []\n idx = 0\n while idx < len(slid):\n if idx == len(slid) - 1:\n paired.append(slid[idx])\n idx += 1\n elif slid[idx] == slid[idx + 1]:\n paired.append(slid[idx] * 2)\n paired.append(0)\n idx += 2\n else:\n paired.append(slid[idx])\n idx += 1\n \n # Slide the tiles in paired.\n merged = []\n for num in paired:\n if num == 0:\n continue\n else:\n merged.append(num)\n for dummy_slot in range(len(line) - len(merged)):\n merged.append(0)\n \n return merged","def zero_one_card(df):\n unique_values = defaultdict()\n for col in df.columns:\n if df[col].nunique() < 2:\n unique_values[col] = df[col].nunique()\n if len(unique_values) > 0:\n printmd(str(\"* Columns: *\"+', '.join(list(unique_values.keys()))+\"* have less than two different values\"))\n for col in unique_values.keys():\n printmd(str('* *' + col + \"* has \" + str(df[col].nunique()) + ' differents values :' + str(df[col].unique())))\n else:\n printmd(\"* No columns have less than 2 different values\")","def expandFromColumn(inputColumn,replaceList):\n \n import pandas as pd\n import re\n \n #necessary, due to escape nonsense\n inputColumn=inputColumn.replace(regex=True, to_replace='\\\\\\\\',value='/')\n \n replaceList['changeNum']=0\n replaceList['changeIndexes']=''\n\n for index, row in replaceList.iterrows():\n curReplaceVal=row[0]\n currentRegexExpression=re.compile(curReplaceVal)\n CurrentBoolVec=inputColumn.str.contains(currentRegexExpression,na=False)\n replaceList['changeIndexes'].iloc[index]=[i for i, x in enumerate(CurrentBoolVec) if x]\n replaceList['changeNum'].iloc[index]=len(replaceList['changeIndexes'].iloc[index])\n inputColumn=inputColumn.replace(regex=True, to_replace=currentRegexExpression,value=row[1])\n return inputColumn, replaceList;","def merge(self, nums1, m, nums2, n):\n offset = len(nums1) - m\n i = 0\n while i < len(nums1) and nums2:\n num = nums1[i]\n num2 = nums2[0]\n\n if num2 < num:\n nums1.insert(i, num2)\n nums2.pop(0)\n i += 1\n\n if i >= len(nums1) and nums2 is not None:\n nums1[len(nums1) - offset:] = nums2\n while len(nums1) > m + n:\n nums1.pop()","def fillup_x(self):\n assert not np.all(self.x == None)\n x_df = pd.DataFrame(self.x, columns=self.x_title)\n self.df = pd.concat([self.df, x_df], axis=1)","def add_data_from_columns_into_rows(columns: list, fixed_rows: list):\n for column in range(len(max(columns))):\n for row in range(len(columns)):\n try:\n fixed_rows[column].append(columns[row][column])\n except IndexError:\n fixed_rows[column].append('')\n return fixed_rows","def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n j = 0\n i = 0\n while i < m:\n if j >= n:\n break\n if nums1[i] == 0 and i >= m:\n \n nums1[i:] = nums2[j:]\n break\n else:\n if nums1[i] < nums2[j]:\n i+= 1\n else:\n\n nums1[i:] = [nums2[j]]+nums1[i:-1]\n j+=1\n i+=1\n m+=1","def _add_column(self, column):\n if column is None:\n column = len(self._columns)\n\n if column in self._columns:\n raise ValueError(f\"Duplicate column name: {column}\")\n\n if isinstance(column, int):\n assert column >= len(self._columns)\n for empty in range(len(self._columns), column):\n self._add_column(empty)\n\n self._columns.append(column)\n for idx in self.index:\n row = self._data[idx]\n row.append(None)\n\n return len(self._columns) - 1","def merge(line):\n # replace with your code from the previous mini-project\n l = len(line)\n s1 = [0]*l\n j = 0\n for i in range(l):\n if line[i] != 0:\n s1[j] = line[i]\n j += 1\n\n for k in range(l-1):\n if s1[k] == s1[k+1]:\n s1[k] *=2\n s1.pop(k+1)\n s1.append(0)\n\n return s1","def _set_unique_and_null_vals(self):\n self.unique_vals = {}\n \n df_col = self.df[self.col]\n u_vals = pandas.unique( df_col[ df_col.notnull() ] )\n \n for val in u_vals:\n self.unique_vals[val] = np.where( df_col==val)[0]\n \n null_inds = np.where(self.df.isnull()[self.col]) [0]\n if null_inds.size:\n self.unique_vals['NULL__'] = null_inds","def _insert_into_clean(self, entry):\n i = entry.hash\n new_entry = self.table[i]\n while new_entry.key is not None:\n i += self.second_hash(new_entry.key)\n new_entry = self.table[i]\n new_entry.key = entry.key\n new_entry.value = entry.value\n new_entry.hash = entry.hash\n self.used += 1\n self.filled += 1","def fill_inside_of_the_blocks(nonogram, row):\n hints = nonogram.data.get_row_hints(row)\n endings = nonogram.limits.get_row_endings(row)\n origins = nonogram.limits.get_row_origins(row)\n\n sth_changed = False\n\n for i, hint in enumerate(hints):\n cols = range(endings[i] + 1 - hint, origins[i] + hint)\n changed = fill_range_in_row(nonogram, row, cols, 1)\n sth_changed = sth_changed or changed\n\n return sth_changed","def merge(line):\n def combine_alike(line):\n \"\"\"\n Inner function that combines adjacent, equal numbers\n once and replaces the second number with a zero.\n \"\"\"\n for idx in range(len(line)-1):\n if line[idx] == line[idx+1] and line[idx] != 0:\n line[idx] *= 2\n line[idx+1] = 0\n return line\n \n merged = combine_alike([num for num in line if num!= 0])\n result = [num for num in merged if num!= 0]\n return result + [0]*(len(line)-len(result))","def transform(self, X):\n\n X = X.copy()\n\n X[pd.isnull(X)] = self.fill\n\n return np.asarray(X)","def merge(line):\n new_line = [0] * len(line)\n merged = [False] * len(line)\n pos = 0\n for item in line:\n if not item == 0:\n if new_line[pos - 1] == item and merged[pos - 1] == False:\n new_line[pos - 1] = item * 2\n merged[pos - 1] = True\n else:\n new_line[pos] = item\n pos += 1\n return new_line","def setColumnColor(self, column, color = \"CCCCCC\"):\n\n\t\t\t\tfillObject = openpyxl.styles.PatternFill(start_color = color, end_color = color, fill_type = \"solid\")\n\n\t\t\t\tfor i, row in enumerate(self.thing.iter_rows(), start = 1):\n\t\t\t\t\tcell = self.getCell(row = i, column = column)\n\t\t\t\t\tcell.fill = fillObject","def reset_to_last2_junction(self):\n del self._junction_index[-1]\n del self._dead_end_direction[-1]\n self.reset_to_last_junction()","def set_column(self, column, values):\n values = to_list(values, size=self.size)\n\n if len(values) != self.size:\n raise ValueError(\n f\"Values length ({len(values)}) should match data length ({self.size})\"\n )\n\n if column not in self._columns:\n self._add_column(column)\n\n for index in self.index:\n self.set_cell(index, column, values[index])","def filling_nan_values(df: pd.DataFrame) -> pd.DataFrame: \n ratio = df.count()/len(df) \n cols = ratio[ratio < 1].index\n for col in cols: \n print(f\"Filling Column:{col}\")\n df[col] = df[col].fillna(df[col].mean())\n return df","def merge_columns(self_columns, other_columns):\n sorted_self_columns, sorted_other_columns = sorted(self_columns), sorted(other_columns)\n self_idx = other_idx = 0\n self_len, other_len = len(self_columns), len(other_columns)\n while self_idx < self_len and other_idx < other_len:\n curr_self_column, curr_other_column = sorted_self_columns[self_idx], sorted_other_columns[other_idx]\n if curr_self_column == curr_other_column:\n yield curr_self_column, curr_other_column\n self_idx += 1\n other_idx += 1\n elif curr_self_column < curr_other_column:\n yield curr_self_column, None\n self_idx += 1\n else:\n yield None, curr_other_column\n other_idx += 1\n while self_idx < self_len:\n yield sorted_self_columns[self_idx], None\n self_idx += 1\n while other_idx < other_len:\n yield None, sorted_other_columns[other_idx]\n other_idx += 1","def merge(nums1, m, nums2, n):\r\n while len(nums1) != m and nums1[len(nums1)-1] == 0:\r\n nums1.pop()\r\n for each in nums2:\r\n nums1.append(each)\r\n nums1.sort()"],"string":"[\n \"def _fill_col1_val_where_col2_notna(col1, col2, val):\\n fill_ser = col1.copy()\\n fill_ser[col2.notna()] = val\\n return col1.fillna(fill_ser)\",\n \"def fill_col(col, x):\\n col.append(x)\\n return col\",\n \"def merge(line):\\n #Step1. Putting 0 to the end of the list.\\n result = []\\n for cell in line:\\n if cell != 0:\\n result.append(cell)\\n for cell in range(line.count(0)):\\n result.append(0)\\n #Step2. Replaced with a tile of twice the value and a zero tile\\n for cell in range(len(result)-1):\\n if result[cell] == result[cell+1] and len(result) != 1:\\n result[cell] += result[cell]\\n result[cell+1] = 0\\n #Step3. Repeat step1\\n final_result = []\\n for cell in result:\\n if cell != 0:\\n final_result.append(cell)\\n for cell in range(result.count(0)):\\n final_result.append(0)\\n return final_result\",\n \"def fill_cells_to_the_right(nonogram, row, col):\\n sth_changed = False\\n\\n # leeway stores a number of fillable cells to the left\\n # -1 at the end returns length of line, when there is no true empty cell\\n left_cells = nonogram.data.get_row(row)[:col]\\n leeway = (left_cells[::-1]+[-1]).index(-1)\\n\\n block_length = find_min_block_length(nonogram, row, col)\\n\\n # filling cells enforced by minimal block length\\n for position in range(col + 1, col + block_length - leeway):\\n nonogram.fill_cell(row, position, 1)\\n sth_changed = True\\n\\n return sth_changed\",\n \"def modify_d2(d1, d2):\\n val_list = [i for i in d2.keys()]\\n \\n for key in val_list:\\n for i in range(len(d2[key])):\\n try:\\n val = d1[d2[key][i][2]]\\n d2[key][i][2] = val\\n if None in d2[key][i]:\\n d2[key][i].remove(None)\\n except:\\n pass\\n return d2\",\n \"def fill_cells_to_the_left(nonogram, row, col):\\n sth_changed = False\\n\\n # leeway stores a number of fillable cells to the right\\n # -1 at the end returns length of line, when there is no true empty cell\\n right_cells = nonogram.data.get_row(row)[col+1:]\\n leeway = (right_cells + [-1]).index(-1)\\n\\n block_length = find_min_block_length(nonogram, row, col)\\n\\n # filling cells enforced by minimal block length\\n for position in range(col + leeway + 1 - block_length, col):\\n nonogram.fill_cell(row, position, 1)\\n sth_changed = True\\n\\n return sth_changed\",\n \"def normalize(column):\\n value_set = set(column)\\n unique_count = len(value_set)\\n if unique_count == 1:\\n # skip everything in this column. \\n return []\\n elif unique_count == 2:\\n zero = list(value_set)[0]\\n one = list(value_set)[1]\\n normalized_column = []\\n for value in column:\\n normalized_column.append(1 if value == one else 0)\\n return [normalized_column]\\n else: \\n all_values = list(value_set)\\n normalized_column = []\\n\\n # expand into multiple columns \\n for index in range(len(all_values)):\\n normalized_column.append([])\\n\\n for value in column:\\n for index in range(len(all_values)):\\n normalized_column[index].append(1 if value == all_values[index] else 0)\\n \\n return normalized_column\",\n \"def merge(line):\\r\\n # Create a copy of the input list line\\r\\n list_copy=[]\\r\\n #adding the none zero elements of line to list_copy\\r\\n for dummy_i in range(len(line)):\\r\\n if line[dummy_i] != 0:\\r\\n list_copy.append(line[dummy_i])\\r\\n # adding the appropriate number of zeros to match the length of list_copy and line\\r\\n for dummy_j in range(len(list_copy),len(line)):\\r\\n list_copy.append(0)\\r\\n \\r\\n # merging the tiles that have the same value\\r\\n for dummy_k in range(len(list_copy)-1):\\r\\n # checking for equal values of the adjacent tiles \\r\\n if list_copy[dummy_k]!=0 and list_copy[dummy_k]==list_copy[dummy_k+1]:\\r\\n # if equal double the value of the first tile and assign zero to second tile\\r\\n list_copy[dummy_k]=2*list_copy[dummy_k]\\r\\n list_copy[dummy_k+1]=0\\r\\n \\r\\n #shifting the rest of the values ot the tiles by one place\\r\\n for dummy_p in range(dummy_k+1,len(list_copy)-1):\\r\\n list_copy[dummy_p]=list_copy[dummy_p+1]\\r\\n if (len(line)>3):\\r\\n list_copy[-2]=list_copy[-1]\\r\\n list_copy[-1]=0\\r\\n # returning list_copy which is the answer\\r\\n return list_copy\",\n \"def fill_hom(patient, gene):\\n\\n first = 'HR_' + patient + '_First_' + gene + '_Split'\\n second = 'HR_' + patient + '_Second_' + gene + '_Split'\\n\\n for column in data.columns:\\n f = re.match(second, column)\\n if f:\\n data[second] = data[second].fillna(data[first])\\n else:\\n pass\",\n \"def fill_data(column, data):\\n data[column].fillna(data[column].value_counts().index[0], inplace=True)\",\n \"def backfill(arr, arr1):\\n \\n arr = np.where(arr < 0.01, np.NaN, arr)\\n # FIXME:\\n # RuntimeWarning: invalid value encountered in less\\n # arr = np.where(arr < 0.01, np.NaN, arr)\\n\\n x = np.isnan(arr1)\\n arr1[x] = arr[x]\\n return arr1\",\n \"def _update_context_no_unique_values(metadata, column, unique_values):\\r\\n\\r\\n return None\",\n \"def merge(line):\\n line2=[]\\n line3=[]\\n line4=[]\\n pair=0\\n shift=0\\n line1=[0]*len(line)\\n if(len(line)==1):\\n for iota in line:\\n line1[0]=iota\\n return line1\\n \\n for iota in xrange(len(line)):\\n line4.append(line[iota])\\n \\n for iota in xrange(len(line)):\\n line3.append(line[iota])\\n \\n \\n \\n for xinn in xrange(len(line3)):\\n for iota in xrange(len(line3)-1):\\n if(line3[iota]==0):\\n if((line3[iota+1])>0):\\n temp=line3[iota];\\n line3[iota]=line3[iota+1];\\n line3[iota+1]=temp\\n shift=1\\n xinn=xinn+1\\n \\n \\n if(shift==1):\\n for iota in xrange(len(line3)):\\n line2.append(line3[iota])\\n else:\\n for iota in xrange(len(line4)):\\n line2.append(line4[iota])\\n \\n \\n \\n \\n \\n \\n \\n for olay in range(len(line2)-1):\\n \\n \\n if(line2[olay]==line2[olay+1]):\\n line1[olay]=2*line2[olay];\\n line2[olay+1]=0\\n line1[olay+1]=line2[olay+1]\\n pair=1;\\n olay=olay+2\\n else:\\n line1[olay]=line2[olay]\\n line1[olay+1]=line2[olay+1]\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n if(pair==0):\\n for lonn in xrange(len(line3)):\\n line1[lonn]=line3[lonn]\\n return line1\\n \\n \\n \\n for xinn in xrange(len(line1)):\\n for iota in xrange(len(line1)-1):\\n if(line1[iota]==0):\\n if((line1[iota+1])>0):\\n temp=line1[iota];\\n line1[iota]=line1[iota+1];\\n line1[iota+1]=temp\\n \\n xinn=xinn+1\\n \\n return line1\",\n \"def switchColumn(data_file, column1, column2):\\n\\tdata = []\\n\\tfor dataLine in readData(data_file):\\n\\t\\ttmp = dataLine[column1-1]\\n\\t\\tdataLine[column1-1] = dataLine[column2-1]\\n\\t\\tdataLine[column2-1] = tmp\\n\\t\\tdata.append(dataLine)\\n\\twriteData(data_file, data)\",\n \"def fillna(df, col: str, forward: bool):\\n na_prev = len(df)\\n report = f'fillna(\\\"{col}\\\") ' + ('forward' if forward else 'backward') + ' NA count:'\\n while True:\\n na = df[col].isna().sum()\\n report += f' {na}'\\n if na == na_prev or na == 0: break\\n na_prev = na\\n # df must to be sorted by (ABI, YEAR)\\n df.loc[df[col].isna(), col] = df.groupby('ABI')[col].shift(1 if forward else -1)\",\n \"def fillna_negtive1(df, target=None):\\n if not target:\\n target = ['price', 'image_top_1']\\n for col in target:\\n df[col] = df[col].fillna(-1)\\n return None\",\n \"def _exch(self, ix_1, ix_2):\\n tmp = self._vals[ix_1]\\n self._vals[ix_1] = self._vals[ix_2]\\n self._vals[ix_2] = tmp\",\n \"def addColumnValues(self, column):\\n nr1 = self.data.shape[1]\\n nr = len(column)\\n if nr1 == 0:\\n # case 1: empty table\\n if nr == 0:\\n # case 1a: we're just adding a name\\n self.data = numpy.reshape(self.data, (1, 0))\\n pass\\n else:\\n # case 1b: we're adding a column of values\\n self.data = numpy.reshape(numpy.array(column), (1, nr))\\n pass\\n pass\\n else:\\n # case 2: non-empty table\\n if nr1 > 0 and nr != nr1:\\n raise Exception(\\\"New column must have the same length as existing ones %s %s\\\"%(nr1,nr))\\n new_column = numpy.reshape(numpy.array(column), (1, nr))\\n self.data = numpy.concatenate((self.data, new_column))\\n pass\\n return\",\n \"def _merge_row(self, row1, row2):\\n\\n duprow = list(row1)\\n duprow.extend(list(row2))\\n row1.clear()\\n overlap_map = {}\\n\\n for body, overlap in duprow:\\n if body not in overlap_map:\\n overlap_map[body] = 0\\n overlap_map[body] += overlap\\n\\n for body, overlap in overlap_map.items():\\n row1.add((body, overlap))\",\n \"def fill_forward(df):\\n df = df.fillna(method='ffill')\\n df = df.fillna(method='bfill').fillna(0)\\n return df\",\n \"def assemble_col(c1, c2):\\n c1.extend(c2)\\n return c1\",\n \"def fill_row(row, x):\\n row.append(x)\\n return row\",\n \"def merge(line):\\r\\n setup_line = line[:]\\r\\n new_line = []\\r\\n for num in setup_line:\\r\\n if num == 0:\\r\\n setup_line.remove(0)\\r\\n setup_line.append(0)\\r\\n \\r\\n setup_line.append(0)\\r\\n setup_line.append(0)\\r\\n setup_line.append(0)\\r\\n setup_line.append(0)\\r\\n \\r\\n for itr in range(len(line)):\\r\\n if setup_line[0] == setup_line[1] and setup_line[0] != 0:\\r\\n new_line.append(setup_line[0] * 2)\\r\\n setup_line.remove(setup_line[0])\\r\\n setup_line.remove(setup_line[0])\\r\\n else:\\r\\n new_line.append(setup_line[0])\\r\\n setup_line.remove(setup_line[0])\\r\\n new_line.append(0)\\r\\n \\r\\n for itr in range(len(new_line)):\\r\\n for num in new_line[len(line):]:\\r\\n if num == 0:\\r\\n new_line.remove(0)\\r\\n \\r\\n return new_line\",\n \"def merge(line):\\n lst = [0] * len(line) # we start with a 0-filled list.\\n pos = 0 # index position in the new list\\n pvl = 0 # we keep the previous value\\n for val in line:\\n if val: # we only care about the non zero values.\\n if not pvl: # this tile is empty\\n lst[pos] = val # let's fill with val\\n pvl = val\\n elif pvl - val: # different non zero values?\\n pos += 1\\n lst[pos] = val # tiles don't merge\\n pvl = val\\n else: # same values!\\n lst[pos] <<= 1 # it merges!\\n pos += 1\\n pvl = 0 # next value is 0\\n return lst\",\n \"def merge(line):\\n # replace with your code\\n result = []\\n for index in range(len(line)):\\n result.append(0)\\n result = shift_down(line, result)\\n for index in range(len(result) - 1):\\n if result[index] == result[index + 1]:\\n result[index] *= 2\\n result[index + 1] = 0\\n result = shift_down(result, result)\\n return result\",\n \"def merge_right(row):\\r\\n row1 = reverse(row)\\r\\n row2 = add_tiles(row1)\\r\\n row3 = reverse(row2)\\r\\n row = row3\\r\\n\\r\\n return row\",\n \"def merge(line):\\r\\n origin_len = len(line)\\r\\n new_line = list(line)\\r\\n empty_space = 0\\r\\n # remove zero\\r\\n while empty_space in new_line:\\r\\n new_line.remove(0)\\r\\n # merge\\r\\n tile_cursor = 0\\r\\n for dummy_count in range(len(new_line) - 1):\\r\\n if tile_cursor >= (len(new_line) - 1):\\r\\n break\\r\\n elif new_line[tile_cursor] == new_line[tile_cursor + 1]:\\r\\n new_line[tile_cursor] = 2 * new_line[tile_cursor]\\r\\n new_line[tile_cursor + 1] = 0\\r\\n tile_cursor = tile_cursor + 2\\r\\n else:\\r\\n tile_cursor += 1\\r\\n \\r\\n #remove zero\\r\\n while empty_space in new_line:\\r\\n new_line.remove(0)\\r\\n list_zero = [0] * (origin_len - len(new_line))\\r\\n new_line.extend(list_zero)\\r\\n \\r\\n return new_line\",\n \"def fill_league_currency(self, df, latest_currency_list):\\n league_currency_list = [currency[0] for currency in df.columns]\\n for lastest_currency in latest_currency_list:\\n if lastest_currency not in league_currency_list:\\n df[lastest_currency, df.columns[0][1]] = np.nan\\n df = df.sort_index(axis=1)\\n return df\",\n \"def merge(line):\\n # create a list of non zero values from input\\n input_size = len(line)\\n line = [dummy_value for dummy_value in line if dummy_value > 0]\\n \\n # create an output list of same length as input with zero values\\n line2 = [0] * input_size\\n \\n #update the output list with the non zero input list based on certain conditions\\n line2[0:len(line)] = line\\n \\n pos = [dummy_no for dummy_no in range(0, len(line2))]\\n \\n for jos in pos[0:input_size -1]:\\n if line2[jos] == line2[pos[jos+1]]:\\n line2[jos] = line2[jos] + line2[pos[jos+1]]\\n line2[jos+1] = 0\\n \\n # repeat last two steps above\\n # create an output list of same length as input with zero values\\n line2 = [dummy_val for dummy_val in line2 if dummy_val > 0]\\n \\n # create an output list of same length as input with zero values\\n line3 = [0] * input_size\\n \\n #update the output list with the non zero input list \\n line3[0:len(line2)] = line2\\n \\n return line3\",\n \"def fill_missing_admission_type(df):\\n for admit_type in df[\\\"admission_type\\\"].unique():\\n type_facilities = df[df[\\\"admission_type\\\"] == admit_type][\\\"facility\\\"].unique()\\n\\n df[\\\"admission_type\\\"] = np.where(\\n (df[\\\"admission_type\\\"].isnull() & df[\\\"facility\\\"].isin(type_facilities)),\\n admit_type,\\n df[\\\"admission_type\\\"],\\n )\\n\\n return df\",\n \"def merge(line):\\r\\n result_list = [0] * len(line)\\r\\n medium_list = []\\r\\n zero = 0\\r\\n \\r\\n for non_zero in range(len(line)):\\r\\n if line[non_zero] > 0:\\r\\n medium_list.append(line[non_zero])\\r\\n \\r\\n for position in range(len(medium_list)):\\r\\n result_list.pop(position)\\r\\n result_list.insert(position, medium_list[position])\\r\\n \\r\\n \\r\\n for tile in range(len(result_list)):\\r\\n if tile + 1 > len(result_list) -1:\\r\\n break\\r\\n if result_list[tile] == result_list[tile + 1]:\\r\\n result_list[tile] *= 2\\r\\n result_list[tile+1] = 0\\r\\n \\r\\n \\r\\n while zero in result_list:\\r\\n result_list.remove(zero) \\r\\n \\r\\n \\r\\n while len(result_list) != len(line):\\r\\n result_list.append(zero)\\r\\n \\r\\n \\r\\n return result_list\",\n \"def _rebuild_compareset(self, result, rewrapped_columns, columns):\\n normalize = lambda x: x if (isinstance(x, str) or not x) else tuple(x)\\n rewrapped_columns = normalize(rewrapped_columns)\\n columns = normalize(columns)\\n\\n if rewrapped_columns == columns:\\n return result # <- EXIT!\\n\\n missing = self._missing\\n def rebuild(x):\\n lookup_dict = dict(zip(rewrapped_columns, x))\\n return tuple(lookup_dict.get(c, missing) for c in columns)\\n return CompareSet(rebuild(x) for x in result)\",\n \"def merge(self, nums1, m, nums2, n):\\n nums1.extend([0]*n)\\n j=0\\n for i in range(len(nums1)):\\n if nums2[j]<nums1[i]:\\n nums1.remove(0)\\n nums1.insert(i,nums2[j])\\n j=j+1\",\n \"def expand_df(df, column):\\n expanded2 = pd.DataFrame({\\n col: np.repeat(df[col].values, df[column].str.len())\\n for col in df.columns.drop(column)}\\n ).assign(**{column: list(np.concatenate(df[column].values))})\\n return expanded2\",\n \"def right_to_left(data, key, col_tuple, col_tuples, re_tuples,\\n re_triple, cnt):\\n first_col = col_tuples[0]\\n second_col = col_tuples[1]\\n if col_tuple == first_col or col_tuple == second_col:\\n if col_tuple == first_col:\\n data[\\\"tmp_0\\\"] = data[col_tuple[1]].astype(str).str.extract(re_triple[cnt][0].format(key),\\n expand=True)\\n else:\\n data[\\\"tmp_0\\\"] = data[col_tuple[1]].astype(str).str.extract(re_triple[cnt][0],\\n expand=True)\\n data[\\\"tmp_1\\\"] = data[\\\"tmp_0\\\"].str.extract(re_triple[cnt][1],\\n expand=True)\\n if col_tuple == first_col:\\n regex = re_triple[cnt][2].format(key)\\n data[\\\"tmp_0\\\"] = data[\\\"tmp_0\\\"].str.extract(regex, expand=True)\\n else:\\n regex = re_triple[cnt][2]\\n data[\\\"tmp_0\\\"] = data[\\\"tmp_0\\\"].str.extract(regex, expand=True)\\n tmp_0_clean = data[\\\"tmp_0\\\"].str.strip()\\n data[col_tuple[0]] = data[col_tuple[0]].fillna(tmp_0_clean)\\n if col_tuple == first_col:\\n data[col_tuple[1]] = data[col_tuple[1]].replace(re_triple[cnt][0].format(key),\\n np.NaN, regex=True)\\n else:\\n data[col_tuple[1]] = data[col_tuple[1]].replace(re_triple[cnt][0][:-15]+\\\")\\\",\\n np.NaN, regex=True)\\n data[col_tuple[1]] = data[col_tuple[1]].replace(re_triple[cnt][0],\\n np.NaN, regex=True)\\n tmp_1_clean = data[\\\"tmp_1\\\"].str.strip()\\n data[col_tuple[1]] = data[col_tuple[1]].fillna(tmp_1_clean)\\n data = data.drop(columns=\\\"tmp_0\\\")\\n data = data.drop(columns=\\\"tmp_1\\\")\\n return data\",\n \"def map (a_data,a_column,a_old,a_new) :\\n loc_new_data = a_data\\n a_data[a_column].replace(a_old,a_new,inplace=True)\",\n \"def fix_null_vals(dataset):\\n\\tprint(\\\"\\\\tFixing null values\\\")\\n\\n\\tif not dataset.isnull().any().any():\\n\\t\\treturn dataset\\n\\telse:\\n\\t\\treturn dataset.fillna(method=\\\"ffill\\\")\",\n \"def combine_columns(allowed_columns):\\n\\n v_columns = [v for v in allowed_columns if v in df.columns]\\n v_columns.sort()\\n for i in range(1, len(v_columns)):\\n df[v_columns[0]] = df[v_columns[0]].fillna(df[v_columns[i]])\\n df.drop(v_columns[i], 1, inplace=True)\\n return v_columns[0]\",\n \"def merge(self, nums1, m, nums2, n):\\n n=len(nums1)\\n j=0\\n for i in range(n):\\n if nums2[j]<nums1[i] and nums2[j]<len(nums2):\\n nums1.remove(0)\\n nums1.insert(i,nums2[j])\\n j=j+1\\n if nums1[i]==0 and nums2[j]<len(nums2):\\n nums1[i]=nums2[j]\",\n \"def fill_end_of_the_row(nono, row):\\n ending = nono.limits.get_row_endings(row, -1)\\n sth_changed = fill_range_in_row(nono, row,\\n range(ending + 1, nono.meta_data.n_cols),\\n -1)\\n return sth_changed\",\n \"def _propagate_duplicate_cols(self, duplicate_cols):\\n for duplicate in duplicate_cols:\\n no_suffix = \\\"_\\\".join(duplicate.split(\\\"_\\\")[:-1])\\n null_idx = self._hybrid_meta[no_suffix].isnull()\\n non_null_vals = self._hybrid_meta.loc[null_idx, duplicate].values\\n self._hybrid_meta.loc[null_idx, no_suffix] = non_null_vals\",\n \"def merge(line):\\n result = [0 for idx in range(len(line))]\\n count = 0\\n # push all non-zero values to the left of the tile\\n for num in line:\\n if num != 0:\\n result[count] = num\\n count += 1\\n # merge adjacent values only once left to right\\n for idx in range(len(list(result))-1):\\n if result[idx] == result[idx+1]:\\n result[idx] = result[idx] + result[idx+1]\\n result.pop(idx+1)\\n result.append(0)\\n return result\",\n \"def map_value(self, df, from_column, to_column, value = None,\\n values_map_column = None, values_map = None):\\n if from_column not in df.columns:\\n return df\\n\\n if value:\\n df[to_column] = np.where(df[from_column].notnull(), value, None)\\n elif values_map_column and values_map:\\n #add unit value regardless if there is a measure value\\n df[to_column] = df[values_map_column].map(values_map)\\n #reset all unit values where there's no corresponding measure\\n df[to_column] = df[to_column].mask(df[from_column].isnull(), None)\\n\\n return df\",\n \"def _prepare_data_to_aug(\\n self, col: pd.Series, freq=0.2\\n ) -> Tuple[pd.Series, pd.Series]:\",\n \"def reduce_possibilities_by_column(self):\\n y = self.targetCell.y\\n for i in range(1,10): #content\\n for n in range(9): #x-coord adjacent cells\\n neighbour_cell = self.puzzleGrid.grid[n][y]\\n if self.targetCell != neighbour_cell:\\n self.targetCell.column_neighbour_possibilities.append( neighbour_cell.possibilities)\\n if str(i) == neighbour_cell.finalNumber:\\n self.RemovePossiblityFromTargetCell(i)\\n self.targetCell.column_neighbour_possibilities = flatten_list(self.targetCell.column_neighbour_possibilities)\",\n \"def acumula_x2(self, x2, rodada):\\n self.x2[rodada].append(x2)\",\n \"def fill_with_mode(filename, column):\\r\\n df=None\\r\\n df=pd.read_csv(filename)\\r\\n df[column].fillna(df[column].mode()[0], inplace=True)\\r\\n return df\",\n \"def concat(column_based_table_1: dict[str, list[str]], column_based_table_2: dict[str, list[str]]) -> dict[str, list[str]]:\\n combined_data_table: dict[str, list[str]] = {}\\n for column in column_based_table_1:\\n combined_data_table[column] = column_based_table_1[column]\\n keys_list = list(combined_data_table.keys())\\n for column in column_based_table_2:\\n if column in keys_list:\\n column_data = combined_data_table[column]\\n column_data_2 = column_based_table_2[column]\\n # append to list\\n for item in column_data_2:\\n column_data.append(item)\\n combined_data_table[column] = column_data\\n else:\\n combined_data_table[column] = column_based_table_2[column]\\n return combined_data_table\",\n \"def merge(line):\\n length = len(line)\\n merge_line = [element for element in line if element != 0]\\n \\n for index in range(0, len(merge_line)-1):\\n if merge_line[index] == merge_line[index+1]:\\n merge_line[index] *= 2\\n merge_line[index+1] = 0\\n merge_line = [element for element in merge_line if element != 0]\\n while len(merge_line) != length:\\n merge_line.append(0)\\n \\n return merge_line\",\n \"def ffill(data):\\n last = data[0]\\n new = []\\n for line in data:\\n if line:\\n new.append(line)\\n last = line\\n else:\\n new.append(last)\\n return new\",\n \"def fill_beggining_of_the_row(nonogram, row):\\n origin = nonogram.limits.get_row_origins(row, 0)\\n sth_changed = fill_range_in_row(nonogram, row, range(origin), -1)\\n return sth_changed\",\n \"def fill(self, value):\\n if self.fragmented:\\n (self[self._begin:].view(ndarray)).fill(value)\\n (self[:self._end].view(ndarray)).fill(value)\\n else:\\n if self._begin < self._end:\\n part = self[self._begin:self._end]\\n elif self._end == 0:\\n part = self[self._begin:]\\n\\n (part.view(ndarray)).fill(value)\",\n \"def augment_column(self, col: pd.Series,) -> pd.Series:\",\n \"def merge(self, nums1, m, nums2, n):\\n nums1.extend([0]*len(nums2))\\n j=0\\n for i in range(len(nums2)):\\n if nums2[i]<nums1[j]:\\n nums1.pop()\\n print(nums1)\\n nums1.insert(j,nums2[i])\\n j=j+1\",\n \"def fix_values(df, col):\\n broken_values = [value for value in df[col]]\\n fixed_values = []\\n for value in broken_values:\\n fixed_values.append(int(value.replace(',','')\\n .replace('$','')))\\n df[col] = fixed_values\",\n \"def fill_range_in_row(nonogram, row, cols, value):\\n sth_changed = False\\n\\n for col in cols:\\n change = nonogram.fill_cell(row, col, value)\\n sth_changed = sth_changed or change\\n\\n return sth_changed\",\n \"def fill(self, recoValue, l1Value, weight=1.):\\n self._total.fill(recoValue, weight)\\n self._dist.fill(l1Value, weight)\\n if l1Value > self._threshold:\\n self._pass.fill(recoValue, weight)\",\n \"def island_fill(i: int, j: int, islandMatrix: List[List[int]]) -> List[List[int]]:\\n q = [(i, j)]\\n while q:\\n element = q.pop()\\n if islandMatrix[element[0]][element[1]] == 1:\\n for e in neighbourhood(element[0], element[1], islandMatrix):\\n q.append(e)\\n islandMatrix[element[0]][element[1]] = 2\\n return islandMatrix\",\n \"def merge(self, nums1, m, nums2, n):\\n n0=len(nums1)-n\\n j=0\\n for i in range(n0):\\n while nums2[j]<nums1[i]:\\n nums1.remove(0)\\n nums1.insert(i,nums2[j])\\n j=j+1\",\n \"def _switch_column_values(self, row, column_target):\\n cols = row.index.tolist()\\n column_target_index = cols.index(column_target)\\n\\n if column_target_index == 0:\\n column_source_index = 1\\n elif column_target_index == len(cols) - 1:\\n column_source_index = column_target_index - 1\\n else:\\n column_source_index = column_target_index - 1\\n\\n column_source = cols[column_source_index]\\n replace_value = row[column_source]\\n if self.log:\\n print(\\\">>> Replacing values between {}: {} and {}: {}\\\".format(column_target, row[column_target]\\n , column_source, replace_value))\\n row[column_source] = row[column_target]\\n row[column_target] = replace_value\\n return row\",\n \"def DealWithMissingValues(data_set: pd.DataFrame):\\n data_set.fillna(method=\\\"pad\\\", inplace=True)\",\n \"def set_cell_by_index(self, column_index, cell):\\n while len(self) <= column_index:\\n self.append(None)\\n self[column_index] = cell\",\n \"def fill_between_the_blocks(nonogram, row):\\n hints = nonogram.data.get_row_hints(row)\\n endings = nonogram.limits.get_row_endings(row)\\n origins = nonogram.limits.get_row_origins(row)\\n\\n sth_changed = False\\n\\n for i in range(len(hints) - 1):\\n cols = range(endings[i] + 1, origins[i+1])\\n changed = fill_range_in_row(nonogram, row, cols, -1)\\n sth_changed = sth_changed or changed\\n\\n return sth_changed\",\n \"def fill_valid2(df):\\n for idx, row in df.iterrows():\\n if pd.isnull(row['cid']) &\\n (pd.isnull(row['byr']) |\\n pd.isnull(row['iyr']) |\\n pd.isnull(row['hgt']) |\\n pd.isnull(row['hcl']) |\\n pd.isnull(row['ecl']) |\\n pd.isnull(row['pid']) |\\n pd.isnull(row['hgt'])):\\n df['valid'][idx] = 0\",\n \"def generate_column(values, previous_table):\\n\\n # result = []\\n\\n for i in range(0, len(previous_table)):\\n # current_item = previous_table[i] + values[i]\\n # result.append(current_item)\\n values[i][0:0] = previous_table[i]\\n\\n # return result\\n print \\\"Column(s) attached to result\\\"\\n return values\",\n \"def merge(self, nums1, m, nums2, n):\\n n0=len(nums1)-n\\n j=0\\n for i in range(n0):\\n if nums2[j]<nums1[i]:\\n nums1.remove(0)\\n nums1.insert(i,nums2[j])\\n j=j+1\",\n \"def fill_missing(self):\\n df = self.df\\n # Filling with default values\\n logger.debug(\\\"Filling from distributions...\\\")\\n for field in HeatStrokeDataFiller.default_map or field in HeatStrokeDataFiller.positive_default:\\n if field not in df.columns:\\n logger.warning(\\\"(%s) missing from data-frame columns\\\" % field)\\n continue\\n logger.debug(\\\"Setting missing in \\\\\\\"%s\\\\\\\" to default: %s\\\" % (field, HeatStrokeDataFiller.default_map[field]))\\n default_value = HeatStrokeDataFiller.default_map[field]\\n\\n where = HeatStrokeDataFiller.find_where_missing(df, field, find_nan=True, find_str=False)\\n how_many_to_fill = np.sum(where)\\n if field in HeatStrokeDataFiller.positive_default:\\n # Use default positive dietributions\\n distribution = HeatStrokeDataFiller.positive_default[field]\\n df[field].loc[where] = distribution(how_many_to_fill)\\n else:\\n logger.debug(\\\"Using default %s for field: %s\\\" % (default_value, field))\\n # Use default values\\n df[field].loc[where] = np.array([default_value] * how_many_to_fill)\\n\\n # Filling with Zeros\\n logger.debug(\\\"Fillling with zeros...\\\")\\n for field in HeatStrokeDataFiller.fields_to_fill_with_zero:\\n if field not in df.columns:\\n logger.warning(\\\"\\\\\\\"%s\\\\\\\" missing from columns\\\" % field)\\n continue\\n logger.debug(\\\"Setting missing in \\\\\\\"%s\\\\\\\" to 0\\\" % field)\\n\\n where = HeatStrokeDataFiller.find_where_missing(df, field, find_nan=True, find_str=True)\\n how_many_to_fill = np.sum(where)\\n df[field].loc[where] = np.zeros(how_many_to_fill)\\n\\n # Filling in columns with the average from the rest of the column\\n logger.debug(\\\"Filling with agerages...\\\")\\n for field in HeatStrokeDataFiller.fields_to_fill_with_average:\\n if field not in df.columns:\\n logger.warning(\\\"\\\\\\\"%s\\\\\\\" missing from data-frame columns\\\" % field)\\n continue\\n\\n where = HeatStrokeDataFiller.find_where_missing(df, field, find_nan=True, find_str=True)\\n data = df[field][np.invert(where)]\\n mean = np.mean(data)\\n std = np.std(data)\\n if mean == np.nan or std == np.nan:\\n mean, std = (0, 0)\\n logger.debug(\\\"Setting missing in \\\\\\\"%s\\\\\\\" with: %.3f +/- %.3f\\\" % (field, mean, std))\\n how_many_to_fill = np.sum(where)\\n df[field].loc[where] = mean + std * np.random.random(how_many_to_fill)\\n\\n fields_not_modified = set(df.columns) - set(HeatStrokeDataFiller.default_map.keys()) - HeatStrokeDataFiller.fields_to_fill_with_zero - HeatStrokeDataFiller.fields_to_fill_with_zero\\n logger.debug(\\\"Fields not modified: %s\\\" % fields_not_modified.__str__())\\n return df\",\n \"def mode_impute(self, column_val):\\n mode = column_val.mode()[0]\\n column_val = column_val.fillna(mode)\\n return column_val\",\n \"def __init__(self, v1, v2):\\n mergedData = []\\n list(map(mergedData.extend, list(zip_longest(v1, v2))))\\n self.data = list(filter(lambda x: x is not None, mergedData))\\n self.index = 0\",\n \"def compress_dups(data, column):\\n idx = defaultdict(list)\\n for row in data:\\n idx[row[column]].append(row)\\n\\n dedup = []\\n\\n for idx_row in sorted(idx.items()):\\n dedup.append(avg_rows(idx_row[1]))\\n return dedup\",\n \"def same_as(self, rows: List[Row], column: Column) -> List[Row]:\\n return_list: List[Row] = []\\n if not rows:\\n return return_list\\n cell_value = rows[0].values[column.name]\\n for table_row in self.table_data:\\n new_cell_value = table_row.values[column.name]\\n if new_cell_value is None or not isinstance(new_cell_value, type(cell_value)):\\n continue\\n if new_cell_value == cell_value:\\n return_list.append(table_row)\\n return return_list\",\n \"def order_links_end_points(in_file,links_columns,links_columns_all_details,out_file):\\n\\n df = pd.read_csv(in_file)#.iloc[:,1:]\\n # links_columns = [41,45,51,55]\\n links_node_swapped_columns = links_columns[math.floor(len(links_columns)/2):] + links_columns[0:math.floor(len(links_columns)/2)]\\n\\n\\n # links_columns_all_details = list(np.arange(41,61))\\n links_node_swapped_columns_all_details = links_columns_all_details[math.floor(len(links_columns_all_details)/2):] + links_columns_all_details[0:math.floor(len(links_columns_all_details)/2)]\\n\\n\\n for ix1, (Index, row1) in tqdm(enumerate(df.iterrows())):\\n for ix2, (Index, row2) in enumerate(df[ix1+1:].iterrows()):\\n\\n\\n if (row1[links_columns].as_matrix() == row2[links_node_swapped_columns].as_matrix()).all():\\n # print('swapping',ix1,ix1 + 1 +ix2)\\n # import ipdb; ipdb.set_trace()\\n # print('Row2',row2)\\n temp = []\\n for i in range(len(links_columns_all_details)):\\n\\n if i < math.floor(len(links_columns_all_details)/2):\\n temp.append(df.iat[ix1 + 1 + ix2, links_columns_all_details[i]])\\n df.iat[ix1 + 1 + ix2, links_columns_all_details[i]] = df.iat[ix1 + 1 + ix2, links_node_swapped_columns_all_details[i]]\\n else:\\n df.iat[ix1 + 1 + ix2, links_columns_all_details[i]] = temp[i - math.floor(len(links_columns_all_details)/2)]\\n\\n # print('swapped',ix1,ix1 + 1 +ix2)\\n # print('Row1', row1,'Row2', row2)\\n # import ipdb; ipdb.set_trace()\\n\\n\\n\\n df.to_csv(out_file, index=False)\\n\\n return df\",\n \"def _apply_array_spatial12_lowfilling(self, h1e: 'Nparray',\\n h2e: 'Nparray') -> 'Nparray':\\n if fqe.settings.use_accelerated_code:\\n return self._apply_array_spatial12_lowfilling_fast(h1e, h2e)\\n else:\\n return self._apply_array_spatial12_lowfilling_python(h1e, h2e)\",\n \"def clean_df(self, df, column_name):\\r\\n \\r\\n df[column_name] = df[column_name].fillna('').str.replace('\\\\n', ' ')\\r\\n return df\",\n \"def appforth(df, line):\\n df.loc[-1]=line\\n df.index = df.index + 1 # shifting index\\n df = df.sort_index() # sorting by index\\n return df\",\n \"def __clean_repeated_columns(self, df, column_type):\\n for column in df.columns:\\n if column_type in column.lower():\\n # Fill main column with data from \\\"prefix + _\\\" type column names.\\n df[column_type[:-1]].fillna(df[column], inplace=True)\\n # Drop the \\\"prefix + _\\\" type column names.\\n df.drop(column, axis=1, inplace=True)\",\n \"def fix_date_year(df, col_1, col_2):\\n\\n for idx, date in enumerate(df[col_1]):\\n year1 = date.year\\n year2 = df.loc[idx, col_2]\\n if np.abs(year1-year2)>95:\\n year1 -=100\\n df.loc[idx, col_1]=df.loc[idx, col_1].replace(year=year1)\\n return df\",\n \"def merge2(self, nums1, m, nums2, n): \\n # 从nums1的第m个数字开始，用nums2的值来替换\\n for i in range(n):\\n nums1[m+i] = nums2[i]\\n nums1.sort()\",\n \"def expand(table):\\n t = []\\n for r in table:\\n for _ in range(r[1]):\\n try:\\n t.append((r[0], r[2]))\\n except IndexError:\\n t.append((r[0], None))\\n return t\",\n \"def merge(line):\\n # Iterate over input and create output with non-zeros slid to the left.\\n slid = []\\n for num in line:\\n if num == 0:\\n continue\\n else:\\n slid.append(num)\\n for dummy_slot in range(len(line) - len(slid)):\\n slid.append(0)\\n\\n # Iterate over slid_left and create output with tile pairs replaced with\\n # a tile of twice the value and a zero tile.\\n paired = []\\n idx = 0\\n while idx < len(slid):\\n if idx == len(slid) - 1:\\n paired.append(slid[idx])\\n idx += 1\\n elif slid[idx] == slid[idx + 1]:\\n paired.append(slid[idx] * 2)\\n paired.append(0)\\n idx += 2\\n else:\\n paired.append(slid[idx])\\n idx += 1\\n \\n # Slide the tiles in paired.\\n merged = []\\n for num in paired:\\n if num == 0:\\n continue\\n else:\\n merged.append(num)\\n for dummy_slot in range(len(line) - len(merged)):\\n merged.append(0)\\n \\n return merged\",\n \"def zero_one_card(df):\\n unique_values = defaultdict()\\n for col in df.columns:\\n if df[col].nunique() < 2:\\n unique_values[col] = df[col].nunique()\\n if len(unique_values) > 0:\\n printmd(str(\\\"* Columns: *\\\"+', '.join(list(unique_values.keys()))+\\\"* have less than two different values\\\"))\\n for col in unique_values.keys():\\n printmd(str('* *' + col + \\\"* has \\\" + str(df[col].nunique()) + ' differents values :' + str(df[col].unique())))\\n else:\\n printmd(\\\"* No columns have less than 2 different values\\\")\",\n \"def expandFromColumn(inputColumn,replaceList):\\n \\n import pandas as pd\\n import re\\n \\n #necessary, due to escape nonsense\\n inputColumn=inputColumn.replace(regex=True, to_replace='\\\\\\\\\\\\\\\\',value='/')\\n \\n replaceList['changeNum']=0\\n replaceList['changeIndexes']=''\\n\\n for index, row in replaceList.iterrows():\\n curReplaceVal=row[0]\\n currentRegexExpression=re.compile(curReplaceVal)\\n CurrentBoolVec=inputColumn.str.contains(currentRegexExpression,na=False)\\n replaceList['changeIndexes'].iloc[index]=[i for i, x in enumerate(CurrentBoolVec) if x]\\n replaceList['changeNum'].iloc[index]=len(replaceList['changeIndexes'].iloc[index])\\n inputColumn=inputColumn.replace(regex=True, to_replace=currentRegexExpression,value=row[1])\\n return inputColumn, replaceList;\",\n \"def merge(self, nums1, m, nums2, n):\\n offset = len(nums1) - m\\n i = 0\\n while i < len(nums1) and nums2:\\n num = nums1[i]\\n num2 = nums2[0]\\n\\n if num2 < num:\\n nums1.insert(i, num2)\\n nums2.pop(0)\\n i += 1\\n\\n if i >= len(nums1) and nums2 is not None:\\n nums1[len(nums1) - offset:] = nums2\\n while len(nums1) > m + n:\\n nums1.pop()\",\n \"def fillup_x(self):\\n assert not np.all(self.x == None)\\n x_df = pd.DataFrame(self.x, columns=self.x_title)\\n self.df = pd.concat([self.df, x_df], axis=1)\",\n \"def add_data_from_columns_into_rows(columns: list, fixed_rows: list):\\n for column in range(len(max(columns))):\\n for row in range(len(columns)):\\n try:\\n fixed_rows[column].append(columns[row][column])\\n except IndexError:\\n fixed_rows[column].append('')\\n return fixed_rows\",\n \"def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n j = 0\\n i = 0\\n while i < m:\\n if j >= n:\\n break\\n if nums1[i] == 0 and i >= m:\\n \\n nums1[i:] = nums2[j:]\\n break\\n else:\\n if nums1[i] < nums2[j]:\\n i+= 1\\n else:\\n\\n nums1[i:] = [nums2[j]]+nums1[i:-1]\\n j+=1\\n i+=1\\n m+=1\",\n \"def _add_column(self, column):\\n if column is None:\\n column = len(self._columns)\\n\\n if column in self._columns:\\n raise ValueError(f\\\"Duplicate column name: {column}\\\")\\n\\n if isinstance(column, int):\\n assert column >= len(self._columns)\\n for empty in range(len(self._columns), column):\\n self._add_column(empty)\\n\\n self._columns.append(column)\\n for idx in self.index:\\n row = self._data[idx]\\n row.append(None)\\n\\n return len(self._columns) - 1\",\n \"def merge(line):\\n # replace with your code from the previous mini-project\\n l = len(line)\\n s1 = [0]*l\\n j = 0\\n for i in range(l):\\n if line[i] != 0:\\n s1[j] = line[i]\\n j += 1\\n\\n for k in range(l-1):\\n if s1[k] == s1[k+1]:\\n s1[k] *=2\\n s1.pop(k+1)\\n s1.append(0)\\n\\n return s1\",\n \"def _set_unique_and_null_vals(self):\\n self.unique_vals = {}\\n \\n df_col = self.df[self.col]\\n u_vals = pandas.unique( df_col[ df_col.notnull() ] )\\n \\n for val in u_vals:\\n self.unique_vals[val] = np.where( df_col==val)[0]\\n \\n null_inds = np.where(self.df.isnull()[self.col]) [0]\\n if null_inds.size:\\n self.unique_vals['NULL__'] = null_inds\",\n \"def _insert_into_clean(self, entry):\\n i = entry.hash\\n new_entry = self.table[i]\\n while new_entry.key is not None:\\n i += self.second_hash(new_entry.key)\\n new_entry = self.table[i]\\n new_entry.key = entry.key\\n new_entry.value = entry.value\\n new_entry.hash = entry.hash\\n self.used += 1\\n self.filled += 1\",\n \"def fill_inside_of_the_blocks(nonogram, row):\\n hints = nonogram.data.get_row_hints(row)\\n endings = nonogram.limits.get_row_endings(row)\\n origins = nonogram.limits.get_row_origins(row)\\n\\n sth_changed = False\\n\\n for i, hint in enumerate(hints):\\n cols = range(endings[i] + 1 - hint, origins[i] + hint)\\n changed = fill_range_in_row(nonogram, row, cols, 1)\\n sth_changed = sth_changed or changed\\n\\n return sth_changed\",\n \"def merge(line):\\n def combine_alike(line):\\n \\\"\\\"\\\"\\n Inner function that combines adjacent, equal numbers\\n once and replaces the second number with a zero.\\n \\\"\\\"\\\"\\n for idx in range(len(line)-1):\\n if line[idx] == line[idx+1] and line[idx] != 0:\\n line[idx] *= 2\\n line[idx+1] = 0\\n return line\\n \\n merged = combine_alike([num for num in line if num!= 0])\\n result = [num for num in merged if num!= 0]\\n return result + [0]*(len(line)-len(result))\",\n \"def transform(self, X):\\n\\n X = X.copy()\\n\\n X[pd.isnull(X)] = self.fill\\n\\n return np.asarray(X)\",\n \"def merge(line):\\n new_line = [0] * len(line)\\n merged = [False] * len(line)\\n pos = 0\\n for item in line:\\n if not item == 0:\\n if new_line[pos - 1] == item and merged[pos - 1] == False:\\n new_line[pos - 1] = item * 2\\n merged[pos - 1] = True\\n else:\\n new_line[pos] = item\\n pos += 1\\n return new_line\",\n \"def setColumnColor(self, column, color = \\\"CCCCCC\\\"):\\n\\n\\t\\t\\t\\tfillObject = openpyxl.styles.PatternFill(start_color = color, end_color = color, fill_type = \\\"solid\\\")\\n\\n\\t\\t\\t\\tfor i, row in enumerate(self.thing.iter_rows(), start = 1):\\n\\t\\t\\t\\t\\tcell = self.getCell(row = i, column = column)\\n\\t\\t\\t\\t\\tcell.fill = fillObject\",\n \"def reset_to_last2_junction(self):\\n del self._junction_index[-1]\\n del self._dead_end_direction[-1]\\n self.reset_to_last_junction()\",\n \"def set_column(self, column, values):\\n values = to_list(values, size=self.size)\\n\\n if len(values) != self.size:\\n raise ValueError(\\n f\\\"Values length ({len(values)}) should match data length ({self.size})\\\"\\n )\\n\\n if column not in self._columns:\\n self._add_column(column)\\n\\n for index in self.index:\\n self.set_cell(index, column, values[index])\",\n \"def filling_nan_values(df: pd.DataFrame) -> pd.DataFrame: \\n ratio = df.count()/len(df) \\n cols = ratio[ratio < 1].index\\n for col in cols: \\n print(f\\\"Filling Column:{col}\\\")\\n df[col] = df[col].fillna(df[col].mean())\\n return df\",\n \"def merge_columns(self_columns, other_columns):\\n sorted_self_columns, sorted_other_columns = sorted(self_columns), sorted(other_columns)\\n self_idx = other_idx = 0\\n self_len, other_len = len(self_columns), len(other_columns)\\n while self_idx < self_len and other_idx < other_len:\\n curr_self_column, curr_other_column = sorted_self_columns[self_idx], sorted_other_columns[other_idx]\\n if curr_self_column == curr_other_column:\\n yield curr_self_column, curr_other_column\\n self_idx += 1\\n other_idx += 1\\n elif curr_self_column < curr_other_column:\\n yield curr_self_column, None\\n self_idx += 1\\n else:\\n yield None, curr_other_column\\n other_idx += 1\\n while self_idx < self_len:\\n yield sorted_self_columns[self_idx], None\\n self_idx += 1\\n while other_idx < other_len:\\n yield None, sorted_other_columns[other_idx]\\n other_idx += 1\",\n \"def merge(nums1, m, nums2, n):\\r\\n while len(nums1) != m and nums1[len(nums1)-1] == 0:\\r\\n nums1.pop()\\r\\n for each in nums2:\\r\\n nums1.append(each)\\r\\n nums1.sort()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6066896","0.5588243","0.5520393","0.5153865","0.5142474","0.5100762","0.50284475","0.50032073","0.4990765","0.4952544","0.49398243","0.49170038","0.4903504","0.4887256","0.48762384","0.48469424","0.48462567","0.48410118","0.47721502","0.47698507","0.47568175","0.4755987","0.47121626","0.46946415","0.46859962","0.46799126","0.4679654","0.46685728","0.46435165","0.4633871","0.46272057","0.46266726","0.46211508","0.46115947","0.46034238","0.46012294","0.45925233","0.45918795","0.45759243","0.45730543","0.45602632","0.45581284","0.45372522","0.45300347","0.45173723","0.45166117","0.45159134","0.45096081","0.45056036","0.44981644","0.44936815","0.44891027","0.44859755","0.44710147","0.44667777","0.44632152","0.44449374","0.4435677","0.4435338","0.44326308","0.44324198","0.44286332","0.44264585","0.4404352","0.43963972","0.43957728","0.439365","0.43849853","0.43804228","0.43746564","0.4372797","0.43684366","0.4366692","0.43646517","0.43585452","0.43499735","0.43466842","0.43455508","0.43431664","0.4339803","0.43356654","0.4334153","0.43326807","0.4326872","0.43245953","0.43217868","0.4318595","0.43136042","0.43126372","0.43069154","0.43048504","0.42999148","0.42995107","0.4294924","0.42895094","0.42881355","0.42874885","0.4287334","0.42872402","0.42855346"],"string":"[\n \"0.6066896\",\n \"0.5588243\",\n \"0.5520393\",\n \"0.5153865\",\n \"0.5142474\",\n \"0.5100762\",\n \"0.50284475\",\n \"0.50032073\",\n \"0.4990765\",\n \"0.4952544\",\n \"0.49398243\",\n \"0.49170038\",\n \"0.4903504\",\n \"0.4887256\",\n \"0.48762384\",\n \"0.48469424\",\n \"0.48462567\",\n \"0.48410118\",\n \"0.47721502\",\n \"0.47698507\",\n \"0.47568175\",\n \"0.4755987\",\n \"0.47121626\",\n \"0.46946415\",\n \"0.46859962\",\n \"0.46799126\",\n \"0.4679654\",\n \"0.46685728\",\n \"0.46435165\",\n \"0.4633871\",\n \"0.46272057\",\n \"0.46266726\",\n \"0.46211508\",\n \"0.46115947\",\n \"0.46034238\",\n \"0.46012294\",\n \"0.45925233\",\n \"0.45918795\",\n \"0.45759243\",\n \"0.45730543\",\n \"0.45602632\",\n \"0.45581284\",\n \"0.45372522\",\n \"0.45300347\",\n \"0.45173723\",\n \"0.45166117\",\n \"0.45159134\",\n \"0.45096081\",\n \"0.45056036\",\n \"0.44981644\",\n \"0.44936815\",\n \"0.44891027\",\n \"0.44859755\",\n \"0.44710147\",\n \"0.44667777\",\n \"0.44632152\",\n \"0.44449374\",\n \"0.4435677\",\n \"0.4435338\",\n \"0.44326308\",\n \"0.44324198\",\n \"0.44286332\",\n \"0.44264585\",\n \"0.4404352\",\n \"0.43963972\",\n \"0.43957728\",\n \"0.439365\",\n \"0.43849853\",\n \"0.43804228\",\n \"0.43746564\",\n \"0.4372797\",\n \"0.43684366\",\n \"0.4366692\",\n \"0.43646517\",\n \"0.43585452\",\n \"0.43499735\",\n \"0.43466842\",\n \"0.43455508\",\n \"0.43431664\",\n \"0.4339803\",\n \"0.43356654\",\n \"0.4334153\",\n \"0.43326807\",\n \"0.4326872\",\n \"0.43245953\",\n \"0.43217868\",\n \"0.4318595\",\n \"0.43136042\",\n \"0.43126372\",\n \"0.43069154\",\n \"0.43048504\",\n \"0.42999148\",\n \"0.42995107\",\n \"0.4294924\",\n \"0.42895094\",\n \"0.42881355\",\n \"0.42874885\",\n \"0.4287334\",\n \"0.42872402\",\n \"0.42855346\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57042193"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":180,"cells":{"query":{"kind":"string","value":"Returns true if player has 3 of spades in their hand."},"document":{"kind":"string","value":"def has_3_spades(self):\n if Card('3', 'spades') in self.hand:\n return True\n return False"},"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 has_three_of_a_kind(self):\n self.suit_hist()\n for val in self.ranks.values():\n if val >= 3:\n self.rank_per_hand['2'] = \"three of a kind\"\n return True\n return False","def is_three_of_a_kind(hand):\n count = {c:0 for c in cards.keys()}\n for card in hand:\n count[card[0]] += 1\n for c in count:\n if count[c] == 3:\n return (True, cards[c])\n return None","def is_three_of_a_kind(hand):\n\tis_a_three_of_a_kind = False\n\ti = 0\n\twhile i < 13:\n\t\tif hand[i] == 3:\n\t\t\tis_a_three_of_a_kind = True\n\t\ti += 1 \n\t\t\n\thigh_card = 0\n\tj = 0\n\twhile j < 13 and is_a_three_of_a_kind == True:\n\t\tif hand[j] == 3 and j >= high_card:\n\t\t\thigh_card = j\n\t\tj += 1\n\tif is_a_three_of_a_kind:\n\t\treturn True, high_card\n\telse:\n\t\treturn False","def has_pair(self):\n self.suit_hist()\n for val in self.ranks.values():\n if val == 2:\n self.rank_per_hand['0'] = \"pair\"\n return True\n return False","def is_3flush(holecards, flop, required_holecards=2):\n assert 0 <= required_holecards <= 2\n suit1, suit2 = [card.suit for card in holecards]\n hand = tuple(chain(holecards, flop))\n suit_counts = Counter([card.suit for card in hand])\n\n for suit in suit_counts:\n if suit_counts[suit] == 3:\n if required_holecards == 2 and (suit1 == suit2 == suit):\n return True\n elif required_holecards == 1:\n if (suit1 == suit or suit2 == suit):\n return True\n elif required_holecards == 0:\n return True\n return False","def still_in_hand(self):\n return len(self.hand.cards)!=0","def is_full_house(hand):\n count = {c:0 for c in cards.keys()}\n for card in hand:\n count[card[0]] += 1\n for c in count:\n if count[c] != 0 and count[c] != 2 and count[c] != 3:\n return None\n triple = 0\n for k in count:\n if count[k] == 3:\n triple = cards[k]\n return (True, triple)","def has_four_of_a_kind(self):\n self.suit_hist()\n for val in self.ranks.values():\n if val >= 4:\n self.rank_per_hand['6'] = \"four of a kind\"\n return True\n return False","def has_twopair(self):\n count = 0\n self.suit_hist()\n for val in self.ranks.values():\n if val == 2:\n count += 1\n if count >= 2:\n self.rank_per_hand['1'] = \"two pair\"\n return True\n return False","def can_play(self) -> bool:\n purple_card = self.game.board.purple\n return (\n self.game.current_player != self\n and purple_card is not None\n and purple_card.space > len(self.game.board.yellow[self])\n )","def has_cards(self):\n return self.hand.len() > 0","def is_3straight(holecards, flop, required_holecards=2):\n assert 0 <= required_holecards <= 2\n rank1, rank2 = sorted_numerical_ranks(holecards)\n hand = tuple(chain(holecards, flop))\n\n for subseq in rank_subsequences(hand):\n x, y, z = subseq\n if x == y-1 == z-2:\n if x == 1:\n # Special case for Ace playing low, to allow\n # for the `rank in subseq` check to work\n subseq.append(14)\n if required_holecards == 2:\n if rank1 in subseq and rank2 in subseq:\n return True\n elif required_holecards == 1:\n if rank1 in subseq or rank2 in subseq:\n return True\n elif required_holecards == 0:\n return True\n return False","def is_soft_hand(self):\n is_soft = False\n for i in self.cards:\n if i.value == 'ACE':\n is_soft = True\n\n return is_soft","def is_three_channeled(value):\n return len(value) == 3","def has_won(self):\n coders_card = self.get_coders().get_amount()\n if coders_card > 3:\n return True\n else:\n return False","def is_four_of_a_kind(hand):\n count = {c:0 for c in cards.keys()}\n for card in hand:\n count[card[0]] += 1\n for c in count:\n if count[c] == 4:\n return (True, cards[c])\n return None","def flush(hand):\n return len(set([suit for value, suit in hand])) == 1","def hasBlackjack(self):\n return len(self.cards) == 2 and self.getPoints() == 21","def does_player_have_card(self, player, card):\n return card in self.hands[player]","def is_four_of_a_kind(hand):\n\tis_a_four_of_a_kind = False\n\ti = 0\n\twhile i < 13:\n\t\tif hand[i] == 4:\n\t\t\tis_a_four_of_a_kind = True\n\t\ti += 1 \n\t\t\n\thigh_card = 0\n\tj = 0\n\twhile j < 13 and is_a_four_of_a_kind == True:\n\t\tif hand[j] == 4 and j >= high_card:\n\t\t\thigh_card = j\n\t\tj += 1\n\tif is_a_four_of_a_kind:\n\t\treturn True, high_card\n\telse:\n\t\treturn False","def is_blackjack(self):\n if self.hand == 21 and len(list(self)) ==2:\n print '%s = Blackjack'%self\n return True","def is_full_house(hand):\n\tis_a_full_house = False\n\tnum_three_kind = 0\n\tnum_pair = 0\n\ti = 0\n\twhile i < 13:\n\t\tif hand[i] == 3:\n\t\t\tnum_three_kind += 1\n\t\telif hand[i] == 2:\n\t\t\tnum_pair += 1\n\t\ti += 1\n\tif num_three_kind ==1 and num_pair == 1:\n\t\tis_a_full_house = True\n\t\n\thigh_card = 0\n\tj = 0\n\twhile j < 13 and is_a_full_house == True:\n\t\tif (hand[j] == 2 or hand[j] == 3) and j >= high_card:\n\t\t\thigh_card = j\n\t\tj += 1\n\tif is_a_full_house:\n\t\treturn True, high_card\n\telse:\n\t\treturn False","def is_game_win(self):\n return not self.deck and not self.hand","def is_card_playable(self, card):\n color_index = COLOR.index(card[0])\n return len(self.firework[color_index]) == int(card[1]) - 1","def is_straight(hand):\n # same suite\n suite = hand[0][1]\n vals = []\n for c in hand:\n vals.append(cards[c[0]])\n # check if vals are consecutive or not\n if is_contiguous(vals):\n return True\n else:\n return False","def is_pair(hand):\n\tis_a_pair = False\n\ti = 0\n\twhile i < 13:\n\t\tif hand[i] == 2:\n\t\t\tis_a_pair = True\n\t\ti += 1 \n\thigh_card = 0\n\tj = 0\n\twhile j < 13 and is_a_pair == True:\n\t\tif hand[j] == 2 and j >= high_card:\n\t\t\thigh_card = j\n\t\tj += 1\n\tif is_a_pair:\n\t\treturn True, high_card\n\telse:\n\t\treturn False","def make_card_wish(self, symbol, player):\n if player == self.current_player:\n if symbol in \"s c h d\":\n self.wait_for_card_wish = False\n self.card_wished = symbol\n self.choose_next_player()\n return True\n return False","def is_royal_flush(hand):\n\n # same suit\n suite = hand[0][1]\n count = {c:0 for c in cards.keys()}\n for c in hand:\n if suite != c[1]:\n return False\n count[c[0]] += 1\n # all in same suit\n for c in 'T J Q K A'.split():\n if count[c] != 1:\n return False\n return True","def is_straight(hand):\n\ti = 0\n\twhile i < 8:\n\t\tif hand[i] == 1 and hand[i+1] == 1 and hand[i+2] == 1 and hand[i+3] == 1 and hand[i+4] == 1:\n\t\t\treturn True, i + 4\n\t\ti += 1\n\treturn False","def has_fullhouse(self):\n if self.has_pair() & self.has_three_of_a_kind():\n self.rank_per_hand['5'] = \"full house\"\n return True\n return False","def game_over(players):\n active_players = players_with_decks(players)\n if not active_players or len(active_players) == 1:\n return True\n return False","def won_game(self):\n for player in self.players:\n if len(player.cards) == 0:\n\n return True\n return False","def flush_udacity(hand):\n suits = [s for r,s in hand]\n return len(set(suits)) == 1","def is_blackjack(self) -> bool:\n if self.score == 21 and len(self.cards) == 2:\n return True\n else:\n return False","def is_miss_deal(hand: list, mighty: Card) -> bool:\n point_card_count = 0\n for card in hand:\n if card.is_pointcard() and card != mighty:\n point_card_count += 1\n\n if point_card_count <= 1:\n return True\n else:\n return False","def checkPlayerDies(self, player):\n\n listOfSpikesCoordinates = self._get_spikes()\n playerCoordinates = (player.positionRect.x, player.positionRect.y)\n\n if listOfSpikesCoordinates is not None:\n for spike in listOfSpikesCoordinates:\n if playerCoordinates == spike:\n return True","def is_carrying_vespene(self) -> bool:\n return (\n self.has_buff(BuffId.CARRYHARVESTABLEVESPENEGEYSERGAS)\n or self.has_buff(BuffId.CARRYHARVESTABLEVESPENEGEYSERGASPROTOSS)\n or self.has_buff(BuffId.CARRYHARVESTABLEVESPENEGEYSERGASZERG)\n )","def check_color_card(player, color):\n for card in player.cards:\n if card.suit == color:\n return True","def is_bust(self, hand_idx=0):\n if self.player_hand_value(hand_idx) > 21:\n return True\n else:\n return False","def player_hand_contains_suit(self, user_id, suit):\n print \"player_hand_contains_suit(self, user_id, suit) \"\n print \" Checking if player hand contains expected suit: {}\".format(self.bot.leading_suit)\n for user_object in self.bot.current_game.players:\n if user_object.id == user_id:\n card_value = None\n card_suit = None\n for card_obj in user_object.cards_in_hand:\n if len(card_obj) == 2:\n card_value = str(card_obj[0])\n card_suit = card_obj[1]\n else:\n card_value = str(card_obj)\n card_suit = None\n if \"d_\" not in card_value and \"t_\" not in card_value and \"vm_\" not in card_value:\n if card_suit == suit:\n return True\n return False","def is_card_in_other_hands(self, own_hand_index, card):\n for i, hand in enumerate(self.hands):\n if i == own_hand_index:\n continue\n if card in hand:\n return True\n return False","def test_hand_has_three_of_a_kind(hand, card_list, expected):\n hand.add_cards(card_list)\n assert hand.has_three_of_a_kind() == expected","def discarded(self) -> bool:\n return (\n len(self.cards) == 13 - self.game.board.purple.space - self.discard_amount\n )","def is_valid_play(play, curr_trick, hand):\n\tif len(curr_trick) == 0: # Player is lead\n\t\treturn True\n\telse:\n\t\tlead_suit = curr_trick[0][1]\n\t\tplay_suit = play[1]\n\n\t\tif play_suit == lead_suit:\n\t\t\treturn True\n\t\telse:\n\t\t\t# Check remaining cards in hand\n\t\t\tfor card in hand:\n\t\t\t\tsuit = card[1]\n\t\t\t\tif suit == lead_suit:\n\t\t\t\t\treturn False\n\t\t\t# no card in hand matches lead_suit\n\t\t\treturn True","def is_hungry(self) -> bool:\n if self.eat_count <= 3:\n return True\n else:\n return False","def check_cards(self, cards):\n if len(cards) != 3:\n return False\n\n match = 0\n card1 = cards[0][1]\n card2 = cards[1][1]\n card3 = cards[2][1]\n\n match += self.compare_element(card1, card2, card3, 'shape')\n match += self.compare_element(card1, card2, card3, 'colour')\n match += self.compare_element(card1, card2, card3, 'count')\n match += self.compare_element(card1, card2, card3, 'fill')\n\n return match == 4","def has_straight(self):\n res = []\n self.suit_hist()\n for val in self.ranks.keys():\n res.append(val)\n res.sort()\n self.is_sequence(res, 3)","def is_same_sign(self, cards):\n\n jokers = 0\n w_o_jokers = []\n for card in cards:\n if self.num_to_card(int(card)) == 0:\n jokers += 1\n else:\n w_o_jokers.append(int(card))\n\n w_o_jokers = sorted(w_o_jokers)\n print(\"whitout jokers: \", w_o_jokers)\n if w_o_jokers[0] <= 12: # if the cards are CLUBS\n if w_o_jokers[-1] > 12:\n return False\n if w_o_jokers[0] <= 25: # if the cards are DIAMONDS\n if w_o_jokers[-1] > 25:\n return False\n if w_o_jokers[0] <= 38: # HEARTS\n if w_o_jokers[-1] > 38:\n return False\n if w_o_jokers[0] <= 51:\n if w_o_jokers[-1] > 51:\n return False\n return True","def flush(hand):\n checkflush = [s for r, s in hand]\n return checkflush.count(checkflush[1]) == 5","def enough_players():\n return True","def is_round_over(whose_turn,players):\n if ((len(players[whose_turn].hand.cards) == 0) and (players[whose_turn].has_discarded == True)):\n round_over = True\n else:\n round_over = False\n return round_over","def has_won(self):\n return len(self.hand) == 0","def hand_empty(self):\n return len(self.cards) == 0","def is_game_over(self):\n if self.just_cheated_a or self.just_cheated_b:\n return False\n if self.game_stage == 3:\n return (self.die_a.current_value == \"5\" and self.die_b.current_value == \"6\" or\n self.die_a.current_value == \"6\" and self.die_b.current_value == \"5\")\n else:\n return False","def has_flush(self):\n self.suit_hist()\n for val in self.suits.values():\n if val >= 5:\n return True\n return False","def test_shared_cards_len(self):\n self.assertEqual(len(self.hand.sharedCards), 3)","def __suitIsLured(self, suitId, prevRound=0):\n inList = self.currentlyLuredSuits.has_key(suitId)\n if prevRound:\n # only return true if the suit has been lured for at least\n # one entire round\n return inList and self.currentlyLuredSuits[suitId][0] != -1\n return inList","def is_high_card(hand):\n\tis_a_high_card = True\n\ti = 0\n\twhile i < 13:\n\t\tif hand[i] > 1:\n\t\t\tis_high_card = False\n\t\ti += 1\n\t\t\n\thigh_card = 0\n\tj = 0\n\twhile j < 13 and is_a_high_card == True:\n\t\tif hand[j] == 1 and j >= high_card:\n\t\t\thigh_card = j\n\t\tj += 1\n\tif is_a_high_card:\n\t\treturn True, high_card\n\telse:\n\t\treturn False","def issolved(self) -> bool:\n if not self._pile:\n return True\n for c_card in self._pile:\n if not c_card.visible:\n return False\n return True","def has_flush(self):\n self.suit_hist()\n for val in self.suits.values():\n if val >= 5:\n self.rank_per_hand['4'] = \"flush\"\n return True\n return False","def is_suicide(self, stone_color, index):\n cardinal_indices = self.cardinal_indices(index)\n # First check to see if there are any immediate liberties\n for ci in cardinal_indices:\n stone = self.get(ci)\n if stone is None:\n # There is an empty liberty so the move is not suicide\n return False\n # No liberties, so all spaces around the stone are filled\n # Two conditions will save us, an enemy group being captured,\n # or a single friendly group having more than 1 liberty.\n for ci in cardinal_indices:\n stone = self.get(ci)\n # Adjacent group is friendly\n if stone.color == stone_color:\n # And we are not filling its last liberty\n if self.group_liberties(ci) > 1:\n return False\n # Adjacent group is foe\n else:\n # But we *are* filling its last liberty\n if self.group_liberties(ci) == 1:\n return False\n # If none of the above is true, this is an invalid move\n return True","def cardPlayable(self, card):\n return self.field[Suit.toInt(card.getSuit()) - 1] == card.getValue() - 1","def scalene(sides: list) -> bool:\n\n return validate_triangle(sides) and len(set(sides)) == 3","def can_complete_three_in_row(self, row_positions, board):\n\n row = [board.get_piece(row_positions[0][0], row_positions[0][1]), board.get_piece(row_positions[1][0], row_positions[1][1]), board.get_piece(row_positions[2][0], row_positions[2][1])]\n\n if row.count(' ') == 1 and row.count(self._piece) == 2:\n self_winner = row.index(' ')\n else:\n self_winner = -1\n\n\n if row.count(' ') == 1 and row.count(self._piece) == 0:\n opponent_winner = row.index(' ')\n else:\n opponent_winner = -1\n \n return (self_winner, opponent_winner)","def multi_player_support(self, num_of_players):\n if self.screen['columns'] / num_of_players > 40:\n return True\n else:\n return False","def before_first_stich(self):\n return len(self.cards) == 9","def in_suit3(list, list0):\n text = list.replace(\"-\", \"\")\n text0 = list0.replace(\"-\", \"\")\n if (\"-\" in list) and (\"-\" in list0) and (text.isdigit() is True) and (text0.isdigit() is True):\n\n list1 = list.split(\"-\")\n x = int(list1[0])\n suit = set()\n suit.add(x)\n while x < int(list1[len(list1) - 1]):\n x += 1\n suit.add(x)\n suit.add(int(list1[len(list1) - 1]))\n\n list2 = list0.split(\"-\")\n y = int(list2[0])\n suit0 = set()\n suit0.add(y)\n while y < int(list2[len(list2) - 1]):\n y += 1\n suit0.add(y)\n suit0.add(int(list2[len(list2) - 1]))\n temp = [item for item in suit if item in suit0]\n if len(temp) > 0: return True\n\n return False","def is_twenty_four_tone_complete(self):\n pcs = [x / 2.0 for x in range(24)]\n pcs = [int(x) if int(x) == x else x for x in pcs]\n return set(pcs).issubset(set(self._color_dictionary.keys()))","def hitMe(hand, deck):\n if deck.cardsLeft == 0:\n return False\n hand.getCard(deck.drawCard())\n return True","def is_winner(self, player: str) -> bool:\n total_result = self.current_state.hori_result + self.current_state.left_result + self.current_state.right_result\n total_line = len(total_result)\n p1_taken = 0\n p2_taken = 0\n for item in total_result:\n if item == '1':\n p1_taken+=1\n elif item == '2':\n p2_taken += 1\n if player == \"p1\":\n return float(p1_taken) >= total_line/2\n return float(p2_taken) >= total_line/2","def isPlayed(self, item):\n userState = self.userState(item)\n return bool(userState.viewCount > 0) if userState.viewCount else False","def can_play(self, card):\n played_cards = map(lambda x: str(x).lower(), self.played_cards)\n if str(card).lower() in played_cards:\n return False\n if card.prebuild in played_cards:\n return True\n\n for res in card.cost","def third_street ():\r\n global all_hands\r\n global deck\r\n global players\r\n #Set of all cards for third street draw \r\n third_street_draws = random.sample(deck, len(players)*3)\r\n #Remove drawn cards from deck\r\n for card in third_street_draws:\r\n deck.remove(card)\r\n #Deal 1 Card Each Player Until 3, then reveal third street.\r\n for player in players:\r\n hand = []\r\n for i in range(0,3):\r\n hand.append(third_street_draws[player+len(players)*i])\r\n all_hands.append(hand)\r\n if player == you:\r\n print(\"Your hand is: \", str(all_hands[you]))\r\n else:\r\n print(\"Player \", str(player+1), \"'s 3rd Street hand is: \", str(hand[2]))","def check_for_game_won(self):\n all_moscuvites_captured = True\n king_captured = True\n king_escaped = True\n for piece in self.game_pieces:\n if piece.player == 2:\n all_moscuvites_captured = False\n elif piece.player == 3:\n king_captured = False\n king_coords = (piece.x,piece.y)\n escape_coords = [(0, 0), (0, 8),\n (8, 0), (8, 8)]\n if king_coords not in escape_coords:\n king_escaped = False\n if king_captured:\n return 2\n elif king_escaped or all_moscuvites_captured:\n return 1\n else:\n return 0","def playerCanPlay(game, situation, player):\r\n return True","def has_player(self, p: Player) -> bool:\n return p in self.players","def can_split(self) -> bool:\n if len(self.cards) == 2 and self.cards[0].value == self.cards[1].value:\n return True\n else:\n return False","def is_straight_flush(hand):\n # same suite\n suite = hand[0][1]\n vals = []\n for c in hand:\n if suite != c[1]:\n return False\n vals.append(cards[c[0]])\n # check if vals are consecutive or not\n if is_contiguous(vals):\n return (True, max(vals))\n else:\n return False","def play_game(play_shoe, player_list, dealer, number_of_decks):\n # Check if the shoe is still valid (contains a cut card) if not,\n # create a new shoe\n play_shoe = shoe_check(play_shoe, number_of_decks)\n initial_deal(play_shoe, player_list, dealer)\n for player in player_list:\n user_play(play_shoe, player, dealer)\n dealer_play(play_shoe, dealer)\n display_results(check_results(player_list, dealer))\n if play_again():\n return True, play_shoe\n return False","def is_straight_flush(hand):\n\tis_a_local_flush = False\n\tis_a_local_straight = False\n\tlocal_high_card = 0\n\ti = 16\n\twhile i >= 13:\n\t\tif hand[i] == 5:\n\t\t\tis_a_local_flush = True\n\t\ti -= 1\n\tif is_a_local_flush:\n\t\tj = 0\n\t\twhile j < 8:\n\t\t\tif hand[j] == 1 and hand[j + 1] == 1 and hand[j + 2] == 1 and hand[j + 3] == 1 and hand[j + 4] == 1:\n\t\t\t\tis_a_local_straight = True\n\t\t\t\tlocal_high_card = j + 4\n\t\t\tj += 1\n\tif is_a_local_flush and is_a_local_straight:\n\t\treturn True, local_high_card\n\treturn False","def is_valid_deck(deck: List[int]) -> bool:\n check_deck = []\n check_deck.extend(deck)\n check_deck.sort()\n return len(check_deck) >= 3 and \\\n all(isinstance(item, int) for item in check_deck) \\\n and len(check_deck) == check_deck[-1]","def still_playing_game(self):\n for player in self.players:\n if player.is_playing:\n return True\n return False","def has_straight_flush(self):\n res = []\n self.suit_hist()\n for card in self.cards:\n if self.suits[card.suit] >= 5:\n res.append(card.rank)\n self.is_sequence(res, 7)","def been_played(self, word):\n words = self.played_out or ''\n words = words.split(' ')\n\n return True if ((words.count(word) > 0) or \n (words.count( singularize(word) ) > 0) or \n (words.count( pluralize(word) ) > 0)) else False","def has_siete_de_velo(self):\n for card in self._cards[\"oro\"]:\n if card.value == 7:\n return True\n\n return False","def check_hand(self, player):\n\n total = player.score()\n if total > 21:\n status = 'bust'\n elif total == 21:\n status = 'win'\n else:\n status = 'okay'\n\n if self.verbose:\n print(total, 'points')\n \n return status","def is_two_pair(hand):\n\tfaces_of_pairs = []\n\tis_a_two_pair = False\n\ti = 0\n\twhile i < 13:\n\t\tif hand[i] == 2:\n\t\t\tfaces_of_pairs.append(i)\n\t\ti += 1\n\tif len(faces_of_pairs) == 2:\n\t\tis_a_two_pair = True\n\tfor fp in faces_of_pairs:\n\t\tprint(fp)\n\tif is_a_two_pair:\n\t\treturn True, faces_of_pairs[1]\n\telse:\n\t\treturn False","def at_last_stich(self):\n return len(self.cards) == 1","def verify_winner(self):\r\n return self.count_pegs() == 1","def IsItem3State(self, item):\r\n\r\n return item.Is3State()","def is_ok_three_lines(line1, line2, line3):\n card1 = line1[0]\n card2 = line1[1]\n card3 = line1[2]\n card4 = line2[0]\n card5 = line2[1]\n card6 = line2[2]\n\n card7 = line3[0]\n card8 = line3[1]\n card9 = line3[2]\n idents1 = [card.ident for card in line1]\n idents2 = [card.ident for card in line2]\n idents3 = [card.ident for card in line3]\n\n intersection = list(set(idents1) & set(idents2))\n if intersection:\n dprint(\"intersection 12\")\n return False\n\n intersection = list(set(idents1) & set(idents3))\n if intersection:\n return False\n\n intersection = list(set(idents2) & set(idents3))\n if intersection:\n return False\n\n print(\"??????????????\")\n show_triple(line1, line2, line3)\n print(\"??????????????\")\n\n if not is_ok_two_lines(line1, line2):\n return False\n if not is_ok_two_lines(line2, line3):\n return False\n\n return True","def validate_cards(self, cards_list):\n return set(self.hand).issubset(set(cards_list))","def EndHand(redtricks, blacktricks):\r\n if redtricks >= 3 and blacktricks == 1:\r\n return True\r\n elif blacktricks >= 3 and redtricks == 1:\r\n return True\r\n elif (redtricks + blacktricks) == 5:\r\n return True\r\n else:\r\n return False","def player_hit(self):\n self.player.hit(self.deck)\n self.print_hands()\n \n if self.player.sum_cards() > 21:\n self.round_winner = True\n self.print_hands()\n print(\"BUST! Dealer wins.\")","def player_has_won(self):\n return len(self._words_guessed) == self._num_words","def is_horizontal_four(self, row, col):\r\n player = self.board[row][col]\r\n consecutiveL = 0\r\n consecutiveR = 0\r\n # count consecutive left discs\r\n i = col\r\n current = player\r\n while current == player:\r\n consecutiveL += 1\r\n i -= 1\r\n if i < 0:\r\n break\r\n current = self.board[row][i]\r\n\r\n # count consecutive right discs\r\n i = col\r\n current = self.board[row][i]\r\n while current == player:\r\n consecutiveR += 1\r\n i += 1\r\n if i >= 7:\r\n break\r\n current = self.board[row][i]\r\n\r\n # since (row, col) cell was counted twice, we reduce by 1\r\n if consecutiveL + consecutiveR - 1 >= 4:\r\n return True\r\n\r\n return False","def isGameOver(self):\n for i in range(self.rows):\n for j in range(self.columns):\n if self.grid[i][j].face == 'down':\n return False\n #if here then all cards must be face up\n return True","def is_ok_line(line):\n card1 = line[0]\n card2 = line[1]\n card3 = line[2]\n\n if not is_coupled(card1.east, card2.west):\n return False\n if not is_coupled(card2.east, card3.west):\n return False\n return True","def deck_has_cards(deck, cards):\n deck_dict = collections.defaultdict(int)\n for card in itertools.chain(deck.draw_pile, deck.discard_pile, deck.hand):\n deck_dict[card] += 1\n return deck_dict == cards","def check_full_house(dice_list):\n roll_counts = [dice_list.count(value) for value in range(1, 7)]\n return 2 in roll_counts and 3 in roll_counts"],"string":"[\n \"def has_three_of_a_kind(self):\\n self.suit_hist()\\n for val in self.ranks.values():\\n if val >= 3:\\n self.rank_per_hand['2'] = \\\"three of a kind\\\"\\n return True\\n return False\",\n \"def is_three_of_a_kind(hand):\\n count = {c:0 for c in cards.keys()}\\n for card in hand:\\n count[card[0]] += 1\\n for c in count:\\n if count[c] == 3:\\n return (True, cards[c])\\n return None\",\n \"def is_three_of_a_kind(hand):\\n\\tis_a_three_of_a_kind = False\\n\\ti = 0\\n\\twhile i < 13:\\n\\t\\tif hand[i] == 3:\\n\\t\\t\\tis_a_three_of_a_kind = True\\n\\t\\ti += 1 \\n\\t\\t\\n\\thigh_card = 0\\n\\tj = 0\\n\\twhile j < 13 and is_a_three_of_a_kind == True:\\n\\t\\tif hand[j] == 3 and j >= high_card:\\n\\t\\t\\thigh_card = j\\n\\t\\tj += 1\\n\\tif is_a_three_of_a_kind:\\n\\t\\treturn True, high_card\\n\\telse:\\n\\t\\treturn False\",\n \"def has_pair(self):\\n self.suit_hist()\\n for val in self.ranks.values():\\n if val == 2:\\n self.rank_per_hand['0'] = \\\"pair\\\"\\n return True\\n return False\",\n \"def is_3flush(holecards, flop, required_holecards=2):\\n assert 0 <= required_holecards <= 2\\n suit1, suit2 = [card.suit for card in holecards]\\n hand = tuple(chain(holecards, flop))\\n suit_counts = Counter([card.suit for card in hand])\\n\\n for suit in suit_counts:\\n if suit_counts[suit] == 3:\\n if required_holecards == 2 and (suit1 == suit2 == suit):\\n return True\\n elif required_holecards == 1:\\n if (suit1 == suit or suit2 == suit):\\n return True\\n elif required_holecards == 0:\\n return True\\n return False\",\n \"def still_in_hand(self):\\n return len(self.hand.cards)!=0\",\n \"def is_full_house(hand):\\n count = {c:0 for c in cards.keys()}\\n for card in hand:\\n count[card[0]] += 1\\n for c in count:\\n if count[c] != 0 and count[c] != 2 and count[c] != 3:\\n return None\\n triple = 0\\n for k in count:\\n if count[k] == 3:\\n triple = cards[k]\\n return (True, triple)\",\n \"def has_four_of_a_kind(self):\\n self.suit_hist()\\n for val in self.ranks.values():\\n if val >= 4:\\n self.rank_per_hand['6'] = \\\"four of a kind\\\"\\n return True\\n return False\",\n \"def has_twopair(self):\\n count = 0\\n self.suit_hist()\\n for val in self.ranks.values():\\n if val == 2:\\n count += 1\\n if count >= 2:\\n self.rank_per_hand['1'] = \\\"two pair\\\"\\n return True\\n return False\",\n \"def can_play(self) -> bool:\\n purple_card = self.game.board.purple\\n return (\\n self.game.current_player != self\\n and purple_card is not None\\n and purple_card.space > len(self.game.board.yellow[self])\\n )\",\n \"def has_cards(self):\\n return self.hand.len() > 0\",\n \"def is_3straight(holecards, flop, required_holecards=2):\\n assert 0 <= required_holecards <= 2\\n rank1, rank2 = sorted_numerical_ranks(holecards)\\n hand = tuple(chain(holecards, flop))\\n\\n for subseq in rank_subsequences(hand):\\n x, y, z = subseq\\n if x == y-1 == z-2:\\n if x == 1:\\n # Special case for Ace playing low, to allow\\n # for the `rank in subseq` check to work\\n subseq.append(14)\\n if required_holecards == 2:\\n if rank1 in subseq and rank2 in subseq:\\n return True\\n elif required_holecards == 1:\\n if rank1 in subseq or rank2 in subseq:\\n return True\\n elif required_holecards == 0:\\n return True\\n return False\",\n \"def is_soft_hand(self):\\n is_soft = False\\n for i in self.cards:\\n if i.value == 'ACE':\\n is_soft = True\\n\\n return is_soft\",\n \"def is_three_channeled(value):\\n return len(value) == 3\",\n \"def has_won(self):\\n coders_card = self.get_coders().get_amount()\\n if coders_card > 3:\\n return True\\n else:\\n return False\",\n \"def is_four_of_a_kind(hand):\\n count = {c:0 for c in cards.keys()}\\n for card in hand:\\n count[card[0]] += 1\\n for c in count:\\n if count[c] == 4:\\n return (True, cards[c])\\n return None\",\n \"def flush(hand):\\n return len(set([suit for value, suit in hand])) == 1\",\n \"def hasBlackjack(self):\\n return len(self.cards) == 2 and self.getPoints() == 21\",\n \"def does_player_have_card(self, player, card):\\n return card in self.hands[player]\",\n \"def is_four_of_a_kind(hand):\\n\\tis_a_four_of_a_kind = False\\n\\ti = 0\\n\\twhile i < 13:\\n\\t\\tif hand[i] == 4:\\n\\t\\t\\tis_a_four_of_a_kind = True\\n\\t\\ti += 1 \\n\\t\\t\\n\\thigh_card = 0\\n\\tj = 0\\n\\twhile j < 13 and is_a_four_of_a_kind == True:\\n\\t\\tif hand[j] == 4 and j >= high_card:\\n\\t\\t\\thigh_card = j\\n\\t\\tj += 1\\n\\tif is_a_four_of_a_kind:\\n\\t\\treturn True, high_card\\n\\telse:\\n\\t\\treturn False\",\n \"def is_blackjack(self):\\n if self.hand == 21 and len(list(self)) ==2:\\n print '%s = Blackjack'%self\\n return True\",\n \"def is_full_house(hand):\\n\\tis_a_full_house = False\\n\\tnum_three_kind = 0\\n\\tnum_pair = 0\\n\\ti = 0\\n\\twhile i < 13:\\n\\t\\tif hand[i] == 3:\\n\\t\\t\\tnum_three_kind += 1\\n\\t\\telif hand[i] == 2:\\n\\t\\t\\tnum_pair += 1\\n\\t\\ti += 1\\n\\tif num_three_kind ==1 and num_pair == 1:\\n\\t\\tis_a_full_house = True\\n\\t\\n\\thigh_card = 0\\n\\tj = 0\\n\\twhile j < 13 and is_a_full_house == True:\\n\\t\\tif (hand[j] == 2 or hand[j] == 3) and j >= high_card:\\n\\t\\t\\thigh_card = j\\n\\t\\tj += 1\\n\\tif is_a_full_house:\\n\\t\\treturn True, high_card\\n\\telse:\\n\\t\\treturn False\",\n \"def is_game_win(self):\\n return not self.deck and not self.hand\",\n \"def is_card_playable(self, card):\\n color_index = COLOR.index(card[0])\\n return len(self.firework[color_index]) == int(card[1]) - 1\",\n \"def is_straight(hand):\\n # same suite\\n suite = hand[0][1]\\n vals = []\\n for c in hand:\\n vals.append(cards[c[0]])\\n # check if vals are consecutive or not\\n if is_contiguous(vals):\\n return True\\n else:\\n return False\",\n \"def is_pair(hand):\\n\\tis_a_pair = False\\n\\ti = 0\\n\\twhile i < 13:\\n\\t\\tif hand[i] == 2:\\n\\t\\t\\tis_a_pair = True\\n\\t\\ti += 1 \\n\\thigh_card = 0\\n\\tj = 0\\n\\twhile j < 13 and is_a_pair == True:\\n\\t\\tif hand[j] == 2 and j >= high_card:\\n\\t\\t\\thigh_card = j\\n\\t\\tj += 1\\n\\tif is_a_pair:\\n\\t\\treturn True, high_card\\n\\telse:\\n\\t\\treturn False\",\n \"def make_card_wish(self, symbol, player):\\n if player == self.current_player:\\n if symbol in \\\"s c h d\\\":\\n self.wait_for_card_wish = False\\n self.card_wished = symbol\\n self.choose_next_player()\\n return True\\n return False\",\n \"def is_royal_flush(hand):\\n\\n # same suit\\n suite = hand[0][1]\\n count = {c:0 for c in cards.keys()}\\n for c in hand:\\n if suite != c[1]:\\n return False\\n count[c[0]] += 1\\n # all in same suit\\n for c in 'T J Q K A'.split():\\n if count[c] != 1:\\n return False\\n return True\",\n \"def is_straight(hand):\\n\\ti = 0\\n\\twhile i < 8:\\n\\t\\tif hand[i] == 1 and hand[i+1] == 1 and hand[i+2] == 1 and hand[i+3] == 1 and hand[i+4] == 1:\\n\\t\\t\\treturn True, i + 4\\n\\t\\ti += 1\\n\\treturn False\",\n \"def has_fullhouse(self):\\n if self.has_pair() & self.has_three_of_a_kind():\\n self.rank_per_hand['5'] = \\\"full house\\\"\\n return True\\n return False\",\n \"def game_over(players):\\n active_players = players_with_decks(players)\\n if not active_players or len(active_players) == 1:\\n return True\\n return False\",\n \"def won_game(self):\\n for player in self.players:\\n if len(player.cards) == 0:\\n\\n return True\\n return False\",\n \"def flush_udacity(hand):\\n suits = [s for r,s in hand]\\n return len(set(suits)) == 1\",\n \"def is_blackjack(self) -> bool:\\n if self.score == 21 and len(self.cards) == 2:\\n return True\\n else:\\n return False\",\n \"def is_miss_deal(hand: list, mighty: Card) -> bool:\\n point_card_count = 0\\n for card in hand:\\n if card.is_pointcard() and card != mighty:\\n point_card_count += 1\\n\\n if point_card_count <= 1:\\n return True\\n else:\\n return False\",\n \"def checkPlayerDies(self, player):\\n\\n listOfSpikesCoordinates = self._get_spikes()\\n playerCoordinates = (player.positionRect.x, player.positionRect.y)\\n\\n if listOfSpikesCoordinates is not None:\\n for spike in listOfSpikesCoordinates:\\n if playerCoordinates == spike:\\n return True\",\n \"def is_carrying_vespene(self) -> bool:\\n return (\\n self.has_buff(BuffId.CARRYHARVESTABLEVESPENEGEYSERGAS)\\n or self.has_buff(BuffId.CARRYHARVESTABLEVESPENEGEYSERGASPROTOSS)\\n or self.has_buff(BuffId.CARRYHARVESTABLEVESPENEGEYSERGASZERG)\\n )\",\n \"def check_color_card(player, color):\\n for card in player.cards:\\n if card.suit == color:\\n return True\",\n \"def is_bust(self, hand_idx=0):\\n if self.player_hand_value(hand_idx) > 21:\\n return True\\n else:\\n return False\",\n \"def player_hand_contains_suit(self, user_id, suit):\\n print \\\"player_hand_contains_suit(self, user_id, suit) \\\"\\n print \\\" Checking if player hand contains expected suit: {}\\\".format(self.bot.leading_suit)\\n for user_object in self.bot.current_game.players:\\n if user_object.id == user_id:\\n card_value = None\\n card_suit = None\\n for card_obj in user_object.cards_in_hand:\\n if len(card_obj) == 2:\\n card_value = str(card_obj[0])\\n card_suit = card_obj[1]\\n else:\\n card_value = str(card_obj)\\n card_suit = None\\n if \\\"d_\\\" not in card_value and \\\"t_\\\" not in card_value and \\\"vm_\\\" not in card_value:\\n if card_suit == suit:\\n return True\\n return False\",\n \"def is_card_in_other_hands(self, own_hand_index, card):\\n for i, hand in enumerate(self.hands):\\n if i == own_hand_index:\\n continue\\n if card in hand:\\n return True\\n return False\",\n \"def test_hand_has_three_of_a_kind(hand, card_list, expected):\\n hand.add_cards(card_list)\\n assert hand.has_three_of_a_kind() == expected\",\n \"def discarded(self) -> bool:\\n return (\\n len(self.cards) == 13 - self.game.board.purple.space - self.discard_amount\\n )\",\n \"def is_valid_play(play, curr_trick, hand):\\n\\tif len(curr_trick) == 0: # Player is lead\\n\\t\\treturn True\\n\\telse:\\n\\t\\tlead_suit = curr_trick[0][1]\\n\\t\\tplay_suit = play[1]\\n\\n\\t\\tif play_suit == lead_suit:\\n\\t\\t\\treturn True\\n\\t\\telse:\\n\\t\\t\\t# Check remaining cards in hand\\n\\t\\t\\tfor card in hand:\\n\\t\\t\\t\\tsuit = card[1]\\n\\t\\t\\t\\tif suit == lead_suit:\\n\\t\\t\\t\\t\\treturn False\\n\\t\\t\\t# no card in hand matches lead_suit\\n\\t\\t\\treturn True\",\n \"def is_hungry(self) -> bool:\\n if self.eat_count <= 3:\\n return True\\n else:\\n return False\",\n \"def check_cards(self, cards):\\n if len(cards) != 3:\\n return False\\n\\n match = 0\\n card1 = cards[0][1]\\n card2 = cards[1][1]\\n card3 = cards[2][1]\\n\\n match += self.compare_element(card1, card2, card3, 'shape')\\n match += self.compare_element(card1, card2, card3, 'colour')\\n match += self.compare_element(card1, card2, card3, 'count')\\n match += self.compare_element(card1, card2, card3, 'fill')\\n\\n return match == 4\",\n \"def has_straight(self):\\n res = []\\n self.suit_hist()\\n for val in self.ranks.keys():\\n res.append(val)\\n res.sort()\\n self.is_sequence(res, 3)\",\n \"def is_same_sign(self, cards):\\n\\n jokers = 0\\n w_o_jokers = []\\n for card in cards:\\n if self.num_to_card(int(card)) == 0:\\n jokers += 1\\n else:\\n w_o_jokers.append(int(card))\\n\\n w_o_jokers = sorted(w_o_jokers)\\n print(\\\"whitout jokers: \\\", w_o_jokers)\\n if w_o_jokers[0] <= 12: # if the cards are CLUBS\\n if w_o_jokers[-1] > 12:\\n return False\\n if w_o_jokers[0] <= 25: # if the cards are DIAMONDS\\n if w_o_jokers[-1] > 25:\\n return False\\n if w_o_jokers[0] <= 38: # HEARTS\\n if w_o_jokers[-1] > 38:\\n return False\\n if w_o_jokers[0] <= 51:\\n if w_o_jokers[-1] > 51:\\n return False\\n return True\",\n \"def flush(hand):\\n checkflush = [s for r, s in hand]\\n return checkflush.count(checkflush[1]) == 5\",\n \"def enough_players():\\n return True\",\n \"def is_round_over(whose_turn,players):\\n if ((len(players[whose_turn].hand.cards) == 0) and (players[whose_turn].has_discarded == True)):\\n round_over = True\\n else:\\n round_over = False\\n return round_over\",\n \"def has_won(self):\\n return len(self.hand) == 0\",\n \"def hand_empty(self):\\n return len(self.cards) == 0\",\n \"def is_game_over(self):\\n if self.just_cheated_a or self.just_cheated_b:\\n return False\\n if self.game_stage == 3:\\n return (self.die_a.current_value == \\\"5\\\" and self.die_b.current_value == \\\"6\\\" or\\n self.die_a.current_value == \\\"6\\\" and self.die_b.current_value == \\\"5\\\")\\n else:\\n return False\",\n \"def has_flush(self):\\n self.suit_hist()\\n for val in self.suits.values():\\n if val >= 5:\\n return True\\n return False\",\n \"def test_shared_cards_len(self):\\n self.assertEqual(len(self.hand.sharedCards), 3)\",\n \"def __suitIsLured(self, suitId, prevRound=0):\\n inList = self.currentlyLuredSuits.has_key(suitId)\\n if prevRound:\\n # only return true if the suit has been lured for at least\\n # one entire round\\n return inList and self.currentlyLuredSuits[suitId][0] != -1\\n return inList\",\n \"def is_high_card(hand):\\n\\tis_a_high_card = True\\n\\ti = 0\\n\\twhile i < 13:\\n\\t\\tif hand[i] > 1:\\n\\t\\t\\tis_high_card = False\\n\\t\\ti += 1\\n\\t\\t\\n\\thigh_card = 0\\n\\tj = 0\\n\\twhile j < 13 and is_a_high_card == True:\\n\\t\\tif hand[j] == 1 and j >= high_card:\\n\\t\\t\\thigh_card = j\\n\\t\\tj += 1\\n\\tif is_a_high_card:\\n\\t\\treturn True, high_card\\n\\telse:\\n\\t\\treturn False\",\n \"def issolved(self) -> bool:\\n if not self._pile:\\n return True\\n for c_card in self._pile:\\n if not c_card.visible:\\n return False\\n return True\",\n \"def has_flush(self):\\n self.suit_hist()\\n for val in self.suits.values():\\n if val >= 5:\\n self.rank_per_hand['4'] = \\\"flush\\\"\\n return True\\n return False\",\n \"def is_suicide(self, stone_color, index):\\n cardinal_indices = self.cardinal_indices(index)\\n # First check to see if there are any immediate liberties\\n for ci in cardinal_indices:\\n stone = self.get(ci)\\n if stone is None:\\n # There is an empty liberty so the move is not suicide\\n return False\\n # No liberties, so all spaces around the stone are filled\\n # Two conditions will save us, an enemy group being captured,\\n # or a single friendly group having more than 1 liberty.\\n for ci in cardinal_indices:\\n stone = self.get(ci)\\n # Adjacent group is friendly\\n if stone.color == stone_color:\\n # And we are not filling its last liberty\\n if self.group_liberties(ci) > 1:\\n return False\\n # Adjacent group is foe\\n else:\\n # But we *are* filling its last liberty\\n if self.group_liberties(ci) == 1:\\n return False\\n # If none of the above is true, this is an invalid move\\n return True\",\n \"def cardPlayable(self, card):\\n return self.field[Suit.toInt(card.getSuit()) - 1] == card.getValue() - 1\",\n \"def scalene(sides: list) -> bool:\\n\\n return validate_triangle(sides) and len(set(sides)) == 3\",\n \"def can_complete_three_in_row(self, row_positions, board):\\n\\n row = [board.get_piece(row_positions[0][0], row_positions[0][1]), board.get_piece(row_positions[1][0], row_positions[1][1]), board.get_piece(row_positions[2][0], row_positions[2][1])]\\n\\n if row.count(' ') == 1 and row.count(self._piece) == 2:\\n self_winner = row.index(' ')\\n else:\\n self_winner = -1\\n\\n\\n if row.count(' ') == 1 and row.count(self._piece) == 0:\\n opponent_winner = row.index(' ')\\n else:\\n opponent_winner = -1\\n \\n return (self_winner, opponent_winner)\",\n \"def multi_player_support(self, num_of_players):\\n if self.screen['columns'] / num_of_players > 40:\\n return True\\n else:\\n return False\",\n \"def before_first_stich(self):\\n return len(self.cards) == 9\",\n \"def in_suit3(list, list0):\\n text = list.replace(\\\"-\\\", \\\"\\\")\\n text0 = list0.replace(\\\"-\\\", \\\"\\\")\\n if (\\\"-\\\" in list) and (\\\"-\\\" in list0) and (text.isdigit() is True) and (text0.isdigit() is True):\\n\\n list1 = list.split(\\\"-\\\")\\n x = int(list1[0])\\n suit = set()\\n suit.add(x)\\n while x < int(list1[len(list1) - 1]):\\n x += 1\\n suit.add(x)\\n suit.add(int(list1[len(list1) - 1]))\\n\\n list2 = list0.split(\\\"-\\\")\\n y = int(list2[0])\\n suit0 = set()\\n suit0.add(y)\\n while y < int(list2[len(list2) - 1]):\\n y += 1\\n suit0.add(y)\\n suit0.add(int(list2[len(list2) - 1]))\\n temp = [item for item in suit if item in suit0]\\n if len(temp) > 0: return True\\n\\n return False\",\n \"def is_twenty_four_tone_complete(self):\\n pcs = [x / 2.0 for x in range(24)]\\n pcs = [int(x) if int(x) == x else x for x in pcs]\\n return set(pcs).issubset(set(self._color_dictionary.keys()))\",\n \"def hitMe(hand, deck):\\n if deck.cardsLeft == 0:\\n return False\\n hand.getCard(deck.drawCard())\\n return True\",\n \"def is_winner(self, player: str) -> bool:\\n total_result = self.current_state.hori_result + self.current_state.left_result + self.current_state.right_result\\n total_line = len(total_result)\\n p1_taken = 0\\n p2_taken = 0\\n for item in total_result:\\n if item == '1':\\n p1_taken+=1\\n elif item == '2':\\n p2_taken += 1\\n if player == \\\"p1\\\":\\n return float(p1_taken) >= total_line/2\\n return float(p2_taken) >= total_line/2\",\n \"def isPlayed(self, item):\\n userState = self.userState(item)\\n return bool(userState.viewCount > 0) if userState.viewCount else False\",\n \"def can_play(self, card):\\n played_cards = map(lambda x: str(x).lower(), self.played_cards)\\n if str(card).lower() in played_cards:\\n return False\\n if card.prebuild in played_cards:\\n return True\\n\\n for res in card.cost\",\n \"def third_street ():\\r\\n global all_hands\\r\\n global deck\\r\\n global players\\r\\n #Set of all cards for third street draw \\r\\n third_street_draws = random.sample(deck, len(players)*3)\\r\\n #Remove drawn cards from deck\\r\\n for card in third_street_draws:\\r\\n deck.remove(card)\\r\\n #Deal 1 Card Each Player Until 3, then reveal third street.\\r\\n for player in players:\\r\\n hand = []\\r\\n for i in range(0,3):\\r\\n hand.append(third_street_draws[player+len(players)*i])\\r\\n all_hands.append(hand)\\r\\n if player == you:\\r\\n print(\\\"Your hand is: \\\", str(all_hands[you]))\\r\\n else:\\r\\n print(\\\"Player \\\", str(player+1), \\\"'s 3rd Street hand is: \\\", str(hand[2]))\",\n \"def check_for_game_won(self):\\n all_moscuvites_captured = True\\n king_captured = True\\n king_escaped = True\\n for piece in self.game_pieces:\\n if piece.player == 2:\\n all_moscuvites_captured = False\\n elif piece.player == 3:\\n king_captured = False\\n king_coords = (piece.x,piece.y)\\n escape_coords = [(0, 0), (0, 8),\\n (8, 0), (8, 8)]\\n if king_coords not in escape_coords:\\n king_escaped = False\\n if king_captured:\\n return 2\\n elif king_escaped or all_moscuvites_captured:\\n return 1\\n else:\\n return 0\",\n \"def playerCanPlay(game, situation, player):\\r\\n return True\",\n \"def has_player(self, p: Player) -> bool:\\n return p in self.players\",\n \"def can_split(self) -> bool:\\n if len(self.cards) == 2 and self.cards[0].value == self.cards[1].value:\\n return True\\n else:\\n return False\",\n \"def is_straight_flush(hand):\\n # same suite\\n suite = hand[0][1]\\n vals = []\\n for c in hand:\\n if suite != c[1]:\\n return False\\n vals.append(cards[c[0]])\\n # check if vals are consecutive or not\\n if is_contiguous(vals):\\n return (True, max(vals))\\n else:\\n return False\",\n \"def play_game(play_shoe, player_list, dealer, number_of_decks):\\n # Check if the shoe is still valid (contains a cut card) if not,\\n # create a new shoe\\n play_shoe = shoe_check(play_shoe, number_of_decks)\\n initial_deal(play_shoe, player_list, dealer)\\n for player in player_list:\\n user_play(play_shoe, player, dealer)\\n dealer_play(play_shoe, dealer)\\n display_results(check_results(player_list, dealer))\\n if play_again():\\n return True, play_shoe\\n return False\",\n \"def is_straight_flush(hand):\\n\\tis_a_local_flush = False\\n\\tis_a_local_straight = False\\n\\tlocal_high_card = 0\\n\\ti = 16\\n\\twhile i >= 13:\\n\\t\\tif hand[i] == 5:\\n\\t\\t\\tis_a_local_flush = True\\n\\t\\ti -= 1\\n\\tif is_a_local_flush:\\n\\t\\tj = 0\\n\\t\\twhile j < 8:\\n\\t\\t\\tif hand[j] == 1 and hand[j + 1] == 1 and hand[j + 2] == 1 and hand[j + 3] == 1 and hand[j + 4] == 1:\\n\\t\\t\\t\\tis_a_local_straight = True\\n\\t\\t\\t\\tlocal_high_card = j + 4\\n\\t\\t\\tj += 1\\n\\tif is_a_local_flush and is_a_local_straight:\\n\\t\\treturn True, local_high_card\\n\\treturn False\",\n \"def is_valid_deck(deck: List[int]) -> bool:\\n check_deck = []\\n check_deck.extend(deck)\\n check_deck.sort()\\n return len(check_deck) >= 3 and \\\\\\n all(isinstance(item, int) for item in check_deck) \\\\\\n and len(check_deck) == check_deck[-1]\",\n \"def still_playing_game(self):\\n for player in self.players:\\n if player.is_playing:\\n return True\\n return False\",\n \"def has_straight_flush(self):\\n res = []\\n self.suit_hist()\\n for card in self.cards:\\n if self.suits[card.suit] >= 5:\\n res.append(card.rank)\\n self.is_sequence(res, 7)\",\n \"def been_played(self, word):\\n words = self.played_out or ''\\n words = words.split(' ')\\n\\n return True if ((words.count(word) > 0) or \\n (words.count( singularize(word) ) > 0) or \\n (words.count( pluralize(word) ) > 0)) else False\",\n \"def has_siete_de_velo(self):\\n for card in self._cards[\\\"oro\\\"]:\\n if card.value == 7:\\n return True\\n\\n return False\",\n \"def check_hand(self, player):\\n\\n total = player.score()\\n if total > 21:\\n status = 'bust'\\n elif total == 21:\\n status = 'win'\\n else:\\n status = 'okay'\\n\\n if self.verbose:\\n print(total, 'points')\\n \\n return status\",\n \"def is_two_pair(hand):\\n\\tfaces_of_pairs = []\\n\\tis_a_two_pair = False\\n\\ti = 0\\n\\twhile i < 13:\\n\\t\\tif hand[i] == 2:\\n\\t\\t\\tfaces_of_pairs.append(i)\\n\\t\\ti += 1\\n\\tif len(faces_of_pairs) == 2:\\n\\t\\tis_a_two_pair = True\\n\\tfor fp in faces_of_pairs:\\n\\t\\tprint(fp)\\n\\tif is_a_two_pair:\\n\\t\\treturn True, faces_of_pairs[1]\\n\\telse:\\n\\t\\treturn False\",\n \"def at_last_stich(self):\\n return len(self.cards) == 1\",\n \"def verify_winner(self):\\r\\n return self.count_pegs() == 1\",\n \"def IsItem3State(self, item):\\r\\n\\r\\n return item.Is3State()\",\n \"def is_ok_three_lines(line1, line2, line3):\\n card1 = line1[0]\\n card2 = line1[1]\\n card3 = line1[2]\\n card4 = line2[0]\\n card5 = line2[1]\\n card6 = line2[2]\\n\\n card7 = line3[0]\\n card8 = line3[1]\\n card9 = line3[2]\\n idents1 = [card.ident for card in line1]\\n idents2 = [card.ident for card in line2]\\n idents3 = [card.ident for card in line3]\\n\\n intersection = list(set(idents1) & set(idents2))\\n if intersection:\\n dprint(\\\"intersection 12\\\")\\n return False\\n\\n intersection = list(set(idents1) & set(idents3))\\n if intersection:\\n return False\\n\\n intersection = list(set(idents2) & set(idents3))\\n if intersection:\\n return False\\n\\n print(\\\"??????????????\\\")\\n show_triple(line1, line2, line3)\\n print(\\\"??????????????\\\")\\n\\n if not is_ok_two_lines(line1, line2):\\n return False\\n if not is_ok_two_lines(line2, line3):\\n return False\\n\\n return True\",\n \"def validate_cards(self, cards_list):\\n return set(self.hand).issubset(set(cards_list))\",\n \"def EndHand(redtricks, blacktricks):\\r\\n if redtricks >= 3 and blacktricks == 1:\\r\\n return True\\r\\n elif blacktricks >= 3 and redtricks == 1:\\r\\n return True\\r\\n elif (redtricks + blacktricks) == 5:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def player_hit(self):\\n self.player.hit(self.deck)\\n self.print_hands()\\n \\n if self.player.sum_cards() > 21:\\n self.round_winner = True\\n self.print_hands()\\n print(\\\"BUST! Dealer wins.\\\")\",\n \"def player_has_won(self):\\n return len(self._words_guessed) == self._num_words\",\n \"def is_horizontal_four(self, row, col):\\r\\n player = self.board[row][col]\\r\\n consecutiveL = 0\\r\\n consecutiveR = 0\\r\\n # count consecutive left discs\\r\\n i = col\\r\\n current = player\\r\\n while current == player:\\r\\n consecutiveL += 1\\r\\n i -= 1\\r\\n if i < 0:\\r\\n break\\r\\n current = self.board[row][i]\\r\\n\\r\\n # count consecutive right discs\\r\\n i = col\\r\\n current = self.board[row][i]\\r\\n while current == player:\\r\\n consecutiveR += 1\\r\\n i += 1\\r\\n if i >= 7:\\r\\n break\\r\\n current = self.board[row][i]\\r\\n\\r\\n # since (row, col) cell was counted twice, we reduce by 1\\r\\n if consecutiveL + consecutiveR - 1 >= 4:\\r\\n return True\\r\\n\\r\\n return False\",\n \"def isGameOver(self):\\n for i in range(self.rows):\\n for j in range(self.columns):\\n if self.grid[i][j].face == 'down':\\n return False\\n #if here then all cards must be face up\\n return True\",\n \"def is_ok_line(line):\\n card1 = line[0]\\n card2 = line[1]\\n card3 = line[2]\\n\\n if not is_coupled(card1.east, card2.west):\\n return False\\n if not is_coupled(card2.east, card3.west):\\n return False\\n return True\",\n \"def deck_has_cards(deck, cards):\\n deck_dict = collections.defaultdict(int)\\n for card in itertools.chain(deck.draw_pile, deck.discard_pile, deck.hand):\\n deck_dict[card] += 1\\n return deck_dict == cards\",\n \"def check_full_house(dice_list):\\n roll_counts = [dice_list.count(value) for value in range(1, 7)]\\n return 2 in roll_counts and 3 in roll_counts\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72666436","0.7080395","0.70760804","0.6595992","0.65198547","0.6504807","0.6470795","0.6453197","0.63943964","0.6391937","0.6380108","0.63546914","0.63495284","0.63185066","0.62931806","0.6260325","0.61777973","0.61756945","0.61107355","0.6093892","0.60865194","0.6032814","0.60217035","0.60090405","0.5986928","0.5974971","0.59615004","0.5937205","0.5901767","0.5898353","0.58930653","0.58891785","0.5851097","0.5849321","0.5836648","0.5787658","0.57812995","0.57802105","0.57685983","0.5743755","0.5741915","0.57355076","0.5717875","0.57170135","0.5710494","0.5698669","0.5698435","0.5696897","0.56840074","0.5679742","0.56728","0.5664815","0.56618345","0.5638342","0.5638335","0.5634101","0.5620652","0.5616434","0.5609873","0.56064945","0.56017613","0.5585795","0.55834186","0.55582696","0.5553376","0.5528218","0.55216336","0.55069995","0.55020386","0.5486131","0.5475107","0.5453296","0.54445004","0.54437375","0.5440602","0.54349256","0.53995913","0.5396965","0.5395423","0.53916055","0.5387889","0.53853154","0.53851503","0.5382429","0.53777915","0.5368128","0.5352952","0.5346107","0.5341501","0.53241396","0.5315627","0.53152597","0.53087926","0.5295733","0.5282761","0.5279858","0.52761334","0.52723163","0.5267721","0.5256944"],"string":"[\n \"0.72666436\",\n \"0.7080395\",\n \"0.70760804\",\n \"0.6595992\",\n \"0.65198547\",\n \"0.6504807\",\n \"0.6470795\",\n \"0.6453197\",\n \"0.63943964\",\n \"0.6391937\",\n \"0.6380108\",\n \"0.63546914\",\n \"0.63495284\",\n \"0.63185066\",\n \"0.62931806\",\n \"0.6260325\",\n \"0.61777973\",\n \"0.61756945\",\n \"0.61107355\",\n \"0.6093892\",\n \"0.60865194\",\n \"0.6032814\",\n \"0.60217035\",\n \"0.60090405\",\n \"0.5986928\",\n \"0.5974971\",\n \"0.59615004\",\n \"0.5937205\",\n \"0.5901767\",\n \"0.5898353\",\n \"0.58930653\",\n \"0.58891785\",\n \"0.5851097\",\n \"0.5849321\",\n \"0.5836648\",\n \"0.5787658\",\n \"0.57812995\",\n \"0.57802105\",\n \"0.57685983\",\n \"0.5743755\",\n \"0.5741915\",\n \"0.57355076\",\n \"0.5717875\",\n \"0.57170135\",\n \"0.5710494\",\n \"0.5698669\",\n \"0.5698435\",\n \"0.5696897\",\n \"0.56840074\",\n \"0.5679742\",\n \"0.56728\",\n \"0.5664815\",\n \"0.56618345\",\n \"0.5638342\",\n \"0.5638335\",\n \"0.5634101\",\n \"0.5620652\",\n \"0.5616434\",\n \"0.5609873\",\n \"0.56064945\",\n \"0.56017613\",\n \"0.5585795\",\n \"0.55834186\",\n \"0.55582696\",\n \"0.5553376\",\n \"0.5528218\",\n \"0.55216336\",\n \"0.55069995\",\n \"0.55020386\",\n \"0.5486131\",\n \"0.5475107\",\n \"0.5453296\",\n \"0.54445004\",\n \"0.54437375\",\n \"0.5440602\",\n \"0.54349256\",\n \"0.53995913\",\n \"0.5396965\",\n \"0.5395423\",\n \"0.53916055\",\n \"0.5387889\",\n \"0.53853154\",\n \"0.53851503\",\n \"0.5382429\",\n \"0.53777915\",\n \"0.5368128\",\n \"0.5352952\",\n \"0.5346107\",\n \"0.5341501\",\n \"0.53241396\",\n \"0.5315627\",\n \"0.53152597\",\n \"0.53087926\",\n \"0.5295733\",\n \"0.5282761\",\n \"0.5279858\",\n \"0.52761334\",\n \"0.52723163\",\n \"0.5267721\",\n \"0.5256944\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.89362204"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":181,"cells":{"query":{"kind":"string","value":"Return all components that match the given type and filter"},"document":{"kind":"string","value":"def queryComponent(type=None, filter=None, all=0):"},"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_components(self, filter_type=None):\n\n if filter_type is None:\n out = self.components\n elif isinstance(filter_type, str):\n out = {}\n cls = co.str_to_comp(filter_type)\n for comp in self.get_components():\n if isinstance(self.components[comp], cls):\n out[comp] = self.components[comp]\n else:\n out = {}\n for comp in self.get_components():\n if isinstance(self.components[comp], filter_type):\n out[comp] = self.components[comp]\n\n return out","def type_filter(self, items, types=None):","def _filter(self, location, component=\"Hosting\", compute_type=None):\n filters = [\n [\"TERM_MATCH\", \"location\", location],\n [\"TERM_MATCH\", \"productFamily\", \"ML Instance\"],\n [\"TERM_MATCH\", \"currentGeneration\", \"Yes\"],\n [\"TERM_MATCH\", \"component\", component]\n ]\n if compute_type:\n filters.append([\"TERM_MATCH\", \"computeType\", compute_type])\n return [{\n 'Type': x[0],\n 'Field': x[1],\n 'Value': x[2]\n } for x in filters]","def search_items(self, filter_text, type_filter=None):\n output = []\n\n for item in self._all_items:\n\n if type_filter:\n if item.match(filter_text) and item.resource_type == type_filter:\n output.append(item)\n else:\n if item.match(filter_text):\n output.append(item)\n\n return output","def get_components_by_type(\n self, component_type: Union[type, Tuple[type, ...]]\n ) -> List[Any]:\n return [c for c in self._components if isinstance(c, component_type)]","def filter(self, filters):","def get_components(self,filt):\n comps = [self.components[i] for i in xrange(len(self.header)) if filt == self.header[i]]\n return comps","def get_components_by_type(\n self, component_type: Union[type, Tuple[type, ...]]\n ) -> List[Any]:\n return self._manager.get_components_by_type(component_type)","def getFilter(self, type: int) -> int:\n ...","def by_type(cls, typ='creditcard'):\n return Filter('type', values=(typ,), operator=Filter.OPERATOR['EQUAL'])","def search_filter(query_params, query):\n if query_params.get('type') is not None:\n query = query.filter(search.c.kind == query_params.get('type'))\n return query","def type_filter(self, items, types=None):\n if not types:\n return items\n allowed_items = []\n for item in items:\n if item.portal_type not in types:\n continue\n allowed_items.append(item)\n return allowed_items","def filter_evaluations_by_type(self, type_):\n from .evaluation import Evaluation\n from .code_component import CodeComponent\n\n joined_eval = join(\n Evaluation.t, CodeComponent.t,\n ((Evaluation.m.trial_id == CodeComponent.m.trial_id) &\n (Evaluation.m.code_component_id == CodeComponent.m.id))\n )\n joined = join(\n Activation.t, joined_eval,\n ((Evaluation.m.trial_id == Activation.m.trial_id) &\n (Evaluation.m.activation_id == Activation.m.id))\n )\n query = (\n select([CodeComponent.m.name, Evaluation.m.repr])\n .select_from(joined)\n .where((Activation.m.trial_id == self.trial_id) &\n (Activation.m.id == self.id) &\n (CodeComponent.m.type == type_))\n )\n for result in relational.session.execute(query):\n yield result","def all(self, type_filter=None):\n res = []\n if type_filter is None or isinstance(self, type_filter):\n res.append(self)\n for v in self._all_subnodes():\n if isinstance(v, IDLNode):\n res.extend(v.all(type_filter))\n elif isinstance(v, list):\n for item in v:\n if isinstance(item, IDLNode):\n res.extend(item.all(type_filter))\n return res","def filter_queries_by_nlp_component(\n query_list: ProcessedQueryList, component_type: str, component_name: str\n ):\n\n filtered_queries = []\n filtered_queries_indices = []\n for index, query in enumerate(query_list.processed_queries()):\n if getattr(query, component_type) == component_name:\n filtered_queries_indices.append(index)\n filtered_queries.append(query)\n return filtered_queries_indices, filtered_queries","def search(self, filtro):\n return [nota for nota in self.notas if nota.match(filtro)]","def filterPick(list, filter, classification):\n y = []\n for job in list:\n x = [(job, classification) for l in job for m in (filter(l),) if m]\n y.append(x)\n return y","def get_filters(self):","def _getRecords(self, record_type, filters):\n if not filters:\n # Always return a copy for consistency\n return list(self._dump_data[record_type])\n response = self._dump_data[record_type]\n for f in filters:\n response = [r for r in response if f(r)]\n return response","def filter_geom(geom, _type):\n return list(filter(lambda x: isinstance(x, _type), geom))","def get_objects(filter_rule=\"**\", obj_type=\"*\"):\n objects = ix.api.OfObjectVector()\n project_root = ix.application.get_factory().get_project()\n ix.application.get_matching_objects(objects, filter_rule, project_root,\n obj_type)\n return objects","def filter(*args, name: Union[AnyStr, bool]=\"\", type: Union[AnyStr, bool]=\"\", q=True,\n query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\n pass","def get_type_filters(self, list_type: ListType) -> List[TypeFilter]:\n if hasattr(self, \"json\") and isinstance(self.json, dict):\n type_filters_raw = self.json.get(\"filter\", None)\n\n if type_filters_raw is not None:\n if isinstance(type_filters_raw, str):\n type_filters_raw = loads(type_filters_raw)\n\n if not isinstance(type_filters_raw, list):\n type_filters_raw = [type_filters_raw]\n\n try:\n type_filters: List[TypeFilter] = AvailableTypeFilters.from_string_list(type_filters_raw)\n return type_filters\n except UnknownTypeFilter as e:\n # Import logger here to prevent circular dependency on module import\n message = \"Received unknown type filter: '{0}'\".format(e.unknown_type_filter)\n logger.error(self.request_id, message, exc_info=e)\n raise InvalidUsage(message)\n\n return list_type.to_type_filters()","def get_filter_types(verbose=False):\n if verbose:\n pprint(filter_types)\n return filter_types","def test_api_type_filtering(api_client, by_type, by_state):\n response = api_client.get(path='/breweries', params={'by_type': by_type, 'by_state': by_state})\n assert response.json() != []\n assert response.ok","def get_events(self, type_filter=None):\n\n if type_filter:\n filtered_events = self.__events.get(type_filter, [])\n else:\n filtered_events = [ev for ev_type_list in self.__events.values() for ev in ev_type_list]\n\n return filtered_events","def fetch(self, compute_type=None):\n has_next_page = True\n next_token = None\n results = []\n while has_next_page:\n params = {\n \"ServiceCode\": self.SERVICE_CODE,\n \"Filters\": self._filter(self.location, compute_type=compute_type)\n }\n if next_token:\n params[\"NextToken\"] = next_token\n response = self.pricing.get_products(**params)\n results += self._format(response)\n next_token = response.get(\"NextToken\")\n has_next_page = next_token is not None\n results = self.filters.apply(results)\n return results","def extract_filter_list(self, filter_type, elements):\n titleLabel = QLabel(filter_type)\n titleLabel.setStyleSheet('font: 20pt \"Imprint MT Shadow\"; color: #ffffff;')\n grid = QGridLayout()\n self.filterVbox.addWidget(titleLabel, alignment=Qt.AlignCenter)\n self.filterVbox.addLayout(grid)\n\n counter = 0\n for element in elements:\n nextLabel = QLabel(element)\n nextLabel.setStyleSheet('font: 12pt \"Times New Roman\"; color: rgb(188, 189, 177);')\n grid.addWidget(nextLabel, math.floor(counter/3), counter % 3, alignment=Qt.AlignCenter)\n counter += 1","def search(self, filter: str = None) -> dict:\n r = requests.get(self.url, headers=self.headers)\n\n if filter:\n data = r.json()\n return filter_list(data=data, filter_by=filter)\n\n return r.json()","def filter(self, *args, **kwargs):","def _get_tuya_devices_filtered(self, types, exclude_mode=False, type_prefix=True):\n config_list = {}\n types_filter = set(types)\n tuya = self.hass.data[DOMAIN][TUYA_DATA]\n devices_list = tuya.get_all_devices()\n for device in devices_list:\n dev_type = device.device_type()\n exclude = (\n dev_type in types_filter\n if exclude_mode\n else dev_type not in types_filter\n )\n if exclude:\n continue\n dev_id = device.object_id()\n if type_prefix:\n dev_id = f\"{dev_type}-{dev_id}\"\n config_list[dev_id] = f\"{device.name()} ({dev_type})\"\n\n return config_list","def ls(tesserae, order_by, order_type, filter_types):\n try:\n return tesserae.ls(order_by, order_type, set([x.strip() for x in filter_types.split(\",\")]) if filter_types else set())\n except TesseraError, e:\n sys.stderr.write(\"Error: %s\\n\" % str(e))\n return False","def itemFilterType(*args, text: Union[AnyStr, bool]=\"\", type: bool=True, q=True, query=True,\n e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\n pass","def visitCriteria(self, ctx: ApiQLParser.CriteriaContext):\n return lmap(lambda c: c.accept(self), ctx.getChildren(self.filter_ignored))","def search(self, filters=None):\n raise NotImplementedError","def type_search(self, queryset, name, value):\n qs_filter = Q(type=ROUTING_POLICY_TYPE_IMPORT_EXPORT)\n for v in value:\n qs_filter |= Q(type=v)\n return queryset.filter(qs_filter)","def filter(self, cls):\n return ElementList([x for x in self._elements if isinstance(x, cls)])","def get_all_items(model, type):\n if(type == \"office\"):\n return model.get_all_offices()\n elif(type == \"party\"):\n return model.get_all_parties()\n return []","def filter(full_poi_list, type_of_poi):\n pois = []\n if type_of_poi == \"all\":\n for i in full_poi_list:\n entry = i[0]\n pois.append(entry)\n if type_of_poi == \"gym\":\n for i in full_poi_list:\n if i[1] == 2:\n entry = i[0]\n pois.append(entry)\n return pois","def search_project_or_study(obj_type):\n\n matches = []\n response = None\n\n try:\n if obj_type not in set([\"projects\", \"studies\"]):\n raise Exception(\"Invalid object type specified\")\n\n possible_filters = filters_d[obj_type]\n \n for f in file_dict[obj_type][\"valid\"].values():\n json_file = data_dir + f\n json_s = open(json_file, \"r\").read()\n json_obj = json.loads(json_s)\n add_to_matches = True\n\n for filter_name in possible_filters:\n filter_val = request.args.get(filter_name)\n if filter_val:\n if json_obj[filter_name] != filter_val:\n add_to_matches = False\n \n if add_to_matches:\n matches.append(json_s)\n\n response_body = \"[\" + \",\".join(matches) + \"]\"\n response = get_response(response_body, status=200)\n\n except Exception as e:\n print(\"bad request\")\n response_body = '''{\"message\": \"invalid resource '%s'\"}''' % obj_type\n response = get_response(response_body, status=400)\n\n return response","def test_filter_mixed_function(self):\n for none_type in (False, True):\n for all_type in (False, True):\n for any_type in (False, True, None):\n result = none_type is False and all_type is True \\\n and (any_type is None or any_type is True)\n self._test_filter(none_type, all_type, any_type, result)","def itemFilter(*args, byBin: Union[AnyStr, List[AnyStr], bool]=\"\", byName: Union[AnyStr,\n bool]=\"\", byScript: Union[AnyStr, bool]=\"\", byType: Union[AnyStr, List[AnyStr],\n bool]=\"\", category: Union[AnyStr, List[AnyStr], bool]=\"\", classification:\n Union[AnyStr, bool]=\"\", clearByBin: bool=True, clearByType: bool=True,\n difference: Union[List[AnyStr, AnyStr], bool]=None, exists: bool=True,\n intersect: Union[List[AnyStr, AnyStr], bool]=None, listBuiltInFilters: bool=True,\n listOtherFilters: bool=True, listUserFilters: bool=True, negate: bool=True,\n parent: Union[AnyStr, bool]=\"\", pythonModule: Union[AnyStr, bool]=\"\",\n secondScript: Union[AnyStr, bool]=\"\", text: Union[AnyStr, bool]=\"\", union:\n Union[List[AnyStr, AnyStr], bool]=None, uniqueNodeNames: bool=True, q=True,\n query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\n pass","def node_type_filter(node_list, *filter_types):\n\n flg = logging.getLogger(\"lettuce.xgenSetup.node_type_filter\")\n\n flg.info(\"Filtering Node List\")\n\n filtered_list = []\n for node in node_list:\n node_type = mc.nodeType(node)\n flg.debug(\"Node, {0}, is of type, {1}\".format(node, node_type))\n if node_type not in filter_types:\n flg.debug(\"Node kept\")\n filtered_list.append(node)\n else:\n flg.debug(\"Node filtered\")\n flg.info(\"Returning Filtered List\")\n return filtered_list","def by_type(self, type):\n return self.filter(related_type__title=type)","def filter_all(_):\n return True","def all(self):\n\t\timport revitron\n\t\tdb = revitron.DB\n\t\tf = db.LogicalOrFilter(\n\t\t db.ElementIsElementTypeFilter(False),\n\t\t db.ElementIsElementTypeFilter(True)\n\t\t)\n\n\t\tself.collector = self.collector.WherePasses(f)\n\t\treturn self","def by_card_type(cls, card_type):\n return Filter('card_type', values=(card_type,), operator=Filter.OPERATOR['EQUAL'])","def filter_room_type(self, criterias, index, bool_room_type):\n # if the user input doesn't pass verification, don't filter by this criteria\n # so always return True\n if bool_room_type == False:\n return True\n\n criterias = {key: self.convert_room_type_input(\n val) for key, val in criterias.items()}\n listing_room_type = self.process_room_type(\n self.data[index]['roomType'])\n bool_bed = criterias['Bedrooms'][1](\n listing_room_type['Bedrooms'], criterias['Bedrooms'][0])\n bool_bath = criterias['Bathrooms'][1](\n listing_room_type['Bathrooms'], criterias['Bathrooms'][0])\n return bool_bed & bool_bath","def get_object_from_filter(obj, components):\n\n components = components[:]\n while len(components) > 2:\n obj = getattr(obj, components.pop(0))\n if len(components) == 2:\n if components[-1] != \"regex\":\n if not hasattr(obj, f\"__{components[-1]}__\"):\n obj = getattr(obj, components[0])\n return obj","def _set_runtime_filters(self):\n runtime_filters = []\n if not all(len(filter_tuple) == 3 for filter_tuple in self.filters):\n raise TypeError(\n '%s: filters must be a sequence of tuple with length=3'\n ' got %r instead' % (self.__class__.__name__, self.filters))\n\n for filter_type, filter_operator, filter_value in self.filters:\n if isinstance(filter_type, ValueProvider):\n filter_type = filter_type.get()\n if isinstance(filter_operator, ValueProvider):\n filter_operator = filter_operator.get()\n if isinstance(filter_value, ValueProvider):\n filter_value = filter_value.get()\n runtime_filters.append((filter_type, filter_operator, filter_value))\n\n return runtime_filters or ()","def filter_features_by_type(feats: FeaturesTuple, feat_type: FeatureTypeTypes) -> FeaturesTuple:\n return tuple([feat for feat in feats if type(feat) == feat_type])","def _filter(self, lst):\n\n lst = list(set(lst)) # removes duplicate items\n if lst is None:\n return []\n arr = []\n for item in lst:\n for typ in [str(g) for g in self.__class__.OBJ_TYPES]:\n if cmds.objectType(item) == typ:\n arr.append(item)\n\n arr.sort(key=lambda x: x.count('|'))\n return arr[::-1] # reverse list","def filter_by_type(x, _request_type_list=None):\n if _request_type_list:\n for request_type in _request_type_list:\n if x[\"request_type\"] == request_type:\n return True\n return False\n return True","def components(self, predicate=None):\n \n if predicate is None:\n return self._get(\"components\").json()\n else:\n return self._get(\"components/search\", params={\"predicate\":predicate}).json()","def filter_transactions_by_type(self, request):\n transactions = Transaction.objects.all()\n type = request.data[\"type\"]\n if type == \"in\" :\n transactions = transactions.filter(amount__gt=0)\n else:\n transactions = transactions.filter(amount__lt=0)\n serializer = TransactionSerializer(transactions, many=True)\n return Response(serializer.data)","def filter_by_class(objects, cls):\n if cls is not None:\n filtered = []\n classes = cls if isinstance(cls, tuple) else (cls,)\n for o in objects:\n valid = False\n for c in classes:\n try:\n if o.is_valid(c):\n valid = True\n break\n except AttributeError:\n continue\n if valid:\n filtered.append(o)\n return filtered\n else:\n return list(objects)","def get_recipes_by_types(self, recipe_type): \n\t\tfor key, val in self.recipes_list.items():\n\t\t\tif key == recipe_type:\n\t\t\t\tfor a, b in val.items():\n\t\t\t\t\tprint(str(b))","def get_items_of_type(self, item_type):\n return (item for item in self.items if item.get_type() == item_type)","def filter(data, mask, **kwargs):\n return Component(\n \"Filter\",\n arguments={\n 'data': Component.of(data),\n 'mask': Component.of(mask)\n },\n options={\n \n },\n constraints=kwargs)","def attribute_search(self, attribute, filters):\n for i in self.response_info['results']:\n if filters in i[attribute]:\n self.output.append(i)\n self.counter += 1","def get_search(self, type, params, batch=False):\n path = 'search'\n args = {'type': type}\n args.update(params)\n return self.make_request(path, 'GET', args, batch=batch)","def filter(self, filters:list)->list:\n for item in self.list:\n use_item = True\n for filter in filters:\n filter_key, filter_value, filter_type = filter\n if filter_type == \"<\" and item[filter_key] >= filter_value:\n use_item = False\n break\n elif filter_type == \">\" and item[filter_key] <= filter_value:\n use_item = False\n break\n elif filter_type == \"<=\" and item[filter_key] > filter_value:\n use_item = False\n break\n elif filter_type == \">=\" and item[filter_key] < filter_value:\n use_item = False\n break\n elif filter_type == \"=\" and not item[filter_key] == filter_value:\n use_item = False\n break\n if use_item:\n yield item","def _build_filters(self, criteria: Q):\n # Decide the function based on the connector type\n func = and_ if criteria.connector == criteria.AND else or_\n params = []\n for child in criteria.children:\n if isinstance(child, Q):\n # Call the function again with the child\n params.append(self._build_filters(child))\n else:\n # Find the lookup class and the key\n stripped_key, lookup_class = self.provider._extract_lookup(child[0])\n\n # Instantiate the lookup class and get the expression\n lookup = lookup_class(stripped_key, child[1], self.model_cls)\n if criteria.negated:\n params.append(~lookup.as_expression())\n else:\n params.append(lookup.as_expression())\n\n return func(*params)","def matching_blocks_by_type(self):\n try:\n block_structure = get_course_in_cache(self.course_key)\n matching_blocks = block_structure.topological_traversal(\n filter_func=self.block_type_filter,\n yield_descendants_of_unyielded=True,\n )\n self.course_block_structure = block_structure\n except item_not_found_error():\n return []\n\n return list(matching_blocks)","def _filter_for_panel( item, item_type, filters, context ):\n def _apply_filter( filter_item, filter_list ):\n for filter_method in filter_list:\n try:\n if not filter_method( context, filter_item ):\n return False\n except Exception as e:\n raise MessageException( \"Toolbox filter exception from '%s': %s.\" % ( filter_method.__name__, e ) )\n return True\n if item_type == panel_item_types.TOOL:\n if _apply_filter( item, filters[ 'tool' ] ):\n return item\n elif item_type == panel_item_types.LABEL:\n if _apply_filter( item, filters[ 'label' ] ):\n return item\n elif item_type == panel_item_types.SECTION:\n # Filter section item-by-item. Only show a label if there are\n # non-filtered tools below it.\n\n if _apply_filter( item, filters[ 'section' ] ):\n cur_label_key = None\n tools_under_label = False\n filtered_elems = item.elems.copy()\n for key, section_item_type, section_item in item.panel_items_iter():\n if section_item_type == panel_item_types.TOOL:\n # Filter tool.\n if _apply_filter( section_item, filters[ 'tool' ] ):\n tools_under_label = True\n else:\n del filtered_elems[ key ]\n elif section_item_type == panel_item_types.LABEL:\n # If there is a label and it does not have tools,\n # remove it.\n if cur_label_key and ( not tools_under_label or not _apply_filter( section_item, filters[ 'label' ] ) ):\n del filtered_elems[ cur_label_key ]\n\n # Reset attributes for new label.\n cur_label_key = key\n tools_under_label = False\n\n # Handle last label.\n if cur_label_key and not tools_under_label:\n del filtered_elems[ cur_label_key ]\n\n # Only return section if there are elements.\n if len( filtered_elems ) != 0:\n copy = item.copy()\n copy.elems = filtered_elems\n return copy\n\n return None","def filter_or(filters):\n def filt(item):\n for f in filters:\n if f(item):\n return True\n return False\n return filt","def _build_filter_part(self, cls, filters, order_by=None, select=None):\r\n import types\r\n query_parts = []\r\n\r\n order_by_filtered = False\r\n\r\n if order_by:\r\n if order_by[0] == \"-\":\r\n order_by_method = \"DESC\";\r\n order_by = order_by[1:]\r\n else:\r\n order_by_method = \"ASC\";\r\n\r\n if select:\r\n if order_by and order_by in select:\r\n order_by_filtered = True\r\n query_parts.append(\"(%s)\" % select)\r\n\r\n if isinstance(filters, str) or isinstance(filters, unicode):\r\n query = \"WHERE %s AND `__type__` = '%s'\" % (filters, cls.__name__)\r\n if order_by in [\"__id__\", \"itemName()\"]:\r\n query += \" ORDER BY itemName() %s\" % order_by_method\r\n elif order_by != None:\r\n query += \" ORDER BY `%s` %s\" % (order_by, order_by_method)\r\n return query\r\n\r\n for filter in filters:\r\n filter_parts = []\r\n filter_props = filter[0]\r\n if type(filter_props) != list:\r\n filter_props = [filter_props]\r\n for filter_prop in filter_props:\r\n (name, op) = filter_prop.strip().split(\" \", 1)\r\n value = filter[1]\r\n property = cls.find_property(name)\r\n if name == order_by:\r\n order_by_filtered = True\r\n if types.TypeType(value) == types.ListType:\r\n filter_parts_sub = []\r\n for val in value:\r\n val = self.encode_value(property, val)\r\n if isinstance(val, list):\r\n for v in val:\r\n filter_parts_sub.append(self._build_filter(property, name, op, v))\r\n else:\r\n filter_parts_sub.append(self._build_filter(property, name, op, val))\r\n filter_parts.append(\"(%s)\" % (\" OR \".join(filter_parts_sub)))\r\n else:\r\n val = self.encode_value(property, value)\r\n if isinstance(val, list):\r\n for v in val:\r\n filter_parts.append(self._build_filter(property, name, op, v))\r\n else:\r\n filter_parts.append(self._build_filter(property, name, op, val))\r\n query_parts.append(\"(%s)\" % (\" or \".join(filter_parts)))\r\n\r\n\r\n type_query = \"(`__type__` = '%s'\" % cls.__name__\r\n for subclass in self._get_all_decendents(cls).keys():\r\n type_query += \" or `__type__` = '%s'\" % subclass\r\n type_query +=\")\"\r\n query_parts.append(type_query)\r\n\r\n order_by_query = \"\"\r\n\r\n if order_by:\r\n if not order_by_filtered:\r\n query_parts.append(\"`%s` LIKE '%%'\" % order_by)\r\n if order_by in [\"__id__\", \"itemName()\"]:\r\n order_by_query = \" ORDER BY itemName() %s\" % order_by_method\r\n else:\r\n order_by_query = \" ORDER BY `%s` %s\" % (order_by, order_by_method)\r\n\r\n if len(query_parts) > 0:\r\n return \"WHERE %s %s\" % (\" AND \".join(query_parts), order_by_query)\r\n else:\r\n return \"\"","def filter_scalings(scaling_list, scaling_type):\n return filter(\n lambda _f: True if scaling_type in _f[\"runname\"] else False,\n scaling_list)","def get_objects_by_type(self, *types) -> List[TgnObject]:\n if not types:\n return list(self.objects.values())\n types_l = [o.lower() for o in types]\n return [o for o in self.objects.values() if o.type.lower() in types_l]","def extract_filters(self):\n self.filters = self.controller.filters\n\n self.extract_core_stats()\n self.extract_abilities()\n # goes through and adds all list-based filters\n for filterType, elements in self.filters.items():\n if type(elements) == list and len(elements) > 0:\n self.extract_filter_list(filterType, elements)","def setFilter(self, type: int, filter: int) -> None:\n ...","def _base_proxies_filter(self, category: str, filters: list) -> list:\n\n data_filtered = []\n \n if category == 'country':\n data_filtered.extend(\n Froxy._filter_model(self.storage.get(), line=2, col=0, filters=filters)\n )\n \n elif category == 'anonymity':\n data_filtered.extend(\n Froxy._filter_model(self.storage.get(), line=2, col=1, filters=filters)\n )\n\n elif category == 'protocol':\n data_filtered.extend(\n Froxy._filter_model(self.storage.get(), line=2, col=2, filters=filters)\n )\n \n elif category == 'google_passed':\n data_filtered.extend(\n Froxy._filter_model(self.storage.get(), line=2, col=3, filters=filters)\n )\n\n return data_filtered","def get_node_components(self, node=None, filter_type=None):\n if node is not None and node not in self.get_nodes():\n raise KeyError('{} is not an exiting node'.format(node))\n\n if node is not None:\n return self.components[node].get_components(filter_type=filter_type)\n else:\n out = {}\n for node_name in self.get_nodes():\n for comp_name, comp in self.components[\n node_name].get_components(\n filter_type=filter_type).items():\n out[comp_name] = comp\n return out","def getResultDefs(self, type=None):\n results = self.results.values()\n\n if type:\n results = filter(lambda result: result.type == type, results)\n\n return results","def dependency_filter(dependencies,start=0,end=-1,filter_val=None,filter_vals=[],field=None,filter_range='dependent'):\n return [getattr(i, field) if field else i for i in dependencies if \n (start == 0 or getattr(i, filter_range).idx >= start) and \n (end == -1 or getattr(i, filter_range).idx < end) and \n ((filter_val == None and not filter_vals) or i.type in filter_vals + [filter_val] or (filter_val[-1]=='*' and i.type.startswith(filter_val[0:-1])))\n ]","def get_contract_filters(*contracts):\n return [generate_filter(filter_text) for filter_text in contracts]","def ListMatchingComponents(self, policy_type):\n base_name = self.GetBaseFilename(policy_type)\n files = glob.glob('%s_*.*' % base_name)\n len_base_name = len(base_name) + 1\n return [ file[len_base_name:file.rfind('.')] for file in files ]","def types_query(owner_name):\n query = Products.query.with_entities(Products.type_name.label('Type'))\\\n .filter_by(owner_name=owner_name)\\\n .distinct()\n return query","def test_get_component_descriptors_by_type_using_get(self):\n pass","def servicemanage_type_get_all(context, inactive=False, filters=None):\n filters = filters or {}\n\n read_deleted = \"yes\" if inactive else \"no\"\n rows = model_query(context, models.ServiceManageTypes,\n read_deleted=read_deleted).\\\n options(joinedload('extra_specs')).\\\n order_by(\"name\").\\\n all()\n\n # TODO(sirp): this patern of converting rows to a result with extra_specs\n # is repeated quite a bit, might be worth creating a method for it\n result = {}\n for row in rows:\n result[row['name']] = _dict_with_extra_specs(row)\n\n return result","def filter(self, *args):\n return _libsbml.ElementFilter_filter(self, *args)","def _filter(self, filter_condition):\n def _inner_filter(item: list):\n return self._default_filter(item, filter_condition)\n\n self._result = list(filter(_inner_filter, self._data))","def _filter_types_index(self, types_index, resource_type_id):\n entities = []\n if resource_type_id in types_index:\n entities.extend(types_index[resource_type_id])\n return entities","def get_fields_by_type(self, field_type):\n for field in self.fields:\n if field.get_field_type() == field_type:\n yield field","def search(self, filter):\n return [note for note in self.notes if note.match(filter)]","def get_estimators(type_filter='all'):\n\n if type_filter not in ['all', 'classifier', 'transformer', 'cluster']:\n # TODO: make this exception more specific\n raise Exception(\"type_filter should be element of \"\n \"['all', 'classifier', 'transformer', 'cluster']\")\n\n all_classes = _get_all_classes()\n\n # Filter out those that are not a subclass of `sklearn.BaseEstimator`\n all_classes = [c for c in set(all_classes)\n if issubclass(c[1], BaseEstimator)]\n\n # get rid of abstract base classes\n all_classes = filter(lambda c: not is_abstract(c[1]), all_classes)\n\n # only keep those that are from tslearn\n all_classes = filter(lambda c: not is_sklearn(c[1]), all_classes)\n\n # Now filter out the estimators that are not of the specified type\n filters = {\n 'all': [ClassifierMixin, RegressorMixin,\n TransformerMixin, ClusterMixin],\n 'classifier': [ClassifierMixin],\n 'transformer': [TransformerMixin],\n 'cluster': [ClusterMixin]\n }[type_filter]\n filtered_classes = []\n for _class in all_classes:\n if any([issubclass(_class[1], mixin) for mixin in filters]):\n filtered_classes.append(_class)\n\n # Remove duplicates and return the list of remaining estimators\n return sorted(set(filtered_classes), key=itemgetter(0))","def _queryset(self):\n return self.type.objects.filter(id__in=self.ids)","def __init__(self, type: int, filter: int):\n ...","def sol_type_filter(opps, types):\n global _total_skipped, _total_kept\n filtered_opps = []\n for opp in opps:\n if opp['type']['value'] in types:\n filtered_opps.append(opp)\n _total_kept += 1\n else:\n _total_skipped += 1\n\n logger.debug(\"Total skip stats so far: Skipping {} out of {} due to solicitation type\".format(_total_skipped, _total_kept + _total_skipped))\n return filtered_opps","def filter_by_query_params(self, request):\n items = self\n company = request.GET.get('company', None)\n main_contractor = request.GET.get('main_contractor', None)\n main_sub_contractor = request.GET.get('main_sub_contractor', None)\n client = request.GET.get('client', None)\n q = request.GET.get('q', None)\n sort_by = request.GET.get('sort_by', None)\n str = request.GET.get('str', None)\n\n # filter\n if main_contractor:\n items = items.filter(main_contractor=main_contractor).distinct()\n if main_sub_contractor:\n items = items.filter(main_sub_contractor=main_sub_contractor).distinct()\n if client:\n items = items.filter(client=client).distinct()\n if company:\n items = items.filter(companies_linked__in=[company]).distinct()\n # sort\n if q == 'asc' and sort_by:\n items = items.order_by(sort_by).distinct()\n\n if q == 'des' and sort_by:\n items = items.order_by('-' + sort_by).distinct()\n\n if str:\n # str = str.strip().lower()\n items = items.filter(Q(reference_no__icontains=str) |\n Q(name__icontains=str)).distinct()\n return items","def filter(self, filter_dict):\n pass","def test_filter_services_by_components(self):\n\n service1 = sample_services(user=self.user, title='Mechanical Work 1')\n service2 = sample_services(user=self.user, title='Mechanical Work 2')\n service3 = sample_services(user=self.user, title='Mechanical Work 3')\n\n component1 = sample_componenets(user=self.user, name='Mech1')\n component2 = sample_componenets(user=self.user, name='Mech2')\n component3 = sample_componenets(user=self.user, name='mech3')\n\n service1.components.add(component1)\n service2.components.add(component2)\n service3.components.add(component3)\n\n res = self.client.get(\n SERVICES_URL,\n {'tags': f'{component1.id},{component2.id},{component3.id}'}\n )\n\n serializer1 = ServiceSerializer(service1)\n serializer2 = ServiceSerializer(service2)\n serializer3 = ServiceSerializer(service3)\n\n self.assertIn(serializer1.data, res.data)\n self.assertIn(serializer2.data, res.data)\n self.assertNotIn(serializer3.data, res.data)","def filt(rec):\n return True # Show everything","def filter(self, viewer, parent, elements):\n\n return [e for e in elements if self.select(viewer, parent, e)]","def filter(self, filters):\r\n # because http.Request needs params to be a dict of strings to strings\r\n # (roughly) and since BitBucket wants repeated parameters to express\r\n # OR, we'll do the quoting by hand ourselves\r\n def flatten_conditions(filters):\r\n for key, val in filters.items():\r\n if isinstance(val, (list, tuple)):\r\n for v in val:\r\n yield (port.to_b(key), port.to_b(v))\r\n else:\r\n yield (port.to_b(key), port.to_b(val))\r\n\r\n to_encode = tuple(flatten_conditions(filters))\r\n qs = port.urlencode(to_encode)\r\n\r\n url = '{0}/?{1}'.format(self.get_url(), qs)\r\n return http.Request('GET', url), parsers.parse_json","def doFiltering(self, searchfunc, filters=None):\n F=[]\n for f in self.filters:\n F.append(f.getFilter())\n #print F\n sets = []\n for f in F:\n col, val, op, boolean = f\n names = searchfunc(col, val, op)\n sets.append((set(names), boolean))\n names = sets[0][0]\n for s in sets[1:]:\n b=s[1]\n if b == 'AND':\n names = names & s[0]\n elif b == 'OR':\n names = names | s[0]\n elif b == 'NOT':\n names = names - s[0]\n names = list(names)\n self.updateResults(len(names))\n return names","def test_get_component_descriptors_by_types_using_get(self):\n pass","def filter_inspection_type(data, inspection_type):\n return [row for row in data if row['inspection_type'] == inspection_type]","def find(cls, **filters):\n return cls.query.filter_by(**filters).all()","def filter_items(self, filter_data: Dict[str, str] = None) -> List[WalletItem]:\n filtered_items = self.items\n for key, value in filter_data.items():\n if key == \"category\":\n filtered_items = [item for item in filtered_items\n if re.search(value, item.category, re.IGNORECASE)]\n if key == \"account\":\n filtered_items = [item for item in filtered_items\n if re.search(value, item.account, re.IGNORECASE)]\n if key == \"notes\" in filter_data:\n filtered_items = [item for item in filtered_items\n if re.search(value, item.notes, re.IGNORECASE)]\n if key == \"amt_min\":\n value = float(value)\n filtered_items = [item for item in filtered_items if item.amount >= value]\n if key == \"amt_max\":\n value = float(value)\n filtered_items = [item for item in filtered_items if item.amount <= value]\n if key == \"begin_date\":\n try:\n begin_date = datetime.strptime(value, '%d/%m/%Y')\n filtered_items = [item for item in filtered_items if begin_date <= item.date]\n except ValueError as ex:\n print(ex)\n exit(1)\n if key == \"end_date\":\n try:\n end_date = datetime.strptime(value, '%d/%m/%Y')\n filtered_items = [item for item in filtered_items if item.date <= end_date]\n except ValueError as ex:\n print(ex)\n exit(1)\n return filtered_items"],"string":"[\n \"def get_components(self, filter_type=None):\\n\\n if filter_type is None:\\n out = self.components\\n elif isinstance(filter_type, str):\\n out = {}\\n cls = co.str_to_comp(filter_type)\\n for comp in self.get_components():\\n if isinstance(self.components[comp], cls):\\n out[comp] = self.components[comp]\\n else:\\n out = {}\\n for comp in self.get_components():\\n if isinstance(self.components[comp], filter_type):\\n out[comp] = self.components[comp]\\n\\n return out\",\n \"def type_filter(self, items, types=None):\",\n \"def _filter(self, location, component=\\\"Hosting\\\", compute_type=None):\\n filters = [\\n [\\\"TERM_MATCH\\\", \\\"location\\\", location],\\n [\\\"TERM_MATCH\\\", \\\"productFamily\\\", \\\"ML Instance\\\"],\\n [\\\"TERM_MATCH\\\", \\\"currentGeneration\\\", \\\"Yes\\\"],\\n [\\\"TERM_MATCH\\\", \\\"component\\\", component]\\n ]\\n if compute_type:\\n filters.append([\\\"TERM_MATCH\\\", \\\"computeType\\\", compute_type])\\n return [{\\n 'Type': x[0],\\n 'Field': x[1],\\n 'Value': x[2]\\n } for x in filters]\",\n \"def search_items(self, filter_text, type_filter=None):\\n output = []\\n\\n for item in self._all_items:\\n\\n if type_filter:\\n if item.match(filter_text) and item.resource_type == type_filter:\\n output.append(item)\\n else:\\n if item.match(filter_text):\\n output.append(item)\\n\\n return output\",\n \"def get_components_by_type(\\n self, component_type: Union[type, Tuple[type, ...]]\\n ) -> List[Any]:\\n return [c for c in self._components if isinstance(c, component_type)]\",\n \"def filter(self, filters):\",\n \"def get_components(self,filt):\\n comps = [self.components[i] for i in xrange(len(self.header)) if filt == self.header[i]]\\n return comps\",\n \"def get_components_by_type(\\n self, component_type: Union[type, Tuple[type, ...]]\\n ) -> List[Any]:\\n return self._manager.get_components_by_type(component_type)\",\n \"def getFilter(self, type: int) -> int:\\n ...\",\n \"def by_type(cls, typ='creditcard'):\\n return Filter('type', values=(typ,), operator=Filter.OPERATOR['EQUAL'])\",\n \"def search_filter(query_params, query):\\n if query_params.get('type') is not None:\\n query = query.filter(search.c.kind == query_params.get('type'))\\n return query\",\n \"def type_filter(self, items, types=None):\\n if not types:\\n return items\\n allowed_items = []\\n for item in items:\\n if item.portal_type not in types:\\n continue\\n allowed_items.append(item)\\n return allowed_items\",\n \"def filter_evaluations_by_type(self, type_):\\n from .evaluation import Evaluation\\n from .code_component import CodeComponent\\n\\n joined_eval = join(\\n Evaluation.t, CodeComponent.t,\\n ((Evaluation.m.trial_id == CodeComponent.m.trial_id) &\\n (Evaluation.m.code_component_id == CodeComponent.m.id))\\n )\\n joined = join(\\n Activation.t, joined_eval,\\n ((Evaluation.m.trial_id == Activation.m.trial_id) &\\n (Evaluation.m.activation_id == Activation.m.id))\\n )\\n query = (\\n select([CodeComponent.m.name, Evaluation.m.repr])\\n .select_from(joined)\\n .where((Activation.m.trial_id == self.trial_id) &\\n (Activation.m.id == self.id) &\\n (CodeComponent.m.type == type_))\\n )\\n for result in relational.session.execute(query):\\n yield result\",\n \"def all(self, type_filter=None):\\n res = []\\n if type_filter is None or isinstance(self, type_filter):\\n res.append(self)\\n for v in self._all_subnodes():\\n if isinstance(v, IDLNode):\\n res.extend(v.all(type_filter))\\n elif isinstance(v, list):\\n for item in v:\\n if isinstance(item, IDLNode):\\n res.extend(item.all(type_filter))\\n return res\",\n \"def filter_queries_by_nlp_component(\\n query_list: ProcessedQueryList, component_type: str, component_name: str\\n ):\\n\\n filtered_queries = []\\n filtered_queries_indices = []\\n for index, query in enumerate(query_list.processed_queries()):\\n if getattr(query, component_type) == component_name:\\n filtered_queries_indices.append(index)\\n filtered_queries.append(query)\\n return filtered_queries_indices, filtered_queries\",\n \"def search(self, filtro):\\n return [nota for nota in self.notas if nota.match(filtro)]\",\n \"def filterPick(list, filter, classification):\\n y = []\\n for job in list:\\n x = [(job, classification) for l in job for m in (filter(l),) if m]\\n y.append(x)\\n return y\",\n \"def get_filters(self):\",\n \"def _getRecords(self, record_type, filters):\\n if not filters:\\n # Always return a copy for consistency\\n return list(self._dump_data[record_type])\\n response = self._dump_data[record_type]\\n for f in filters:\\n response = [r for r in response if f(r)]\\n return response\",\n \"def filter_geom(geom, _type):\\n return list(filter(lambda x: isinstance(x, _type), geom))\",\n \"def get_objects(filter_rule=\\\"**\\\", obj_type=\\\"*\\\"):\\n objects = ix.api.OfObjectVector()\\n project_root = ix.application.get_factory().get_project()\\n ix.application.get_matching_objects(objects, filter_rule, project_root,\\n obj_type)\\n return objects\",\n \"def filter(*args, name: Union[AnyStr, bool]=\\\"\\\", type: Union[AnyStr, bool]=\\\"\\\", q=True,\\n query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def get_type_filters(self, list_type: ListType) -> List[TypeFilter]:\\n if hasattr(self, \\\"json\\\") and isinstance(self.json, dict):\\n type_filters_raw = self.json.get(\\\"filter\\\", None)\\n\\n if type_filters_raw is not None:\\n if isinstance(type_filters_raw, str):\\n type_filters_raw = loads(type_filters_raw)\\n\\n if not isinstance(type_filters_raw, list):\\n type_filters_raw = [type_filters_raw]\\n\\n try:\\n type_filters: List[TypeFilter] = AvailableTypeFilters.from_string_list(type_filters_raw)\\n return type_filters\\n except UnknownTypeFilter as e:\\n # Import logger here to prevent circular dependency on module import\\n message = \\\"Received unknown type filter: '{0}'\\\".format(e.unknown_type_filter)\\n logger.error(self.request_id, message, exc_info=e)\\n raise InvalidUsage(message)\\n\\n return list_type.to_type_filters()\",\n \"def get_filter_types(verbose=False):\\n if verbose:\\n pprint(filter_types)\\n return filter_types\",\n \"def test_api_type_filtering(api_client, by_type, by_state):\\n response = api_client.get(path='/breweries', params={'by_type': by_type, 'by_state': by_state})\\n assert response.json() != []\\n assert response.ok\",\n \"def get_events(self, type_filter=None):\\n\\n if type_filter:\\n filtered_events = self.__events.get(type_filter, [])\\n else:\\n filtered_events = [ev for ev_type_list in self.__events.values() for ev in ev_type_list]\\n\\n return filtered_events\",\n \"def fetch(self, compute_type=None):\\n has_next_page = True\\n next_token = None\\n results = []\\n while has_next_page:\\n params = {\\n \\\"ServiceCode\\\": self.SERVICE_CODE,\\n \\\"Filters\\\": self._filter(self.location, compute_type=compute_type)\\n }\\n if next_token:\\n params[\\\"NextToken\\\"] = next_token\\n response = self.pricing.get_products(**params)\\n results += self._format(response)\\n next_token = response.get(\\\"NextToken\\\")\\n has_next_page = next_token is not None\\n results = self.filters.apply(results)\\n return results\",\n \"def extract_filter_list(self, filter_type, elements):\\n titleLabel = QLabel(filter_type)\\n titleLabel.setStyleSheet('font: 20pt \\\"Imprint MT Shadow\\\"; color: #ffffff;')\\n grid = QGridLayout()\\n self.filterVbox.addWidget(titleLabel, alignment=Qt.AlignCenter)\\n self.filterVbox.addLayout(grid)\\n\\n counter = 0\\n for element in elements:\\n nextLabel = QLabel(element)\\n nextLabel.setStyleSheet('font: 12pt \\\"Times New Roman\\\"; color: rgb(188, 189, 177);')\\n grid.addWidget(nextLabel, math.floor(counter/3), counter % 3, alignment=Qt.AlignCenter)\\n counter += 1\",\n \"def search(self, filter: str = None) -> dict:\\n r = requests.get(self.url, headers=self.headers)\\n\\n if filter:\\n data = r.json()\\n return filter_list(data=data, filter_by=filter)\\n\\n return r.json()\",\n \"def filter(self, *args, **kwargs):\",\n \"def _get_tuya_devices_filtered(self, types, exclude_mode=False, type_prefix=True):\\n config_list = {}\\n types_filter = set(types)\\n tuya = self.hass.data[DOMAIN][TUYA_DATA]\\n devices_list = tuya.get_all_devices()\\n for device in devices_list:\\n dev_type = device.device_type()\\n exclude = (\\n dev_type in types_filter\\n if exclude_mode\\n else dev_type not in types_filter\\n )\\n if exclude:\\n continue\\n dev_id = device.object_id()\\n if type_prefix:\\n dev_id = f\\\"{dev_type}-{dev_id}\\\"\\n config_list[dev_id] = f\\\"{device.name()} ({dev_type})\\\"\\n\\n return config_list\",\n \"def ls(tesserae, order_by, order_type, filter_types):\\n try:\\n return tesserae.ls(order_by, order_type, set([x.strip() for x in filter_types.split(\\\",\\\")]) if filter_types else set())\\n except TesseraError, e:\\n sys.stderr.write(\\\"Error: %s\\\\n\\\" % str(e))\\n return False\",\n \"def itemFilterType(*args, text: Union[AnyStr, bool]=\\\"\\\", type: bool=True, q=True, query=True,\\n e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def visitCriteria(self, ctx: ApiQLParser.CriteriaContext):\\n return lmap(lambda c: c.accept(self), ctx.getChildren(self.filter_ignored))\",\n \"def search(self, filters=None):\\n raise NotImplementedError\",\n \"def type_search(self, queryset, name, value):\\n qs_filter = Q(type=ROUTING_POLICY_TYPE_IMPORT_EXPORT)\\n for v in value:\\n qs_filter |= Q(type=v)\\n return queryset.filter(qs_filter)\",\n \"def filter(self, cls):\\n return ElementList([x for x in self._elements if isinstance(x, cls)])\",\n \"def get_all_items(model, type):\\n if(type == \\\"office\\\"):\\n return model.get_all_offices()\\n elif(type == \\\"party\\\"):\\n return model.get_all_parties()\\n return []\",\n \"def filter(full_poi_list, type_of_poi):\\n pois = []\\n if type_of_poi == \\\"all\\\":\\n for i in full_poi_list:\\n entry = i[0]\\n pois.append(entry)\\n if type_of_poi == \\\"gym\\\":\\n for i in full_poi_list:\\n if i[1] == 2:\\n entry = i[0]\\n pois.append(entry)\\n return pois\",\n \"def search_project_or_study(obj_type):\\n\\n matches = []\\n response = None\\n\\n try:\\n if obj_type not in set([\\\"projects\\\", \\\"studies\\\"]):\\n raise Exception(\\\"Invalid object type specified\\\")\\n\\n possible_filters = filters_d[obj_type]\\n \\n for f in file_dict[obj_type][\\\"valid\\\"].values():\\n json_file = data_dir + f\\n json_s = open(json_file, \\\"r\\\").read()\\n json_obj = json.loads(json_s)\\n add_to_matches = True\\n\\n for filter_name in possible_filters:\\n filter_val = request.args.get(filter_name)\\n if filter_val:\\n if json_obj[filter_name] != filter_val:\\n add_to_matches = False\\n \\n if add_to_matches:\\n matches.append(json_s)\\n\\n response_body = \\\"[\\\" + \\\",\\\".join(matches) + \\\"]\\\"\\n response = get_response(response_body, status=200)\\n\\n except Exception as e:\\n print(\\\"bad request\\\")\\n response_body = '''{\\\"message\\\": \\\"invalid resource '%s'\\\"}''' % obj_type\\n response = get_response(response_body, status=400)\\n\\n return response\",\n \"def test_filter_mixed_function(self):\\n for none_type in (False, True):\\n for all_type in (False, True):\\n for any_type in (False, True, None):\\n result = none_type is False and all_type is True \\\\\\n and (any_type is None or any_type is True)\\n self._test_filter(none_type, all_type, any_type, result)\",\n \"def itemFilter(*args, byBin: Union[AnyStr, List[AnyStr], bool]=\\\"\\\", byName: Union[AnyStr,\\n bool]=\\\"\\\", byScript: Union[AnyStr, bool]=\\\"\\\", byType: Union[AnyStr, List[AnyStr],\\n bool]=\\\"\\\", category: Union[AnyStr, List[AnyStr], bool]=\\\"\\\", classification:\\n Union[AnyStr, bool]=\\\"\\\", clearByBin: bool=True, clearByType: bool=True,\\n difference: Union[List[AnyStr, AnyStr], bool]=None, exists: bool=True,\\n intersect: Union[List[AnyStr, AnyStr], bool]=None, listBuiltInFilters: bool=True,\\n listOtherFilters: bool=True, listUserFilters: bool=True, negate: bool=True,\\n parent: Union[AnyStr, bool]=\\\"\\\", pythonModule: Union[AnyStr, bool]=\\\"\\\",\\n secondScript: Union[AnyStr, bool]=\\\"\\\", text: Union[AnyStr, bool]=\\\"\\\", union:\\n Union[List[AnyStr, AnyStr], bool]=None, uniqueNodeNames: bool=True, q=True,\\n query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def node_type_filter(node_list, *filter_types):\\n\\n flg = logging.getLogger(\\\"lettuce.xgenSetup.node_type_filter\\\")\\n\\n flg.info(\\\"Filtering Node List\\\")\\n\\n filtered_list = []\\n for node in node_list:\\n node_type = mc.nodeType(node)\\n flg.debug(\\\"Node, {0}, is of type, {1}\\\".format(node, node_type))\\n if node_type not in filter_types:\\n flg.debug(\\\"Node kept\\\")\\n filtered_list.append(node)\\n else:\\n flg.debug(\\\"Node filtered\\\")\\n flg.info(\\\"Returning Filtered List\\\")\\n return filtered_list\",\n \"def by_type(self, type):\\n return self.filter(related_type__title=type)\",\n \"def filter_all(_):\\n return True\",\n \"def all(self):\\n\\t\\timport revitron\\n\\t\\tdb = revitron.DB\\n\\t\\tf = db.LogicalOrFilter(\\n\\t\\t db.ElementIsElementTypeFilter(False),\\n\\t\\t db.ElementIsElementTypeFilter(True)\\n\\t\\t)\\n\\n\\t\\tself.collector = self.collector.WherePasses(f)\\n\\t\\treturn self\",\n \"def by_card_type(cls, card_type):\\n return Filter('card_type', values=(card_type,), operator=Filter.OPERATOR['EQUAL'])\",\n \"def filter_room_type(self, criterias, index, bool_room_type):\\n # if the user input doesn't pass verification, don't filter by this criteria\\n # so always return True\\n if bool_room_type == False:\\n return True\\n\\n criterias = {key: self.convert_room_type_input(\\n val) for key, val in criterias.items()}\\n listing_room_type = self.process_room_type(\\n self.data[index]['roomType'])\\n bool_bed = criterias['Bedrooms'][1](\\n listing_room_type['Bedrooms'], criterias['Bedrooms'][0])\\n bool_bath = criterias['Bathrooms'][1](\\n listing_room_type['Bathrooms'], criterias['Bathrooms'][0])\\n return bool_bed & bool_bath\",\n \"def get_object_from_filter(obj, components):\\n\\n components = components[:]\\n while len(components) > 2:\\n obj = getattr(obj, components.pop(0))\\n if len(components) == 2:\\n if components[-1] != \\\"regex\\\":\\n if not hasattr(obj, f\\\"__{components[-1]}__\\\"):\\n obj = getattr(obj, components[0])\\n return obj\",\n \"def _set_runtime_filters(self):\\n runtime_filters = []\\n if not all(len(filter_tuple) == 3 for filter_tuple in self.filters):\\n raise TypeError(\\n '%s: filters must be a sequence of tuple with length=3'\\n ' got %r instead' % (self.__class__.__name__, self.filters))\\n\\n for filter_type, filter_operator, filter_value in self.filters:\\n if isinstance(filter_type, ValueProvider):\\n filter_type = filter_type.get()\\n if isinstance(filter_operator, ValueProvider):\\n filter_operator = filter_operator.get()\\n if isinstance(filter_value, ValueProvider):\\n filter_value = filter_value.get()\\n runtime_filters.append((filter_type, filter_operator, filter_value))\\n\\n return runtime_filters or ()\",\n \"def filter_features_by_type(feats: FeaturesTuple, feat_type: FeatureTypeTypes) -> FeaturesTuple:\\n return tuple([feat for feat in feats if type(feat) == feat_type])\",\n \"def _filter(self, lst):\\n\\n lst = list(set(lst)) # removes duplicate items\\n if lst is None:\\n return []\\n arr = []\\n for item in lst:\\n for typ in [str(g) for g in self.__class__.OBJ_TYPES]:\\n if cmds.objectType(item) == typ:\\n arr.append(item)\\n\\n arr.sort(key=lambda x: x.count('|'))\\n return arr[::-1] # reverse list\",\n \"def filter_by_type(x, _request_type_list=None):\\n if _request_type_list:\\n for request_type in _request_type_list:\\n if x[\\\"request_type\\\"] == request_type:\\n return True\\n return False\\n return True\",\n \"def components(self, predicate=None):\\n \\n if predicate is None:\\n return self._get(\\\"components\\\").json()\\n else:\\n return self._get(\\\"components/search\\\", params={\\\"predicate\\\":predicate}).json()\",\n \"def filter_transactions_by_type(self, request):\\n transactions = Transaction.objects.all()\\n type = request.data[\\\"type\\\"]\\n if type == \\\"in\\\" :\\n transactions = transactions.filter(amount__gt=0)\\n else:\\n transactions = transactions.filter(amount__lt=0)\\n serializer = TransactionSerializer(transactions, many=True)\\n return Response(serializer.data)\",\n \"def filter_by_class(objects, cls):\\n if cls is not None:\\n filtered = []\\n classes = cls if isinstance(cls, tuple) else (cls,)\\n for o in objects:\\n valid = False\\n for c in classes:\\n try:\\n if o.is_valid(c):\\n valid = True\\n break\\n except AttributeError:\\n continue\\n if valid:\\n filtered.append(o)\\n return filtered\\n else:\\n return list(objects)\",\n \"def get_recipes_by_types(self, recipe_type): \\n\\t\\tfor key, val in self.recipes_list.items():\\n\\t\\t\\tif key == recipe_type:\\n\\t\\t\\t\\tfor a, b in val.items():\\n\\t\\t\\t\\t\\tprint(str(b))\",\n \"def get_items_of_type(self, item_type):\\n return (item for item in self.items if item.get_type() == item_type)\",\n \"def filter(data, mask, **kwargs):\\n return Component(\\n \\\"Filter\\\",\\n arguments={\\n 'data': Component.of(data),\\n 'mask': Component.of(mask)\\n },\\n options={\\n \\n },\\n constraints=kwargs)\",\n \"def attribute_search(self, attribute, filters):\\n for i in self.response_info['results']:\\n if filters in i[attribute]:\\n self.output.append(i)\\n self.counter += 1\",\n \"def get_search(self, type, params, batch=False):\\n path = 'search'\\n args = {'type': type}\\n args.update(params)\\n return self.make_request(path, 'GET', args, batch=batch)\",\n \"def filter(self, filters:list)->list:\\n for item in self.list:\\n use_item = True\\n for filter in filters:\\n filter_key, filter_value, filter_type = filter\\n if filter_type == \\\"<\\\" and item[filter_key] >= filter_value:\\n use_item = False\\n break\\n elif filter_type == \\\">\\\" and item[filter_key] <= filter_value:\\n use_item = False\\n break\\n elif filter_type == \\\"<=\\\" and item[filter_key] > filter_value:\\n use_item = False\\n break\\n elif filter_type == \\\">=\\\" and item[filter_key] < filter_value:\\n use_item = False\\n break\\n elif filter_type == \\\"=\\\" and not item[filter_key] == filter_value:\\n use_item = False\\n break\\n if use_item:\\n yield item\",\n \"def _build_filters(self, criteria: Q):\\n # Decide the function based on the connector type\\n func = and_ if criteria.connector == criteria.AND else or_\\n params = []\\n for child in criteria.children:\\n if isinstance(child, Q):\\n # Call the function again with the child\\n params.append(self._build_filters(child))\\n else:\\n # Find the lookup class and the key\\n stripped_key, lookup_class = self.provider._extract_lookup(child[0])\\n\\n # Instantiate the lookup class and get the expression\\n lookup = lookup_class(stripped_key, child[1], self.model_cls)\\n if criteria.negated:\\n params.append(~lookup.as_expression())\\n else:\\n params.append(lookup.as_expression())\\n\\n return func(*params)\",\n \"def matching_blocks_by_type(self):\\n try:\\n block_structure = get_course_in_cache(self.course_key)\\n matching_blocks = block_structure.topological_traversal(\\n filter_func=self.block_type_filter,\\n yield_descendants_of_unyielded=True,\\n )\\n self.course_block_structure = block_structure\\n except item_not_found_error():\\n return []\\n\\n return list(matching_blocks)\",\n \"def _filter_for_panel( item, item_type, filters, context ):\\n def _apply_filter( filter_item, filter_list ):\\n for filter_method in filter_list:\\n try:\\n if not filter_method( context, filter_item ):\\n return False\\n except Exception as e:\\n raise MessageException( \\\"Toolbox filter exception from '%s': %s.\\\" % ( filter_method.__name__, e ) )\\n return True\\n if item_type == panel_item_types.TOOL:\\n if _apply_filter( item, filters[ 'tool' ] ):\\n return item\\n elif item_type == panel_item_types.LABEL:\\n if _apply_filter( item, filters[ 'label' ] ):\\n return item\\n elif item_type == panel_item_types.SECTION:\\n # Filter section item-by-item. Only show a label if there are\\n # non-filtered tools below it.\\n\\n if _apply_filter( item, filters[ 'section' ] ):\\n cur_label_key = None\\n tools_under_label = False\\n filtered_elems = item.elems.copy()\\n for key, section_item_type, section_item in item.panel_items_iter():\\n if section_item_type == panel_item_types.TOOL:\\n # Filter tool.\\n if _apply_filter( section_item, filters[ 'tool' ] ):\\n tools_under_label = True\\n else:\\n del filtered_elems[ key ]\\n elif section_item_type == panel_item_types.LABEL:\\n # If there is a label and it does not have tools,\\n # remove it.\\n if cur_label_key and ( not tools_under_label or not _apply_filter( section_item, filters[ 'label' ] ) ):\\n del filtered_elems[ cur_label_key ]\\n\\n # Reset attributes for new label.\\n cur_label_key = key\\n tools_under_label = False\\n\\n # Handle last label.\\n if cur_label_key and not tools_under_label:\\n del filtered_elems[ cur_label_key ]\\n\\n # Only return section if there are elements.\\n if len( filtered_elems ) != 0:\\n copy = item.copy()\\n copy.elems = filtered_elems\\n return copy\\n\\n return None\",\n \"def filter_or(filters):\\n def filt(item):\\n for f in filters:\\n if f(item):\\n return True\\n return False\\n return filt\",\n \"def _build_filter_part(self, cls, filters, order_by=None, select=None):\\r\\n import types\\r\\n query_parts = []\\r\\n\\r\\n order_by_filtered = False\\r\\n\\r\\n if order_by:\\r\\n if order_by[0] == \\\"-\\\":\\r\\n order_by_method = \\\"DESC\\\";\\r\\n order_by = order_by[1:]\\r\\n else:\\r\\n order_by_method = \\\"ASC\\\";\\r\\n\\r\\n if select:\\r\\n if order_by and order_by in select:\\r\\n order_by_filtered = True\\r\\n query_parts.append(\\\"(%s)\\\" % select)\\r\\n\\r\\n if isinstance(filters, str) or isinstance(filters, unicode):\\r\\n query = \\\"WHERE %s AND `__type__` = '%s'\\\" % (filters, cls.__name__)\\r\\n if order_by in [\\\"__id__\\\", \\\"itemName()\\\"]:\\r\\n query += \\\" ORDER BY itemName() %s\\\" % order_by_method\\r\\n elif order_by != None:\\r\\n query += \\\" ORDER BY `%s` %s\\\" % (order_by, order_by_method)\\r\\n return query\\r\\n\\r\\n for filter in filters:\\r\\n filter_parts = []\\r\\n filter_props = filter[0]\\r\\n if type(filter_props) != list:\\r\\n filter_props = [filter_props]\\r\\n for filter_prop in filter_props:\\r\\n (name, op) = filter_prop.strip().split(\\\" \\\", 1)\\r\\n value = filter[1]\\r\\n property = cls.find_property(name)\\r\\n if name == order_by:\\r\\n order_by_filtered = True\\r\\n if types.TypeType(value) == types.ListType:\\r\\n filter_parts_sub = []\\r\\n for val in value:\\r\\n val = self.encode_value(property, val)\\r\\n if isinstance(val, list):\\r\\n for v in val:\\r\\n filter_parts_sub.append(self._build_filter(property, name, op, v))\\r\\n else:\\r\\n filter_parts_sub.append(self._build_filter(property, name, op, val))\\r\\n filter_parts.append(\\\"(%s)\\\" % (\\\" OR \\\".join(filter_parts_sub)))\\r\\n else:\\r\\n val = self.encode_value(property, value)\\r\\n if isinstance(val, list):\\r\\n for v in val:\\r\\n filter_parts.append(self._build_filter(property, name, op, v))\\r\\n else:\\r\\n filter_parts.append(self._build_filter(property, name, op, val))\\r\\n query_parts.append(\\\"(%s)\\\" % (\\\" or \\\".join(filter_parts)))\\r\\n\\r\\n\\r\\n type_query = \\\"(`__type__` = '%s'\\\" % cls.__name__\\r\\n for subclass in self._get_all_decendents(cls).keys():\\r\\n type_query += \\\" or `__type__` = '%s'\\\" % subclass\\r\\n type_query +=\\\")\\\"\\r\\n query_parts.append(type_query)\\r\\n\\r\\n order_by_query = \\\"\\\"\\r\\n\\r\\n if order_by:\\r\\n if not order_by_filtered:\\r\\n query_parts.append(\\\"`%s` LIKE '%%'\\\" % order_by)\\r\\n if order_by in [\\\"__id__\\\", \\\"itemName()\\\"]:\\r\\n order_by_query = \\\" ORDER BY itemName() %s\\\" % order_by_method\\r\\n else:\\r\\n order_by_query = \\\" ORDER BY `%s` %s\\\" % (order_by, order_by_method)\\r\\n\\r\\n if len(query_parts) > 0:\\r\\n return \\\"WHERE %s %s\\\" % (\\\" AND \\\".join(query_parts), order_by_query)\\r\\n else:\\r\\n return \\\"\\\"\",\n \"def filter_scalings(scaling_list, scaling_type):\\n return filter(\\n lambda _f: True if scaling_type in _f[\\\"runname\\\"] else False,\\n scaling_list)\",\n \"def get_objects_by_type(self, *types) -> List[TgnObject]:\\n if not types:\\n return list(self.objects.values())\\n types_l = [o.lower() for o in types]\\n return [o for o in self.objects.values() if o.type.lower() in types_l]\",\n \"def extract_filters(self):\\n self.filters = self.controller.filters\\n\\n self.extract_core_stats()\\n self.extract_abilities()\\n # goes through and adds all list-based filters\\n for filterType, elements in self.filters.items():\\n if type(elements) == list and len(elements) > 0:\\n self.extract_filter_list(filterType, elements)\",\n \"def setFilter(self, type: int, filter: int) -> None:\\n ...\",\n \"def _base_proxies_filter(self, category: str, filters: list) -> list:\\n\\n data_filtered = []\\n \\n if category == 'country':\\n data_filtered.extend(\\n Froxy._filter_model(self.storage.get(), line=2, col=0, filters=filters)\\n )\\n \\n elif category == 'anonymity':\\n data_filtered.extend(\\n Froxy._filter_model(self.storage.get(), line=2, col=1, filters=filters)\\n )\\n\\n elif category == 'protocol':\\n data_filtered.extend(\\n Froxy._filter_model(self.storage.get(), line=2, col=2, filters=filters)\\n )\\n \\n elif category == 'google_passed':\\n data_filtered.extend(\\n Froxy._filter_model(self.storage.get(), line=2, col=3, filters=filters)\\n )\\n\\n return data_filtered\",\n \"def get_node_components(self, node=None, filter_type=None):\\n if node is not None and node not in self.get_nodes():\\n raise KeyError('{} is not an exiting node'.format(node))\\n\\n if node is not None:\\n return self.components[node].get_components(filter_type=filter_type)\\n else:\\n out = {}\\n for node_name in self.get_nodes():\\n for comp_name, comp in self.components[\\n node_name].get_components(\\n filter_type=filter_type).items():\\n out[comp_name] = comp\\n return out\",\n \"def getResultDefs(self, type=None):\\n results = self.results.values()\\n\\n if type:\\n results = filter(lambda result: result.type == type, results)\\n\\n return results\",\n \"def dependency_filter(dependencies,start=0,end=-1,filter_val=None,filter_vals=[],field=None,filter_range='dependent'):\\n return [getattr(i, field) if field else i for i in dependencies if \\n (start == 0 or getattr(i, filter_range).idx >= start) and \\n (end == -1 or getattr(i, filter_range).idx < end) and \\n ((filter_val == None and not filter_vals) or i.type in filter_vals + [filter_val] or (filter_val[-1]=='*' and i.type.startswith(filter_val[0:-1])))\\n ]\",\n \"def get_contract_filters(*contracts):\\n return [generate_filter(filter_text) for filter_text in contracts]\",\n \"def ListMatchingComponents(self, policy_type):\\n base_name = self.GetBaseFilename(policy_type)\\n files = glob.glob('%s_*.*' % base_name)\\n len_base_name = len(base_name) + 1\\n return [ file[len_base_name:file.rfind('.')] for file in files ]\",\n \"def types_query(owner_name):\\n query = Products.query.with_entities(Products.type_name.label('Type'))\\\\\\n .filter_by(owner_name=owner_name)\\\\\\n .distinct()\\n return query\",\n \"def test_get_component_descriptors_by_type_using_get(self):\\n pass\",\n \"def servicemanage_type_get_all(context, inactive=False, filters=None):\\n filters = filters or {}\\n\\n read_deleted = \\\"yes\\\" if inactive else \\\"no\\\"\\n rows = model_query(context, models.ServiceManageTypes,\\n read_deleted=read_deleted).\\\\\\n options(joinedload('extra_specs')).\\\\\\n order_by(\\\"name\\\").\\\\\\n all()\\n\\n # TODO(sirp): this patern of converting rows to a result with extra_specs\\n # is repeated quite a bit, might be worth creating a method for it\\n result = {}\\n for row in rows:\\n result[row['name']] = _dict_with_extra_specs(row)\\n\\n return result\",\n \"def filter(self, *args):\\n return _libsbml.ElementFilter_filter(self, *args)\",\n \"def _filter(self, filter_condition):\\n def _inner_filter(item: list):\\n return self._default_filter(item, filter_condition)\\n\\n self._result = list(filter(_inner_filter, self._data))\",\n \"def _filter_types_index(self, types_index, resource_type_id):\\n entities = []\\n if resource_type_id in types_index:\\n entities.extend(types_index[resource_type_id])\\n return entities\",\n \"def get_fields_by_type(self, field_type):\\n for field in self.fields:\\n if field.get_field_type() == field_type:\\n yield field\",\n \"def search(self, filter):\\n return [note for note in self.notes if note.match(filter)]\",\n \"def get_estimators(type_filter='all'):\\n\\n if type_filter not in ['all', 'classifier', 'transformer', 'cluster']:\\n # TODO: make this exception more specific\\n raise Exception(\\\"type_filter should be element of \\\"\\n \\\"['all', 'classifier', 'transformer', 'cluster']\\\")\\n\\n all_classes = _get_all_classes()\\n\\n # Filter out those that are not a subclass of `sklearn.BaseEstimator`\\n all_classes = [c for c in set(all_classes)\\n if issubclass(c[1], BaseEstimator)]\\n\\n # get rid of abstract base classes\\n all_classes = filter(lambda c: not is_abstract(c[1]), all_classes)\\n\\n # only keep those that are from tslearn\\n all_classes = filter(lambda c: not is_sklearn(c[1]), all_classes)\\n\\n # Now filter out the estimators that are not of the specified type\\n filters = {\\n 'all': [ClassifierMixin, RegressorMixin,\\n TransformerMixin, ClusterMixin],\\n 'classifier': [ClassifierMixin],\\n 'transformer': [TransformerMixin],\\n 'cluster': [ClusterMixin]\\n }[type_filter]\\n filtered_classes = []\\n for _class in all_classes:\\n if any([issubclass(_class[1], mixin) for mixin in filters]):\\n filtered_classes.append(_class)\\n\\n # Remove duplicates and return the list of remaining estimators\\n return sorted(set(filtered_classes), key=itemgetter(0))\",\n \"def _queryset(self):\\n return self.type.objects.filter(id__in=self.ids)\",\n \"def __init__(self, type: int, filter: int):\\n ...\",\n \"def sol_type_filter(opps, types):\\n global _total_skipped, _total_kept\\n filtered_opps = []\\n for opp in opps:\\n if opp['type']['value'] in types:\\n filtered_opps.append(opp)\\n _total_kept += 1\\n else:\\n _total_skipped += 1\\n\\n logger.debug(\\\"Total skip stats so far: Skipping {} out of {} due to solicitation type\\\".format(_total_skipped, _total_kept + _total_skipped))\\n return filtered_opps\",\n \"def filter_by_query_params(self, request):\\n items = self\\n company = request.GET.get('company', None)\\n main_contractor = request.GET.get('main_contractor', None)\\n main_sub_contractor = request.GET.get('main_sub_contractor', None)\\n client = request.GET.get('client', None)\\n q = request.GET.get('q', None)\\n sort_by = request.GET.get('sort_by', None)\\n str = request.GET.get('str', None)\\n\\n # filter\\n if main_contractor:\\n items = items.filter(main_contractor=main_contractor).distinct()\\n if main_sub_contractor:\\n items = items.filter(main_sub_contractor=main_sub_contractor).distinct()\\n if client:\\n items = items.filter(client=client).distinct()\\n if company:\\n items = items.filter(companies_linked__in=[company]).distinct()\\n # sort\\n if q == 'asc' and sort_by:\\n items = items.order_by(sort_by).distinct()\\n\\n if q == 'des' and sort_by:\\n items = items.order_by('-' + sort_by).distinct()\\n\\n if str:\\n # str = str.strip().lower()\\n items = items.filter(Q(reference_no__icontains=str) |\\n Q(name__icontains=str)).distinct()\\n return items\",\n \"def filter(self, filter_dict):\\n pass\",\n \"def test_filter_services_by_components(self):\\n\\n service1 = sample_services(user=self.user, title='Mechanical Work 1')\\n service2 = sample_services(user=self.user, title='Mechanical Work 2')\\n service3 = sample_services(user=self.user, title='Mechanical Work 3')\\n\\n component1 = sample_componenets(user=self.user, name='Mech1')\\n component2 = sample_componenets(user=self.user, name='Mech2')\\n component3 = sample_componenets(user=self.user, name='mech3')\\n\\n service1.components.add(component1)\\n service2.components.add(component2)\\n service3.components.add(component3)\\n\\n res = self.client.get(\\n SERVICES_URL,\\n {'tags': f'{component1.id},{component2.id},{component3.id}'}\\n )\\n\\n serializer1 = ServiceSerializer(service1)\\n serializer2 = ServiceSerializer(service2)\\n serializer3 = ServiceSerializer(service3)\\n\\n self.assertIn(serializer1.data, res.data)\\n self.assertIn(serializer2.data, res.data)\\n self.assertNotIn(serializer3.data, res.data)\",\n \"def filt(rec):\\n return True # Show everything\",\n \"def filter(self, viewer, parent, elements):\\n\\n return [e for e in elements if self.select(viewer, parent, e)]\",\n \"def filter(self, filters):\\r\\n # because http.Request needs params to be a dict of strings to strings\\r\\n # (roughly) and since BitBucket wants repeated parameters to express\\r\\n # OR, we'll do the quoting by hand ourselves\\r\\n def flatten_conditions(filters):\\r\\n for key, val in filters.items():\\r\\n if isinstance(val, (list, tuple)):\\r\\n for v in val:\\r\\n yield (port.to_b(key), port.to_b(v))\\r\\n else:\\r\\n yield (port.to_b(key), port.to_b(val))\\r\\n\\r\\n to_encode = tuple(flatten_conditions(filters))\\r\\n qs = port.urlencode(to_encode)\\r\\n\\r\\n url = '{0}/?{1}'.format(self.get_url(), qs)\\r\\n return http.Request('GET', url), parsers.parse_json\",\n \"def doFiltering(self, searchfunc, filters=None):\\n F=[]\\n for f in self.filters:\\n F.append(f.getFilter())\\n #print F\\n sets = []\\n for f in F:\\n col, val, op, boolean = f\\n names = searchfunc(col, val, op)\\n sets.append((set(names), boolean))\\n names = sets[0][0]\\n for s in sets[1:]:\\n b=s[1]\\n if b == 'AND':\\n names = names & s[0]\\n elif b == 'OR':\\n names = names | s[0]\\n elif b == 'NOT':\\n names = names - s[0]\\n names = list(names)\\n self.updateResults(len(names))\\n return names\",\n \"def test_get_component_descriptors_by_types_using_get(self):\\n pass\",\n \"def filter_inspection_type(data, inspection_type):\\n return [row for row in data if row['inspection_type'] == inspection_type]\",\n \"def find(cls, **filters):\\n return cls.query.filter_by(**filters).all()\",\n \"def filter_items(self, filter_data: Dict[str, str] = None) -> List[WalletItem]:\\n filtered_items = self.items\\n for key, value in filter_data.items():\\n if key == \\\"category\\\":\\n filtered_items = [item for item in filtered_items\\n if re.search(value, item.category, re.IGNORECASE)]\\n if key == \\\"account\\\":\\n filtered_items = [item for item in filtered_items\\n if re.search(value, item.account, re.IGNORECASE)]\\n if key == \\\"notes\\\" in filter_data:\\n filtered_items = [item for item in filtered_items\\n if re.search(value, item.notes, re.IGNORECASE)]\\n if key == \\\"amt_min\\\":\\n value = float(value)\\n filtered_items = [item for item in filtered_items if item.amount >= value]\\n if key == \\\"amt_max\\\":\\n value = float(value)\\n filtered_items = [item for item in filtered_items if item.amount <= value]\\n if key == \\\"begin_date\\\":\\n try:\\n begin_date = datetime.strptime(value, '%d/%m/%Y')\\n filtered_items = [item for item in filtered_items if begin_date <= item.date]\\n except ValueError as ex:\\n print(ex)\\n exit(1)\\n if key == \\\"end_date\\\":\\n try:\\n end_date = datetime.strptime(value, '%d/%m/%Y')\\n filtered_items = [item for item in filtered_items if item.date <= end_date]\\n except ValueError as ex:\\n print(ex)\\n exit(1)\\n return filtered_items\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7252907","0.6754801","0.6730381","0.66894734","0.6564939","0.6288751","0.6273336","0.62642753","0.6115402","0.5971226","0.59191287","0.5848749","0.58480895","0.5832433","0.5759755","0.5755212","0.56894547","0.56826574","0.5639281","0.56076664","0.5592761","0.55915564","0.5583345","0.54409814","0.5439224","0.5420898","0.5412727","0.5404295","0.53887784","0.53765273","0.5369036","0.5367627","0.5361758","0.53568834","0.5348402","0.53368133","0.5330973","0.53249484","0.53220046","0.5321912","0.5321202","0.53184074","0.531246","0.5274514","0.52638537","0.52604777","0.5258013","0.52559274","0.5255614","0.52424014","0.52345604","0.5222513","0.5203605","0.52017033","0.5200359","0.51820076","0.5176559","0.5176214","0.5170003","0.5165079","0.5160561","0.5159679","0.5156709","0.51528263","0.51487833","0.5141232","0.51384294","0.5137739","0.5137098","0.51285505","0.51283485","0.51208675","0.50999403","0.50944513","0.5088926","0.5088843","0.50855887","0.50756794","0.5074656","0.50723374","0.50682783","0.5067265","0.50521946","0.505053","0.50497985","0.5049078","0.50474995","0.50459003","0.5045165","0.50380456","0.5037114","0.50220513","0.5018538","0.50116086","0.5011279","0.5009123","0.49976364","0.49874136","0.49773327","0.4975905"],"string":"[\n \"0.7252907\",\n \"0.6754801\",\n \"0.6730381\",\n \"0.66894734\",\n \"0.6564939\",\n \"0.6288751\",\n \"0.6273336\",\n \"0.62642753\",\n \"0.6115402\",\n \"0.5971226\",\n \"0.59191287\",\n \"0.5848749\",\n \"0.58480895\",\n \"0.5832433\",\n \"0.5759755\",\n \"0.5755212\",\n \"0.56894547\",\n \"0.56826574\",\n \"0.5639281\",\n \"0.56076664\",\n \"0.5592761\",\n \"0.55915564\",\n \"0.5583345\",\n \"0.54409814\",\n \"0.5439224\",\n \"0.5420898\",\n \"0.5412727\",\n \"0.5404295\",\n \"0.53887784\",\n \"0.53765273\",\n \"0.5369036\",\n \"0.5367627\",\n \"0.5361758\",\n \"0.53568834\",\n \"0.5348402\",\n \"0.53368133\",\n \"0.5330973\",\n \"0.53249484\",\n \"0.53220046\",\n \"0.5321912\",\n \"0.5321202\",\n \"0.53184074\",\n \"0.531246\",\n \"0.5274514\",\n \"0.52638537\",\n \"0.52604777\",\n \"0.5258013\",\n \"0.52559274\",\n \"0.5255614\",\n \"0.52424014\",\n \"0.52345604\",\n \"0.5222513\",\n \"0.5203605\",\n \"0.52017033\",\n \"0.5200359\",\n \"0.51820076\",\n \"0.5176559\",\n \"0.5176214\",\n \"0.5170003\",\n \"0.5165079\",\n \"0.5160561\",\n \"0.5159679\",\n \"0.5156709\",\n \"0.51528263\",\n \"0.51487833\",\n \"0.5141232\",\n \"0.51384294\",\n \"0.5137739\",\n \"0.5137098\",\n \"0.51285505\",\n \"0.51283485\",\n \"0.51208675\",\n \"0.50999403\",\n \"0.50944513\",\n \"0.5088926\",\n \"0.5088843\",\n \"0.50855887\",\n \"0.50756794\",\n \"0.5074656\",\n \"0.50723374\",\n \"0.50682783\",\n \"0.5067265\",\n \"0.50521946\",\n \"0.505053\",\n \"0.50497985\",\n \"0.5049078\",\n \"0.50474995\",\n \"0.50459003\",\n \"0.5045165\",\n \"0.50380456\",\n \"0.5037114\",\n \"0.50220513\",\n \"0.5018538\",\n \"0.50116086\",\n \"0.5011279\",\n \"0.5009123\",\n \"0.49976364\",\n \"0.49874136\",\n \"0.49773327\",\n \"0.4975905\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74276376"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":182,"cells":{"query":{"kind":"string","value":"Inform a service component that it is providing a service Called when an immediatelycontaining service manager binds this object to perform the named service."},"document":{"kind":"string","value":"def bound(name):"},"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 service(self, service):\n \n self._service = service","def register_service(self) -> None:\n strategy = cast(Strategy, self.context.strategy)\n description = strategy.get_register_service_description()\n self._register(description, \"registering agent's service on the SOEF.\")","def service(self):\n pass","def register_service(service, iface, name):","def _hs_service(self, service_name, address, port, properties):\n identifier = service_name.split(\".\")[0]\n name = properties.get(\"Name\")\n hsgid = properties.get(\"hG\")\n service = conf.DmapService(identifier, hsgid, port=port, properties=properties)\n self._handle_service(address, name, service)","def on_service_arrival(self, svc_ref):\n with self._lock:\n new_ranking = svc_ref.get_property(SERVICE_RANKING)\n if self._current_ranking is not None:\n if new_ranking > self._current_ranking:\n # New service with better ranking: use it\n self._pending_ref = svc_ref\n old_ref = self.reference\n old_value = self._value\n\n # Clean up like for a departure\n self._current_ranking = None\n self._value = None\n self.reference = None\n\n # Unbind (new binding will be done afterwards)\n self._ipopo_instance.unbind(self, old_value, old_ref)\n else:\n # No ranking yet: inject the service\n self.reference = svc_ref\n self._value = self._context.get_service(svc_ref)\n self._current_ranking = new_ranking\n self._pending_ref = None\n\n self._ipopo_instance.bind(self, self._value, self.reference)","def service(self) -> BaseService:","def add_service(self, service):\n self.app.add_service(service)","def find_service(iface, context, name):","def register_service(self, service, iface, name=''):\n key = 'component' if not callable(service) else 'factory'\n kwargs = {'provided': iface, key: service, 'name': name}\n self._component.registerUtility(**kwargs)","def set_service(self):\n\n if self.service:\n self.service = self.service(\n json=self.json,\n google_user=self.google_user,\n endpoint=self\n )","def service_handler(service):\n entity_id = ENTITY_ID_FORMAT.format(service.service)\n script = component.entities.get(entity_id)\n if script:\n script.turn_on()","def _bind_to_service(self):\n if self._service_dn:\n # bind with the service_dn\n self._server.simple_bind_s(self._service_dn, self._service_password)\n else:\n # force a connection without binding\n self._server.whoami_s()","def offerService(self, serviceName):\n service = Service(serviceName)\n self.serviceTable[serviceName] = service\n return service","def get_service(self):","def set_service(service_name, reference):\n Container.services[service_name] = reference","def servicesChanged(self) -> None:\n ...","def service(self, block, service_name):\n declaration = block.service_declaration(service_name)\n if declaration is None:\n raise NoSuchServiceError(f\"Service {service_name!r} was not requested.\")\n service = self._services.get(service_name)\n if service is None and declaration == \"need\":\n raise NoSuchServiceError(f\"Service {service_name!r} is not available.\")\n return service","def _remember_service_name(self, event):\n service_name = event[\"arguments\"][\"service_name\"]\n # We've added logging of the service_handle to the API signature in\n # the Monitor, but for backwards compatibility we'll keep it as\n # follows for now.\n service_handle = \"0x%08x\" % event[\"return_value\"]\n self.services[service_handle] = service_name","def __init__(self, service_name):\n self.service_name = service_name","def set_service_name(name):\n emit(UPDATE_SERVICE_SIGNAL, BREADCRUMB_SENDER, name=name)","def register_service(self, service, name):\n assert service._remote_service, \"Services should be decorated correctly.\"\n \n prepare_remote_service(service)\n self._services[name] = service","def _bind_agent(self, field, service, svc_ref):\n # Tell it to handle remaining components\n service.handle(self._remaining)\n self._remaining.clear()","def future_supported_service(service_name):\n print('Service {} linked.'.format(service_name))\n pass","def register_service(self, service: str, cb: Callable, **kwargs: Optional[Any]) -> None:\n self._check_service(service)\n d, s = service.split(\"/\")\n self.logger.debug(\"register_service: %s/%s, %s\", d, s, kwargs)\n\n namespace = self._get_namespace(**kwargs)\n\n if \"namespace\" in kwargs:\n del kwargs[\"namespace\"]\n\n kwargs[\"__name\"] = self.name\n\n self.AD.services.register_service(namespace, d, s, cb, __async=\"auto\", **kwargs)","def register_service(self, name, command):\n service_name = command['service_name']\n try:\n service_type = self.get_interface_type(command['interface_type'], '.srv')\n self.srv_clients[service_name] = self.AsyncServiceProxy(\n self,\n service_name,\n service_type)\n\n if service_name in self.offline_services:\n self.offline_services.remove(service_name)\n except JoyTeleopException:\n if service_name not in self.offline_services:\n self.offline_services.append(service_name)","def _registerService(self, callerId, service, serviceApi, callerApi):\n if service not in self.FilterServices:\n # The type of the service is not included in the XMLRPC call\n self.__docWriter.addService(callerId, service, \"TODO: type\")","def startService(self):\n super(MasterService, self).startService()\n self.dispatcher.startDispatching()","def bind(self, svc, svc_ref):\n with self._lock:\n if ORDER_HANDLER in svc_ref.get_property(pelix.OBJECTCLASS):\n targets = svc_ref.get_property(ORDER_TARGETS)\n if isinstance(targets, (list, tuple)):\n for target in targets:\n self._target_handlers.setdefault(target, []).append(svc)\n\n else:\n self._target_handlers.setdefault(str(targets), []).append(svc)","def namingService(self):\n return _libSALOME_LifeCycleCORBA.SALOME_LifeCycleCORBA_namingService(self)","def _call_service(hass, entity, service):\n _LOGGER.debug('Command: %s %s', entity, service)\n hass.services.call(\n 'homeassistant', service, {'entity_id': entity})","def add_service(self, zeroconf, service_type, name):\n self.pending.add(\n asyncio.ensure_future(self._internal_add(zeroconf, service_type, name))\n )","def initService(self):","def add(self, service: AbstractService):\n self.services.append(service)","def unrecognised_service(service_name):\n print('Service {} not (yet) supported.'.format(service_name))\n pass","def register_service_agent(cm, sc, conf, rpcmgr):\n\n service_type = lb_const.SERVICE_TYPE\n cm.register_service_agent(service_type, rpcmgr)","def addService(self, interfaceClass: java.lang.Class, service: object) -> None:\n ...","def _service_task(self):\n pass","def service(self, service: IBMExperimentService) -> None:\n self._set_service(service)","def setService(self, service):\n self.__service = service\n self.__buttons.setDisabled(False)\n self.name.setText(service.data.name)\n self.threadable.setChecked(service.data.threadable)\n self.min_cores.setValue(service.data.min_cores)\n self.max_cores.setValue(service.data.max_cores)\n self.min_memory.setValue(service.data.min_memory // 1024)\n self.min_gpu_memory.setValue(service.data.min_gpu_memory // 1024)\n self._tags_w.set_tags(service.data.tags)\n self.timeout.setValue(service.data.timeout)\n self.timeout_llu.setValue(service.data.timeout_llu)\n self.min_memory_increase.setValue(service.data.min_memory_increase // 1024)\n self.__service = service.data","def fastlyservice(args):\n pprint(api.service(service_id).attrs)","async def on_terncy_svc_add(event):\n dev_id = event.data[\"dev_id\"]\n _LOGGER.info(\"found terncy service: %s %s\", dev_id, event.data)\n host = event.data[\"ip\"]\n if dev_id == tern.dev_id and not tern.is_connected():\n tern.host = host\n _LOGGER.info(\"start connection to %s %s\", dev_id, tern.host)\n\n hass.async_create_task(setup_terncy_loop())","def _get_service(self, service_name):\n if self._service:\n return self._service\n res = self._cc.services().get_by_name(service_name, name='label')\n self._service = res.resource\n return self._service","def addService(self, service):\n\t\tself.services.append(service)\n\t\treturn self","def _non_hs_service(self, service_name, address, port, properties):\n identifier = service_name.split(\".\")[0]\n name = properties.get(\"CtlN\")\n service = conf.DmapService(identifier, None, port=port, properties=properties)\n self._handle_service(address, name, service)","def update_service(self, service_id, service_ref):\n raise exception.NotImplemented() # pragma: no cover","def save(self):\n if len(str(self.name.text())) < 3:\n QtWidgets.QMessageBox.critical(self, \"Error\",\n \"The service name must be at least 3 characters.\")\n return\n\n if not str(self.name.text()).isalnum():\n QtWidgets.QMessageBox.critical(self, \"Error\", \"The service name must alphanumeric.\")\n return\n\n if self.min_memory_increase.value() <= 0:\n QtWidgets.QMessageBox.critical(self, \"Error\",\n \"The minimum memory increase must be more than 0 MB\")\n return\n\n service = opencue.wrappers.service.Service()\n if self.__service:\n service.data.id = self.__service.data.id\n service.setName(str(self.name.text()))\n service.setThreadable(self.threadable.isChecked())\n service.setMinCores(self.min_cores.value())\n service.setMaxCores(self.max_cores.value())\n service.setMinMemory(self.min_memory.value() * 1024)\n service.setMinGpuMemory(self.min_gpu_memory.value() * 1024)\n service.setTimeout(self.timeout.value())\n service.setTimeoutLLU(self.timeout_llu.value())\n service.setMinMemoryIncrease(self.min_memory_increase.value() * 1024)\n service.setTags(self._tags_w.get_tags())\n\n self.saved.emit(service)","def enable_service(self, service):\n svc = self.service_path % service\n ret = self.rclient.put(svc)\n if ret.status != restclient.Status.ACCEPTED:\n exception_msg = (_(\"Cannot enable %s service.\") % service)\n raise exception.ShareBackendException(msg=exception_msg)","def register_service(self, service):\n for message_handler in service.iter_message_handlers():\n self.message_handlers[message_handler.name] = message_handler","def _register(service, notifier=None):\n\n full_name = service.iden\n slot = service_store[full_name]\n try:\n slot['msg'] = 'Async image creation started'\n slot['stage'] = 2\n service_store[full_name] = slot\n\n service.make_image()\n\n slot['msg'] = 'Image for service created'\n slot['stage'] = 3\n service_store[full_name] = slot\n\n service.start_workers()\n\n slot['msg'] = 'Workers started'\n slot['stage'] = 4\n service_store[full_name] = slot\n\n service.check_health()\n\n slot['msg'] = 'Service ready'\n slot['stage'] = 5\n slot['slot'] = 'ready'\n slot['service'] = service\n service_store[full_name] = slot\n\n result = ok\n data = service\n except Exception as exc:\n slot['msg'] = 'Error: {}'.format(exc)\n slot['slot'] = 'error'\n service_store[full_name] = slot\n\n result = error\n data = str(exc)\n\n if service.notify and notifier is not None:\n notifier(service.notify, result, data)","def turn_on_service(service):\n # We could turn on script directly here, but we only want to offer\n # one way to do it. Otherwise no easy way to call invocations.\n for script in component.extract_from_service(service):\n turn_on(hass, script.entity_id)","def service(self):\n return self._service","def service(self):\n return self._service","def definition_of_services(self):\r\n return True","def start_as_service(self):\n from ..program_manager import ProgramManager\n send_action(ProgramManager.NAME, 'start', self.name)","def hostsplit_service(self):\n self.which_owner()\n self.which_security()\n\n for service, value in self.service_discovery.items():\n self.details[\"services\"][service] = self.which_service(service, **value)","def setContextAsService(self, contextAsService):\n pass","def __getitem__(self, name):\r\n return Service(self, name)","def service_status(self, service_status):\n\n self._service_status = service_status","def service(self, service_name: str, **kw):\n for (_, name, _) in pkgutil.iter_modules([str(SERVICES_PATH)]):\n if name == service_name:\n log.debug(\"Importing service %s\", name)\n module = import_module(\"..services.{}\".format(name), __name__)\n svc = module.Service(client=self, **kw) # type: ignore\n return svc\n raise ServiceNotFound()","def svc_provider(self, svc_provider):\n\n self._svc_provider = svc_provider","def _mrp_service(self, _, address, port, properties):\n identifier = properties.get(\"UniqueIdentifier\")\n name = properties.get(\"Name\")\n service = conf.MrpService(identifier, port, properties=properties)\n self._handle_service(address, name, service)","def publishService(self, name, stype, port, domain=\"\", host=\"\"):\n if name in self.published:\n return\n\n if not self.bus:\n self.bus = dbus.SystemBus()\n\n server = dbus.Interface(\n self.bus.get_object(\n avahi.DBUS_NAME,\n avahi.DBUS_PATH_SERVER),\n avahi.DBUS_INTERFACE_SERVER)\n\n g = dbus.Interface(\n self.bus.get_object(avahi.DBUS_NAME,\n server.EntryGroupNew()),\n avahi.DBUS_INTERFACE_ENTRY_GROUP)\n\n g.AddService(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC,dbus.UInt32(0),\n name, stype, domain, host,\n dbus.UInt16(port), \"\")\n\n g.Commit()\n self.published[name] = g","def get_service(self):\n return self.__service","def service_mange(self, room, service):\n self.room[room] = service\n return True","async def async_service_handler(service):\n _LOGGER.info(\"%s service called\", service.service)\n method = SERVICE_TO_METHOD.get(service.service)\n if not method:\n _LOGGER.warning(\"Unknown service method %s\", service.service)\n return\n\n params = {\n key: value for key, value in service.data.items() if key != ATTR_ENTITY_ID\n }\n entity_ids = service.data.get(ATTR_ENTITY_ID)\n component = hass.data.get(SWITCH_DOMAIN)\n if entity_ids:\n target_switches = [component.get_entity(entity) for entity in entity_ids]\n else:\n return\n\n method_name = method[\"method\"]\n _LOGGER.debug(\"Service handler: %s %s\", method_name, params)\n\n for entity in target_switches:\n if not hasattr(entity, method_name):\n _LOGGER.error(\"Service not implemented: %s\", method_name)\n return\n await getattr(entity, method_name)(**params)","def custom_service_endpoint(self) -> global___Snippet.ClientInitialization.ServiceEndpoint:","def service_code(self, service_code):\n \n self._service_code = service_code","def register_service(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details(\"Method not implemented!\")\n raise NotImplementedError(\"Method not implemented!\")","def get_service():\n if not hasattr(g, 'service'):\n g.service = Service()\n return g.service","def test_startService(self):\n port = self.port(description=u'foo')\n port.privilegedStartService()\n self.assertTrue(self._service.privilegedStarted)\n port.startService()\n self.assertTrue(self._service.started)","def service(self):\n self.serviceConnects()\n self.serviceQueries()","def on_service_departure(self, svc_ref):\n with self._lock:\n if svc_ref is self.reference:\n # Injected service going away...\n service = self._value\n\n # Clear the instance values\n self._current_ranking = None\n self._value = None\n self.reference = None\n\n if self.requirement.immediate_rebind:\n # Look for a replacement\n self._pending_ref = self._context.get_service_reference(\n self.requirement.specification, self.requirement.filter\n )\n else:\n self._pending_ref = None\n\n self._ipopo_instance.unbind(self, service, svc_ref)","def test_add_virtual_service(self):\n pass","def register(service_class, args, namespace, user_code, notifier=None):\n try:\n user = g.user\n except RuntimeError:\n user = 'anonymous'\n service = service_class(\n namespace=namespace, code_dir=user_code,\n users={user: ['POST', 'PUT', 'DELETE']},\n **dict(args))\n try:\n slot = service_store[service.iden]['slot']\n except KeyError:\n slot = 'free'\n\n # make sure to only use free or errored out slots\n if slot not in ('free', 'error'):\n raise APIException(\"service slot not available: {}\\n\"\n \"Current state: {}\"\n .format(service.iden, slot), 400)\n\n service_store[service.iden] = {\n 'slot': 'busy',\n 'msg': 'Empty service created',\n 'stage': 1,\n 'total_stages': 5,\n 'service': None\n }\n\n _async_register(service, notifier)\n return service","def ServiceRequest(self):\n #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n pass","def service_instance(self):\n return self.service_class(self)","def _spawn_service_process(self, process_id, name, module, cls, config, proc_attr):\n process_instance = self._create_process_instance(process_id, name, module, cls, config, proc_attr)\n\n listen_name = get_safe(config, \"process.listen_name\") or process_instance.name\n log.debug(\"Service Process (%s) listen_name: %s\", name, listen_name)\n process_instance._proc_listen_name = listen_name\n\n # Service RPC endpoint\n rsvc1 = self._create_listening_endpoint(node=self.container.node,\n from_name=listen_name,\n process=process_instance)\n # Named local RPC endpoint\n rsvc2 = self._create_listening_endpoint(node=self.container.node,\n from_name=process_instance.id,\n process=process_instance)\n\n # cleanup method to delete process queue\n cleanup = lambda _: self._cleanup_method(process_instance.id, rsvc2)\n\n # Start an ION process with the right kind of endpoint factory\n proc = self.proc_sup.spawn(name=process_instance.id,\n service=process_instance,\n listeners=[rsvc1, rsvc2],\n proc_name=process_instance._proc_name,\n cleanup_method=cleanup)\n proc.proc._glname = \"ION Proc %s\" % process_instance._proc_name\n self.proc_sup.ensure_ready(proc, \"_spawn_service_process for %s\" % \",\".join((listen_name, process_instance.id)))\n\n # map gproc to process_instance\n self._spawned_proc_to_process[proc.proc] = process_instance\n\n # set service's reference to process\n process_instance._process = proc\n\n self._process_init(process_instance)\n self._process_start(process_instance)\n\n try:\n proc.start_listeners()\n except IonProcessError:\n self._process_quit(process_instance)\n self._call_proc_state_changed(process_instance, ProcessStateEnum.FAILED)\n raise\n\n return process_instance","def get_service(self, service_id):\n raise exception.NotImplemented() # pragma: no cover","def _register_services(self, pipeline):\n\n pipeline.register_service(self._aprs_service)","def saved(self, service):\n if not self.__show:\n msg = QtWidgets.QMessageBox()\n msg.setText(\"You are about to modify a facility wide service configuration. \"\n \"Are you in PSR-Resources?\")\n msg.setStandardButtons(QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)\n msg.setDefaultButton(QtWidgets.QMessageBox.No)\n if msg.exec_() == QtWidgets.QMessageBox.No:\n return\n\n if self.__new_service:\n if self.__show:\n self.__show.createServiceOverride(service.data)\n else:\n opencue.api.createService(service.data)\n else:\n service.update()\n\n self.refresh()\n self.__new_service = False\n\n for i in range(0, self.__service_list.count()):\n item = self.__service_list.item(i)\n if item:\n if str(item.text()) == service.name():\n self.__service_list.setCurrentRow(i, QtCore.QItemSelectionModel.Select)\n break","def _call_service(self, action):\n conf_service = action.get(CONF_SERVICE, action.get(CONF_SERVICE_OLD))\n self._last_action = action.get(CONF_ALIAS, conf_service)\n _LOGGER.info(\"Executing script %s step %s\", self._name,\n self._last_action)\n domain, service = split_entity_id(conf_service)\n data = action.get(CONF_SERVICE_DATA, {})\n self.hass.services.call(domain, service, data)","def _patch(self, _) -> None:\n if not self.charm.unit.is_leader():\n return\n\n client = Client()\n try:\n if self.service_name != self._app:\n self._delete_and_create_service(client)\n client.patch(Service, self.service_name, self.service, patch_type=PatchType.MERGE)\n except ApiError as e:\n if e.status.code == 403:\n logger.error(\"Kubernetes service patch failed: `juju trust` this application.\")\n else:\n logger.error(\"Kubernetes service patch failed: %s\", str(e))\n else:\n logger.info(\"Kubernetes service '%s' patched successfully\", self._app)","def services(self, services):\n\n self._services = services","def services(self, services):\n\n self._services = services","def test_modify_virtual_service(self):\n pass","def services(**kwargs):\n pass","def register(self, service_name, service_addr, service_ttl):\n raise NotImplementedError","def service_bus_server():\n pass","def __init__(self, task_id: int) -> None:\n BaseModifierHandler.__init__(self, task_id, HandlerNames.enable_service)","async def reload_service_handler(service: ServiceCall) -> None:\n auto = [e for e in component.entities if not e.user_defined]\n\n if (conf := await component.async_prepare_reload()) is None:\n return\n await _async_process_config(hass, conf)\n\n await component.async_add_entities(auto)\n\n await async_reload_integration_platforms(hass, DOMAIN, PLATFORMS)","def addServiceListener(self, listener: ghidra.framework.plugintool.util.ServiceListener) -> None:\n ...","def with_service_binding(self, alias: str, service: \"Container\") -> \"Container\":\n _args = [\n Arg(\"alias\", alias),\n Arg(\"service\", service),\n ]\n _ctx = self._select(\"withServiceBinding\", _args)\n return Container(_ctx)","async def async_service_handler(service: ServiceCall) -> None:\n api_endpoint = MAP_SERVICE_API[service.service]\n\n data = service.data.copy()\n addon = data.pop(ATTR_ADDON, None)\n slug = data.pop(ATTR_SLUG, None)\n payload = None\n\n # Pass data to Hass.io API\n if service.service == SERVICE_ADDON_STDIN:\n payload = data[ATTR_INPUT]\n elif api_endpoint.pass_data:\n payload = data\n\n # Call API\n # The exceptions are logged properly in hassio.send_command\n with suppress(HassioAPIError):\n await hassio.send_command(\n api_endpoint.command.format(addon=addon, slug=slug),\n payload=payload,\n timeout=api_endpoint.timeout,\n )","def resolve_service(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details(\"Method not implemented!\")\n raise NotImplementedError(\"Method not implemented!\")","def service():\n conf = template('remote/addok.service', **config)\n put(conf, '/etc/systemd/system/addok.service')\n systemctl('enable addok.service')","def pre_service_instance_update(self, resource_id, resource_dict):\n pass","def print_service_available():\n if WithingsDataManager.service_available is not True:\n _LOGGER.info(\"Looks like the service is available again\")\n WithingsDataManager.service_available = True\n return True","def startService(self):\n self.world.start()","async def async_service_handler(service):\n api_command = MAP_SERVICE_API[service.service][0]\n data = service.data.copy()\n addon = data.pop(ATTR_ADDON, None)\n snapshot = data.pop(ATTR_SNAPSHOT, None)\n payload = None\n\n # Pass data to Opp.io API\n if service.service == SERVICE_ADDON_STDIN:\n payload = data[ATTR_INPUT]\n elif MAP_SERVICE_API[service.service][3]:\n payload = data\n\n # Call API\n try:\n await oppio.send_command(\n api_command.format(addon=addon, snapshot=snapshot),\n payload=payload,\n timeout=MAP_SERVICE_API[service.service][2],\n )\n except OppioAPIError as err:\n _LOGGER.error(\"Error on Opp.io API: %s\", err)","def test_service(self):\n port = self.port(store=self.store)\n installOn(port, self.store)\n\n self.assertEqual(\n list(self.store.powerupsFor(IService)),\n [port])"],"string":"[\n \"def service(self, service):\\n \\n self._service = service\",\n \"def register_service(self) -> None:\\n strategy = cast(Strategy, self.context.strategy)\\n description = strategy.get_register_service_description()\\n self._register(description, \\\"registering agent's service on the SOEF.\\\")\",\n \"def service(self):\\n pass\",\n \"def register_service(service, iface, name):\",\n \"def _hs_service(self, service_name, address, port, properties):\\n identifier = service_name.split(\\\".\\\")[0]\\n name = properties.get(\\\"Name\\\")\\n hsgid = properties.get(\\\"hG\\\")\\n service = conf.DmapService(identifier, hsgid, port=port, properties=properties)\\n self._handle_service(address, name, service)\",\n \"def on_service_arrival(self, svc_ref):\\n with self._lock:\\n new_ranking = svc_ref.get_property(SERVICE_RANKING)\\n if self._current_ranking is not None:\\n if new_ranking > self._current_ranking:\\n # New service with better ranking: use it\\n self._pending_ref = svc_ref\\n old_ref = self.reference\\n old_value = self._value\\n\\n # Clean up like for a departure\\n self._current_ranking = None\\n self._value = None\\n self.reference = None\\n\\n # Unbind (new binding will be done afterwards)\\n self._ipopo_instance.unbind(self, old_value, old_ref)\\n else:\\n # No ranking yet: inject the service\\n self.reference = svc_ref\\n self._value = self._context.get_service(svc_ref)\\n self._current_ranking = new_ranking\\n self._pending_ref = None\\n\\n self._ipopo_instance.bind(self, self._value, self.reference)\",\n \"def service(self) -> BaseService:\",\n \"def add_service(self, service):\\n self.app.add_service(service)\",\n \"def find_service(iface, context, name):\",\n \"def register_service(self, service, iface, name=''):\\n key = 'component' if not callable(service) else 'factory'\\n kwargs = {'provided': iface, key: service, 'name': name}\\n self._component.registerUtility(**kwargs)\",\n \"def set_service(self):\\n\\n if self.service:\\n self.service = self.service(\\n json=self.json,\\n google_user=self.google_user,\\n endpoint=self\\n )\",\n \"def service_handler(service):\\n entity_id = ENTITY_ID_FORMAT.format(service.service)\\n script = component.entities.get(entity_id)\\n if script:\\n script.turn_on()\",\n \"def _bind_to_service(self):\\n if self._service_dn:\\n # bind with the service_dn\\n self._server.simple_bind_s(self._service_dn, self._service_password)\\n else:\\n # force a connection without binding\\n self._server.whoami_s()\",\n \"def offerService(self, serviceName):\\n service = Service(serviceName)\\n self.serviceTable[serviceName] = service\\n return service\",\n \"def get_service(self):\",\n \"def set_service(service_name, reference):\\n Container.services[service_name] = reference\",\n \"def servicesChanged(self) -> None:\\n ...\",\n \"def service(self, block, service_name):\\n declaration = block.service_declaration(service_name)\\n if declaration is None:\\n raise NoSuchServiceError(f\\\"Service {service_name!r} was not requested.\\\")\\n service = self._services.get(service_name)\\n if service is None and declaration == \\\"need\\\":\\n raise NoSuchServiceError(f\\\"Service {service_name!r} is not available.\\\")\\n return service\",\n \"def _remember_service_name(self, event):\\n service_name = event[\\\"arguments\\\"][\\\"service_name\\\"]\\n # We've added logging of the service_handle to the API signature in\\n # the Monitor, but for backwards compatibility we'll keep it as\\n # follows for now.\\n service_handle = \\\"0x%08x\\\" % event[\\\"return_value\\\"]\\n self.services[service_handle] = service_name\",\n \"def __init__(self, service_name):\\n self.service_name = service_name\",\n \"def set_service_name(name):\\n emit(UPDATE_SERVICE_SIGNAL, BREADCRUMB_SENDER, name=name)\",\n \"def register_service(self, service, name):\\n assert service._remote_service, \\\"Services should be decorated correctly.\\\"\\n \\n prepare_remote_service(service)\\n self._services[name] = service\",\n \"def _bind_agent(self, field, service, svc_ref):\\n # Tell it to handle remaining components\\n service.handle(self._remaining)\\n self._remaining.clear()\",\n \"def future_supported_service(service_name):\\n print('Service {} linked.'.format(service_name))\\n pass\",\n \"def register_service(self, service: str, cb: Callable, **kwargs: Optional[Any]) -> None:\\n self._check_service(service)\\n d, s = service.split(\\\"/\\\")\\n self.logger.debug(\\\"register_service: %s/%s, %s\\\", d, s, kwargs)\\n\\n namespace = self._get_namespace(**kwargs)\\n\\n if \\\"namespace\\\" in kwargs:\\n del kwargs[\\\"namespace\\\"]\\n\\n kwargs[\\\"__name\\\"] = self.name\\n\\n self.AD.services.register_service(namespace, d, s, cb, __async=\\\"auto\\\", **kwargs)\",\n \"def register_service(self, name, command):\\n service_name = command['service_name']\\n try:\\n service_type = self.get_interface_type(command['interface_type'], '.srv')\\n self.srv_clients[service_name] = self.AsyncServiceProxy(\\n self,\\n service_name,\\n service_type)\\n\\n if service_name in self.offline_services:\\n self.offline_services.remove(service_name)\\n except JoyTeleopException:\\n if service_name not in self.offline_services:\\n self.offline_services.append(service_name)\",\n \"def _registerService(self, callerId, service, serviceApi, callerApi):\\n if service not in self.FilterServices:\\n # The type of the service is not included in the XMLRPC call\\n self.__docWriter.addService(callerId, service, \\\"TODO: type\\\")\",\n \"def startService(self):\\n super(MasterService, self).startService()\\n self.dispatcher.startDispatching()\",\n \"def bind(self, svc, svc_ref):\\n with self._lock:\\n if ORDER_HANDLER in svc_ref.get_property(pelix.OBJECTCLASS):\\n targets = svc_ref.get_property(ORDER_TARGETS)\\n if isinstance(targets, (list, tuple)):\\n for target in targets:\\n self._target_handlers.setdefault(target, []).append(svc)\\n\\n else:\\n self._target_handlers.setdefault(str(targets), []).append(svc)\",\n \"def namingService(self):\\n return _libSALOME_LifeCycleCORBA.SALOME_LifeCycleCORBA_namingService(self)\",\n \"def _call_service(hass, entity, service):\\n _LOGGER.debug('Command: %s %s', entity, service)\\n hass.services.call(\\n 'homeassistant', service, {'entity_id': entity})\",\n \"def add_service(self, zeroconf, service_type, name):\\n self.pending.add(\\n asyncio.ensure_future(self._internal_add(zeroconf, service_type, name))\\n )\",\n \"def initService(self):\",\n \"def add(self, service: AbstractService):\\n self.services.append(service)\",\n \"def unrecognised_service(service_name):\\n print('Service {} not (yet) supported.'.format(service_name))\\n pass\",\n \"def register_service_agent(cm, sc, conf, rpcmgr):\\n\\n service_type = lb_const.SERVICE_TYPE\\n cm.register_service_agent(service_type, rpcmgr)\",\n \"def addService(self, interfaceClass: java.lang.Class, service: object) -> None:\\n ...\",\n \"def _service_task(self):\\n pass\",\n \"def service(self, service: IBMExperimentService) -> None:\\n self._set_service(service)\",\n \"def setService(self, service):\\n self.__service = service\\n self.__buttons.setDisabled(False)\\n self.name.setText(service.data.name)\\n self.threadable.setChecked(service.data.threadable)\\n self.min_cores.setValue(service.data.min_cores)\\n self.max_cores.setValue(service.data.max_cores)\\n self.min_memory.setValue(service.data.min_memory // 1024)\\n self.min_gpu_memory.setValue(service.data.min_gpu_memory // 1024)\\n self._tags_w.set_tags(service.data.tags)\\n self.timeout.setValue(service.data.timeout)\\n self.timeout_llu.setValue(service.data.timeout_llu)\\n self.min_memory_increase.setValue(service.data.min_memory_increase // 1024)\\n self.__service = service.data\",\n \"def fastlyservice(args):\\n pprint(api.service(service_id).attrs)\",\n \"async def on_terncy_svc_add(event):\\n dev_id = event.data[\\\"dev_id\\\"]\\n _LOGGER.info(\\\"found terncy service: %s %s\\\", dev_id, event.data)\\n host = event.data[\\\"ip\\\"]\\n if dev_id == tern.dev_id and not tern.is_connected():\\n tern.host = host\\n _LOGGER.info(\\\"start connection to %s %s\\\", dev_id, tern.host)\\n\\n hass.async_create_task(setup_terncy_loop())\",\n \"def _get_service(self, service_name):\\n if self._service:\\n return self._service\\n res = self._cc.services().get_by_name(service_name, name='label')\\n self._service = res.resource\\n return self._service\",\n \"def addService(self, service):\\n\\t\\tself.services.append(service)\\n\\t\\treturn self\",\n \"def _non_hs_service(self, service_name, address, port, properties):\\n identifier = service_name.split(\\\".\\\")[0]\\n name = properties.get(\\\"CtlN\\\")\\n service = conf.DmapService(identifier, None, port=port, properties=properties)\\n self._handle_service(address, name, service)\",\n \"def update_service(self, service_id, service_ref):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"def save(self):\\n if len(str(self.name.text())) < 3:\\n QtWidgets.QMessageBox.critical(self, \\\"Error\\\",\\n \\\"The service name must be at least 3 characters.\\\")\\n return\\n\\n if not str(self.name.text()).isalnum():\\n QtWidgets.QMessageBox.critical(self, \\\"Error\\\", \\\"The service name must alphanumeric.\\\")\\n return\\n\\n if self.min_memory_increase.value() <= 0:\\n QtWidgets.QMessageBox.critical(self, \\\"Error\\\",\\n \\\"The minimum memory increase must be more than 0 MB\\\")\\n return\\n\\n service = opencue.wrappers.service.Service()\\n if self.__service:\\n service.data.id = self.__service.data.id\\n service.setName(str(self.name.text()))\\n service.setThreadable(self.threadable.isChecked())\\n service.setMinCores(self.min_cores.value())\\n service.setMaxCores(self.max_cores.value())\\n service.setMinMemory(self.min_memory.value() * 1024)\\n service.setMinGpuMemory(self.min_gpu_memory.value() * 1024)\\n service.setTimeout(self.timeout.value())\\n service.setTimeoutLLU(self.timeout_llu.value())\\n service.setMinMemoryIncrease(self.min_memory_increase.value() * 1024)\\n service.setTags(self._tags_w.get_tags())\\n\\n self.saved.emit(service)\",\n \"def enable_service(self, service):\\n svc = self.service_path % service\\n ret = self.rclient.put(svc)\\n if ret.status != restclient.Status.ACCEPTED:\\n exception_msg = (_(\\\"Cannot enable %s service.\\\") % service)\\n raise exception.ShareBackendException(msg=exception_msg)\",\n \"def register_service(self, service):\\n for message_handler in service.iter_message_handlers():\\n self.message_handlers[message_handler.name] = message_handler\",\n \"def _register(service, notifier=None):\\n\\n full_name = service.iden\\n slot = service_store[full_name]\\n try:\\n slot['msg'] = 'Async image creation started'\\n slot['stage'] = 2\\n service_store[full_name] = slot\\n\\n service.make_image()\\n\\n slot['msg'] = 'Image for service created'\\n slot['stage'] = 3\\n service_store[full_name] = slot\\n\\n service.start_workers()\\n\\n slot['msg'] = 'Workers started'\\n slot['stage'] = 4\\n service_store[full_name] = slot\\n\\n service.check_health()\\n\\n slot['msg'] = 'Service ready'\\n slot['stage'] = 5\\n slot['slot'] = 'ready'\\n slot['service'] = service\\n service_store[full_name] = slot\\n\\n result = ok\\n data = service\\n except Exception as exc:\\n slot['msg'] = 'Error: {}'.format(exc)\\n slot['slot'] = 'error'\\n service_store[full_name] = slot\\n\\n result = error\\n data = str(exc)\\n\\n if service.notify and notifier is not None:\\n notifier(service.notify, result, data)\",\n \"def turn_on_service(service):\\n # We could turn on script directly here, but we only want to offer\\n # one way to do it. Otherwise no easy way to call invocations.\\n for script in component.extract_from_service(service):\\n turn_on(hass, script.entity_id)\",\n \"def service(self):\\n return self._service\",\n \"def service(self):\\n return self._service\",\n \"def definition_of_services(self):\\r\\n return True\",\n \"def start_as_service(self):\\n from ..program_manager import ProgramManager\\n send_action(ProgramManager.NAME, 'start', self.name)\",\n \"def hostsplit_service(self):\\n self.which_owner()\\n self.which_security()\\n\\n for service, value in self.service_discovery.items():\\n self.details[\\\"services\\\"][service] = self.which_service(service, **value)\",\n \"def setContextAsService(self, contextAsService):\\n pass\",\n \"def __getitem__(self, name):\\r\\n return Service(self, name)\",\n \"def service_status(self, service_status):\\n\\n self._service_status = service_status\",\n \"def service(self, service_name: str, **kw):\\n for (_, name, _) in pkgutil.iter_modules([str(SERVICES_PATH)]):\\n if name == service_name:\\n log.debug(\\\"Importing service %s\\\", name)\\n module = import_module(\\\"..services.{}\\\".format(name), __name__)\\n svc = module.Service(client=self, **kw) # type: ignore\\n return svc\\n raise ServiceNotFound()\",\n \"def svc_provider(self, svc_provider):\\n\\n self._svc_provider = svc_provider\",\n \"def _mrp_service(self, _, address, port, properties):\\n identifier = properties.get(\\\"UniqueIdentifier\\\")\\n name = properties.get(\\\"Name\\\")\\n service = conf.MrpService(identifier, port, properties=properties)\\n self._handle_service(address, name, service)\",\n \"def publishService(self, name, stype, port, domain=\\\"\\\", host=\\\"\\\"):\\n if name in self.published:\\n return\\n\\n if not self.bus:\\n self.bus = dbus.SystemBus()\\n\\n server = dbus.Interface(\\n self.bus.get_object(\\n avahi.DBUS_NAME,\\n avahi.DBUS_PATH_SERVER),\\n avahi.DBUS_INTERFACE_SERVER)\\n\\n g = dbus.Interface(\\n self.bus.get_object(avahi.DBUS_NAME,\\n server.EntryGroupNew()),\\n avahi.DBUS_INTERFACE_ENTRY_GROUP)\\n\\n g.AddService(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC,dbus.UInt32(0),\\n name, stype, domain, host,\\n dbus.UInt16(port), \\\"\\\")\\n\\n g.Commit()\\n self.published[name] = g\",\n \"def get_service(self):\\n return self.__service\",\n \"def service_mange(self, room, service):\\n self.room[room] = service\\n return True\",\n \"async def async_service_handler(service):\\n _LOGGER.info(\\\"%s service called\\\", service.service)\\n method = SERVICE_TO_METHOD.get(service.service)\\n if not method:\\n _LOGGER.warning(\\\"Unknown service method %s\\\", service.service)\\n return\\n\\n params = {\\n key: value for key, value in service.data.items() if key != ATTR_ENTITY_ID\\n }\\n entity_ids = service.data.get(ATTR_ENTITY_ID)\\n component = hass.data.get(SWITCH_DOMAIN)\\n if entity_ids:\\n target_switches = [component.get_entity(entity) for entity in entity_ids]\\n else:\\n return\\n\\n method_name = method[\\\"method\\\"]\\n _LOGGER.debug(\\\"Service handler: %s %s\\\", method_name, params)\\n\\n for entity in target_switches:\\n if not hasattr(entity, method_name):\\n _LOGGER.error(\\\"Service not implemented: %s\\\", method_name)\\n return\\n await getattr(entity, method_name)(**params)\",\n \"def custom_service_endpoint(self) -> global___Snippet.ClientInitialization.ServiceEndpoint:\",\n \"def service_code(self, service_code):\\n \\n self._service_code = service_code\",\n \"def register_service(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 get_service():\\n if not hasattr(g, 'service'):\\n g.service = Service()\\n return g.service\",\n \"def test_startService(self):\\n port = self.port(description=u'foo')\\n port.privilegedStartService()\\n self.assertTrue(self._service.privilegedStarted)\\n port.startService()\\n self.assertTrue(self._service.started)\",\n \"def service(self):\\n self.serviceConnects()\\n self.serviceQueries()\",\n \"def on_service_departure(self, svc_ref):\\n with self._lock:\\n if svc_ref is self.reference:\\n # Injected service going away...\\n service = self._value\\n\\n # Clear the instance values\\n self._current_ranking = None\\n self._value = None\\n self.reference = None\\n\\n if self.requirement.immediate_rebind:\\n # Look for a replacement\\n self._pending_ref = self._context.get_service_reference(\\n self.requirement.specification, self.requirement.filter\\n )\\n else:\\n self._pending_ref = None\\n\\n self._ipopo_instance.unbind(self, service, svc_ref)\",\n \"def test_add_virtual_service(self):\\n pass\",\n \"def register(service_class, args, namespace, user_code, notifier=None):\\n try:\\n user = g.user\\n except RuntimeError:\\n user = 'anonymous'\\n service = service_class(\\n namespace=namespace, code_dir=user_code,\\n users={user: ['POST', 'PUT', 'DELETE']},\\n **dict(args))\\n try:\\n slot = service_store[service.iden]['slot']\\n except KeyError:\\n slot = 'free'\\n\\n # make sure to only use free or errored out slots\\n if slot not in ('free', 'error'):\\n raise APIException(\\\"service slot not available: {}\\\\n\\\"\\n \\\"Current state: {}\\\"\\n .format(service.iden, slot), 400)\\n\\n service_store[service.iden] = {\\n 'slot': 'busy',\\n 'msg': 'Empty service created',\\n 'stage': 1,\\n 'total_stages': 5,\\n 'service': None\\n }\\n\\n _async_register(service, notifier)\\n return service\",\n \"def ServiceRequest(self):\\n #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n pass\",\n \"def service_instance(self):\\n return self.service_class(self)\",\n \"def _spawn_service_process(self, process_id, name, module, cls, config, proc_attr):\\n process_instance = self._create_process_instance(process_id, name, module, cls, config, proc_attr)\\n\\n listen_name = get_safe(config, \\\"process.listen_name\\\") or process_instance.name\\n log.debug(\\\"Service Process (%s) listen_name: %s\\\", name, listen_name)\\n process_instance._proc_listen_name = listen_name\\n\\n # Service RPC endpoint\\n rsvc1 = self._create_listening_endpoint(node=self.container.node,\\n from_name=listen_name,\\n process=process_instance)\\n # Named local RPC endpoint\\n rsvc2 = self._create_listening_endpoint(node=self.container.node,\\n from_name=process_instance.id,\\n process=process_instance)\\n\\n # cleanup method to delete process queue\\n cleanup = lambda _: self._cleanup_method(process_instance.id, rsvc2)\\n\\n # Start an ION process with the right kind of endpoint factory\\n proc = self.proc_sup.spawn(name=process_instance.id,\\n service=process_instance,\\n listeners=[rsvc1, rsvc2],\\n proc_name=process_instance._proc_name,\\n cleanup_method=cleanup)\\n proc.proc._glname = \\\"ION Proc %s\\\" % process_instance._proc_name\\n self.proc_sup.ensure_ready(proc, \\\"_spawn_service_process for %s\\\" % \\\",\\\".join((listen_name, process_instance.id)))\\n\\n # map gproc to process_instance\\n self._spawned_proc_to_process[proc.proc] = process_instance\\n\\n # set service's reference to process\\n process_instance._process = proc\\n\\n self._process_init(process_instance)\\n self._process_start(process_instance)\\n\\n try:\\n proc.start_listeners()\\n except IonProcessError:\\n self._process_quit(process_instance)\\n self._call_proc_state_changed(process_instance, ProcessStateEnum.FAILED)\\n raise\\n\\n return process_instance\",\n \"def get_service(self, service_id):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"def _register_services(self, pipeline):\\n\\n pipeline.register_service(self._aprs_service)\",\n \"def saved(self, service):\\n if not self.__show:\\n msg = QtWidgets.QMessageBox()\\n msg.setText(\\\"You are about to modify a facility wide service configuration. \\\"\\n \\\"Are you in PSR-Resources?\\\")\\n msg.setStandardButtons(QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)\\n msg.setDefaultButton(QtWidgets.QMessageBox.No)\\n if msg.exec_() == QtWidgets.QMessageBox.No:\\n return\\n\\n if self.__new_service:\\n if self.__show:\\n self.__show.createServiceOverride(service.data)\\n else:\\n opencue.api.createService(service.data)\\n else:\\n service.update()\\n\\n self.refresh()\\n self.__new_service = False\\n\\n for i in range(0, self.__service_list.count()):\\n item = self.__service_list.item(i)\\n if item:\\n if str(item.text()) == service.name():\\n self.__service_list.setCurrentRow(i, QtCore.QItemSelectionModel.Select)\\n break\",\n \"def _call_service(self, action):\\n conf_service = action.get(CONF_SERVICE, action.get(CONF_SERVICE_OLD))\\n self._last_action = action.get(CONF_ALIAS, conf_service)\\n _LOGGER.info(\\\"Executing script %s step %s\\\", self._name,\\n self._last_action)\\n domain, service = split_entity_id(conf_service)\\n data = action.get(CONF_SERVICE_DATA, {})\\n self.hass.services.call(domain, service, data)\",\n \"def _patch(self, _) -> None:\\n if not self.charm.unit.is_leader():\\n return\\n\\n client = Client()\\n try:\\n if self.service_name != self._app:\\n self._delete_and_create_service(client)\\n client.patch(Service, self.service_name, self.service, patch_type=PatchType.MERGE)\\n except ApiError as e:\\n if e.status.code == 403:\\n logger.error(\\\"Kubernetes service patch failed: `juju trust` this application.\\\")\\n else:\\n logger.error(\\\"Kubernetes service patch failed: %s\\\", str(e))\\n else:\\n logger.info(\\\"Kubernetes service '%s' patched successfully\\\", self._app)\",\n \"def services(self, services):\\n\\n self._services = services\",\n \"def services(self, services):\\n\\n self._services = services\",\n \"def test_modify_virtual_service(self):\\n pass\",\n \"def services(**kwargs):\\n pass\",\n \"def register(self, service_name, service_addr, service_ttl):\\n raise NotImplementedError\",\n \"def service_bus_server():\\n pass\",\n \"def __init__(self, task_id: int) -> None:\\n BaseModifierHandler.__init__(self, task_id, HandlerNames.enable_service)\",\n \"async def reload_service_handler(service: ServiceCall) -> None:\\n auto = [e for e in component.entities if not e.user_defined]\\n\\n if (conf := await component.async_prepare_reload()) is None:\\n return\\n await _async_process_config(hass, conf)\\n\\n await component.async_add_entities(auto)\\n\\n await async_reload_integration_platforms(hass, DOMAIN, PLATFORMS)\",\n \"def addServiceListener(self, listener: ghidra.framework.plugintool.util.ServiceListener) -> None:\\n ...\",\n \"def with_service_binding(self, alias: str, service: \\\"Container\\\") -> \\\"Container\\\":\\n _args = [\\n Arg(\\\"alias\\\", alias),\\n Arg(\\\"service\\\", service),\\n ]\\n _ctx = self._select(\\\"withServiceBinding\\\", _args)\\n return Container(_ctx)\",\n \"async def async_service_handler(service: ServiceCall) -> None:\\n api_endpoint = MAP_SERVICE_API[service.service]\\n\\n data = service.data.copy()\\n addon = data.pop(ATTR_ADDON, None)\\n slug = data.pop(ATTR_SLUG, None)\\n payload = None\\n\\n # Pass data to Hass.io API\\n if service.service == SERVICE_ADDON_STDIN:\\n payload = data[ATTR_INPUT]\\n elif api_endpoint.pass_data:\\n payload = data\\n\\n # Call API\\n # The exceptions are logged properly in hassio.send_command\\n with suppress(HassioAPIError):\\n await hassio.send_command(\\n api_endpoint.command.format(addon=addon, slug=slug),\\n payload=payload,\\n timeout=api_endpoint.timeout,\\n )\",\n \"def resolve_service(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 service():\\n conf = template('remote/addok.service', **config)\\n put(conf, '/etc/systemd/system/addok.service')\\n systemctl('enable addok.service')\",\n \"def pre_service_instance_update(self, resource_id, resource_dict):\\n pass\",\n \"def print_service_available():\\n if WithingsDataManager.service_available is not True:\\n _LOGGER.info(\\\"Looks like the service is available again\\\")\\n WithingsDataManager.service_available = True\\n return True\",\n \"def startService(self):\\n self.world.start()\",\n \"async def async_service_handler(service):\\n api_command = MAP_SERVICE_API[service.service][0]\\n data = service.data.copy()\\n addon = data.pop(ATTR_ADDON, None)\\n snapshot = data.pop(ATTR_SNAPSHOT, None)\\n payload = None\\n\\n # Pass data to Opp.io API\\n if service.service == SERVICE_ADDON_STDIN:\\n payload = data[ATTR_INPUT]\\n elif MAP_SERVICE_API[service.service][3]:\\n payload = data\\n\\n # Call API\\n try:\\n await oppio.send_command(\\n api_command.format(addon=addon, snapshot=snapshot),\\n payload=payload,\\n timeout=MAP_SERVICE_API[service.service][2],\\n )\\n except OppioAPIError as err:\\n _LOGGER.error(\\\"Error on Opp.io API: %s\\\", err)\",\n \"def test_service(self):\\n port = self.port(store=self.store)\\n installOn(port, self.store)\\n\\n self.assertEqual(\\n list(self.store.powerupsFor(IService)),\\n [port])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6836905","0.6561478","0.63746643","0.62869096","0.61396533","0.61276996","0.6079517","0.6064858","0.60322297","0.60286254","0.6019076","0.6012391","0.60076535","0.5998224","0.5997815","0.5986478","0.5975217","0.59336156","0.59249896","0.5881597","0.58615196","0.58580655","0.58483875","0.5814194","0.581376","0.5797374","0.57731545","0.5772075","0.5763532","0.575385","0.573631","0.57260245","0.57047886","0.56880826","0.5669847","0.56584334","0.5648049","0.5631191","0.5621488","0.55993927","0.55987304","0.55738884","0.55668145","0.5555359","0.55510336","0.5521098","0.5519171","0.55183053","0.5516355","0.5514428","0.5505173","0.54962254","0.54962254","0.54943997","0.54929405","0.5469701","0.54659134","0.5460516","0.5458643","0.5457313","0.54508376","0.54308","0.5421372","0.54053247","0.53941655","0.5388375","0.53879446","0.5384783","0.5382371","0.5381731","0.53777194","0.53759074","0.53754103","0.53684586","0.5359594","0.5352799","0.53446585","0.5341798","0.53377676","0.53373003","0.53293157","0.53075236","0.5304401","0.52977943","0.52977943","0.528649","0.52824956","0.5282316","0.52672535","0.52660793","0.5265604","0.52650285","0.52617615","0.52342385","0.5232075","0.522601","0.5205359","0.52045465","0.51994085","0.51990664","0.519834"],"string":"[\n \"0.6836905\",\n \"0.6561478\",\n \"0.63746643\",\n \"0.62869096\",\n \"0.61396533\",\n \"0.61276996\",\n \"0.6079517\",\n \"0.6064858\",\n \"0.60322297\",\n \"0.60286254\",\n \"0.6019076\",\n \"0.6012391\",\n \"0.60076535\",\n \"0.5998224\",\n \"0.5997815\",\n \"0.5986478\",\n \"0.5975217\",\n \"0.59336156\",\n \"0.59249896\",\n \"0.5881597\",\n \"0.58615196\",\n \"0.58580655\",\n \"0.58483875\",\n \"0.5814194\",\n \"0.581376\",\n \"0.5797374\",\n \"0.57731545\",\n \"0.5772075\",\n \"0.5763532\",\n \"0.575385\",\n \"0.573631\",\n \"0.57260245\",\n \"0.57047886\",\n \"0.56880826\",\n \"0.5669847\",\n \"0.56584334\",\n \"0.5648049\",\n \"0.5631191\",\n \"0.5621488\",\n \"0.55993927\",\n \"0.55987304\",\n \"0.55738884\",\n \"0.55668145\",\n \"0.5555359\",\n \"0.55510336\",\n \"0.5521098\",\n \"0.5519171\",\n \"0.55183053\",\n \"0.5516355\",\n \"0.5514428\",\n \"0.5505173\",\n \"0.54962254\",\n \"0.54962254\",\n \"0.54943997\",\n \"0.54929405\",\n \"0.5469701\",\n \"0.54659134\",\n \"0.5460516\",\n \"0.5458643\",\n \"0.5457313\",\n \"0.54508376\",\n \"0.54308\",\n \"0.5421372\",\n \"0.54053247\",\n \"0.53941655\",\n \"0.5388375\",\n \"0.53879446\",\n \"0.5384783\",\n \"0.5382371\",\n \"0.5381731\",\n \"0.53777194\",\n \"0.53759074\",\n \"0.53754103\",\n \"0.53684586\",\n \"0.5359594\",\n \"0.5352799\",\n \"0.53446585\",\n \"0.5341798\",\n \"0.53377676\",\n \"0.53373003\",\n \"0.53293157\",\n \"0.53075236\",\n \"0.5304401\",\n \"0.52977943\",\n \"0.52977943\",\n \"0.528649\",\n \"0.52824956\",\n \"0.5282316\",\n \"0.52672535\",\n \"0.52660793\",\n \"0.5265604\",\n \"0.52650285\",\n \"0.52617615\",\n \"0.52342385\",\n \"0.5232075\",\n \"0.522601\",\n \"0.5205359\",\n \"0.52045465\",\n \"0.51994085\",\n \"0.51990664\",\n \"0.519834\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":183,"cells":{"query":{"kind":"string","value":"Inform a service component that it is no longer providing a service Called when an immediatelycontaining service manager unbinds this object from performing the named service."},"document":{"kind":"string","value":"def unbound(name):"},"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 on_service_departure(self, svc_ref):\n with self._lock:\n if svc_ref is self.reference:\n # Injected service going away...\n service = self._value\n\n # Clear the instance values\n self._current_ranking = None\n self._value = None\n self.reference = None\n\n if self.requirement.immediate_rebind:\n # Look for a replacement\n self._pending_ref = self._context.get_service_reference(\n self.requirement.specification, self.requirement.filter\n )\n else:\n self._pending_ref = None\n\n self._ipopo_instance.unbind(self, service, svc_ref)","def _unregister_service(self) -> None:\n strategy = cast(Strategy, self.context.strategy)\n description = strategy.get_unregister_service_description()\n oef_search_dialogues = cast(\n OefSearchDialogues, self.context.oef_search_dialogues\n )\n oef_search_msg, _ = oef_search_dialogues.create(\n counterparty=self.context.search_service_address,\n performative=OefSearchMessage.Performative.UNREGISTER_SERVICE,\n service_description=description,\n )\n self.context.outbox.put_message(message=oef_search_msg)\n self.context.logger.info(\"unregistering service from SOEF.\")","def unregister(self, service_name, service_addr):\n raise NotImplementedError","def remove_service(self, zeroconf, service_type, name):","def disownService(self, name):\r\n _service = self.hendrix.getServiceNamed(name)\r\n _service.disownServiceParent()\r\n return _service.factory","def unregister_service(self, name):\n self._services.remove(name)","def unregister_service(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details(\"Method not implemented!\")\n raise NotImplementedError(\"Method not implemented!\")","def stop_service(self):\n\n logger = logging.getLogger(self.dkr_name)\n logger.info(\"Tearing down service\")\n\n try:\n self.dkr_service.remove()\n except:\n logging.warning(\"Failed to stop service {}\".format(self.dkr_name))\n pass","def unpublishService(self, name):\n self.published[name].Reset()\n del self.published[name]","def deregisterService(self, serviceName):\n res = internals.blpapi_ProviderSession_deregisterService(\n self.__handle, serviceName)\n return res == 0","def unbind(self, svc, svc_ref):\n with self._lock:\n if ORDER_HANDLER in svc_ref.get_property(pelix.OBJECTCLASS):\n targets = svc_ref.get_property(ORDER_TARGETS)\n if isinstance(targets, (list, tuple)):\n for target in targets:\n associates = self._target_handlers.get(target, None)\n if svc in associates:\n del associates[svc]\n\n else:\n associates = self._target_handlers.get(str(targets), None)\n if svc in associates:\n del associates[svc]","def disable(self):\n self.registrar.unregister_service(\"say\", namespace=__name__)","async def async_will_remove_from_hass(self):\n await super().async_will_remove_from_hass()\n for service in self._device.device_services:\n service.unsubscribe_callback(self.entity_id)","def unregister(self, name):\r\n\r\n if name in self.components:\r\n logger.debug(\"Unregistering Component: %s\", name)\r\n self.stop([name])\r\n del self.components[name]","def removeServiceListener(self, listener: ghidra.framework.plugintool.util.ServiceListener) -> None:\n ...","def unregister(self, name):\r\n raise NotImplementedError","def stopService(self):\n connectionService = self.getServiceNamed(self.connectionServiceName)\n # Note: removeService() also calls stopService()\n yield self.removeService(connectionService)\n # At this point, all outstanding requests have been responded to\n yield super(CalDAVService, self).stopService()\n self.logObserver.stop()","def stopService(self):\n self.world.stop()","def deregister(self, service_id):\n return self.agent.http.get(\n lambda x: x.code == 200,\n '/v1/agent/service/deregister/%s' % service_id)","async def async_will_remove_from_hass(self) -> None:\n self._nobo.deregister_callback(self._after_update)","def stop(self, context):\n # Unregister the service\n self.__registration.unregister()\n self.__registration = None","def unbind(cls, name: str):\n if cls.instance() is None:\n return\n\n if not name in cls.instance().m_axis_bindings and not name in cls.instance().m_button_bindings:\n print( 'Unable to unbind: {}. Name not bound to axis or button.'.format( name ) )\n return\n\n if name in cls.instance().m_axis_bindings:\n axis = cls.instance().m_axis_bindings[ name ].axis\n del cls.instance().m_axis_bindings[ name ]\n del cls.instance().m_axis_name_table[ axis ]\n if name in cls.instance().m_button_bindings:\n button = cls.instance().m_button_bindings[ name ].button\n del cls.instance().m_button_bindings[ name ]\n del cls.instance().m_button_name_table[ button ]","async def _async_unsubscribe_service(self, sid: str) -> None:\n assert self._event_handler\n\n try:\n await self._event_handler.async_unsubscribe(sid)\n except UpnpError as err:\n _LOGGER.debug(\"Failed unsubscribing from: %s, reason: %r\", sid, err)\n except KeyError:\n _LOGGER.warning(\n \"%s was already unsubscribed. AiohttpNotifyServer was \"\n \"probably stopped before we could unsubscribe.\",\n sid,\n )","def removeService(self, interfaceClass: java.lang.Class, service: object) -> None:\n ...","def unregister(self, target, hostname, listener_type):","def __del__(self):\n\n if hasattr(self, '_socket') and self._socket is not None:\n try:\n self.unbind()\n except (exceptions.PDUError, exceptions.ConnectionError) as error:\n if len(getattr(error, 'args', tuple())) > 1:\n logging.warning('({0}) {1}. Ignored'.format(error.args[1], error.args[0]))\n else:\n logging.warning('{error}. Ignored'.format(error=error))\n self.disconnect()","async def unlistened(self, value=None):\n pass","def unsubscribe(self):\n pass # pragma: no cover","def at_removed(self, host):\n if host != self.host:\n raise ComponentRegisterError(\"Component attempted to remove from the wrong host.\")\n self.host = None","async def on_terncy_svc_remove(event):\n dev_id = event.data[\"dev_id\"]\n _LOGGER.info(\"terncy svc remove %s\", dev_id)\n if not tern.is_connected():\n await tern.stop()","def unbind_receive_notification(self, mtype, declare=True):\n if self._callable:\n del self._notification_bindings[mtype]\n if declare:\n self._declare_subscriptions()\n else:\n raise SAMPClientError(\"Client not callable.\")","def deregister(self):\n self.callback = None","def unlisten(cls, name: str):\r\n cls.Unlisten(name)","def unsubscribe(self):\r\n self._unregister()","def unbind_receive_response(self, msg_tag):\n if self._callable:\n del self._response_bindings[msg_tag]\n else:\n raise SAMPClientError(\"Client not callable.\")","def stopService(self):\n super(_SiteScheduler, self).stopService()\n if self.timer is not None:\n self.timer.cancel()\n self.timer = None","def stop(self):\n rospy.wait_for_service(self._service_name)\n try:\n trigger = rospy.ServiceProxy(self._service_name, Trigger)\n resp = trigger(on=False)\n return resp.success, resp.message\n except rospy.ServiceException as e:\n rospy.logerr('%s service call failed: %s' % (self, e))","def stop(name):\n __salt__[\"file.touch\"](\"{}/down\".format(_service_path(name)))\n cmd = \"svc -d {}\".format(_service_path(name))\n return not __salt__[\"cmd.retcode\"](cmd, python_shell=False)","def unpause_physics_service(self):\n return self._unpause_physics","def unsubscribe(self, name, callback_function):\n # Remove the callback from _callbacks.\n if self._callbacks.has_key(name):\n if callback_function in self._callbacks[name]:\n self._callbacks[name].remove(callback_function)\n if len(self._callbacks[name]) == 0:\n self._callbacks.pop(name)\n else:\n raise PresenceException('This function is not registered to receive callbacks.')\n else:\n raise PresenceException('Unknown service name. No callback handler exists.')","def _async_device_unavailable(\n _service_info: bluetooth.BluetoothServiceInfoBleak,\n ) -> None:\n push_lock.reset_advertisement_state()","def unregister(self, service_name, service_addr, addr_cls=None):\n addr_cls = addr_cls or PlainAddress\n etcd_delete = True\n if addr_cls != PlainAddress:\n etcd_delete = False\n\n for service_name in service_name:\n key = self._form_service_key(service_name, service_addr)\n if etcd_delete:\n self._client.delete(key)\n else:\n self._client.put(addr_cls(service_addr).delete_value())\n\n self._services.get(service_addr, {}).discard(service_name)","def _unregister(self):\r\n if hasattr(self, '_registered') and self._registered:\r\n self._conn.unregisterInterface(self._iTag, self)\r\n self._registered = False","def stop_notify(self):\n raise NotImplementedError","def StopControlService(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def unsubscribe(self, item_name):\n self.subscribed = None","def unbind_receive_call(self, mtype, declare=True):\n if self._callable:\n del self._call_bindings[mtype]\n if declare:\n self._declare_subscriptions()\n else:\n raise SAMPClientError(\"Client not callable.\")","def deregister_service(self, service: str, **kwargs: Optional[Any]) -> bool:\n self._check_service(service)\n d, s = service.split(\"/\")\n self.logger.debug(\"deregister_service: %s/%s, %s\", d, s, kwargs)\n\n namespace = self._get_namespace(**kwargs)\n\n if \"namespace\" in kwargs:\n del kwargs[\"namespace\"]\n\n kwargs[\"__name\"] = self.name\n\n return self.AD.services.deregister_service(namespace, d, s, **kwargs)","def stop_service(dauth_directory: DauthDirectoryConnection) -> None:\n print(dauth_directory.stop_service())","def unregister(self):\n assert self.state == State.SHUTDOWN\n del self._proto[self.dest_addr]","def _non_hs_service(self, service_name, address, port, properties):\n identifier = service_name.split(\".\")[0]\n name = properties.get(\"CtlN\")\n service = conf.DmapService(identifier, None, port=port, properties=properties)\n self._handle_service(address, name, service)","def __del__(self):\n self.unsubscribe()","def stop(self):\n for service_id in self.keys():\n self[service_id].stop()\n del self[service_id]\n\n self._stopped = True","def unregister(self, old):\n raise NotImplementedError","def unregister(self):\r\n self._unregister()","def _unregister_agent(self) -> None:\n strategy = cast(Strategy, self.context.strategy)\n description = strategy.get_location_description()\n oef_search_dialogues = cast(\n OefSearchDialogues, self.context.oef_search_dialogues\n )\n oef_search_msg, _ = oef_search_dialogues.create(\n counterparty=self.context.search_service_address,\n performative=OefSearchMessage.Performative.UNREGISTER_SERVICE,\n service_description=description,\n )\n self.context.outbox.put_message(message=oef_search_msg)\n self.context.logger.info(\"unregistering agent from SOEF.\")","def unsubscribe(receiver):","def unsubscribe(receiver):","def unsubscribe(receiver):","def unsubscribe(receiver):","def unsubscribe(receiver):","def service_absent(name, profile=None, **connection_args):\n ret = {\n \"name\": name,\n \"changes\": {},\n \"result\": True,\n \"comment\": 'Service \"{}\" is already absent'.format(name),\n }\n\n # Check if service is present\n role = __salt__[\"keystone.service_get\"](\n name=name, profile=profile, **connection_args\n )\n if \"Error\" not in role:\n if __opts__.get(\"test\"):\n ret[\"result\"] = None\n ret[\"comment\"] = 'Service \"{}\" will be deleted'.format(name)\n return ret\n # Delete service\n __salt__[\"keystone.service_delete\"](\n name=name, profile=profile, **connection_args\n )\n ret[\"comment\"] = 'Service \"{}\" has been deleted'.format(name)\n ret[\"changes\"][\"Service\"] = \"Deleted\"\n\n return ret","def _unbind_event(\r\n self, handler: Handler, event_type: EventType,\r\n handlers_dict: Dict[str, HandlerData]) -> None:\r\n from apysc.event.handler import append_unbinding_expression\r\n from apysc.event.handler import get_handler_name\r\n self_instance: VariableNameInterface = \\\r\n self._validate_self_is_variable_name_interface()\r\n name: str = get_handler_name(handler=handler, instance=self)\r\n if name in handlers_dict:\r\n del handlers_dict[name]\r\n append_unbinding_expression(\r\n this=self_instance, handler_name=name,\r\n event_type=event_type)","def disable(self):\n self.registrar.unregister_service(\"map\", namespace=__name__)\n self.registrar.unregister_service(\"directions\", namespace=__name__)","def stop_subscription(self, event):\r\n _LOGGER.info(\"Shutting down subscriptions\")\r\n asyncio.ensure_future(self.service_panel_stop(event), loop=self.hass.loop)","def unregister(target: str) -> bool:\n ...","def unsubscribe(observer):","def unsubscribe(observer):","def stop_subscription(self, event):\r\n _LOGGER.debug(\"Shutting down subscriptions\")\r\n asyncio.ensure_future(self.service_panel_stop(event), loop=self.hass.loop)","def unsubscribe(self, observer, name=None):\n if name is None:\n name = 'default'\n if observer in self._observers:\n del self._observers[observer][name]","def unregister(self, old):\n if old is not None and old is not Uninitialized:\n try:\n active = self.active.pop(old, None)\n if active is not None:\n for name, type in active:\n getattr(self, type)(old, name, True)\n except TypeError:\n # An error can occur if 'old' is a list or other object for\n # which a weakref cannot be created and used an a key for\n # 'self.active':\n pass","async def on_disconnected(self):\n self._connected = False\n self._connectedToBroker = False","def consul_deregister(self):\n try:\n if self.svc_name not in self.consul.agent.services():\n return\n self.log.info(\"consul-deregister\")\n self.consul.agent.service.deregister(\"qemu-{}\".format(self.name))\n except requests.exceptions.ConnectionError:\n pass\n except Exception:\n self.log.exception(\"consul-deregister-failed\", exc_info=True)","def Stop(self):\n self.stopping = True\n service_names = umpire_service.GetAllServiceNames()\n deferred = self.StopServices(service_names)\n deferred.addBoth(lambda _: reactor.stop())\n return deferred","def unbind_class(self, className, sequence):\n return super().unbind_class(className, sequence)","def remote_destroy(self):\r\n # TODO: WHY ???\r\n if not self._owner:\r\n return\r\n\r\n self.stop()\r\n\r\n if self._owner:\r\n self._owner.unregisterInterface(self)\r\n self._owner = None","async def async_will_remove_from_hass(self) -> None:\n self._disconnect_dispatcher()","def unregisterStatusListener(self, cb):\r\n self._statusListener.discard(cb)","def unlock_control(self):\n raise NotImplementedError('PlatformService: Implementation incomplete')","def unregisterSimulationEvent(self, handle):\r\n raise NotImplementedError()","def removeStatusChangeListener(self, handle):\n pass","def test_disownServiceParent(self):\n port = self.port(store=self.store)\n port.setServiceParent(self.store)\n port.disownServiceParent()\n self.failIfIn(port, list(IService(self.store)))","def destroy_service(\n self,\n service_name,\n manager_name,\n ):\n # Gets the node IP address.\n ip = self.get_node_ip(manager_name)\n\n ssh_username = self.get_ssh_username(manager_name)\n ssh_private_key_file = self.get_ssh_private_key_file(manager_name)\n\n # Creates the service.\n docker_utils.service_destroy(\n name=service_name,\n hostname=ip,\n ssh_port=SSH_PORT,\n ssh_username=ssh_username,\n ssh_private_key_file=ssh_private_key_file,\n executor=manager_name,\n logger=self._logger,\n )\n\n # Waits until all the replicas are not running anymore.\n while True:\n count = docker_utils.service_count_running(\n name=service_name,\n hostname=ip,\n ssh_port=SSH_PORT,\n ssh_username=ssh_username,\n ssh_private_key_file=ssh_private_key_file,\n executor=manager_name,\n logger=self._logger,\n )\n if count == 0:\n break\n time.sleep(1)","async def async_will_remove_from_hass(self):\n self._unsub_dispatcher()","def deregister(self, srvurl, callback = None, cbdata = None):\n cb = callback\n if not callback:\n cb = self.__errcb\n cbdata = [ SLPError.SLP_OK ]\n err = self.slph.deregister(srvurl, cb, cbdata)\n if err != SLPError.SLP_OK:\n raise SLPError(err)\n if not callback:\n if cbdata[0] != SLPError.SLP_OK:\n raise SLPError(cbdata[0])","def InterfaceRemoved(self, interface_name):\n pass","def unsetComponent(self):\n return _libsbml.OutwardBindingSite_unsetComponent(self)","def off(self) -> bool:\n off_cmd = HomeAssistantPlugin.service_map[self.domain.lower()][\"off\"]\n return self.send(off_cmd)","def __del__(self):\n\t\trospy.logdebug('MAVROSListener destruction')\n\t\t\n\t\tfor sub in self.__subs.values():\n\t\t\tsub.unregister()","def stop_app(self, name, stateless):\n raise NotImplementedError","def remove(self, service):\n os.remove(os.path.join(self.directory, service))","def destroy(self, name):\n self._assert_space()\n\n service_instance = self._get_service_instance(name)\n if service_instance:\n lastop = service_instance.last_operation\n if 'delete' == lastop['type']:\n return service_instance\n return self._cc \\\n .service_instances(service_instance.guid) \\\n .set_query(accepts_incomplete='true') \\\n .delete()\n return None","def __del__(self):\r\n self.debug(\"%s unloaded\" % self.name)","async def deregister_endpoint(self, handle: str) -> None:\n await self.AD.http.deregister_endpoint(handle, self.name)","def command_stop_tracking(self, active_command):\n\n # Stop the service if it is running\n if self.driver._aprs_service._tracking_update_loop is not None and self.driver._aprs_service._tracking_update_loop.running:\n self.driver._aprs_service._tracking_update_loop.stop()\n return {'message': \"The balloon tracker has been stopped.\"}\n else:\n raise command.CommandError(\"The balloon tracker is not currently running.\")","def stop_service(service_name):\n subprocess.run([SUPERVISOR_CMD, \"stop\", service_name])","def unbind(self):\n if not self.isBound():\n return defer.fail(SMPPClientSessionStateError('unbind called with illegal session state: %s' % self.sessionState))\n\n self.cancelEnquireLinkTimer()\n \n self.log.info('Waiting for in-progress transactions to finish...')\n \n #Signal that\n # - no new data requests should be sent\n # - no new incoming data requests should be accepted\n self.sessionState = SMPPSessionStates.UNBIND_PENDING\n \n unbindDeferred = defer.Deferred()\n #Wait for any in-progress txns to finish\n self.finishTxns().addCallback(self.unbindAfterInProgressTxnsFinished, unbindDeferred)\n #Result is the deferred for the unbind txn\n return unbindDeferred","def stopService(self):\n self.stopping = True\n self.deferreds = {}\n for name in self.processes:\n self.deferreds[name] = Deferred()\n super(DelayedStartupProcessMonitor, self).stopService()\n\n # Cancel any outstanding restarts\n for name, delayedCall in self.restart.items():\n if delayedCall.active():\n delayedCall.cancel()\n\n # Stop processes in the reverse order from which they were added and\n # started\n for name in reversed(self.processes):\n self.stopProcess(name)\n return gatherResults(self.deferreds.values())","def __del__(self):\n try:\n pybullet.disconnect(physicsClientId=self._client)\n except pybullet.error:\n pass","def print_service_unavailable():\n if WithingsDataManager.service_available is not False:\n _LOGGER.error(\"Looks like the service is not available at the moment\")\n WithingsDataManager.service_available = False\n return True","def removeOutputBinding(self, factory, product):\n # remove the {product} monitor from my pile of observers\n self.removeObserver(observer=product.pyre_status)\n # and chain up\n return super().removeOutputBinding(factory=factory, product=product)"],"string":"[\n \"def on_service_departure(self, svc_ref):\\n with self._lock:\\n if svc_ref is self.reference:\\n # Injected service going away...\\n service = self._value\\n\\n # Clear the instance values\\n self._current_ranking = None\\n self._value = None\\n self.reference = None\\n\\n if self.requirement.immediate_rebind:\\n # Look for a replacement\\n self._pending_ref = self._context.get_service_reference(\\n self.requirement.specification, self.requirement.filter\\n )\\n else:\\n self._pending_ref = None\\n\\n self._ipopo_instance.unbind(self, service, svc_ref)\",\n \"def _unregister_service(self) -> None:\\n strategy = cast(Strategy, self.context.strategy)\\n description = strategy.get_unregister_service_description()\\n oef_search_dialogues = cast(\\n OefSearchDialogues, self.context.oef_search_dialogues\\n )\\n oef_search_msg, _ = oef_search_dialogues.create(\\n counterparty=self.context.search_service_address,\\n performative=OefSearchMessage.Performative.UNREGISTER_SERVICE,\\n service_description=description,\\n )\\n self.context.outbox.put_message(message=oef_search_msg)\\n self.context.logger.info(\\\"unregistering service from SOEF.\\\")\",\n \"def unregister(self, service_name, service_addr):\\n raise NotImplementedError\",\n \"def remove_service(self, zeroconf, service_type, name):\",\n \"def disownService(self, name):\\r\\n _service = self.hendrix.getServiceNamed(name)\\r\\n _service.disownServiceParent()\\r\\n return _service.factory\",\n \"def unregister_service(self, name):\\n self._services.remove(name)\",\n \"def unregister_service(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 stop_service(self):\\n\\n logger = logging.getLogger(self.dkr_name)\\n logger.info(\\\"Tearing down service\\\")\\n\\n try:\\n self.dkr_service.remove()\\n except:\\n logging.warning(\\\"Failed to stop service {}\\\".format(self.dkr_name))\\n pass\",\n \"def unpublishService(self, name):\\n self.published[name].Reset()\\n del self.published[name]\",\n \"def deregisterService(self, serviceName):\\n res = internals.blpapi_ProviderSession_deregisterService(\\n self.__handle, serviceName)\\n return res == 0\",\n \"def unbind(self, svc, svc_ref):\\n with self._lock:\\n if ORDER_HANDLER in svc_ref.get_property(pelix.OBJECTCLASS):\\n targets = svc_ref.get_property(ORDER_TARGETS)\\n if isinstance(targets, (list, tuple)):\\n for target in targets:\\n associates = self._target_handlers.get(target, None)\\n if svc in associates:\\n del associates[svc]\\n\\n else:\\n associates = self._target_handlers.get(str(targets), None)\\n if svc in associates:\\n del associates[svc]\",\n \"def disable(self):\\n self.registrar.unregister_service(\\\"say\\\", namespace=__name__)\",\n \"async def async_will_remove_from_hass(self):\\n await super().async_will_remove_from_hass()\\n for service in self._device.device_services:\\n service.unsubscribe_callback(self.entity_id)\",\n \"def unregister(self, name):\\r\\n\\r\\n if name in self.components:\\r\\n logger.debug(\\\"Unregistering Component: %s\\\", name)\\r\\n self.stop([name])\\r\\n del self.components[name]\",\n \"def removeServiceListener(self, listener: ghidra.framework.plugintool.util.ServiceListener) -> None:\\n ...\",\n \"def unregister(self, name):\\r\\n raise NotImplementedError\",\n \"def stopService(self):\\n connectionService = self.getServiceNamed(self.connectionServiceName)\\n # Note: removeService() also calls stopService()\\n yield self.removeService(connectionService)\\n # At this point, all outstanding requests have been responded to\\n yield super(CalDAVService, self).stopService()\\n self.logObserver.stop()\",\n \"def stopService(self):\\n self.world.stop()\",\n \"def deregister(self, service_id):\\n return self.agent.http.get(\\n lambda x: x.code == 200,\\n '/v1/agent/service/deregister/%s' % service_id)\",\n \"async def async_will_remove_from_hass(self) -> None:\\n self._nobo.deregister_callback(self._after_update)\",\n \"def stop(self, context):\\n # Unregister the service\\n self.__registration.unregister()\\n self.__registration = None\",\n \"def unbind(cls, name: str):\\n if cls.instance() is None:\\n return\\n\\n if not name in cls.instance().m_axis_bindings and not name in cls.instance().m_button_bindings:\\n print( 'Unable to unbind: {}. Name not bound to axis or button.'.format( name ) )\\n return\\n\\n if name in cls.instance().m_axis_bindings:\\n axis = cls.instance().m_axis_bindings[ name ].axis\\n del cls.instance().m_axis_bindings[ name ]\\n del cls.instance().m_axis_name_table[ axis ]\\n if name in cls.instance().m_button_bindings:\\n button = cls.instance().m_button_bindings[ name ].button\\n del cls.instance().m_button_bindings[ name ]\\n del cls.instance().m_button_name_table[ button ]\",\n \"async def _async_unsubscribe_service(self, sid: str) -> None:\\n assert self._event_handler\\n\\n try:\\n await self._event_handler.async_unsubscribe(sid)\\n except UpnpError as err:\\n _LOGGER.debug(\\\"Failed unsubscribing from: %s, reason: %r\\\", sid, err)\\n except KeyError:\\n _LOGGER.warning(\\n \\\"%s was already unsubscribed. AiohttpNotifyServer was \\\"\\n \\\"probably stopped before we could unsubscribe.\\\",\\n sid,\\n )\",\n \"def removeService(self, interfaceClass: java.lang.Class, service: object) -> None:\\n ...\",\n \"def unregister(self, target, hostname, listener_type):\",\n \"def __del__(self):\\n\\n if hasattr(self, '_socket') and self._socket is not None:\\n try:\\n self.unbind()\\n except (exceptions.PDUError, exceptions.ConnectionError) as error:\\n if len(getattr(error, 'args', tuple())) > 1:\\n logging.warning('({0}) {1}. Ignored'.format(error.args[1], error.args[0]))\\n else:\\n logging.warning('{error}. Ignored'.format(error=error))\\n self.disconnect()\",\n \"async def unlistened(self, value=None):\\n pass\",\n \"def unsubscribe(self):\\n pass # pragma: no cover\",\n \"def at_removed(self, host):\\n if host != self.host:\\n raise ComponentRegisterError(\\\"Component attempted to remove from the wrong host.\\\")\\n self.host = None\",\n \"async def on_terncy_svc_remove(event):\\n dev_id = event.data[\\\"dev_id\\\"]\\n _LOGGER.info(\\\"terncy svc remove %s\\\", dev_id)\\n if not tern.is_connected():\\n await tern.stop()\",\n \"def unbind_receive_notification(self, mtype, declare=True):\\n if self._callable:\\n del self._notification_bindings[mtype]\\n if declare:\\n self._declare_subscriptions()\\n else:\\n raise SAMPClientError(\\\"Client not callable.\\\")\",\n \"def deregister(self):\\n self.callback = None\",\n \"def unlisten(cls, name: str):\\r\\n cls.Unlisten(name)\",\n \"def unsubscribe(self):\\r\\n self._unregister()\",\n \"def unbind_receive_response(self, msg_tag):\\n if self._callable:\\n del self._response_bindings[msg_tag]\\n else:\\n raise SAMPClientError(\\\"Client not callable.\\\")\",\n \"def stopService(self):\\n super(_SiteScheduler, self).stopService()\\n if self.timer is not None:\\n self.timer.cancel()\\n self.timer = None\",\n \"def stop(self):\\n rospy.wait_for_service(self._service_name)\\n try:\\n trigger = rospy.ServiceProxy(self._service_name, Trigger)\\n resp = trigger(on=False)\\n return resp.success, resp.message\\n except rospy.ServiceException as e:\\n rospy.logerr('%s service call failed: %s' % (self, e))\",\n \"def stop(name):\\n __salt__[\\\"file.touch\\\"](\\\"{}/down\\\".format(_service_path(name)))\\n cmd = \\\"svc -d {}\\\".format(_service_path(name))\\n return not __salt__[\\\"cmd.retcode\\\"](cmd, python_shell=False)\",\n \"def unpause_physics_service(self):\\n return self._unpause_physics\",\n \"def unsubscribe(self, name, callback_function):\\n # Remove the callback from _callbacks.\\n if self._callbacks.has_key(name):\\n if callback_function in self._callbacks[name]:\\n self._callbacks[name].remove(callback_function)\\n if len(self._callbacks[name]) == 0:\\n self._callbacks.pop(name)\\n else:\\n raise PresenceException('This function is not registered to receive callbacks.')\\n else:\\n raise PresenceException('Unknown service name. No callback handler exists.')\",\n \"def _async_device_unavailable(\\n _service_info: bluetooth.BluetoothServiceInfoBleak,\\n ) -> None:\\n push_lock.reset_advertisement_state()\",\n \"def unregister(self, service_name, service_addr, addr_cls=None):\\n addr_cls = addr_cls or PlainAddress\\n etcd_delete = True\\n if addr_cls != PlainAddress:\\n etcd_delete = False\\n\\n for service_name in service_name:\\n key = self._form_service_key(service_name, service_addr)\\n if etcd_delete:\\n self._client.delete(key)\\n else:\\n self._client.put(addr_cls(service_addr).delete_value())\\n\\n self._services.get(service_addr, {}).discard(service_name)\",\n \"def _unregister(self):\\r\\n if hasattr(self, '_registered') and self._registered:\\r\\n self._conn.unregisterInterface(self._iTag, self)\\r\\n self._registered = False\",\n \"def stop_notify(self):\\n raise NotImplementedError\",\n \"def StopControlService(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 unsubscribe(self, item_name):\\n self.subscribed = None\",\n \"def unbind_receive_call(self, mtype, declare=True):\\n if self._callable:\\n del self._call_bindings[mtype]\\n if declare:\\n self._declare_subscriptions()\\n else:\\n raise SAMPClientError(\\\"Client not callable.\\\")\",\n \"def deregister_service(self, service: str, **kwargs: Optional[Any]) -> bool:\\n self._check_service(service)\\n d, s = service.split(\\\"/\\\")\\n self.logger.debug(\\\"deregister_service: %s/%s, %s\\\", d, s, kwargs)\\n\\n namespace = self._get_namespace(**kwargs)\\n\\n if \\\"namespace\\\" in kwargs:\\n del kwargs[\\\"namespace\\\"]\\n\\n kwargs[\\\"__name\\\"] = self.name\\n\\n return self.AD.services.deregister_service(namespace, d, s, **kwargs)\",\n \"def stop_service(dauth_directory: DauthDirectoryConnection) -> None:\\n print(dauth_directory.stop_service())\",\n \"def unregister(self):\\n assert self.state == State.SHUTDOWN\\n del self._proto[self.dest_addr]\",\n \"def _non_hs_service(self, service_name, address, port, properties):\\n identifier = service_name.split(\\\".\\\")[0]\\n name = properties.get(\\\"CtlN\\\")\\n service = conf.DmapService(identifier, None, port=port, properties=properties)\\n self._handle_service(address, name, service)\",\n \"def __del__(self):\\n self.unsubscribe()\",\n \"def stop(self):\\n for service_id in self.keys():\\n self[service_id].stop()\\n del self[service_id]\\n\\n self._stopped = True\",\n \"def unregister(self, old):\\n raise NotImplementedError\",\n \"def unregister(self):\\r\\n self._unregister()\",\n \"def _unregister_agent(self) -> None:\\n strategy = cast(Strategy, self.context.strategy)\\n description = strategy.get_location_description()\\n oef_search_dialogues = cast(\\n OefSearchDialogues, self.context.oef_search_dialogues\\n )\\n oef_search_msg, _ = oef_search_dialogues.create(\\n counterparty=self.context.search_service_address,\\n performative=OefSearchMessage.Performative.UNREGISTER_SERVICE,\\n service_description=description,\\n )\\n self.context.outbox.put_message(message=oef_search_msg)\\n self.context.logger.info(\\\"unregistering agent from SOEF.\\\")\",\n \"def unsubscribe(receiver):\",\n \"def unsubscribe(receiver):\",\n \"def unsubscribe(receiver):\",\n \"def unsubscribe(receiver):\",\n \"def unsubscribe(receiver):\",\n \"def service_absent(name, profile=None, **connection_args):\\n ret = {\\n \\\"name\\\": name,\\n \\\"changes\\\": {},\\n \\\"result\\\": True,\\n \\\"comment\\\": 'Service \\\"{}\\\" is already absent'.format(name),\\n }\\n\\n # Check if service is present\\n role = __salt__[\\\"keystone.service_get\\\"](\\n name=name, profile=profile, **connection_args\\n )\\n if \\\"Error\\\" not in role:\\n if __opts__.get(\\\"test\\\"):\\n ret[\\\"result\\\"] = None\\n ret[\\\"comment\\\"] = 'Service \\\"{}\\\" will be deleted'.format(name)\\n return ret\\n # Delete service\\n __salt__[\\\"keystone.service_delete\\\"](\\n name=name, profile=profile, **connection_args\\n )\\n ret[\\\"comment\\\"] = 'Service \\\"{}\\\" has been deleted'.format(name)\\n ret[\\\"changes\\\"][\\\"Service\\\"] = \\\"Deleted\\\"\\n\\n return ret\",\n \"def _unbind_event(\\r\\n self, handler: Handler, event_type: EventType,\\r\\n handlers_dict: Dict[str, HandlerData]) -> None:\\r\\n from apysc.event.handler import append_unbinding_expression\\r\\n from apysc.event.handler import get_handler_name\\r\\n self_instance: VariableNameInterface = \\\\\\r\\n self._validate_self_is_variable_name_interface()\\r\\n name: str = get_handler_name(handler=handler, instance=self)\\r\\n if name in handlers_dict:\\r\\n del handlers_dict[name]\\r\\n append_unbinding_expression(\\r\\n this=self_instance, handler_name=name,\\r\\n event_type=event_type)\",\n \"def disable(self):\\n self.registrar.unregister_service(\\\"map\\\", namespace=__name__)\\n self.registrar.unregister_service(\\\"directions\\\", namespace=__name__)\",\n \"def stop_subscription(self, event):\\r\\n _LOGGER.info(\\\"Shutting down subscriptions\\\")\\r\\n asyncio.ensure_future(self.service_panel_stop(event), loop=self.hass.loop)\",\n \"def unregister(target: str) -> bool:\\n ...\",\n \"def unsubscribe(observer):\",\n \"def unsubscribe(observer):\",\n \"def stop_subscription(self, event):\\r\\n _LOGGER.debug(\\\"Shutting down subscriptions\\\")\\r\\n asyncio.ensure_future(self.service_panel_stop(event), loop=self.hass.loop)\",\n \"def unsubscribe(self, observer, name=None):\\n if name is None:\\n name = 'default'\\n if observer in self._observers:\\n del self._observers[observer][name]\",\n \"def unregister(self, old):\\n if old is not None and old is not Uninitialized:\\n try:\\n active = self.active.pop(old, None)\\n if active is not None:\\n for name, type in active:\\n getattr(self, type)(old, name, True)\\n except TypeError:\\n # An error can occur if 'old' is a list or other object for\\n # which a weakref cannot be created and used an a key for\\n # 'self.active':\\n pass\",\n \"async def on_disconnected(self):\\n self._connected = False\\n self._connectedToBroker = False\",\n \"def consul_deregister(self):\\n try:\\n if self.svc_name not in self.consul.agent.services():\\n return\\n self.log.info(\\\"consul-deregister\\\")\\n self.consul.agent.service.deregister(\\\"qemu-{}\\\".format(self.name))\\n except requests.exceptions.ConnectionError:\\n pass\\n except Exception:\\n self.log.exception(\\\"consul-deregister-failed\\\", exc_info=True)\",\n \"def Stop(self):\\n self.stopping = True\\n service_names = umpire_service.GetAllServiceNames()\\n deferred = self.StopServices(service_names)\\n deferred.addBoth(lambda _: reactor.stop())\\n return deferred\",\n \"def unbind_class(self, className, sequence):\\n return super().unbind_class(className, sequence)\",\n \"def remote_destroy(self):\\r\\n # TODO: WHY ???\\r\\n if not self._owner:\\r\\n return\\r\\n\\r\\n self.stop()\\r\\n\\r\\n if self._owner:\\r\\n self._owner.unregisterInterface(self)\\r\\n self._owner = None\",\n \"async def async_will_remove_from_hass(self) -> None:\\n self._disconnect_dispatcher()\",\n \"def unregisterStatusListener(self, cb):\\r\\n self._statusListener.discard(cb)\",\n \"def unlock_control(self):\\n raise NotImplementedError('PlatformService: Implementation incomplete')\",\n \"def unregisterSimulationEvent(self, handle):\\r\\n raise NotImplementedError()\",\n \"def removeStatusChangeListener(self, handle):\\n pass\",\n \"def test_disownServiceParent(self):\\n port = self.port(store=self.store)\\n port.setServiceParent(self.store)\\n port.disownServiceParent()\\n self.failIfIn(port, list(IService(self.store)))\",\n \"def destroy_service(\\n self,\\n service_name,\\n manager_name,\\n ):\\n # Gets the node IP address.\\n ip = self.get_node_ip(manager_name)\\n\\n ssh_username = self.get_ssh_username(manager_name)\\n ssh_private_key_file = self.get_ssh_private_key_file(manager_name)\\n\\n # Creates the service.\\n docker_utils.service_destroy(\\n name=service_name,\\n hostname=ip,\\n ssh_port=SSH_PORT,\\n ssh_username=ssh_username,\\n ssh_private_key_file=ssh_private_key_file,\\n executor=manager_name,\\n logger=self._logger,\\n )\\n\\n # Waits until all the replicas are not running anymore.\\n while True:\\n count = docker_utils.service_count_running(\\n name=service_name,\\n hostname=ip,\\n ssh_port=SSH_PORT,\\n ssh_username=ssh_username,\\n ssh_private_key_file=ssh_private_key_file,\\n executor=manager_name,\\n logger=self._logger,\\n )\\n if count == 0:\\n break\\n time.sleep(1)\",\n \"async def async_will_remove_from_hass(self):\\n self._unsub_dispatcher()\",\n \"def deregister(self, srvurl, callback = None, cbdata = None):\\n cb = callback\\n if not callback:\\n cb = self.__errcb\\n cbdata = [ SLPError.SLP_OK ]\\n err = self.slph.deregister(srvurl, cb, cbdata)\\n if err != SLPError.SLP_OK:\\n raise SLPError(err)\\n if not callback:\\n if cbdata[0] != SLPError.SLP_OK:\\n raise SLPError(cbdata[0])\",\n \"def InterfaceRemoved(self, interface_name):\\n pass\",\n \"def unsetComponent(self):\\n return _libsbml.OutwardBindingSite_unsetComponent(self)\",\n \"def off(self) -> bool:\\n off_cmd = HomeAssistantPlugin.service_map[self.domain.lower()][\\\"off\\\"]\\n return self.send(off_cmd)\",\n \"def __del__(self):\\n\\t\\trospy.logdebug('MAVROSListener destruction')\\n\\t\\t\\n\\t\\tfor sub in self.__subs.values():\\n\\t\\t\\tsub.unregister()\",\n \"def stop_app(self, name, stateless):\\n raise NotImplementedError\",\n \"def remove(self, service):\\n os.remove(os.path.join(self.directory, service))\",\n \"def destroy(self, name):\\n self._assert_space()\\n\\n service_instance = self._get_service_instance(name)\\n if service_instance:\\n lastop = service_instance.last_operation\\n if 'delete' == lastop['type']:\\n return service_instance\\n return self._cc \\\\\\n .service_instances(service_instance.guid) \\\\\\n .set_query(accepts_incomplete='true') \\\\\\n .delete()\\n return None\",\n \"def __del__(self):\\r\\n self.debug(\\\"%s unloaded\\\" % self.name)\",\n \"async def deregister_endpoint(self, handle: str) -> None:\\n await self.AD.http.deregister_endpoint(handle, self.name)\",\n \"def command_stop_tracking(self, active_command):\\n\\n # Stop the service if it is running\\n if self.driver._aprs_service._tracking_update_loop is not None and self.driver._aprs_service._tracking_update_loop.running:\\n self.driver._aprs_service._tracking_update_loop.stop()\\n return {'message': \\\"The balloon tracker has been stopped.\\\"}\\n else:\\n raise command.CommandError(\\\"The balloon tracker is not currently running.\\\")\",\n \"def stop_service(service_name):\\n subprocess.run([SUPERVISOR_CMD, \\\"stop\\\", service_name])\",\n \"def unbind(self):\\n if not self.isBound():\\n return defer.fail(SMPPClientSessionStateError('unbind called with illegal session state: %s' % self.sessionState))\\n\\n self.cancelEnquireLinkTimer()\\n \\n self.log.info('Waiting for in-progress transactions to finish...')\\n \\n #Signal that\\n # - no new data requests should be sent\\n # - no new incoming data requests should be accepted\\n self.sessionState = SMPPSessionStates.UNBIND_PENDING\\n \\n unbindDeferred = defer.Deferred()\\n #Wait for any in-progress txns to finish\\n self.finishTxns().addCallback(self.unbindAfterInProgressTxnsFinished, unbindDeferred)\\n #Result is the deferred for the unbind txn\\n return unbindDeferred\",\n \"def stopService(self):\\n self.stopping = True\\n self.deferreds = {}\\n for name in self.processes:\\n self.deferreds[name] = Deferred()\\n super(DelayedStartupProcessMonitor, self).stopService()\\n\\n # Cancel any outstanding restarts\\n for name, delayedCall in self.restart.items():\\n if delayedCall.active():\\n delayedCall.cancel()\\n\\n # Stop processes in the reverse order from which they were added and\\n # started\\n for name in reversed(self.processes):\\n self.stopProcess(name)\\n return gatherResults(self.deferreds.values())\",\n \"def __del__(self):\\n try:\\n pybullet.disconnect(physicsClientId=self._client)\\n except pybullet.error:\\n pass\",\n \"def print_service_unavailable():\\n if WithingsDataManager.service_available is not False:\\n _LOGGER.error(\\\"Looks like the service is not available at the moment\\\")\\n WithingsDataManager.service_available = False\\n return True\",\n \"def removeOutputBinding(self, factory, product):\\n # remove the {product} monitor from my pile of observers\\n self.removeObserver(observer=product.pyre_status)\\n # and chain up\\n return super().removeOutputBinding(factory=factory, product=product)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.770065","0.717073","0.69855356","0.6912879","0.6827076","0.67656344","0.66443497","0.64091897","0.6407706","0.63915473","0.6383925","0.63309795","0.6218311","0.61347353","0.612612","0.6044134","0.60432863","0.60367554","0.60173887","0.60062134","0.6004882","0.5990229","0.59433055","0.59324473","0.5892025","0.5891285","0.5877299","0.58352846","0.5835083","0.5834169","0.5763959","0.5755869","0.57513165","0.57462406","0.57456535","0.57456404","0.57309043","0.57172596","0.57052815","0.5688197","0.5667816","0.5651024","0.5632087","0.5625519","0.5610389","0.56067765","0.5557667","0.5552902","0.55526894","0.5552331","0.5539991","0.5533126","0.55148786","0.55121666","0.55112004","0.5496601","0.5489712","0.5489712","0.5489712","0.5489712","0.5489712","0.54795724","0.5472149","0.54655147","0.54620486","0.54611266","0.54554844","0.54554844","0.54489565","0.5437285","0.5429683","0.54286236","0.5417148","0.54151756","0.5405261","0.5401539","0.5398673","0.5396145","0.5388218","0.53864074","0.53797966","0.53764904","0.53750396","0.5370836","0.5367572","0.536714","0.5365801","0.5363025","0.535839","0.53568864","0.5355594","0.5341265","0.5340231","0.533058","0.53282213","0.5324742","0.5317473","0.53165543","0.5309545","0.53087085","0.5306934"],"string":"[\n \"0.770065\",\n \"0.717073\",\n \"0.69855356\",\n \"0.6912879\",\n \"0.6827076\",\n \"0.67656344\",\n \"0.66443497\",\n \"0.64091897\",\n \"0.6407706\",\n \"0.63915473\",\n \"0.6383925\",\n \"0.63309795\",\n \"0.6218311\",\n \"0.61347353\",\n \"0.612612\",\n \"0.6044134\",\n \"0.60432863\",\n \"0.60367554\",\n \"0.60173887\",\n \"0.60062134\",\n \"0.6004882\",\n \"0.5990229\",\n \"0.59433055\",\n \"0.59324473\",\n \"0.5892025\",\n \"0.5891285\",\n \"0.5877299\",\n \"0.58352846\",\n \"0.5835083\",\n \"0.5834169\",\n \"0.5763959\",\n \"0.5755869\",\n \"0.57513165\",\n \"0.57462406\",\n \"0.57456535\",\n \"0.57456404\",\n \"0.57309043\",\n \"0.57172596\",\n \"0.57052815\",\n \"0.5688197\",\n \"0.5667816\",\n \"0.5651024\",\n \"0.5632087\",\n \"0.5625519\",\n \"0.5610389\",\n \"0.56067765\",\n \"0.5557667\",\n \"0.5552902\",\n \"0.55526894\",\n \"0.5552331\",\n \"0.5539991\",\n \"0.5533126\",\n \"0.55148786\",\n \"0.55121666\",\n \"0.55112004\",\n \"0.5496601\",\n \"0.5489712\",\n \"0.5489712\",\n \"0.5489712\",\n \"0.5489712\",\n \"0.5489712\",\n \"0.54795724\",\n \"0.5472149\",\n \"0.54655147\",\n \"0.54620486\",\n \"0.54611266\",\n \"0.54554844\",\n \"0.54554844\",\n \"0.54489565\",\n \"0.5437285\",\n \"0.5429683\",\n \"0.54286236\",\n \"0.5417148\",\n \"0.54151756\",\n \"0.5405261\",\n \"0.5401539\",\n \"0.5398673\",\n \"0.5396145\",\n \"0.5388218\",\n \"0.53864074\",\n \"0.53797966\",\n \"0.53764904\",\n \"0.53750396\",\n \"0.5370836\",\n \"0.5367572\",\n \"0.536714\",\n \"0.5365801\",\n \"0.5363025\",\n \"0.535839\",\n \"0.53568864\",\n \"0.5355594\",\n \"0.5341265\",\n \"0.5340231\",\n \"0.533058\",\n \"0.53282213\",\n \"0.5324742\",\n \"0.5317473\",\n \"0.53165543\",\n \"0.5309545\",\n \"0.53087085\",\n \"0.5306934\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":184,"cells":{"query":{"kind":"string","value":"checkKey is used to check for authentication"},"document":{"kind":"string","value":"def checkKey(self):\n # TO DO for checking API authentication\n if self.apikey is None:\n return False\n else:\n return True"},"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 check_auth_publickey(self, username, key):\n return AUTH_FAILED","def _check_key(self, key):\n raise NotImplementedError","def api_key_check():\n req_path = request.path\n method_type = request.method\n app.logger.info(\">>> path = {}, method = {}\".format(req_path, method_type))\n\n if not app_props.api_key_check:\n app.logger.debug('>>> api key check closed')\n return None\n\n if req_path in app_props.api_key_white_list:\n app.logger.info('>>> {} in white list, pass'.format(req_path))\n return None\n headers = request.headers\n api_key_from_req = headers.get('x-api-key')\n if not api_key_from_req:\n app.logger.debug('>>> enter api-key error')\n return resp_json(BaseResp.err('no x-api-key header'))\n\n key_obj = Key.query.filter_by(api_key=api_key_from_req).first()\n if key_obj:\n app.logger.debug('>>> consumer_id = {}, secret_key = {}'.format(key_obj.consumer_id, key_obj.secret_key))\n g.consumer_id = key_obj.consumer_id\n g.secret_key = key_obj.secret_key\n return None\n else:\n return resp_json(BaseResp.err('Err api key'))","def isValidKey(key):\n return True","def check_auth():","def check_ssh_key(self):\n return True","def check_keys(self):","def check_key(request):\n try:\n access_key = request.session.get('access_key_tw', None)\n if not access_key:\n return False\n except KeyError:\n return False\n return True\n\n\t# User info","def check_key(cb):\n\n def funcn(*args, **kwargs):\n if 'key' not in kwargs:\n fail(REASON_NO_PASSKEY)\n key = kwargs['key']\n del kwargs['key']\n kwargs['user'] = STORAGE.lookup_user(key)\n if kwargs['user'].is_anonymous:\n fail(REASON_BAD_PASSKEY)\n return cb(*args, **kwargs)\n\n return funcn","def get_key(self, user, api_key):\n return True","def remote_verifyKey(self, key, protocol):\r\n if self._authenticated.called:\r\n return Failure(InvalidKey('Only one guess is possible.'))\r\n\r\n if isinstance(protocol, Failure):\r\n self._authenticated.errback(protocol)\r\n else:\r\n if self._key != key:\r\n e = Failure(InvalidKey('Wrong key supplied.'))\r\n self._authenticated.errback(e)\r\n return e\r\n\r\n self._authenticated.callback(protocol)","def check_key(request):\n\ttry:\n\t\taccess_key = request.session.get('access_key_tw', None)\n\t\tif not access_key:\n\t\t\treturn False\n\texcept KeyError:\n\t\treturn False\n\treturn True","def get_key(self, user, api_key):\r\n from delicious_cake.models import ApiKey\r\n\r\n try:\r\n ApiKey.objects.get(user=user, key=api_key)\r\n except ApiKey.DoesNotExist:\r\n return self._unauthorized()\r\n\r\n return True","def test_validate_api_key(app, seed_data, key, result):\n user_id, api_key = seed_data\n if key == 'use-valid-key':\n key = api_key\n with app.app_context():\n assert auth.validate_api_key(user_id, key) == result","def verify_key(self, providerkey = None):\n h = Https(API_DOMAIN)\n\n data = {'apikey' : self.apikey}\n\n if providerkey is not None:\n data['providerkey'] = providerkey\n\n h.request( \"GET\",\n \"/publicapi/verify\"+ urlencode(data),\n headers=self.headers)\n\n request_status = h.getresponse().status\n\n if request_status != 200:\n raise Exception(\"Invalid API Key %s\" % self.apikey)","def check_api_key(x_api_key: str = Security(api_key_header_auth)):\n\n if x_api_key != API_KEY:\n raise HTTPException(\n status_code=status.HTTP_401_UNAUTHORIZED,\n detail=\"Invalid API Key\",\n )","def verify_auth_key(cls, auth_key):\n key = ObjectId(auth_key)\n db = cls.mongo_cli.get_database(collection=\"users\")\n if db.count({\"_id\": key}) > 0:\n return True\n return False","def check_empty_key(self, key):\n if key is None or key == \"\" or key == self.empty_api_key:\n print(\"ERROR, A KEY IS EMPTY - CHECK YOUR FILE\")\n return False\n return True","def check_api(submitted_key, users_key):\r\n if users_key != submitted_key:\r\n return False\r\n else:\r\n return True","def keyIsValid(key):\n\n isValid = 1\n \n try:\n temp = getParam(key)\n\n except ValueError:\n isValid = 0\n warning(\" WARNING: %s not set\" % (key))\n\n return isValid","def checkKeys( ):\n\n if (HMACKey is None) or (AESKey is None):\n loadKeys()\n\n if (int(time.time()) - creationTime) > const.KEY_ROTATION_TIME:\n rotateKeys()","def auth_isok(self):\n # pylint: disable=W0603\n global KEY\n return_value = False\n if KEY is None:\n return_value = True\n elif self.headers.get('Authorization') == 'Basic ' + KEY:\n return_value = True\n return return_value","def test_api_key (key):\n\tdb = getattr(g,'db', None)\n\n\tif isinstance(key, unicode):\n\t\tkey = key.encode('utf-8')\n\n\tqry = \"SELECT apikey FROM api_keys WHERE apikey=%s;\"\n\twith db as cur:\n\t\treturn 0 < cur.execute(qry, (key,))","def valid_key(self): \n self.so.ValidKey.restype = c_bool\n result = self.so.ValidKey()\n return result","def test_validate_yubikey(self):\n from_key = self.yk_rnd.from_key(self.yk_public_id, self.yk_key)\n self.assertTrue(pyhsm.yubikey.validate_yubikey_with_aead( \\\n self.hsm, from_key, self.aead.data, self.kh_validate))","def _check_auth(self, group_id):\n return","def execute_request(self, request: Request) -> bool:\r\n print(\"Handler is validating key\")\r\n if request.key is not None:\r\n if not self.next_handler:\r\n return True\r\n return self.next_handler.execute_request(request)\r\n else:\r\n print(\"Key is not valid\")\r\n return False","def check_key(key):\n # Get config\n line = getfromconfig()\n\t\n # Open a new connection\n conn = my.MySQLConnection(line[0], line[1], line[2], line[3])\n set_of_tables = ['A']\n\n # Go through each table\n for table in set_of_tables:\n c = my.radiogaga_db_get(conn, table, {'ukey': key})\n if len(c) > 0:\n return(1)\n\n # End connection and return answer\n conn.end_connection()\n return(0)","def _key_to_key_verify(self):\n params = {\n 'host': self._redis_host,\n 'port': self._redis_port,\n 'db': self._from_db,\n 'password': self._password\n }\n client = RedisPool(**params)\n proxy_list = client.get_all()\n if proxy_list:\n self._loop.run_until_complete(self.verify(proxy_list))\n self._update(client)","def verify_request_session_key(self, key, uuid):\n return self.compute_request_session_key(uuid) == key","def get_key_input():\n return get_input(message='Please enter your master key:',\n secure=True, check_timer=False)","def check_key(self, key, key_pkl):\r\n start_time = time.time()\r\n # Verify that when we reload the KeyData from the pickled file, the\r\n # same key can be found in it, and is not equal to more than one\r\n # other key.\r\n key_data = cPickle.load(open(key_pkl, 'rb'))\r\n found = sum(key == other_key for other_key in key_data.keys)\r\n msg = ''\r\n if found == 0:\r\n msg = 'Key not found in unpickled KeyData file'\r\n if key_data.keys:\r\n # This is to make debugging in pdb easier, by providing\r\n # the offending keys in the local context.\r\n # key_data_keys = list(key_data.keys)\r\n ## import pdb; pdb.set_trace()\r\n pass\r\n elif found > 1:\r\n msg = 'Multiple equal keys found in unpickled KeyData file'\r\n if msg:\r\n raise AssertionError(\r\n \"%s. Verify the __eq__ and __hash__ functions of your \"\r\n \"Ops. The file is: %s. The key is: %s\" %\r\n (msg, key_pkl, key))\r\n # Also verify that there exists no other loaded key that would be equal\r\n # to this key. In order to speed things up, we only compare to keys\r\n # with the same version part and config md5, since we can assume this\r\n # part of the key is not broken.\r\n for other in self.similar_keys.get(get_safe_part(key), []):\r\n if other is not key and other == key and hash(other) != hash(key):\r\n raise AssertionError(\r\n \"Found two keys that are equal but have a different hash. \"\r\n \"Verify the __eq__ and __hash__ functions of your Ops. \"\r\n \"The keys are:\\n %s\\nand\\n %s\\n(found in %s).\" %\r\n (other, key, key_pkl))\r\n\r\n self.time_spent_in_check_key += time.time() - start_time","def test_valid_keys(client):\n response=client.post(\"/signin\",data=dict(username=TestSignin.email, password=TestSignin.password), content_type=\"multipart/form-data\")\n data=json.loads(response.data)\n assert response.status_code==400\n assert data[\"error\"] == \"Please provide email and password as keys\"","def test_api_key(self):\n self.assertEqual(self.route4me.key, '11111111111111111111111111111111')","def _check_auth(self):\n if self.authToken:\n return True\n else:\n msg = \"you need to login\"\n self.raise_error(msg)","def private_key(self):","def validate_key(key):\r\n try:\r\n secret.Secret(key)\r\n except secret.Secret.InvalidSecret as e:\r\n raise KeyIsInvalid(e.message)","def __contains__(self, key):\n return self.cli.passwords.contains(key)","def validate_handshake_public_key(cls, public_key: bytes) -> None:\n ...","def authenticate(self, request=None):\r\n try:\r\n token = request.META.get('HTTP_AUTHORIZATION') or request.REQUEST['key']\r\n accesskey = AccessKey.objects.select_related('user').get(key=token)\r\n request.user = accesskey.user\r\n return request.user and request.user.is_active\r\n\r\n except(KeyError, AccessKey.DoesNotExist):\r\n return False","def chk_key(chkname):\n return CHK_PREFIX + chkname","def match_api_keys(key, ip):","def is_valid_key(key, crypt_method):\n logger.info(f\"key: {key}, crypt_method: {crypt_method}\")\n if crypt_method == 'C':\n while type(key) is not int or key not in range(0, 95):\n try:\n key = Check.is_integer(key)[1]\n if key not in range(0, 95):\n raise ValueError\n except (TypeError, ValueError):\n print(\"You must enter an integer between 1 and 95!\")\n key = input(\"Enter an encryption key\\n>> \")\n elif crypt_method in ('M', 'P'):\n pass\n else:\n return False\n return True, key","def userkey(hash):\n user = hl.getUser(\"Name\",session['name'])\n flagCheck = hl.checkDistributeFlag(user[\"Name\"])\n if flagCheck == False:\n return getKeys()\n elif flagCheck == True:\n flash(\"You have been logged out. Please contact your system administrator\")\n return redirect(url_for('logout'))","def handle_key(self, k):\n\t\treturn False","def _check_key(key): # type: (str) -> None\n if not key:\n raise ValueError('Key must not be empty.')\n if '.' in key:\n raise ValueError('Key must not contain dots.')","def check_auth(username, password):\n return username == 'daniel' and password == config['redis_auth_key']","def key_is_present(host):\n if(config.HOST_TYPE == 'linux'):\n status, stdout, stderr = host.conn.execute_command('ls /root/.ssh')\n if status:\n return False\n if 'id_rsa.pub' in stdout[0]:\n return True\n return False\n else:\n status, stdout, stderr = host.conn.execute_command('cmd /c dir \"C:\\\\Program Files (x86)\\\\freeSSHd\"')\n if status:\n return False\n for value in stdout:\n if 'RSAKey.cfg' in value:\n return True\n return False","def getAuthKey( self ):\n d = {\n \"frob\" : FLICKR[ \"frob\" ],\n \"perms\" : \"delete\"\n }\n sig = self.signCall( d )\n url = self.urlGen( api.auth, d, sig )\n ans = \"\"\n try:\n webbrowser.open( url )\n print(\"Copy-paste following URL into a web browser and follow instructions:\")\n print(url)\n ans = raw_input(\"Have you authenticated this application? (Y/N): \")\n except:\n print(str(sys.exc_info()))\n if ( ans.lower() == \"n\" ):\n print(\"You need to allow this program to access your Flickr site.\")\n print(\"Copy-paste following URL into a web browser and follow instructions:\")\n print(url)\n print(\"After you have allowed access restart uploadr.py\")\n sys.exit()","def req_CHECKPRESENT(self, key):\n # TODO: so we need to maintain mapping from urls to keys. Then\n # we could even store the filename within archive\n # Otherwise it is unrealistic to even require to recompute key if we\n # knew the backend etc\n lgr.debug(\"VERIFYING key %s\" % key)\n akey, afile = self._get_akey_afile(key)\n if self.get_contentlocation(akey):\n self.send(\"CHECKPRESENT-SUCCESS\", key)\n else:\n # TODO: proxy the same to annex itself to verify check for archive.\n # If archive is no longer available -- then CHECKPRESENT-FAILURE\n self.send(\"CHECKPRESENT-UNKNOWN\", key)","def api_auth_validate(request, access_key):\n if not request.is_json:\n return {'error' : 'Bad request, payload must be JSON', 'code' : 400}\n if not 'working_repo' in session:\n return {'error' : 'Operation requires authentication', 'code': 401}\n if session['working_repo'] != access_key:\n return {'error' : 'Not authorized for this operation', 'code' : 403}\n \n return True","def test_check_privatekey_valid(self):\n key = load_privatekey(FILETYPE_PEM, client_key_pem)\n cert = load_certificate(FILETYPE_PEM, client_cert_pem)\n context = Context(SSLv23_METHOD)\n context.use_privatekey(key)\n context.use_certificate(cert)\n assert None is context.check_privatekey()","def test_create_key():\n\n assert symmetric.create_key() != \"\"","def check_api_keys(self, request):\n app_id, api_obj = request.META.get(\"HTTP_APP_ID\"), None\n api_secret_key = request.META.get(\"HTTP_API_SECRET_KEY\")\n if app_id and api_secret_key:\n # validate app_id and api_secret_key\n app_id_bool = self._validate_app_id(app_id)\n if not app_id_bool:\n return False, self.app_id_message\n api_secret_key_bool = self._validate_api_secret_key(api_secret_key)\n if not api_secret_key:\n return False, self.api_secret_key_message\n try:\n api_obj = ApiApp.objects.get(app_id=app_id, api_secret_key=api_secret_key, active=True)\n if api_obj:\n self.app(request, api_obj)\n return True, ''\n except ApiApp.DoesNotExist:\n self.app(request, api_obj)\n return False, self.message\n else:\n self.app(request, api_obj)\n return False, self.message","def try_api_keys(self, request, **kwargs):\n email = request.META.get('HTTP_PANDA_EMAIL') or request.GET.get('email')\n api_key = request.META.get('HTTP_PANDA_API_KEY') or request.GET.get('api_key')\n\n if email:\n email = unquote(email)\n\n if not email or not api_key:\n return False\n\n try:\n user = UserProxy.objects.get(username=email.lower())\n except (UserProxy.DoesNotExist, UserProxy.MultipleObjectsReturned):\n return False \n\n if not user.is_active:\n return False\n \n request.user = user\n\n return self.get_key(user, api_key)","def test_getKey_keyexists(self):\n filename = self.mktemp()\n with open(filename, 'wb') as fh:\n fh.write(SEKRIT_KEY)\n fh.flush()\n\n key = crypto.getKey(filename)\n self.failUnlessIsInstance(key, basestring,\n \"key isn't a string! type=%r\" % type(key))\n self.assertEqual(SEKRIT_KEY, key,\n \"\"\"The example key and the one read from file differ!\n key (in hex): %s\n SEKRIT_KEY (in hex): %s\"\"\"\n % (key.encode('hex'), SEKRIT_KEY.encode('hex')))","def test_check_keys_exist_for_provider_string(self):\n\n secret_key = None\n provider_id = 'asu'\n\n serializer = serializers.CreditProviderCallbackSerializer()\n with pytest.raises(PermissionDenied):\n serializer._check_keys_exist_for_provider(secret_key, provider_id) # lint-amnesty, pylint: disable=protected-access","def check_auth_gssapi_keyex(self, username,\n gss_authenticated=AUTH_FAILED,\n cc_file=None):\n if gss_authenticated == AUTH_SUCCESSFUL:\n return AUTH_SUCCESSFUL\n return AUTH_FAILED","def test_good_with_no_prior_key(self):\n # config seems to be shared across tests, so we have to specifically set\n # it to None.\n config.set(xsrf_token_key=None)\n tool = utils.XsrfTool()\n token = tool.generate_token(12345, 'test_action')\n self.assertTrue(tool.verify_token(token, 12345, 'test_action'))","def key_valid(key_data):\n\n gpg = gnupg.GPG(gnupghome=\"gnupg\")\n import_result = gpg.import_keys(key_data)\n\n if import_result.count == 1:\n gpg.delete_keys(import_result.fingerprints[0])\n return True\n else:\n return False","def validate_keystore_key(args):\n expected_name = 'keyRings/%s/cryptoKeys/%s'\n expected_name %= (args.kms_keyring, args.kms_key)\n describe_output = ''\n try:\n describe_output = subprocess.check_output(\n ['gcloud', 'kms', 'keys', 'describe', args.kms_key,\n '--project', args.kms_project,\n '--location', args.kms_location,\n '--keyring', args.kms_keyring,\n '--format', 'value(name)'])\n except subprocess.CalledProcessError:\n pass\n if expected_name in describe_output:\n return\n # Print warning and exit if output did not include the key.\n warning = 'KMS key \"%s\" not found in keyring=%s project=%s location=%s'\n warning %= (args.kms_key,\n args.kms_keyring,\n args.kms_project,\n args.kms_location)\n Print.YL(warning)\n sys.exit(1)","def verify_decrypt_key(self):\r\n\t\tpercent_english = Dict_Control(self.my_code).check_key()\r\n\t\t#If more than half the words are english, the key will pass. \r\n\t\tif percent_english > 50:\r\n\t\t\tself.right_key = False\r\n\t\t#If the key does not pass, the program will give you a warning and prompt you for another key. \r\n\t\telse: \r\n\t\t\tprint(f\"After decryption, it looks like only {percent_english}% of your words are english, you may have entered the wrong key?\")","def validate_key_code(self, code):\n\n key = self.connect().query(KeyCode)\\\n .filter(KeyCode.code == code)\\\n .first()\n\n if key and (key.user and key.enabled):\n return True\n return False","def test_blank_key(self):\n with self.assertRaises(ConfigError) as cm:\n imageroller.main.read_authconfig(\n imageroller.test.get_config_parser(self._blank_key))\n self.assertEqual(str(cm.exception), \"AuthConfig must contain ApiKey\")","def key():","def test_getKey_nokey(self):\n filename = os.path.join(os.getcwd(), 'sekrit')\n key = crypto.getKey(filename)\n self.failUnlessIsInstance(key, basestring,\n \"key isn't a string! type=%r\" % type(key))","def key_request(self, user):\n\t\tclient_log.debug(f'Запрос публичного ключа для {user}')\n\t\treq = {\n\t\t\tACTION: PUBLIC_KEY_REQUEST,\n\t\t\tTIME: time.time(),\n\t\t\tACCOUNT_NAME: user\n\t\t}\n\t\twith socket_lock:\n\t\t\tsend_message(self.transport, req)\n\t\t\tans = get_message(self.transport)\n\t\tif RESPONSE in ans and ans[RESPONSE] == 511:\n\t\t\treturn ans[DATA]\n\t\telse:\n\t\t\tclient_log.error(f'Не удалось получить ключ собеседника{user}.')","def test_no_key(self):\n with self.assertRaises(ConfigError) as cm:\n imageroller.main.read_authconfig(\n imageroller.test.get_config_parser(self._no_key))\n self.assertEqual(str(cm.exception), \"AuthConfig must contain ApiKey\")","def authenticate_header(self, request):\n return \"Api key authentication failed.\"","def check_key(self):\n\n if self.type == \"RSA\" and self.size < 1024:\n raise HostkeyError(\"RSA keys must at least be 1024 bits.\")\n elif self.type == \"DSA\" and self.size != 1024:\n raise HostkeyError(\"DSA keys can only be 1024 bits.\")\n elif self.type == \"ECDSA\" and self.size not in [256, 384, 521]: # yes, that is *really* 521 bits, not a typo!\n raise HostkeyError(\"ECDSA key must be either 256, 384 or 521 bits (yes, 521 not 512!)\")\n elif self.type ==\"ED25519\" and self.size != 128:\n raise HostkeyError(\"ED25519 keys have a fixed size, which cannot be altered.\") # can't really happen, size is ignored for ED25519\n\n # if privkey is already there check size\n self.key_exists = False\n self.key_current_size = 0\n if os.path.exists(self.fullpath):\n self.key_exists = True\n if self.type == \"ED25519\":\n self.curve = \"EC25519\"\n self.key_current_size = 128 # somewhat erbitrary, attack complexity on ED25519 is larger that brute forcing a 128bit key\n self.key_exists = True\n elif self.type == \"RSA1\":\n self.key_exists = True\n self.key_current_size = 1024\n else:\n try:\n with open(self.fullpath, \"rb\") as key_file:\n self.privkey = crypto_serialization.load_pem_private_key(key_file.read(), password=None, backend=crypto_default_backend())\n except IOError:\n raise HostkeyError(get_exception())\n\n if self.type == \"DSA\" or self.type == \"RSA\":\n self.key_current_size = self.privkey.key_size\n elif self.type == \"ED25519\":\n self.key_current_size = 128\n elif self.type == \"ECDSA\":\n self.pubkey = self.privkey.public_key()\n if self.pubkey.curve.name == \"secp256r1\":\n self.key_current_size = 256\n elif self.pubkey.curve.name == \"secp384r1\":\n self.key_current_size = 384\n elif self.pubkey.curve.name == \"secp521r1\":\n self.key_current_size = 521\n else:\n self.curve = self.pubkey.curve.name","def patched_paramiko_transport_verify_key(self, host_key, sig): # pylint: disable=W0613\n key = self._key_info[self.host_key_type](Message(host_key)) # pylint: disable=W0212\n if key is None:\n raise SSHException(\"Unknown host key type\")\n # Patched: no more checks are done here\n self.host_key = key","def is_authenticated(self, request, **kwargs):\n\n try:\n username, api_key = self.extract_credentials(request)\n except ValueError:\n return self._unauthorized()\n\n if not username or not api_key:\n return self._unauthorized()\n\n # cache key=api_key, value=User-object\n user = self._cache.get(api_key)\n logging.error(\"cached ApiKey: %r value: %r==%r\" % (api_key, user and user.username, user))\n if not user:\n try:\n lookup_kwargs = {username_field: username}\n user = User.objects.get(**lookup_kwargs)\n ApiKey.objects.get(user=user, key=api_key)\n self._cache.set(api_key, user, self._ttl_seconds)\n except (User.DoesNotExist, User.MultipleObjectsReturned,\n ApiKey.DoesNotExist, ApiKey.MultipleObjectsReturned):\n return self._unauthorized()\n\n if user.username != username:\n return self._unauthorized()\n\n if not self.check_active(user):\n return False\n\n key_auth_check = self.get_key(user, api_key)\n if key_auth_check and not isinstance(key_auth_check, HttpUnauthorized):\n request.user = user\n\n return key_auth_check","def _check_api_key(self):\n try:\n self.maps.places_nearby(\n location=(53.909804, 27.580184),\n radius=650,\n open_now=False,\n language=config.LANGUAGE,\n type='cafe',\n # rank_by='distance', # IMPORTANT: cannot use rank_by and radius options together\n page_token=None,\n )\n except Exception as e:\n\n with self.__writelock:\n self.print(f'ERROR: bad API key \"{self.maps.key}\" (tracker={self.stats.previous_requests})\\n')\n raise e","def test_get_user_api_keys(self):\n pass","def validate_api_key(self) -> tuple[bool, str]:\n response = self._api_query('wallets')\n\n if response.status_code != HTTPStatus.OK:\n result, msg = self._process_unsuccessful_response(\n response=response,\n case='validate_api_key',\n )\n return result, msg\n\n return True, ''","def test_create_api_key(self):\n pass","def test_validate_credentials(self):\n pass","def _check(self, key):\n if not self.contains(key):\n raise KeyError(\"ConfigManager does not contain key '%s'\" % key)","def test_missingKey(self):\n self.assertIsNone(self.users.key(\"mystery domain\", \"mystery user\"))","def checkkey(self, k):\r\n if k == self.shortcut:\r\n return True\r\n return False","def _is_valid_key(self, key):\r\n\r\n # Check the length\r\n if len(key) > 250:\r\n return False\r\n\r\n # Check that there are no spaces or control characters\r\n for char in key:\r\n if ord(char) < 33 or ord(char) == 127:\r\n return False\r\n\r\n return True","def check_auth(username, password):\n # return username == app.config['USER'] and password == app.config['PASS']\n\n return username == app.config['USER'] and password == app.config['PASS']","def load_key():","def authenticate_key(api_key):\n global db\n if db is None:\n init_db()\n try:\n if not api_key:\n return False\n user_model = Query()\n user = db.search(user_model.api_key == api_key)[0]\n if user:\n return user['username']\n except Exception as e:\n LOGGER.exception(e)\n LOGGER.error(\"Cannot retrieve user for this authentication key {}\".format(api_key))\n return False","def verify_hack_key(self):\r\n\t\tself.percent_english = Dict_Control(self.my_code).check_key()\r\n\t\t#If more than half the words are english, the key will pass. \r\n\t\tif self.percent_english > 50:\r\n\t\t\tself.hack_plausible = True","def _check_transform_key(key: Hashable) -> None:\n _test_hashable = hash(key) # The only 'real' way to make sure is hashable\n # if not isinstance(key, Hashable):\n # raise TypeError((type(key), \"transformation lookup key is not hashable\"))","def apicheck():\n\n async def predicate(ctx: commands.Context):\n travitia_keys = await ctx.bot.get_shared_api_tokens(\"travitia\")\n key = travitia_keys.get(\"api_key\") is None\n if ctx.invoked_with == \"help\" and key:\n return False\n if key:\n await ctx.send(\"The API key is not registered, the command is unavailable.\")\n return False\n return True\n\n return commands.check(predicate)","def test_key_use() -> None:\n # check key usage method\n # don't test if all keys are translated, crowdin will monitor it\n lib_folder = Path(__file__).parents[1] / \"sepal_ui\"\n\n assert \"test_key\" in ms.key_use(lib_folder, \"ms\")\n\n return","def test_incorrect_api_key(self):\n with self.subTest(\"Missing API key\"):\n response = self.client.get(\n self.url, HTTP_AUTHORIZATION=f\"ApiKey {self.web_user.username}:\"\n )\n self.assertEqual(response.status_code, 401)\n\n with self.subTest(\"Missing username\"):\n response = self.client.get(\n self.url, HTTP_AUTHORIZATION=f\"ApiKey :{self.web_user_api_key.key}\"\n )\n self.assertEqual(response.status_code, 401)\n\n with self.subTest(\"Missing header\"):\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, 401)\n\n with self.subTest(\"Incorrect API key\"):\n response = self.client.get(\n self.url,\n HTTP_AUTHORIZATION=f\"ApiKey {self.web_user.username}:Incorrectkey\",\n )\n self.assertEqual(response.status_code, 401)","def test_storeAndRetrieveKey(self):\n domain, username, password, key = \"domain\", \"user\", \"password\", \"key\"\n\n self.assertStored(domain, username, password, key)\n self.assertEqual(self.users.key(domain, username), key)","def check_tokenterminal_key(show_output: bool = False) -> str:\n\n if show_output:\n console.print(\"Checking status...\")\n\n current_user = get_current_user()\n\n if current_user.credentials.API_TOKEN_TERMINAL_KEY == \"REPLACE_ME\":\n logger.info(\"Token Terminal key not defined\")\n status = KeyStatus.NOT_DEFINED\n else:\n token_terminal = TokenTerminal(\n key=current_user.credentials.API_TOKEN_TERMINAL_KEY\n )\n\n if \"message\" in token_terminal.get_all_projects():\n logger.warning(\"Token Terminal key defined, test failed\")\n status = KeyStatus.DEFINED_TEST_FAILED\n else:\n logger.info(\"Token Terminal key defined, test passed\")\n status = KeyStatus.DEFINED_TEST_PASSED\n\n if show_output:\n console.print(status.colorize())\n\n return str(status)","def get_key(self, user):\r\n from delicious_cake.models import ApiKey\r\n\r\n try:\r\n key = ApiKey.objects.get(user=user)\r\n except ApiKey.DoesNotExist:\r\n return False\r\n\r\n return key.key","def getAuthKey(self):\r\n auth_key = 'Que despierte la Red'\r\n assert len(auth_key) == self.AUTH_KEY_LEN\r\n return auth_key","def _verify_keystore(self):\n keystore_uid = FileUtil(self.keystore_file).uid()\n if keystore_uid not in (-1, HostInfo.uid):\n raise IOError(\"not owner of keystore: %s\" % self.keystore_file)\n keystore_dir = os.path.dirname(self.keystore_file)\n if FileUtil(keystore_dir).uid() != HostInfo.uid:\n raise IOError(\"keystore dir not found or not owner: %s\" % keystore_dir)\n if (keystore_uid != -1 and (os.stat(self.keystore_file).st_mode & 0o077)):\n raise IOError(\"keystore is accessible to group or others: %s\" % self.keystore_file)","def attempt(chal, request):\n team = Teams.query.filter_by(id=session['id']).first()\n if locked(chal):\n return False, 'Challenge Locked. You need at least {} points.'.format(chal.unlock_at)\n \n provided_key = request.form['key'].strip()\n chal_keys = Keys.query.filter_by(chal=chal.id).all()\n for chal_key in chal_keys:\n if get_key_class(chal_key.type).compare(chal_key.flag, provided_key):\n return True, 'Correct'\n return False, 'Incorrect'","def test_rsa(self):\n key = c.KEY_RSA\n usage = [\n c.KU_DIGITALSIGNATURE,\n c.KU_NONREPUDIATION,\n c.KU_KEYENCIPHERMENT,\n c.KU_DATAENCIPHERMENT,\n ]\n self.assertTrue(utils.check_key_usage(key, usage))","def _key_check(self, key_list, chk_dict=None):\n exists = False\n if chk_dict is None:\n chk_dict = self._e_dict\n for key in key_list:\n exists = key in chk_dict.keys()\n if exists:\n chk_dict = chk_dict[key]\n else:\n break\n return exists","def key():\n pass","def key():\n pass","def test_get(self):\n key = self.key_gen.get()\n key2 = self.key_gen.get()\n\n self.assertEqual(key, key2 - 1)"],"string":"[\n \"def check_auth_publickey(self, username, key):\\n return AUTH_FAILED\",\n \"def _check_key(self, key):\\n raise NotImplementedError\",\n \"def api_key_check():\\n req_path = request.path\\n method_type = request.method\\n app.logger.info(\\\">>> path = {}, method = {}\\\".format(req_path, method_type))\\n\\n if not app_props.api_key_check:\\n app.logger.debug('>>> api key check closed')\\n return None\\n\\n if req_path in app_props.api_key_white_list:\\n app.logger.info('>>> {} in white list, pass'.format(req_path))\\n return None\\n headers = request.headers\\n api_key_from_req = headers.get('x-api-key')\\n if not api_key_from_req:\\n app.logger.debug('>>> enter api-key error')\\n return resp_json(BaseResp.err('no x-api-key header'))\\n\\n key_obj = Key.query.filter_by(api_key=api_key_from_req).first()\\n if key_obj:\\n app.logger.debug('>>> consumer_id = {}, secret_key = {}'.format(key_obj.consumer_id, key_obj.secret_key))\\n g.consumer_id = key_obj.consumer_id\\n g.secret_key = key_obj.secret_key\\n return None\\n else:\\n return resp_json(BaseResp.err('Err api key'))\",\n \"def isValidKey(key):\\n return True\",\n \"def check_auth():\",\n \"def check_ssh_key(self):\\n return True\",\n \"def check_keys(self):\",\n \"def check_key(request):\\n try:\\n access_key = request.session.get('access_key_tw', None)\\n if not access_key:\\n return False\\n except KeyError:\\n return False\\n return True\\n\\n\\t# User info\",\n \"def check_key(cb):\\n\\n def funcn(*args, **kwargs):\\n if 'key' not in kwargs:\\n fail(REASON_NO_PASSKEY)\\n key = kwargs['key']\\n del kwargs['key']\\n kwargs['user'] = STORAGE.lookup_user(key)\\n if kwargs['user'].is_anonymous:\\n fail(REASON_BAD_PASSKEY)\\n return cb(*args, **kwargs)\\n\\n return funcn\",\n \"def get_key(self, user, api_key):\\n return True\",\n \"def remote_verifyKey(self, key, protocol):\\r\\n if self._authenticated.called:\\r\\n return Failure(InvalidKey('Only one guess is possible.'))\\r\\n\\r\\n if isinstance(protocol, Failure):\\r\\n self._authenticated.errback(protocol)\\r\\n else:\\r\\n if self._key != key:\\r\\n e = Failure(InvalidKey('Wrong key supplied.'))\\r\\n self._authenticated.errback(e)\\r\\n return e\\r\\n\\r\\n self._authenticated.callback(protocol)\",\n \"def check_key(request):\\n\\ttry:\\n\\t\\taccess_key = request.session.get('access_key_tw', None)\\n\\t\\tif not access_key:\\n\\t\\t\\treturn False\\n\\texcept KeyError:\\n\\t\\treturn False\\n\\treturn True\",\n \"def get_key(self, user, api_key):\\r\\n from delicious_cake.models import ApiKey\\r\\n\\r\\n try:\\r\\n ApiKey.objects.get(user=user, key=api_key)\\r\\n except ApiKey.DoesNotExist:\\r\\n return self._unauthorized()\\r\\n\\r\\n return True\",\n \"def test_validate_api_key(app, seed_data, key, result):\\n user_id, api_key = seed_data\\n if key == 'use-valid-key':\\n key = api_key\\n with app.app_context():\\n assert auth.validate_api_key(user_id, key) == result\",\n \"def verify_key(self, providerkey = None):\\n h = Https(API_DOMAIN)\\n\\n data = {'apikey' : self.apikey}\\n\\n if providerkey is not None:\\n data['providerkey'] = providerkey\\n\\n h.request( \\\"GET\\\",\\n \\\"/publicapi/verify\\\"+ urlencode(data),\\n headers=self.headers)\\n\\n request_status = h.getresponse().status\\n\\n if request_status != 200:\\n raise Exception(\\\"Invalid API Key %s\\\" % self.apikey)\",\n \"def check_api_key(x_api_key: str = Security(api_key_header_auth)):\\n\\n if x_api_key != API_KEY:\\n raise HTTPException(\\n status_code=status.HTTP_401_UNAUTHORIZED,\\n detail=\\\"Invalid API Key\\\",\\n )\",\n \"def verify_auth_key(cls, auth_key):\\n key = ObjectId(auth_key)\\n db = cls.mongo_cli.get_database(collection=\\\"users\\\")\\n if db.count({\\\"_id\\\": key}) > 0:\\n return True\\n return False\",\n \"def check_empty_key(self, key):\\n if key is None or key == \\\"\\\" or key == self.empty_api_key:\\n print(\\\"ERROR, A KEY IS EMPTY - CHECK YOUR FILE\\\")\\n return False\\n return True\",\n \"def check_api(submitted_key, users_key):\\r\\n if users_key != submitted_key:\\r\\n return False\\r\\n else:\\r\\n return True\",\n \"def keyIsValid(key):\\n\\n isValid = 1\\n \\n try:\\n temp = getParam(key)\\n\\n except ValueError:\\n isValid = 0\\n warning(\\\" WARNING: %s not set\\\" % (key))\\n\\n return isValid\",\n \"def checkKeys( ):\\n\\n if (HMACKey is None) or (AESKey is None):\\n loadKeys()\\n\\n if (int(time.time()) - creationTime) > const.KEY_ROTATION_TIME:\\n rotateKeys()\",\n \"def auth_isok(self):\\n # pylint: disable=W0603\\n global KEY\\n return_value = False\\n if KEY is None:\\n return_value = True\\n elif self.headers.get('Authorization') == 'Basic ' + KEY:\\n return_value = True\\n return return_value\",\n \"def test_api_key (key):\\n\\tdb = getattr(g,'db', None)\\n\\n\\tif isinstance(key, unicode):\\n\\t\\tkey = key.encode('utf-8')\\n\\n\\tqry = \\\"SELECT apikey FROM api_keys WHERE apikey=%s;\\\"\\n\\twith db as cur:\\n\\t\\treturn 0 < cur.execute(qry, (key,))\",\n \"def valid_key(self): \\n self.so.ValidKey.restype = c_bool\\n result = self.so.ValidKey()\\n return result\",\n \"def test_validate_yubikey(self):\\n from_key = self.yk_rnd.from_key(self.yk_public_id, self.yk_key)\\n self.assertTrue(pyhsm.yubikey.validate_yubikey_with_aead( \\\\\\n self.hsm, from_key, self.aead.data, self.kh_validate))\",\n \"def _check_auth(self, group_id):\\n return\",\n \"def execute_request(self, request: Request) -> bool:\\r\\n print(\\\"Handler is validating key\\\")\\r\\n if request.key is not None:\\r\\n if not self.next_handler:\\r\\n return True\\r\\n return self.next_handler.execute_request(request)\\r\\n else:\\r\\n print(\\\"Key is not valid\\\")\\r\\n return False\",\n \"def check_key(key):\\n # Get config\\n line = getfromconfig()\\n\\t\\n # Open a new connection\\n conn = my.MySQLConnection(line[0], line[1], line[2], line[3])\\n set_of_tables = ['A']\\n\\n # Go through each table\\n for table in set_of_tables:\\n c = my.radiogaga_db_get(conn, table, {'ukey': key})\\n if len(c) > 0:\\n return(1)\\n\\n # End connection and return answer\\n conn.end_connection()\\n return(0)\",\n \"def _key_to_key_verify(self):\\n params = {\\n 'host': self._redis_host,\\n 'port': self._redis_port,\\n 'db': self._from_db,\\n 'password': self._password\\n }\\n client = RedisPool(**params)\\n proxy_list = client.get_all()\\n if proxy_list:\\n self._loop.run_until_complete(self.verify(proxy_list))\\n self._update(client)\",\n \"def verify_request_session_key(self, key, uuid):\\n return self.compute_request_session_key(uuid) == key\",\n \"def get_key_input():\\n return get_input(message='Please enter your master key:',\\n secure=True, check_timer=False)\",\n \"def check_key(self, key, key_pkl):\\r\\n start_time = time.time()\\r\\n # Verify that when we reload the KeyData from the pickled file, the\\r\\n # same key can be found in it, and is not equal to more than one\\r\\n # other key.\\r\\n key_data = cPickle.load(open(key_pkl, 'rb'))\\r\\n found = sum(key == other_key for other_key in key_data.keys)\\r\\n msg = ''\\r\\n if found == 0:\\r\\n msg = 'Key not found in unpickled KeyData file'\\r\\n if key_data.keys:\\r\\n # This is to make debugging in pdb easier, by providing\\r\\n # the offending keys in the local context.\\r\\n # key_data_keys = list(key_data.keys)\\r\\n ## import pdb; pdb.set_trace()\\r\\n pass\\r\\n elif found > 1:\\r\\n msg = 'Multiple equal keys found in unpickled KeyData file'\\r\\n if msg:\\r\\n raise AssertionError(\\r\\n \\\"%s. Verify the __eq__ and __hash__ functions of your \\\"\\r\\n \\\"Ops. The file is: %s. The key is: %s\\\" %\\r\\n (msg, key_pkl, key))\\r\\n # Also verify that there exists no other loaded key that would be equal\\r\\n # to this key. In order to speed things up, we only compare to keys\\r\\n # with the same version part and config md5, since we can assume this\\r\\n # part of the key is not broken.\\r\\n for other in self.similar_keys.get(get_safe_part(key), []):\\r\\n if other is not key and other == key and hash(other) != hash(key):\\r\\n raise AssertionError(\\r\\n \\\"Found two keys that are equal but have a different hash. \\\"\\r\\n \\\"Verify the __eq__ and __hash__ functions of your Ops. \\\"\\r\\n \\\"The keys are:\\\\n %s\\\\nand\\\\n %s\\\\n(found in %s).\\\" %\\r\\n (other, key, key_pkl))\\r\\n\\r\\n self.time_spent_in_check_key += time.time() - start_time\",\n \"def test_valid_keys(client):\\n response=client.post(\\\"/signin\\\",data=dict(username=TestSignin.email, password=TestSignin.password), content_type=\\\"multipart/form-data\\\")\\n data=json.loads(response.data)\\n assert response.status_code==400\\n assert data[\\\"error\\\"] == \\\"Please provide email and password as keys\\\"\",\n \"def test_api_key(self):\\n self.assertEqual(self.route4me.key, '11111111111111111111111111111111')\",\n \"def _check_auth(self):\\n if self.authToken:\\n return True\\n else:\\n msg = \\\"you need to login\\\"\\n self.raise_error(msg)\",\n \"def private_key(self):\",\n \"def validate_key(key):\\r\\n try:\\r\\n secret.Secret(key)\\r\\n except secret.Secret.InvalidSecret as e:\\r\\n raise KeyIsInvalid(e.message)\",\n \"def __contains__(self, key):\\n return self.cli.passwords.contains(key)\",\n \"def validate_handshake_public_key(cls, public_key: bytes) -> None:\\n ...\",\n \"def authenticate(self, request=None):\\r\\n try:\\r\\n token = request.META.get('HTTP_AUTHORIZATION') or request.REQUEST['key']\\r\\n accesskey = AccessKey.objects.select_related('user').get(key=token)\\r\\n request.user = accesskey.user\\r\\n return request.user and request.user.is_active\\r\\n\\r\\n except(KeyError, AccessKey.DoesNotExist):\\r\\n return False\",\n \"def chk_key(chkname):\\n return CHK_PREFIX + chkname\",\n \"def match_api_keys(key, ip):\",\n \"def is_valid_key(key, crypt_method):\\n logger.info(f\\\"key: {key}, crypt_method: {crypt_method}\\\")\\n if crypt_method == 'C':\\n while type(key) is not int or key not in range(0, 95):\\n try:\\n key = Check.is_integer(key)[1]\\n if key not in range(0, 95):\\n raise ValueError\\n except (TypeError, ValueError):\\n print(\\\"You must enter an integer between 1 and 95!\\\")\\n key = input(\\\"Enter an encryption key\\\\n>> \\\")\\n elif crypt_method in ('M', 'P'):\\n pass\\n else:\\n return False\\n return True, key\",\n \"def userkey(hash):\\n user = hl.getUser(\\\"Name\\\",session['name'])\\n flagCheck = hl.checkDistributeFlag(user[\\\"Name\\\"])\\n if flagCheck == False:\\n return getKeys()\\n elif flagCheck == True:\\n flash(\\\"You have been logged out. Please contact your system administrator\\\")\\n return redirect(url_for('logout'))\",\n \"def handle_key(self, k):\\n\\t\\treturn False\",\n \"def _check_key(key): # type: (str) -> None\\n if not key:\\n raise ValueError('Key must not be empty.')\\n if '.' in key:\\n raise ValueError('Key must not contain dots.')\",\n \"def check_auth(username, password):\\n return username == 'daniel' and password == config['redis_auth_key']\",\n \"def key_is_present(host):\\n if(config.HOST_TYPE == 'linux'):\\n status, stdout, stderr = host.conn.execute_command('ls /root/.ssh')\\n if status:\\n return False\\n if 'id_rsa.pub' in stdout[0]:\\n return True\\n return False\\n else:\\n status, stdout, stderr = host.conn.execute_command('cmd /c dir \\\"C:\\\\\\\\Program Files (x86)\\\\\\\\freeSSHd\\\"')\\n if status:\\n return False\\n for value in stdout:\\n if 'RSAKey.cfg' in value:\\n return True\\n return False\",\n \"def getAuthKey( self ):\\n d = {\\n \\\"frob\\\" : FLICKR[ \\\"frob\\\" ],\\n \\\"perms\\\" : \\\"delete\\\"\\n }\\n sig = self.signCall( d )\\n url = self.urlGen( api.auth, d, sig )\\n ans = \\\"\\\"\\n try:\\n webbrowser.open( url )\\n print(\\\"Copy-paste following URL into a web browser and follow instructions:\\\")\\n print(url)\\n ans = raw_input(\\\"Have you authenticated this application? (Y/N): \\\")\\n except:\\n print(str(sys.exc_info()))\\n if ( ans.lower() == \\\"n\\\" ):\\n print(\\\"You need to allow this program to access your Flickr site.\\\")\\n print(\\\"Copy-paste following URL into a web browser and follow instructions:\\\")\\n print(url)\\n print(\\\"After you have allowed access restart uploadr.py\\\")\\n sys.exit()\",\n \"def req_CHECKPRESENT(self, key):\\n # TODO: so we need to maintain mapping from urls to keys. Then\\n # we could even store the filename within archive\\n # Otherwise it is unrealistic to even require to recompute key if we\\n # knew the backend etc\\n lgr.debug(\\\"VERIFYING key %s\\\" % key)\\n akey, afile = self._get_akey_afile(key)\\n if self.get_contentlocation(akey):\\n self.send(\\\"CHECKPRESENT-SUCCESS\\\", key)\\n else:\\n # TODO: proxy the same to annex itself to verify check for archive.\\n # If archive is no longer available -- then CHECKPRESENT-FAILURE\\n self.send(\\\"CHECKPRESENT-UNKNOWN\\\", key)\",\n \"def api_auth_validate(request, access_key):\\n if not request.is_json:\\n return {'error' : 'Bad request, payload must be JSON', 'code' : 400}\\n if not 'working_repo' in session:\\n return {'error' : 'Operation requires authentication', 'code': 401}\\n if session['working_repo'] != access_key:\\n return {'error' : 'Not authorized for this operation', 'code' : 403}\\n \\n return True\",\n \"def test_check_privatekey_valid(self):\\n key = load_privatekey(FILETYPE_PEM, client_key_pem)\\n cert = load_certificate(FILETYPE_PEM, client_cert_pem)\\n context = Context(SSLv23_METHOD)\\n context.use_privatekey(key)\\n context.use_certificate(cert)\\n assert None is context.check_privatekey()\",\n \"def test_create_key():\\n\\n assert symmetric.create_key() != \\\"\\\"\",\n \"def check_api_keys(self, request):\\n app_id, api_obj = request.META.get(\\\"HTTP_APP_ID\\\"), None\\n api_secret_key = request.META.get(\\\"HTTP_API_SECRET_KEY\\\")\\n if app_id and api_secret_key:\\n # validate app_id and api_secret_key\\n app_id_bool = self._validate_app_id(app_id)\\n if not app_id_bool:\\n return False, self.app_id_message\\n api_secret_key_bool = self._validate_api_secret_key(api_secret_key)\\n if not api_secret_key:\\n return False, self.api_secret_key_message\\n try:\\n api_obj = ApiApp.objects.get(app_id=app_id, api_secret_key=api_secret_key, active=True)\\n if api_obj:\\n self.app(request, api_obj)\\n return True, ''\\n except ApiApp.DoesNotExist:\\n self.app(request, api_obj)\\n return False, self.message\\n else:\\n self.app(request, api_obj)\\n return False, self.message\",\n \"def try_api_keys(self, request, **kwargs):\\n email = request.META.get('HTTP_PANDA_EMAIL') or request.GET.get('email')\\n api_key = request.META.get('HTTP_PANDA_API_KEY') or request.GET.get('api_key')\\n\\n if email:\\n email = unquote(email)\\n\\n if not email or not api_key:\\n return False\\n\\n try:\\n user = UserProxy.objects.get(username=email.lower())\\n except (UserProxy.DoesNotExist, UserProxy.MultipleObjectsReturned):\\n return False \\n\\n if not user.is_active:\\n return False\\n \\n request.user = user\\n\\n return self.get_key(user, api_key)\",\n \"def test_getKey_keyexists(self):\\n filename = self.mktemp()\\n with open(filename, 'wb') as fh:\\n fh.write(SEKRIT_KEY)\\n fh.flush()\\n\\n key = crypto.getKey(filename)\\n self.failUnlessIsInstance(key, basestring,\\n \\\"key isn't a string! type=%r\\\" % type(key))\\n self.assertEqual(SEKRIT_KEY, key,\\n \\\"\\\"\\\"The example key and the one read from file differ!\\n key (in hex): %s\\n SEKRIT_KEY (in hex): %s\\\"\\\"\\\"\\n % (key.encode('hex'), SEKRIT_KEY.encode('hex')))\",\n \"def test_check_keys_exist_for_provider_string(self):\\n\\n secret_key = None\\n provider_id = 'asu'\\n\\n serializer = serializers.CreditProviderCallbackSerializer()\\n with pytest.raises(PermissionDenied):\\n serializer._check_keys_exist_for_provider(secret_key, provider_id) # lint-amnesty, pylint: disable=protected-access\",\n \"def check_auth_gssapi_keyex(self, username,\\n gss_authenticated=AUTH_FAILED,\\n cc_file=None):\\n if gss_authenticated == AUTH_SUCCESSFUL:\\n return AUTH_SUCCESSFUL\\n return AUTH_FAILED\",\n \"def test_good_with_no_prior_key(self):\\n # config seems to be shared across tests, so we have to specifically set\\n # it to None.\\n config.set(xsrf_token_key=None)\\n tool = utils.XsrfTool()\\n token = tool.generate_token(12345, 'test_action')\\n self.assertTrue(tool.verify_token(token, 12345, 'test_action'))\",\n \"def key_valid(key_data):\\n\\n gpg = gnupg.GPG(gnupghome=\\\"gnupg\\\")\\n import_result = gpg.import_keys(key_data)\\n\\n if import_result.count == 1:\\n gpg.delete_keys(import_result.fingerprints[0])\\n return True\\n else:\\n return False\",\n \"def validate_keystore_key(args):\\n expected_name = 'keyRings/%s/cryptoKeys/%s'\\n expected_name %= (args.kms_keyring, args.kms_key)\\n describe_output = ''\\n try:\\n describe_output = subprocess.check_output(\\n ['gcloud', 'kms', 'keys', 'describe', args.kms_key,\\n '--project', args.kms_project,\\n '--location', args.kms_location,\\n '--keyring', args.kms_keyring,\\n '--format', 'value(name)'])\\n except subprocess.CalledProcessError:\\n pass\\n if expected_name in describe_output:\\n return\\n # Print warning and exit if output did not include the key.\\n warning = 'KMS key \\\"%s\\\" not found in keyring=%s project=%s location=%s'\\n warning %= (args.kms_key,\\n args.kms_keyring,\\n args.kms_project,\\n args.kms_location)\\n Print.YL(warning)\\n sys.exit(1)\",\n \"def verify_decrypt_key(self):\\r\\n\\t\\tpercent_english = Dict_Control(self.my_code).check_key()\\r\\n\\t\\t#If more than half the words are english, the key will pass. \\r\\n\\t\\tif percent_english > 50:\\r\\n\\t\\t\\tself.right_key = False\\r\\n\\t\\t#If the key does not pass, the program will give you a warning and prompt you for another key. \\r\\n\\t\\telse: \\r\\n\\t\\t\\tprint(f\\\"After decryption, it looks like only {percent_english}% of your words are english, you may have entered the wrong key?\\\")\",\n \"def validate_key_code(self, code):\\n\\n key = self.connect().query(KeyCode)\\\\\\n .filter(KeyCode.code == code)\\\\\\n .first()\\n\\n if key and (key.user and key.enabled):\\n return True\\n return False\",\n \"def test_blank_key(self):\\n with self.assertRaises(ConfigError) as cm:\\n imageroller.main.read_authconfig(\\n imageroller.test.get_config_parser(self._blank_key))\\n self.assertEqual(str(cm.exception), \\\"AuthConfig must contain ApiKey\\\")\",\n \"def key():\",\n \"def test_getKey_nokey(self):\\n filename = os.path.join(os.getcwd(), 'sekrit')\\n key = crypto.getKey(filename)\\n self.failUnlessIsInstance(key, basestring,\\n \\\"key isn't a string! type=%r\\\" % type(key))\",\n \"def key_request(self, user):\\n\\t\\tclient_log.debug(f'Запрос публичного ключа для {user}')\\n\\t\\treq = {\\n\\t\\t\\tACTION: PUBLIC_KEY_REQUEST,\\n\\t\\t\\tTIME: time.time(),\\n\\t\\t\\tACCOUNT_NAME: user\\n\\t\\t}\\n\\t\\twith socket_lock:\\n\\t\\t\\tsend_message(self.transport, req)\\n\\t\\t\\tans = get_message(self.transport)\\n\\t\\tif RESPONSE in ans and ans[RESPONSE] == 511:\\n\\t\\t\\treturn ans[DATA]\\n\\t\\telse:\\n\\t\\t\\tclient_log.error(f'Не удалось получить ключ собеседника{user}.')\",\n \"def test_no_key(self):\\n with self.assertRaises(ConfigError) as cm:\\n imageroller.main.read_authconfig(\\n imageroller.test.get_config_parser(self._no_key))\\n self.assertEqual(str(cm.exception), \\\"AuthConfig must contain ApiKey\\\")\",\n \"def authenticate_header(self, request):\\n return \\\"Api key authentication failed.\\\"\",\n \"def check_key(self):\\n\\n if self.type == \\\"RSA\\\" and self.size < 1024:\\n raise HostkeyError(\\\"RSA keys must at least be 1024 bits.\\\")\\n elif self.type == \\\"DSA\\\" and self.size != 1024:\\n raise HostkeyError(\\\"DSA keys can only be 1024 bits.\\\")\\n elif self.type == \\\"ECDSA\\\" and self.size not in [256, 384, 521]: # yes, that is *really* 521 bits, not a typo!\\n raise HostkeyError(\\\"ECDSA key must be either 256, 384 or 521 bits (yes, 521 not 512!)\\\")\\n elif self.type ==\\\"ED25519\\\" and self.size != 128:\\n raise HostkeyError(\\\"ED25519 keys have a fixed size, which cannot be altered.\\\") # can't really happen, size is ignored for ED25519\\n\\n # if privkey is already there check size\\n self.key_exists = False\\n self.key_current_size = 0\\n if os.path.exists(self.fullpath):\\n self.key_exists = True\\n if self.type == \\\"ED25519\\\":\\n self.curve = \\\"EC25519\\\"\\n self.key_current_size = 128 # somewhat erbitrary, attack complexity on ED25519 is larger that brute forcing a 128bit key\\n self.key_exists = True\\n elif self.type == \\\"RSA1\\\":\\n self.key_exists = True\\n self.key_current_size = 1024\\n else:\\n try:\\n with open(self.fullpath, \\\"rb\\\") as key_file:\\n self.privkey = crypto_serialization.load_pem_private_key(key_file.read(), password=None, backend=crypto_default_backend())\\n except IOError:\\n raise HostkeyError(get_exception())\\n\\n if self.type == \\\"DSA\\\" or self.type == \\\"RSA\\\":\\n self.key_current_size = self.privkey.key_size\\n elif self.type == \\\"ED25519\\\":\\n self.key_current_size = 128\\n elif self.type == \\\"ECDSA\\\":\\n self.pubkey = self.privkey.public_key()\\n if self.pubkey.curve.name == \\\"secp256r1\\\":\\n self.key_current_size = 256\\n elif self.pubkey.curve.name == \\\"secp384r1\\\":\\n self.key_current_size = 384\\n elif self.pubkey.curve.name == \\\"secp521r1\\\":\\n self.key_current_size = 521\\n else:\\n self.curve = self.pubkey.curve.name\",\n \"def patched_paramiko_transport_verify_key(self, host_key, sig): # pylint: disable=W0613\\n key = self._key_info[self.host_key_type](Message(host_key)) # pylint: disable=W0212\\n if key is None:\\n raise SSHException(\\\"Unknown host key type\\\")\\n # Patched: no more checks are done here\\n self.host_key = key\",\n \"def is_authenticated(self, request, **kwargs):\\n\\n try:\\n username, api_key = self.extract_credentials(request)\\n except ValueError:\\n return self._unauthorized()\\n\\n if not username or not api_key:\\n return self._unauthorized()\\n\\n # cache key=api_key, value=User-object\\n user = self._cache.get(api_key)\\n logging.error(\\\"cached ApiKey: %r value: %r==%r\\\" % (api_key, user and user.username, user))\\n if not user:\\n try:\\n lookup_kwargs = {username_field: username}\\n user = User.objects.get(**lookup_kwargs)\\n ApiKey.objects.get(user=user, key=api_key)\\n self._cache.set(api_key, user, self._ttl_seconds)\\n except (User.DoesNotExist, User.MultipleObjectsReturned,\\n ApiKey.DoesNotExist, ApiKey.MultipleObjectsReturned):\\n return self._unauthorized()\\n\\n if user.username != username:\\n return self._unauthorized()\\n\\n if not self.check_active(user):\\n return False\\n\\n key_auth_check = self.get_key(user, api_key)\\n if key_auth_check and not isinstance(key_auth_check, HttpUnauthorized):\\n request.user = user\\n\\n return key_auth_check\",\n \"def _check_api_key(self):\\n try:\\n self.maps.places_nearby(\\n location=(53.909804, 27.580184),\\n radius=650,\\n open_now=False,\\n language=config.LANGUAGE,\\n type='cafe',\\n # rank_by='distance', # IMPORTANT: cannot use rank_by and radius options together\\n page_token=None,\\n )\\n except Exception as e:\\n\\n with self.__writelock:\\n self.print(f'ERROR: bad API key \\\"{self.maps.key}\\\" (tracker={self.stats.previous_requests})\\\\n')\\n raise e\",\n \"def test_get_user_api_keys(self):\\n pass\",\n \"def validate_api_key(self) -> tuple[bool, str]:\\n response = self._api_query('wallets')\\n\\n if response.status_code != HTTPStatus.OK:\\n result, msg = self._process_unsuccessful_response(\\n response=response,\\n case='validate_api_key',\\n )\\n return result, msg\\n\\n return True, ''\",\n \"def test_create_api_key(self):\\n pass\",\n \"def test_validate_credentials(self):\\n pass\",\n \"def _check(self, key):\\n if not self.contains(key):\\n raise KeyError(\\\"ConfigManager does not contain key '%s'\\\" % key)\",\n \"def test_missingKey(self):\\n self.assertIsNone(self.users.key(\\\"mystery domain\\\", \\\"mystery user\\\"))\",\n \"def checkkey(self, k):\\r\\n if k == self.shortcut:\\r\\n return True\\r\\n return False\",\n \"def _is_valid_key(self, key):\\r\\n\\r\\n # Check the length\\r\\n if len(key) > 250:\\r\\n return False\\r\\n\\r\\n # Check that there are no spaces or control characters\\r\\n for char in key:\\r\\n if ord(char) < 33 or ord(char) == 127:\\r\\n return False\\r\\n\\r\\n return True\",\n \"def check_auth(username, password):\\n # return username == app.config['USER'] and password == app.config['PASS']\\n\\n return username == app.config['USER'] and password == app.config['PASS']\",\n \"def load_key():\",\n \"def authenticate_key(api_key):\\n global db\\n if db is None:\\n init_db()\\n try:\\n if not api_key:\\n return False\\n user_model = Query()\\n user = db.search(user_model.api_key == api_key)[0]\\n if user:\\n return user['username']\\n except Exception as e:\\n LOGGER.exception(e)\\n LOGGER.error(\\\"Cannot retrieve user for this authentication key {}\\\".format(api_key))\\n return False\",\n \"def verify_hack_key(self):\\r\\n\\t\\tself.percent_english = Dict_Control(self.my_code).check_key()\\r\\n\\t\\t#If more than half the words are english, the key will pass. \\r\\n\\t\\tif self.percent_english > 50:\\r\\n\\t\\t\\tself.hack_plausible = True\",\n \"def _check_transform_key(key: Hashable) -> None:\\n _test_hashable = hash(key) # The only 'real' way to make sure is hashable\\n # if not isinstance(key, Hashable):\\n # raise TypeError((type(key), \\\"transformation lookup key is not hashable\\\"))\",\n \"def apicheck():\\n\\n async def predicate(ctx: commands.Context):\\n travitia_keys = await ctx.bot.get_shared_api_tokens(\\\"travitia\\\")\\n key = travitia_keys.get(\\\"api_key\\\") is None\\n if ctx.invoked_with == \\\"help\\\" and key:\\n return False\\n if key:\\n await ctx.send(\\\"The API key is not registered, the command is unavailable.\\\")\\n return False\\n return True\\n\\n return commands.check(predicate)\",\n \"def test_key_use() -> None:\\n # check key usage method\\n # don't test if all keys are translated, crowdin will monitor it\\n lib_folder = Path(__file__).parents[1] / \\\"sepal_ui\\\"\\n\\n assert \\\"test_key\\\" in ms.key_use(lib_folder, \\\"ms\\\")\\n\\n return\",\n \"def test_incorrect_api_key(self):\\n with self.subTest(\\\"Missing API key\\\"):\\n response = self.client.get(\\n self.url, HTTP_AUTHORIZATION=f\\\"ApiKey {self.web_user.username}:\\\"\\n )\\n self.assertEqual(response.status_code, 401)\\n\\n with self.subTest(\\\"Missing username\\\"):\\n response = self.client.get(\\n self.url, HTTP_AUTHORIZATION=f\\\"ApiKey :{self.web_user_api_key.key}\\\"\\n )\\n self.assertEqual(response.status_code, 401)\\n\\n with self.subTest(\\\"Missing header\\\"):\\n response = self.client.get(self.url)\\n self.assertEqual(response.status_code, 401)\\n\\n with self.subTest(\\\"Incorrect API key\\\"):\\n response = self.client.get(\\n self.url,\\n HTTP_AUTHORIZATION=f\\\"ApiKey {self.web_user.username}:Incorrectkey\\\",\\n )\\n self.assertEqual(response.status_code, 401)\",\n \"def test_storeAndRetrieveKey(self):\\n domain, username, password, key = \\\"domain\\\", \\\"user\\\", \\\"password\\\", \\\"key\\\"\\n\\n self.assertStored(domain, username, password, key)\\n self.assertEqual(self.users.key(domain, username), key)\",\n \"def check_tokenterminal_key(show_output: bool = False) -> str:\\n\\n if show_output:\\n console.print(\\\"Checking status...\\\")\\n\\n current_user = get_current_user()\\n\\n if current_user.credentials.API_TOKEN_TERMINAL_KEY == \\\"REPLACE_ME\\\":\\n logger.info(\\\"Token Terminal key not defined\\\")\\n status = KeyStatus.NOT_DEFINED\\n else:\\n token_terminal = TokenTerminal(\\n key=current_user.credentials.API_TOKEN_TERMINAL_KEY\\n )\\n\\n if \\\"message\\\" in token_terminal.get_all_projects():\\n logger.warning(\\\"Token Terminal key defined, test failed\\\")\\n status = KeyStatus.DEFINED_TEST_FAILED\\n else:\\n logger.info(\\\"Token Terminal key defined, test passed\\\")\\n status = KeyStatus.DEFINED_TEST_PASSED\\n\\n if show_output:\\n console.print(status.colorize())\\n\\n return str(status)\",\n \"def get_key(self, user):\\r\\n from delicious_cake.models import ApiKey\\r\\n\\r\\n try:\\r\\n key = ApiKey.objects.get(user=user)\\r\\n except ApiKey.DoesNotExist:\\r\\n return False\\r\\n\\r\\n return key.key\",\n \"def getAuthKey(self):\\r\\n auth_key = 'Que despierte la Red'\\r\\n assert len(auth_key) == self.AUTH_KEY_LEN\\r\\n return auth_key\",\n \"def _verify_keystore(self):\\n keystore_uid = FileUtil(self.keystore_file).uid()\\n if keystore_uid not in (-1, HostInfo.uid):\\n raise IOError(\\\"not owner of keystore: %s\\\" % self.keystore_file)\\n keystore_dir = os.path.dirname(self.keystore_file)\\n if FileUtil(keystore_dir).uid() != HostInfo.uid:\\n raise IOError(\\\"keystore dir not found or not owner: %s\\\" % keystore_dir)\\n if (keystore_uid != -1 and (os.stat(self.keystore_file).st_mode & 0o077)):\\n raise IOError(\\\"keystore is accessible to group or others: %s\\\" % self.keystore_file)\",\n \"def attempt(chal, request):\\n team = Teams.query.filter_by(id=session['id']).first()\\n if locked(chal):\\n return False, 'Challenge Locked. You need at least {} points.'.format(chal.unlock_at)\\n \\n provided_key = request.form['key'].strip()\\n chal_keys = Keys.query.filter_by(chal=chal.id).all()\\n for chal_key in chal_keys:\\n if get_key_class(chal_key.type).compare(chal_key.flag, provided_key):\\n return True, 'Correct'\\n return False, 'Incorrect'\",\n \"def test_rsa(self):\\n key = c.KEY_RSA\\n usage = [\\n c.KU_DIGITALSIGNATURE,\\n c.KU_NONREPUDIATION,\\n c.KU_KEYENCIPHERMENT,\\n c.KU_DATAENCIPHERMENT,\\n ]\\n self.assertTrue(utils.check_key_usage(key, usage))\",\n \"def _key_check(self, key_list, chk_dict=None):\\n exists = False\\n if chk_dict is None:\\n chk_dict = self._e_dict\\n for key in key_list:\\n exists = key in chk_dict.keys()\\n if exists:\\n chk_dict = chk_dict[key]\\n else:\\n break\\n return exists\",\n \"def key():\\n pass\",\n \"def key():\\n pass\",\n \"def test_get(self):\\n key = self.key_gen.get()\\n key2 = self.key_gen.get()\\n\\n self.assertEqual(key, key2 - 1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7483722","0.7159838","0.7102654","0.70746124","0.70519286","0.69825","0.69745266","0.6936464","0.6857674","0.6834089","0.67978585","0.6719186","0.661024","0.65871054","0.64848256","0.6452751","0.6445985","0.644107","0.6375559","0.6362564","0.6354385","0.6344735","0.62626284","0.6254767","0.6209742","0.6201196","0.6198189","0.61824095","0.61750257","0.6174351","0.61684465","0.616279","0.6139381","0.6121935","0.60924387","0.6050223","0.60475445","0.604292","0.6028092","0.6017742","0.60026824","0.59959173","0.5986703","0.59849393","0.59561914","0.59494483","0.5939697","0.5939225","0.59274983","0.5924119","0.5913804","0.5906216","0.58919203","0.58790374","0.58746624","0.5870707","0.58522415","0.58434844","0.5838719","0.5819744","0.58182645","0.58168614","0.58101964","0.5808335","0.57974637","0.57913667","0.579019","0.57851726","0.57833344","0.5781537","0.57796746","0.5776966","0.57753944","0.57679874","0.57673377","0.5749965","0.5745414","0.5738429","0.5734095","0.57312745","0.57288444","0.57214046","0.5712755","0.57090783","0.57040954","0.57022214","0.5695404","0.5685032","0.5683717","0.568106","0.56735927","0.5673216","0.56708455","0.5667672","0.5662317","0.56621665","0.56575763","0.56530577","0.56530577","0.5650476"],"string":"[\n \"0.7483722\",\n \"0.7159838\",\n \"0.7102654\",\n \"0.70746124\",\n \"0.70519286\",\n \"0.69825\",\n \"0.69745266\",\n \"0.6936464\",\n \"0.6857674\",\n \"0.6834089\",\n \"0.67978585\",\n \"0.6719186\",\n \"0.661024\",\n \"0.65871054\",\n \"0.64848256\",\n \"0.6452751\",\n \"0.6445985\",\n \"0.644107\",\n \"0.6375559\",\n \"0.6362564\",\n \"0.6354385\",\n \"0.6344735\",\n \"0.62626284\",\n \"0.6254767\",\n \"0.6209742\",\n \"0.6201196\",\n \"0.6198189\",\n \"0.61824095\",\n \"0.61750257\",\n \"0.6174351\",\n \"0.61684465\",\n \"0.616279\",\n \"0.6139381\",\n \"0.6121935\",\n \"0.60924387\",\n \"0.6050223\",\n \"0.60475445\",\n \"0.604292\",\n \"0.6028092\",\n \"0.6017742\",\n \"0.60026824\",\n \"0.59959173\",\n \"0.5986703\",\n \"0.59849393\",\n \"0.59561914\",\n \"0.59494483\",\n \"0.5939697\",\n \"0.5939225\",\n \"0.59274983\",\n \"0.5924119\",\n \"0.5913804\",\n \"0.5906216\",\n \"0.58919203\",\n \"0.58790374\",\n \"0.58746624\",\n \"0.5870707\",\n \"0.58522415\",\n \"0.58434844\",\n \"0.5838719\",\n \"0.5819744\",\n \"0.58182645\",\n \"0.58168614\",\n \"0.58101964\",\n \"0.5808335\",\n \"0.57974637\",\n \"0.57913667\",\n \"0.579019\",\n \"0.57851726\",\n \"0.57833344\",\n \"0.5781537\",\n \"0.57796746\",\n \"0.5776966\",\n \"0.57753944\",\n \"0.57679874\",\n \"0.57673377\",\n \"0.5749965\",\n \"0.5745414\",\n \"0.5738429\",\n \"0.5734095\",\n \"0.57312745\",\n \"0.57288444\",\n \"0.57214046\",\n \"0.5712755\",\n \"0.57090783\",\n \"0.57040954\",\n \"0.57022214\",\n \"0.5695404\",\n \"0.5685032\",\n \"0.5683717\",\n \"0.568106\",\n \"0.56735927\",\n \"0.5673216\",\n \"0.56708455\",\n \"0.5667672\",\n \"0.5662317\",\n \"0.56621665\",\n \"0.56575763\",\n \"0.56530577\",\n \"0.56530577\",\n \"0.5650476\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76604617"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":185,"cells":{"query":{"kind":"string","value":"This function is used to update API endpoints"},"document":{"kind":"string","value":"def update(self):\n # TO DO for updating urls if changed\n pass"},"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_api(self) -> None:\n LOG.debug(\"%sTrying to update RestAPI through client\", self.log_prefix)\n response_put = cast(\n Dict,\n self._api_client.put_rest_api(restApiId=self._api_physical_id, mode=\"overwrite\", body=self._swagger_body),\n )\n LOG.debug(\"%sPut RestApi Result: %s\", self.log_prefix, response_put)","def _update_from_rest_data(self) -> None:","def update():\n return 'update api in put'","def endpoint_update(self, endpoint_name=None, config=None):\n if config is None:\n raise Exception(\"Config required!\")\n if endpoint_name is None:\n self.request('/v1.1/endpoint', 'POST', body=config)\n else:\n self.request('/v1.1/endpoints/%s' % endpoint_name, 'POST', body=config)","def test_otoroshi_controllers_adminapi_tcp_service_api_controller_bulk_update_action(self):\n pass","def test_deprecated_update_bs(self):\n with app.test_client() as client:\n self.login_client(client)\n\n res = client.put(\n '/v1/sim/configs/ae',\n data=json.dumps({}),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(data['message'], 'Method Not Allowed.')\n self.assertEqual(data['status'], 'fail')\n self.assertEqual(res.status_code, 405)","def update(self, params):","def update_endpoint(EndpointName=None, EndpointConfigName=None):\n pass","def taco_test_put_update(self):\n body = '{ \"id\": 400, \"name\": \"item4\", \"content\": \"after test update\" }'\n env = self.get_env('PUT', '/item/4', body=body)\n webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))","def update_api(self, ApiId: str, ApiKeySelectionExpression: str = None, Description: str = None, DisableSchemaValidation: bool = None, Name: str = None, RouteSelectionExpression: str = None, Version: str = None) -> Dict:\n pass","def test_deprecated_update_ae(self):\n with app.test_client() as client:\n self.login_client(client)\n\n res = client.put(\n '/v1/sim/configs/ae',\n data=json.dumps({}),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(data['message'], 'Method Not Allowed.')\n self.assertEqual(data['status'], 'fail')\n self.assertEqual(res.status_code, 405)","def update(self, *args, **kwargs):","def test_otoroshi_controllers_adminapi_tcp_service_api_controller_bulk_patch_action(self):\n pass","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def _register_api(app):\n\n app.add_url_rule('/shipping/',\n \"put_shipping_method\", put_shipping_method, methods=['PUT'])","def updateResource(self, authenticationToken, resource):\r\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, *args, **kwargs): # real signature unknown\n pass","def fusion_api_edit_switch(self, body, uri, api=None, headers=None):\n return self.switch.update(body, uri, api, headers)","def fusion_api_patch_interconnect(self, body, uri, param='', api=None, headers=None):\n return self.ic.patch(body=body, uri=uri, api=api, headers=headers, param=param)","def register_endpoints(api):\n api.add_resource(EventList, '/events')","def test_otoroshi_controllers_adminapi_tcp_service_api_controller_update_entity_action(self):\n pass","def process_resource_api(self, resources, resource, api, context):\n pass","def fusion_api_update_task(self, body, uri, api=None, headers=None):\n return self.task.update(body, uri, api, headers)","def update( ):\r\n pass","def update_controller(self):","def update(self, *args, **kw):\n pass","def fusion_api_generic_patch(self, body, uri, api=None, headers=None):\n if api:\n headers = self.fusion_client._set_req_api_version(api=api)\n elif not headers:\n headers = self.fusion_client._headers\n uri = 'https://%s%s' % (self.fusion_client._host, uri)\n return self.fusion_client.patch(uri=uri, headers=headers, body=json.dumps(body))","def fusion_api_edit_rack(self, body, uri, api=None, headers=None):\n return self.rack.update(body, uri, api, headers)","def update(*args):","def put(self, endpoint: str, json: Any = None) -> Any:\n pass","def test_mocked_api_update_value(self):\n c = Client()\n patch_url = \"/apimock/mocked/api/account/45/?format=json\"\n response = c.get(self.patch_url)\n self.assertEqual(response.status_code, 200)\n self.assertIn('{\"account\": 157}',\n response.content)\n response = c.patch(self.patch_url, data={\"account\": 456})\n self.assertEqual(response.status_code, 200)\n self.assertIn('{\"account\": 456}', response.content)\n response = c.get(self.patch_url)\n self.assertIn('{\"account\": 456}', response.content)\n response = c.patch(self.patch_url, data={\"account\": 654})\n self.assertEqual(response.status_code, 200)\n self.assertIn('{\"account\": 654}', response.content)\n response = c.get(self.patch_url)\n self.assertIn('{\"account\": 654}', response.content)","def update_endpoint(self, endpoint):\n exists = self.get_endpoint(endpoint)\n if exists:\n self.delete_endpoint(endpoint)\n self.add_endpoint(endpoint)","def update(self) -> None:\n ...","def test_api(self):\n new_route = self.route.api(\"new\")\n assert new_route != self.route\n assert new_route.route[\"api\"] == \"new\"","def do_api_check(self):\n for charid in self.conn.get_api_characters():\n self.update_character(charid)\n for corpid in self.conn.get_api_corporations():\n self.update_corporation(corpid)\n for allyid in self.conn.get_api_alliances():\n self.update_alliance(allyid)","def taco_test_post_param_update(self):\n body = '{ \"id\": 400, \"name\": \"item4\", \"content\": \"after test update\" }'\n env = self.get_env('POST', '/item/4', body=body)\n result = webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))\n # webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))\n debug.log('result', result)","def reorder_api(apis, base):\n return","def _load_api(self):\n self.app.add_url_rule('/scheduler', 'get_scheduler_info', self._apply_auth(api.get_scheduler_info))\n self.app.add_url_rule('/scheduler/jobs', 'add_job', self._apply_auth(api.add_job), methods=['POST'])\n self.app.add_url_rule('/scheduler/jobs', 'get_jobs', self._apply_auth(api.get_jobs))\n self.app.add_url_rule('/scheduler/jobs/reload_jobs', 'reload_jobs', self._apply_auth(api.reload_jobs), methods=['POST'])\n self.app.add_url_rule('/scheduler/jobs/<job_id>', 'get_job', self._apply_auth(api.get_job))\n self.app.add_url_rule('/scheduler/jobs/<job_id>', 'delete_job', self._apply_auth(api.delete_job), methods=['DELETE'])\n self.app.add_url_rule('/scheduler/jobs/<job_id>', 'update_job', self._apply_auth(api.update_job), methods=['PATCH'])\n self.app.add_url_rule('/scheduler/jobs/<id>/reschedule', 'reschedule_job', self._apply_auth(api.reschedule_job), methods=['PATCH'])\n self.app.add_url_rule('/scheduler/jobs/<id>/reschedule_once', 'reschedule_job_once', self._apply_auth(api.reschedule_job_once), methods=['PATCH'])\n self.app.add_url_rule('/scheduler/jobs/<job_id>/pause', 'pause_job', self._apply_auth(api.pause_job), methods=['POST'])\n self.app.add_url_rule('/scheduler/jobs/<job_id>/resume', 'resume_job', self._apply_auth(api.resume_job), methods=['POST'])\n self.app.add_url_rule('/scheduler/jobs/<job_id>/run', 'run_job', self._apply_auth(api.run_job), methods=['POST'])","def fusion_api_update_ls(self, body=None, uri=None, api=None, headers=None):\n return self.ls.put(body, uri, api, headers)","def __update_data(self):\r\n # loop = asyncio.get_event_loop()\r\n api_base_info_req = self.loop.run_in_executor(None, self.__get_base_info_api)\r\n api_status_req = self.loop.run_in_executor(None, self.__get_status_api)\r\n api_status_res = yield from api_status_req\r\n api_base_info_res = yield from api_base_info_req\r\n\r\n self.__set_base_info_api(api_base_info_res)\r\n self.__set_status_api(api_status_res)","def test_update(self):\n url_register = reverse('auth_register')\n resp = self.client.post(url_register, {\n \"username\": \"user\",\n \"password\": \"lol1lol1\",\n \"password2\": \"lol1lol1\",\n \"email\": \"lol@gmail.com\",\n \"first_name\": \"\",\n \"last_name\": \"\",\n \"bio\": \"\"\n })\n print(resp.headers[\"Location\"])\n self.assertEqual(resp.status_code, status.HTTP_201_CREATED)\n self.assertEqual(User.objects.count(), 1)\n url_auth = reverse('token_obtain_pair')\n resp = self.client.post(url_auth, {'username':'user', 'password':'lol1lol1'}, format='json')\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\n token = resp.data['access']\n\n url_upd = reverse('auth_update_profile', kwargs={'pk': 2})\n\n client = APIClient()\n client.credentials(HTTP_AUTHORIZATION='Bearer ' + token)\n resp = client.patch(url_upd, {\n \"username\": \"user3\",\n \"email\": \"lol@gmail.com\",\n \"first_name\": \"\",\n \"last_name\": \"\",\n \"image\": \"\",\n \"bio\": \"\",\n \"city\": \"\",\n \"phone\": \"\"\n })\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\n self.assertEqual(User.objects.get().username, 'user3')","def update():","def update():","def _update_params(self):\n pass","def refresh_from_api(self):\n self.populate_from_api(self.get_from_api())","def handle_update(self):\n try:\n for controller in self.controllers:\n self._handle_single_update(controller)\n except urllib3.exceptions.HTTPError as http_error:\n raise HttpError('Error talking to Kubernetes', http_error) from http_error","def update_params(self):\n pass","def do_update(url,indexHeaders,update_file):\n updateUrl=url.replace(\"buckets\",\"riak\")\n indexHeaders['content-type'] = 'application/json'\n r=requests.post(url, data=json.dumps(update_file), headers=indexHeaders)","def fusion_api_patch_li(self, body=None, uri=None, api=None, headers=None):\n return self.li.patch(body, uri, api, headers)","def update(self,request,pk = None):\n return Response({'http_method':'PUT'})","def update_endpoints(user_id):\n\n if not request.json:\n abort(400)\n\n new_ips = request.json[\"ips\"]\n\n db_conn = sqlite3.connect(db_path)\n db = db_conn.cursor()\n db_ips = []\n try:\n for row in db.execute(\"SELECT ip FROM ips WHERE username=?;\", [user_id]):\n db_ips.append(row[0])\n except sqlite3.IntegrityError:\n db_conn.close()\n abort(400)\n\n to_add = []\n to_delete = []\n\n # Put the ips not present in the database in the list of ips to add\n for new_ip in new_ips:\n if(new_ip not in db_ips):\n to_add.append((user_id, new_ip))\n # Put the ips not in the new list in the list of ips to delete\n for db_ip in db_ips:\n if(db_ip not in new_ips):\n to_delete.append((user_id, db_ip))\n\n try:\n db.executemany('INSERT INTO ips (username, ip) VALUES (?,?);', to_add)\n db.executemany('DELETE FROM ips WHERE username=? AND ip=?;', to_delete)\n db_conn.commit()\n db_conn.close()\n except sqlite3.IntegrityError:\n db_conn.close()\n abort(400)\n return jsonify({'status':True})","def test_ipam_services_update(self):\n pass","def update(self, request, pk=None): #update a specific object\n return Response({'http_method': 'PUT'})","def create_api_endpoints(app):\n manager = APIManager(app, flask_sqlalchemy_db=models.database)\n manager.create_api(models.State, results_per_page=0)\n manager.create_api(models.Party, results_per_page=0)\n manager.create_api(models.Candidate, results_per_page=0)\n manager.create_api(models.Election, results_per_page=0)\n manager.create_api(models.ElectoralCollege,\n results_per_page=0, collection_name='electoralcollege')\n manager.create_api(models.PartiesInvolved,\n results_per_page=0, collection_name='partiesinvolved')\n manager.create_api(models.ElectionsToState,\n results_per_page=0, collection_name='electionstostate')","def put(self, request, pk=None): #pk of id of objects to be updated (DB)\n return Response({'method':'PUT'})","def test_ipam_services_partial_update(self):\n pass","def test_update():\n payload = {'age': 99}\n sample_uuid = get_sample_id()\n response = requests.put(f'http://localhost:5000/api/persons/{sample_uuid}', json=payload)\n data = response.json()\n\n assert response.status_code == 200\n for field in FIELDS:\n assert field in data","def access_gemini_url_put_method(context, endpoint):\n url = urljoin(context.gemini_api_url, endpoint)\n context.response = requests.put(url)","def _update(self, host):\n pass","def put(self):\n try:\n rest_params = common.get_restful_params(self.request.uri)\n if rest_params is None:\n common.echo_json_response(self, 405, \"Not Implemented: Use /agents/ interface\")\n return\n\n if \"agents\" not in rest_params:\n common.echo_json_response(self, 400, \"uri not supported\")\n logger.warning('PUT returning 400 response. uri not supported: ' + self.request.path)\n return\n\n agent_id = rest_params[\"agents\"]\n if agent_id is None:\n common.echo_json_response(self, 400, \"uri not supported\")\n logger.warning(\"PUT returning 400 response. uri not supported\")\n\n agent = self.db.get_agent(agent_id)\n\n if agent is not None:\n common.echo_json_response(self, 404, \"agent id not found\")\n logger.info('PUT returning 404 response. agent id: ' + agent_id + ' not found.')\n\n if \"reactivate\" in rest_params:\n agent['operational_state']=cloud_verifier_common.CloudAgent_Operational_State.START\n asyncio.ensure_future(self.process_agent(agent, cloud_verifier_common.CloudAgent_Operational_State.GET_QUOTE))\n common.echo_json_response(self, 200, \"Success\")\n logger.info('PUT returning 200 response for agent id: ' + agent_id)\n elif \"stop\" in rest_params:\n # do stuff for terminate\n logger.debug(\"Stopping polling on %s\"%agent_id)\n self.db.update_agent(agent_id,'operational_state',cloud_verifier_common.CloudAgent_Operational_State.TENANT_FAILED)\n\n common.echo_json_response(self, 200, \"Success\")\n logger.info('PUT returning 200 response for agent id: ' + agent_id)\n else:\n common.echo_json_response(self, 400, \"uri not supported\")\n logger.warning(\"PUT returning 400 response. uri not supported\")\n\n except Exception as e:\n common.echo_json_response(self, 400, \"Exception error: %s\"%e)\n logger.warning(\"PUT returning 400 response. Exception error: %s\"%e)\n logger.exception(e)\n self.finish()","def updateResourceDef(url, user, pWd, resourceName, resJson):\n \n print(\"\\tupdating resource for catalog:-\" + url + \" resource=\" + \n resourceName + ' user=' + user)\n print(\"\\t\" + json.dumps(resJson))\n apiURL = url + '/access/1/catalog/resources/' + resourceName\n print(\"\\turl=\" + apiURL)\n header = {\"Accept\": \"application/json\", \"Content-Type\": \"application/json\"} \n tResp = requests.put(apiURL, data=json.dumps(resJson), headers=header, \n auth=HTTPBasicAuth(user, pWd))\n print(\"\\tresponse=\" + str(tResp.status_code))\n if tResp.status_code == 200:\n # valid - return the jsom\n print(\"\\tyay - update resource worked...\")\n print(tResp)\n return tResp.status_code\n else:\n # not valid\n print(\"\\tdarn - update resource failed...\")\n print(tResp)\n return tResp.status_code","def handle_task_enable(self, request):\n \"\"\"\n @api {post} /task/:id/enable Enable a task\n @apiName EnableTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {Boolean} updated The task has been updated.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"updated\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n \"\"\"\n @api {post} /task/:id/disable Disable a task\n @apiName DisableTask\n @apiGroup Tasks\n @apiVersion 1.0.0\n\n @apiParam {String} :id Task ID.\n\n @apiSuccess {Boolean} updated The task has been updated.\n @apiSuccess {String} id ID of the task.\n\n @apiSuccessExample {json} Example response:\n {\n \"updated\": true,\n \"id\": \"021b2092ef4111e481a852540064e600\"\n }\n \"\"\"\n\n match = re.match('/tasks/([0-9a-z]+)/(en|dis)able', request.uri_path)\n task = match.group(1)\n action = match.group(2)\n\n enabled = (action == 'en')\n\n tasks = self.cluster.config.get('tasks')\n\n if task in tasks:\n code = 200\n\n old = tasks[task].copy()\n tasks[task]['enabled'] = enabled\n self.cluster.config.set('tasks', tasks)\n\n get_plugin_registry().call_hook('TaskUpdated', task, old, tasks[task])\n\n headers = {\n 'Content-Type': 'application/javascript',\n 'Access-Control-Allow-Origin': '*'\n }\n body = json.dumps({\"id\": task, \"updated\": True})\n\n return HTTPReply(code = code, body = body, headers = headers)\n else:\n headers = {\n 'Access-Control-Allow-Origin': '*'\n }\n return HTTPReply(code = 404, headers = headers)","def test_get_api_resources(self):\n pass","def fusion_api_patch_fabric(self, uri, body, api=None, headers=None):\n return self.fabric.patch(uri, body, api, headers)","def update_resolver_endpoint(ResolverEndpointId=None, Name=None):\n pass","async def test_update_dispatch_route_by_id(client):\n update_dispatch_route_params = null\n params = [('access_token', 'access_token_example')]\n headers = { \n 'Accept': 'application/json',\n 'Content-Type': 'application/json',\n }\n response = await client.request(\n method='PUT',\n path='/v1/fleet/dispatch/routes/{route_id}'.format(route_id=56),\n headers=headers,\n json=update_dispatch_route_params,\n params=params,\n )\n assert response.status == 200, 'Response body is : ' + (await response.read()).decode('utf-8')","def update_endpoint_in_sipserver(self, endpoint: str, password: str) -> None:","def fusion_api_edit_interconnect_ports(self, body, uri, api=None, param='', headers=None):\n param = '/update-ports%s' % param\n return self.ic.put(body=body, uri=uri, api=api, headers=headers, param=param)","def endpoints(self, endpoints):\n\n self._endpoints = endpoints","def endpoint_present(\n name,\n publicurl=None,\n internalurl=None,\n adminurl=None,\n region=None,\n profile=None,\n url=None,\n interface=None,\n **connection_args\n):\n ret = {\"name\": name, \"changes\": {}, \"result\": True, \"comment\": \"\"}\n\n _api_version(profile=profile, **connection_args)\n\n endpoint = __salt__[\"keystone.endpoint_get\"](\n name, region, profile=profile, interface=interface, **connection_args\n )\n\n def _changes(desc):\n return ret.get(\"comment\", \"\") + desc + \"\\n\"\n\n def _create_endpoint():\n if _OS_IDENTITY_API_VERSION > 2:\n ret[\"changes\"] = __salt__[\"keystone.endpoint_create\"](\n name,\n region=region,\n url=url,\n interface=interface,\n profile=profile,\n **connection_args\n )\n else:\n ret[\"changes\"] = __salt__[\"keystone.endpoint_create\"](\n name,\n region=region,\n publicurl=publicurl,\n adminurl=adminurl,\n internalurl=internalurl,\n profile=profile,\n **connection_args\n )\n\n if endpoint and \"Error\" not in endpoint and endpoint.get(\"region\") == region:\n\n if _OS_IDENTITY_API_VERSION > 2:\n\n change_url = False\n change_interface = False\n\n if endpoint.get(\"url\", None) != url:\n ret[\"comment\"] = _changes(\n 'URL changes from \"{}\" to \"{}\"'.format(\n endpoint.get(\"url\", None), url\n )\n )\n change_url = True\n\n if endpoint.get(\"interface\", None) != interface:\n ret[\"comment\"] = _changes(\n 'Interface changes from \"{}\" to \"{}\"'.format(\n endpoint.get(\"interface\", None), interface\n )\n )\n change_interface = True\n\n if __opts__.get(\"test\") and (change_url or change_interface):\n ret[\"result\"] = None\n ret[\"changes\"][\"Endpoint\"] = \"Will be updated\"\n ret[\"comment\"] += 'Endpoint for service \"{}\" will be updated'.format(\n name\n )\n return ret\n\n if change_url:\n ret[\"changes\"][\"url\"] = url\n\n if change_interface:\n ret[\"changes\"][\"interface\"] = interface\n\n else:\n change_publicurl = False\n change_adminurl = False\n change_internalurl = False\n\n if endpoint.get(\"publicurl\", None) != publicurl:\n change_publicurl = True\n\n ret[\"comment\"] = _changes(\n 'Public URL changes from \"{}\" to \"{}\"'.format(\n endpoint.get(\"publicurl\", None), publicurl\n )\n )\n\n if endpoint.get(\"adminurl\", None) != adminurl:\n change_adminurl = True\n ret[\"comment\"] = _changes(\n 'Admin URL changes from \"{}\" to \"{}\"'.format(\n endpoint.get(\"adminurl\", None), adminurl\n )\n )\n\n if endpoint.get(\"internalurl\", None) != internalurl:\n change_internalurl = True\n ret[\"comment\"] = _changes(\n 'Internal URL changes from \"{}\" to \"{}\"'.format(\n endpoint.get(\"internalurl\", None), internalurl\n )\n )\n\n if __opts__.get(\"test\") and (\n change_publicurl or change_adminurl or change_internalurl\n ):\n ret[\"result\"] = None\n ret[\"comment\"] += 'Endpoint for service \"{}\" will be updated'.format(\n name\n )\n ret[\"changes\"][\"Endpoint\"] = \"Will be updated\"\n return ret\n\n if change_publicurl:\n ret[\"changes\"][\"publicurl\"] = publicurl\n\n if change_adminurl:\n ret[\"changes\"][\"adminurl\"] = adminurl\n\n if change_internalurl:\n ret[\"changes\"][\"internalurl\"] = internalurl\n\n if ret[\"comment\"]: # changed\n __salt__[\"keystone.endpoint_delete\"](\n name, region, profile=profile, interface=interface, **connection_args\n )\n _create_endpoint()\n ret[\"comment\"] += 'Endpoint for service \"{}\" has been updated'.format(name)\n\n else:\n # Add new endpoint\n if __opts__.get(\"test\"):\n ret[\"result\"] = None\n ret[\"changes\"][\"Endpoint\"] = \"Will be created\"\n ret[\"comment\"] = 'Endpoint for service \"{}\" will be added'.format(name)\n return ret\n _create_endpoint()\n ret[\"comment\"] = 'Endpoint for service \"{}\" has been added'.format(name)\n\n if ret[\"comment\"] == \"\": # => no changes\n ret[\"comment\"] = 'Endpoint for service \"{}\" already exists'.format(name)\n return ret","def update(self):\n self._client.patch(self)","def _register_api(app):\n \n app.add_url_rule('/like/', \n \"new_like\", new_like, methods=['PUT'])\n app.add_url_rule('/like/', \n \"delete_like\", delete_like, methods=['DELETE'])","def test_deprecated_update_ms(self):\n with app.test_client() as client:\n self.login_client(client)\n\n res = client.put(\n '/v1/sim/configs/ms',\n data=json.dumps({}),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(data['message'], 'Method Not Allowed.')\n self.assertEqual(data['status'], 'fail')\n self.assertEqual(res.status_code, 405)","def rest(method, endpoint, access_token, data={}, id=None):\n headers = {\n 'Authorization': f\"Bearer {access_token}\",\n 'Accept': 'application/json',\n 'Content-Type': 'application/json'\n }\n base_url = \"https://api.intercom.io/\"\n\n # for creating and updating a companies api using POST method only\n if endpoint in ['contacts', 'companies', 'events', 'tags'] and method == 'POST':\n url = f\"{base_url}{endpoint}\"\n elif endpoint == 'add_tags' and method == \"POST\":\n url = f\"{base_url}contacts/{id}/tags\"\n elif (endpoint == 'contacts') and method == 'POST':\n url = f\"{base_url}{endpoint}/{id}\"\n elif endpoint == 'contact_email' and method == 'POST':\n url = f\"{base_url}contacts/search\"\n elif endpoint == 'notes' and method == 'POST':\n url = f\"{base_url}contacts/{id}/notes\"\n elif endpoint == 'contacts' and method == 'PUT':\n url = f\"{base_url}{endpoint}/{id}\"\n elif endpoint == 'tags' and method == 'DELETE':\n url = f\"{base_url}contacts/{id[0]}/tags/{id[1]}\"\n elif endpoint == 'contacts' and method == 'GET':\n url = f\"{base_url}{endpoint}/{id}\"\n elif endpoint == 'companies' and method == 'GET':\n url = f\"{base_url}{endpoint}?company_id={id}\"\n elif endpoint == 'admin' and method == 'GET':\n url = f'{base_url}admins'\n\n response = requests.request(\n method, url, headers=headers, data=json.dumps(data))\n return response","def update_api_consumer(self, host, port):\n\n APIConsumer.host = host\n APIConsumer.port = port\n APIConsumer.base_url = \"http://%s:%s\" % (host, port)","def test_updateall():\n url = baseUrl + userurl + emailId\n payload = {'firstName': new_firstName, 'lastName': new_lastName, 'emailId': new_emailId}\n logging.info(\"Update a user's firstName to: %s, lastName to: %s and emailId to: %s\" % (new_firstName, new_lastName, new_emailId))\n r = requests.put(url, data=json.dumps(payload), headers=header)\n assert r.status_code == 200\n resp = r.json()\n assert resp[\"userName\"] == emailId and resp[\"lastName\"] == new_lastName and resp[\"firstName\"] == new_firstName \\\n and resp[\"licenseType\"] == licensetype and resp[\"subscriptionIds\"][0] == subscriptionid and \\\n resp[\"isActive\"] is True and resp[\"source\"] == \"publicapi\" and resp[\"emailId\"] == new_emailId\n global user_id\n user_id = resp[\"id\"]\n assert user_id is not None","def do_PUT(self):\n note_details = NoteDetails\n if self.path == '/note/api/update':\n response_data=note_details.update_data(self)\n Response(self).jsonResponse(status=200, data=response_data)","def update_list(self, apikey):\n\n file = self.retrieve_update(apikey)\n self.parse_update(file)\n self.log.debug(self)","def test_update_should_not_be_allowed(self):\n response = self.client.put(self.get_url(), {})\n self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)","def updateParameters(self):\n\n return","def update(self, request, pk=None):\n\n return Response({'http_method': 'PUT'})","def update_api_access(info):\n try:\n file = open(PATH + \"/../DB/access.json\", 'r')\n accessData = json.load(file)\n except:\n raise\n\n try:\n accessData[info['application_name']] = {\n 'api_list': info['api_list'],\n 'timestamp': info['timestamp']\n }\n except Exception as e:\n print (e)\n raise\n\n try:\n with open(PATH + '/../DB/access.json', 'w') as f:\n f.write(json.dumps(accessData, indent=4, sort_keys=True))\n except:\n raise","async def put(self):\r\n data = await self.request.json()\r\n agent_uuid = data[\"agent_uuid\"]\r\n ip_address = data[\"ip_address\"]\r\n agent_obj = Agent.filter(Agent.uuid == agent_uuid).first()\r\n if not agent_obj:\r\n response_obj = {\"status\": \"failed\"}\r\n logger.error(\"No agent found!!!\")\r\n return web.Response(text=str(response_obj), status=500)\r\n try:\r\n Agent.update(ip_address=ip_address).where(Agent.uuid == agent_uuid)\r\n logger.info(\"Agent updated!!!\")\r\n return web.Response(text=\"successful\", status=200)\r\n except Exception as ex:\r\n response_obj = {\"status\": \"failed\"}\r\n error_message = str(ex)\r\n logger.error(error_message)\r\n return web.Response(text=str(response_obj), status=500)","def test_update_case(self):\n pass","def taco_test_put_new(self):\n body = '{ \"id\": 400, \"name\": \"item_new\", \"content\": \"after test update\" }'\n env = self.get_env('PUT', '/item/4', body=body)\n webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))","def test_task_update(self):\r\n admin = UserFactory.create()\r\n user = UserFactory.create()\r\n non_owner = UserFactory.create()\r\n app = AppFactory.create(owner=user)\r\n task = TaskFactory.create(app=app)\r\n root_task = TaskFactory.create(app=app)\r\n data = {'state': '1'}\r\n datajson = json.dumps(data)\r\n root_data = {'state': '4'}\r\n root_datajson = json.dumps(root_data)\r\n\r\n ## anonymous\r\n res = self.app.put('/api/task/%s' % task.id, data=data)\r\n assert_equal(res.status, '401 UNAUTHORIZED', res.status)\r\n ### real user but not allowed as not owner!\r\n url = '/api/task/%s?api_key=%s' % (task.id, non_owner.api_key)\r\n res = self.app.put(url, data=datajson)\r\n assert_equal(res.status, '403 FORBIDDEN', res.status)\r\n\r\n ### real user\r\n url = '/api/task/%s?api_key=%s' % (task.id, user.api_key)\r\n res = self.app.put(url, data=datajson)\r\n out = json.loads(res.data)\r\n assert_equal(res.status, '200 OK', res.data)\r\n assert_equal(task.state, data['state'])\r\n assert task.id == out['id'], out\r\n\r\n ### root\r\n res = self.app.put('/api/task/%s?api_key=%s' % (root_task.id, admin.api_key),\r\n data=root_datajson)\r\n assert_equal(res.status, '200 OK', res.data)\r\n assert_equal(root_task.state, root_data['state'])\r\n\r\n # PUT with not JSON data\r\n res = self.app.put(url, data=data)\r\n err = json.loads(res.data)\r\n assert res.status_code == 415, err\r\n assert err['status'] == 'failed', err\r\n assert err['target'] == 'task', err\r\n assert err['action'] == 'PUT', err\r\n assert err['exception_cls'] == 'ValueError', err\r\n\r\n # PUT with not allowed args\r\n res = self.app.put(url + \"&foo=bar\", data=json.dumps(data))\r\n err = json.loads(res.data)\r\n assert res.status_code == 415, err\r\n assert err['status'] == 'failed', err\r\n assert err['target'] == 'task', err\r\n assert err['action'] == 'PUT', err\r\n assert err['exception_cls'] == 'AttributeError', err\r\n\r\n # PUT with fake data\r\n data['wrongfield'] = 13\r\n res = self.app.put(url, data=json.dumps(data))\r\n err = json.loads(res.data)\r\n assert res.status_code == 415, err\r\n assert err['status'] == 'failed', err\r\n assert err['target'] == 'task', err\r\n assert err['action'] == 'PUT', err\r\n assert err['exception_cls'] == 'TypeError', err","async def test_update(aresponses):\n aresponses.add(\n MATCH_HOST,\n \"/api/system/status\",\n \"GET\",\n aresponses.Response(\n status=200,\n headers={\"Content-Type\": \"application/json\"},\n text=load_fixture(\"system-status.json\"),\n ),\n )\n\n aresponses.add(\n MATCH_HOST,\n \"/api/diskspace\",\n \"GET\",\n aresponses.Response(\n status=200,\n headers={\"Content-Type\": \"application/json\"},\n text=load_fixture(\"diskspace.json\"),\n ),\n )\n\n aresponses.add(\n MATCH_HOST,\n \"/api/diskspace\",\n \"GET\",\n aresponses.Response(\n status=200,\n headers={\"Content-Type\": \"application/json\"},\n text=load_fixture(\"diskspace.json\"),\n ),\n )\n\n async with ClientSession() as session:\n client = Sonarr(HOST, API_KEY, session=session)\n response = await client.update()\n\n assert response\n assert isinstance(response.info, models.Info)\n assert isinstance(response.disks, List)\n\n response = await client.update()\n\n assert response\n assert isinstance(response.info, models.Info)\n assert isinstance(response.disks, List)","def update(self):\n\n pass","def update(self, request, phone):\n try:\n attrs = self.flatten_dict(request.POST)\n #if self.exists(**attrs):\n #return rc.DUPLICATE_ENTRY\n #else:\n endpoint = Endpoint.objects.get(uid__exact=phone, site__name__exact=request.user)\n if attrs.get('effective_caller_id_name'):\n endpoint.effective_caller_id_name = attrs.get('effective_caller_id_name')\n if attrs.get('password'):\n endpoint.password = attrs.get('password')\n if attrs.get('description'):\n endpoint.description = attrs.get('description')\n if attrs.get(\"enabled\") == \"false\":\n endpoint.enable = False\n elif attrs.get(\"enabled\") == \"true\":\n endpoint.enable = True\n if attrs.get(\"enable\") == \"false\":\n endpoint.enable = False\n elif attrs.get(\"enable\") == \"true\":\n endpoint.enable = True\n endpoint.save()\n return endpoint\n except:\n return rc.NOT_HERE","def update_endpoint(self, endpoint_id, endpoint_ref):\n raise exception.NotImplemented() # pragma: no cover","def test_update(self):\n pass","def test_update(self):\n pass","def test_update(self):\n pass"],"string":"[\n \"def _update_api(self) -> None:\\n LOG.debug(\\\"%sTrying to update RestAPI through client\\\", self.log_prefix)\\n response_put = cast(\\n Dict,\\n self._api_client.put_rest_api(restApiId=self._api_physical_id, mode=\\\"overwrite\\\", body=self._swagger_body),\\n )\\n LOG.debug(\\\"%sPut RestApi Result: %s\\\", self.log_prefix, response_put)\",\n \"def _update_from_rest_data(self) -> None:\",\n \"def update():\\n return 'update api in put'\",\n \"def endpoint_update(self, endpoint_name=None, config=None):\\n if config is None:\\n raise Exception(\\\"Config required!\\\")\\n if endpoint_name is None:\\n self.request('/v1.1/endpoint', 'POST', body=config)\\n else:\\n self.request('/v1.1/endpoints/%s' % endpoint_name, 'POST', body=config)\",\n \"def test_otoroshi_controllers_adminapi_tcp_service_api_controller_bulk_update_action(self):\\n pass\",\n \"def test_deprecated_update_bs(self):\\n with app.test_client() as client:\\n self.login_client(client)\\n\\n res = client.put(\\n '/v1/sim/configs/ae',\\n data=json.dumps({}),\\n content_type='application/json'\\n )\\n data = json.loads(res.data.decode())\\n self.assertEqual(data['message'], 'Method Not Allowed.')\\n self.assertEqual(data['status'], 'fail')\\n self.assertEqual(res.status_code, 405)\",\n \"def update(self, params):\",\n \"def update_endpoint(EndpointName=None, EndpointConfigName=None):\\n pass\",\n \"def taco_test_put_update(self):\\n body = '{ \\\"id\\\": 400, \\\"name\\\": \\\"item4\\\", \\\"content\\\": \\\"after test update\\\" }'\\n env = self.get_env('PUT', '/item/4', body=body)\\n webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))\",\n \"def update_api(self, ApiId: str, ApiKeySelectionExpression: str = None, Description: str = None, DisableSchemaValidation: bool = None, Name: str = None, RouteSelectionExpression: str = None, Version: str = None) -> Dict:\\n pass\",\n \"def test_deprecated_update_ae(self):\\n with app.test_client() as client:\\n self.login_client(client)\\n\\n res = client.put(\\n '/v1/sim/configs/ae',\\n data=json.dumps({}),\\n content_type='application/json'\\n )\\n data = json.loads(res.data.decode())\\n self.assertEqual(data['message'], 'Method Not Allowed.')\\n self.assertEqual(data['status'], 'fail')\\n self.assertEqual(res.status_code, 405)\",\n \"def update(self, *args, **kwargs):\",\n \"def test_otoroshi_controllers_adminapi_tcp_service_api_controller_bulk_patch_action(self):\\n pass\",\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 _register_api(app):\\n\\n app.add_url_rule('/shipping/',\\n \\\"put_shipping_method\\\", put_shipping_method, methods=['PUT'])\",\n \"def updateResource(self, authenticationToken, resource):\\r\\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, *args, **kwargs): # real signature unknown\\n pass\",\n \"def fusion_api_edit_switch(self, body, uri, api=None, headers=None):\\n return self.switch.update(body, uri, api, headers)\",\n \"def fusion_api_patch_interconnect(self, body, uri, param='', api=None, headers=None):\\n return self.ic.patch(body=body, uri=uri, api=api, headers=headers, param=param)\",\n \"def register_endpoints(api):\\n api.add_resource(EventList, '/events')\",\n \"def test_otoroshi_controllers_adminapi_tcp_service_api_controller_update_entity_action(self):\\n pass\",\n \"def process_resource_api(self, resources, resource, api, context):\\n pass\",\n \"def fusion_api_update_task(self, body, uri, api=None, headers=None):\\n return self.task.update(body, uri, api, headers)\",\n \"def update( ):\\r\\n pass\",\n \"def update_controller(self):\",\n \"def update(self, *args, **kw):\\n pass\",\n \"def fusion_api_generic_patch(self, body, uri, api=None, headers=None):\\n if api:\\n headers = self.fusion_client._set_req_api_version(api=api)\\n elif not headers:\\n headers = self.fusion_client._headers\\n uri = 'https://%s%s' % (self.fusion_client._host, uri)\\n return self.fusion_client.patch(uri=uri, headers=headers, body=json.dumps(body))\",\n \"def fusion_api_edit_rack(self, body, uri, api=None, headers=None):\\n return self.rack.update(body, uri, api, headers)\",\n \"def update(*args):\",\n \"def put(self, endpoint: str, json: Any = None) -> Any:\\n pass\",\n \"def test_mocked_api_update_value(self):\\n c = Client()\\n patch_url = \\\"/apimock/mocked/api/account/45/?format=json\\\"\\n response = c.get(self.patch_url)\\n self.assertEqual(response.status_code, 200)\\n self.assertIn('{\\\"account\\\": 157}',\\n response.content)\\n response = c.patch(self.patch_url, data={\\\"account\\\": 456})\\n self.assertEqual(response.status_code, 200)\\n self.assertIn('{\\\"account\\\": 456}', response.content)\\n response = c.get(self.patch_url)\\n self.assertIn('{\\\"account\\\": 456}', response.content)\\n response = c.patch(self.patch_url, data={\\\"account\\\": 654})\\n self.assertEqual(response.status_code, 200)\\n self.assertIn('{\\\"account\\\": 654}', response.content)\\n response = c.get(self.patch_url)\\n self.assertIn('{\\\"account\\\": 654}', response.content)\",\n \"def update_endpoint(self, endpoint):\\n exists = self.get_endpoint(endpoint)\\n if exists:\\n self.delete_endpoint(endpoint)\\n self.add_endpoint(endpoint)\",\n \"def update(self) -> None:\\n ...\",\n \"def test_api(self):\\n new_route = self.route.api(\\\"new\\\")\\n assert new_route != self.route\\n assert new_route.route[\\\"api\\\"] == \\\"new\\\"\",\n \"def do_api_check(self):\\n for charid in self.conn.get_api_characters():\\n self.update_character(charid)\\n for corpid in self.conn.get_api_corporations():\\n self.update_corporation(corpid)\\n for allyid in self.conn.get_api_alliances():\\n self.update_alliance(allyid)\",\n \"def taco_test_post_param_update(self):\\n body = '{ \\\"id\\\": 400, \\\"name\\\": \\\"item4\\\", \\\"content\\\": \\\"after test update\\\" }'\\n env = self.get_env('POST', '/item/4', body=body)\\n result = webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))\\n # webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))\\n debug.log('result', result)\",\n \"def reorder_api(apis, base):\\n return\",\n \"def _load_api(self):\\n self.app.add_url_rule('/scheduler', 'get_scheduler_info', self._apply_auth(api.get_scheduler_info))\\n self.app.add_url_rule('/scheduler/jobs', 'add_job', self._apply_auth(api.add_job), methods=['POST'])\\n self.app.add_url_rule('/scheduler/jobs', 'get_jobs', self._apply_auth(api.get_jobs))\\n self.app.add_url_rule('/scheduler/jobs/reload_jobs', 'reload_jobs', self._apply_auth(api.reload_jobs), methods=['POST'])\\n self.app.add_url_rule('/scheduler/jobs/<job_id>', 'get_job', self._apply_auth(api.get_job))\\n self.app.add_url_rule('/scheduler/jobs/<job_id>', 'delete_job', self._apply_auth(api.delete_job), methods=['DELETE'])\\n self.app.add_url_rule('/scheduler/jobs/<job_id>', 'update_job', self._apply_auth(api.update_job), methods=['PATCH'])\\n self.app.add_url_rule('/scheduler/jobs/<id>/reschedule', 'reschedule_job', self._apply_auth(api.reschedule_job), methods=['PATCH'])\\n self.app.add_url_rule('/scheduler/jobs/<id>/reschedule_once', 'reschedule_job_once', self._apply_auth(api.reschedule_job_once), methods=['PATCH'])\\n self.app.add_url_rule('/scheduler/jobs/<job_id>/pause', 'pause_job', self._apply_auth(api.pause_job), methods=['POST'])\\n self.app.add_url_rule('/scheduler/jobs/<job_id>/resume', 'resume_job', self._apply_auth(api.resume_job), methods=['POST'])\\n self.app.add_url_rule('/scheduler/jobs/<job_id>/run', 'run_job', self._apply_auth(api.run_job), methods=['POST'])\",\n \"def fusion_api_update_ls(self, body=None, uri=None, api=None, headers=None):\\n return self.ls.put(body, uri, api, headers)\",\n \"def __update_data(self):\\r\\n # loop = asyncio.get_event_loop()\\r\\n api_base_info_req = self.loop.run_in_executor(None, self.__get_base_info_api)\\r\\n api_status_req = self.loop.run_in_executor(None, self.__get_status_api)\\r\\n api_status_res = yield from api_status_req\\r\\n api_base_info_res = yield from api_base_info_req\\r\\n\\r\\n self.__set_base_info_api(api_base_info_res)\\r\\n self.__set_status_api(api_status_res)\",\n \"def test_update(self):\\n url_register = reverse('auth_register')\\n resp = self.client.post(url_register, {\\n \\\"username\\\": \\\"user\\\",\\n \\\"password\\\": \\\"lol1lol1\\\",\\n \\\"password2\\\": \\\"lol1lol1\\\",\\n \\\"email\\\": \\\"lol@gmail.com\\\",\\n \\\"first_name\\\": \\\"\\\",\\n \\\"last_name\\\": \\\"\\\",\\n \\\"bio\\\": \\\"\\\"\\n })\\n print(resp.headers[\\\"Location\\\"])\\n self.assertEqual(resp.status_code, status.HTTP_201_CREATED)\\n self.assertEqual(User.objects.count(), 1)\\n url_auth = reverse('token_obtain_pair')\\n resp = self.client.post(url_auth, {'username':'user', 'password':'lol1lol1'}, format='json')\\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\\n token = resp.data['access']\\n\\n url_upd = reverse('auth_update_profile', kwargs={'pk': 2})\\n\\n client = APIClient()\\n client.credentials(HTTP_AUTHORIZATION='Bearer ' + token)\\n resp = client.patch(url_upd, {\\n \\\"username\\\": \\\"user3\\\",\\n \\\"email\\\": \\\"lol@gmail.com\\\",\\n \\\"first_name\\\": \\\"\\\",\\n \\\"last_name\\\": \\\"\\\",\\n \\\"image\\\": \\\"\\\",\\n \\\"bio\\\": \\\"\\\",\\n \\\"city\\\": \\\"\\\",\\n \\\"phone\\\": \\\"\\\"\\n })\\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\\n self.assertEqual(User.objects.get().username, 'user3')\",\n \"def update():\",\n \"def update():\",\n \"def _update_params(self):\\n pass\",\n \"def refresh_from_api(self):\\n self.populate_from_api(self.get_from_api())\",\n \"def handle_update(self):\\n try:\\n for controller in self.controllers:\\n self._handle_single_update(controller)\\n except urllib3.exceptions.HTTPError as http_error:\\n raise HttpError('Error talking to Kubernetes', http_error) from http_error\",\n \"def update_params(self):\\n pass\",\n \"def do_update(url,indexHeaders,update_file):\\n updateUrl=url.replace(\\\"buckets\\\",\\\"riak\\\")\\n indexHeaders['content-type'] = 'application/json'\\n r=requests.post(url, data=json.dumps(update_file), headers=indexHeaders)\",\n \"def fusion_api_patch_li(self, body=None, uri=None, api=None, headers=None):\\n return self.li.patch(body, uri, api, headers)\",\n \"def update(self,request,pk = None):\\n return Response({'http_method':'PUT'})\",\n \"def update_endpoints(user_id):\\n\\n if not request.json:\\n abort(400)\\n\\n new_ips = request.json[\\\"ips\\\"]\\n\\n db_conn = sqlite3.connect(db_path)\\n db = db_conn.cursor()\\n db_ips = []\\n try:\\n for row in db.execute(\\\"SELECT ip FROM ips WHERE username=?;\\\", [user_id]):\\n db_ips.append(row[0])\\n except sqlite3.IntegrityError:\\n db_conn.close()\\n abort(400)\\n\\n to_add = []\\n to_delete = []\\n\\n # Put the ips not present in the database in the list of ips to add\\n for new_ip in new_ips:\\n if(new_ip not in db_ips):\\n to_add.append((user_id, new_ip))\\n # Put the ips not in the new list in the list of ips to delete\\n for db_ip in db_ips:\\n if(db_ip not in new_ips):\\n to_delete.append((user_id, db_ip))\\n\\n try:\\n db.executemany('INSERT INTO ips (username, ip) VALUES (?,?);', to_add)\\n db.executemany('DELETE FROM ips WHERE username=? AND ip=?;', to_delete)\\n db_conn.commit()\\n db_conn.close()\\n except sqlite3.IntegrityError:\\n db_conn.close()\\n abort(400)\\n return jsonify({'status':True})\",\n \"def test_ipam_services_update(self):\\n pass\",\n \"def update(self, request, pk=None): #update a specific object\\n return Response({'http_method': 'PUT'})\",\n \"def create_api_endpoints(app):\\n manager = APIManager(app, flask_sqlalchemy_db=models.database)\\n manager.create_api(models.State, results_per_page=0)\\n manager.create_api(models.Party, results_per_page=0)\\n manager.create_api(models.Candidate, results_per_page=0)\\n manager.create_api(models.Election, results_per_page=0)\\n manager.create_api(models.ElectoralCollege,\\n results_per_page=0, collection_name='electoralcollege')\\n manager.create_api(models.PartiesInvolved,\\n results_per_page=0, collection_name='partiesinvolved')\\n manager.create_api(models.ElectionsToState,\\n results_per_page=0, collection_name='electionstostate')\",\n \"def put(self, request, pk=None): #pk of id of objects to be updated (DB)\\n return Response({'method':'PUT'})\",\n \"def test_ipam_services_partial_update(self):\\n pass\",\n \"def test_update():\\n payload = {'age': 99}\\n sample_uuid = get_sample_id()\\n response = requests.put(f'http://localhost:5000/api/persons/{sample_uuid}', json=payload)\\n data = response.json()\\n\\n assert response.status_code == 200\\n for field in FIELDS:\\n assert field in data\",\n \"def access_gemini_url_put_method(context, endpoint):\\n url = urljoin(context.gemini_api_url, endpoint)\\n context.response = requests.put(url)\",\n \"def _update(self, host):\\n pass\",\n \"def put(self):\\n try:\\n rest_params = common.get_restful_params(self.request.uri)\\n if rest_params is None:\\n common.echo_json_response(self, 405, \\\"Not Implemented: Use /agents/ interface\\\")\\n return\\n\\n if \\\"agents\\\" not in rest_params:\\n common.echo_json_response(self, 400, \\\"uri not supported\\\")\\n logger.warning('PUT returning 400 response. uri not supported: ' + self.request.path)\\n return\\n\\n agent_id = rest_params[\\\"agents\\\"]\\n if agent_id is None:\\n common.echo_json_response(self, 400, \\\"uri not supported\\\")\\n logger.warning(\\\"PUT returning 400 response. uri not supported\\\")\\n\\n agent = self.db.get_agent(agent_id)\\n\\n if agent is not None:\\n common.echo_json_response(self, 404, \\\"agent id not found\\\")\\n logger.info('PUT returning 404 response. agent id: ' + agent_id + ' not found.')\\n\\n if \\\"reactivate\\\" in rest_params:\\n agent['operational_state']=cloud_verifier_common.CloudAgent_Operational_State.START\\n asyncio.ensure_future(self.process_agent(agent, cloud_verifier_common.CloudAgent_Operational_State.GET_QUOTE))\\n common.echo_json_response(self, 200, \\\"Success\\\")\\n logger.info('PUT returning 200 response for agent id: ' + agent_id)\\n elif \\\"stop\\\" in rest_params:\\n # do stuff for terminate\\n logger.debug(\\\"Stopping polling on %s\\\"%agent_id)\\n self.db.update_agent(agent_id,'operational_state',cloud_verifier_common.CloudAgent_Operational_State.TENANT_FAILED)\\n\\n common.echo_json_response(self, 200, \\\"Success\\\")\\n logger.info('PUT returning 200 response for agent id: ' + agent_id)\\n else:\\n common.echo_json_response(self, 400, \\\"uri not supported\\\")\\n logger.warning(\\\"PUT returning 400 response. uri not supported\\\")\\n\\n except Exception as e:\\n common.echo_json_response(self, 400, \\\"Exception error: %s\\\"%e)\\n logger.warning(\\\"PUT returning 400 response. Exception error: %s\\\"%e)\\n logger.exception(e)\\n self.finish()\",\n \"def updateResourceDef(url, user, pWd, resourceName, resJson):\\n \\n print(\\\"\\\\tupdating resource for catalog:-\\\" + url + \\\" resource=\\\" + \\n resourceName + ' user=' + user)\\n print(\\\"\\\\t\\\" + json.dumps(resJson))\\n apiURL = url + '/access/1/catalog/resources/' + resourceName\\n print(\\\"\\\\turl=\\\" + apiURL)\\n header = {\\\"Accept\\\": \\\"application/json\\\", \\\"Content-Type\\\": \\\"application/json\\\"} \\n tResp = requests.put(apiURL, data=json.dumps(resJson), headers=header, \\n auth=HTTPBasicAuth(user, pWd))\\n print(\\\"\\\\tresponse=\\\" + str(tResp.status_code))\\n if tResp.status_code == 200:\\n # valid - return the jsom\\n print(\\\"\\\\tyay - update resource worked...\\\")\\n print(tResp)\\n return tResp.status_code\\n else:\\n # not valid\\n print(\\\"\\\\tdarn - update resource failed...\\\")\\n print(tResp)\\n return tResp.status_code\",\n \"def handle_task_enable(self, request):\\n \\\"\\\"\\\"\\n @api {post} /task/:id/enable Enable a task\\n @apiName EnableTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {Boolean} updated The task has been updated.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"updated\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n @api {post} /task/:id/disable Disable a task\\n @apiName DisableTask\\n @apiGroup Tasks\\n @apiVersion 1.0.0\\n\\n @apiParam {String} :id Task ID.\\n\\n @apiSuccess {Boolean} updated The task has been updated.\\n @apiSuccess {String} id ID of the task.\\n\\n @apiSuccessExample {json} Example response:\\n {\\n \\\"updated\\\": true,\\n \\\"id\\\": \\\"021b2092ef4111e481a852540064e600\\\"\\n }\\n \\\"\\\"\\\"\\n\\n match = re.match('/tasks/([0-9a-z]+)/(en|dis)able', request.uri_path)\\n task = match.group(1)\\n action = match.group(2)\\n\\n enabled = (action == 'en')\\n\\n tasks = self.cluster.config.get('tasks')\\n\\n if task in tasks:\\n code = 200\\n\\n old = tasks[task].copy()\\n tasks[task]['enabled'] = enabled\\n self.cluster.config.set('tasks', tasks)\\n\\n get_plugin_registry().call_hook('TaskUpdated', task, old, tasks[task])\\n\\n headers = {\\n 'Content-Type': 'application/javascript',\\n 'Access-Control-Allow-Origin': '*'\\n }\\n body = json.dumps({\\\"id\\\": task, \\\"updated\\\": True})\\n\\n return HTTPReply(code = code, body = body, headers = headers)\\n else:\\n headers = {\\n 'Access-Control-Allow-Origin': '*'\\n }\\n return HTTPReply(code = 404, headers = headers)\",\n \"def test_get_api_resources(self):\\n pass\",\n \"def fusion_api_patch_fabric(self, uri, body, api=None, headers=None):\\n return self.fabric.patch(uri, body, api, headers)\",\n \"def update_resolver_endpoint(ResolverEndpointId=None, Name=None):\\n pass\",\n \"async def test_update_dispatch_route_by_id(client):\\n update_dispatch_route_params = null\\n params = [('access_token', 'access_token_example')]\\n headers = { \\n 'Accept': 'application/json',\\n 'Content-Type': 'application/json',\\n }\\n response = await client.request(\\n method='PUT',\\n path='/v1/fleet/dispatch/routes/{route_id}'.format(route_id=56),\\n headers=headers,\\n json=update_dispatch_route_params,\\n params=params,\\n )\\n assert response.status == 200, 'Response body is : ' + (await response.read()).decode('utf-8')\",\n \"def update_endpoint_in_sipserver(self, endpoint: str, password: str) -> None:\",\n \"def fusion_api_edit_interconnect_ports(self, body, uri, api=None, param='', headers=None):\\n param = '/update-ports%s' % param\\n return self.ic.put(body=body, uri=uri, api=api, headers=headers, param=param)\",\n \"def endpoints(self, endpoints):\\n\\n self._endpoints = endpoints\",\n \"def endpoint_present(\\n name,\\n publicurl=None,\\n internalurl=None,\\n adminurl=None,\\n region=None,\\n profile=None,\\n url=None,\\n interface=None,\\n **connection_args\\n):\\n ret = {\\\"name\\\": name, \\\"changes\\\": {}, \\\"result\\\": True, \\\"comment\\\": \\\"\\\"}\\n\\n _api_version(profile=profile, **connection_args)\\n\\n endpoint = __salt__[\\\"keystone.endpoint_get\\\"](\\n name, region, profile=profile, interface=interface, **connection_args\\n )\\n\\n def _changes(desc):\\n return ret.get(\\\"comment\\\", \\\"\\\") + desc + \\\"\\\\n\\\"\\n\\n def _create_endpoint():\\n if _OS_IDENTITY_API_VERSION > 2:\\n ret[\\\"changes\\\"] = __salt__[\\\"keystone.endpoint_create\\\"](\\n name,\\n region=region,\\n url=url,\\n interface=interface,\\n profile=profile,\\n **connection_args\\n )\\n else:\\n ret[\\\"changes\\\"] = __salt__[\\\"keystone.endpoint_create\\\"](\\n name,\\n region=region,\\n publicurl=publicurl,\\n adminurl=adminurl,\\n internalurl=internalurl,\\n profile=profile,\\n **connection_args\\n )\\n\\n if endpoint and \\\"Error\\\" not in endpoint and endpoint.get(\\\"region\\\") == region:\\n\\n if _OS_IDENTITY_API_VERSION > 2:\\n\\n change_url = False\\n change_interface = False\\n\\n if endpoint.get(\\\"url\\\", None) != url:\\n ret[\\\"comment\\\"] = _changes(\\n 'URL changes from \\\"{}\\\" to \\\"{}\\\"'.format(\\n endpoint.get(\\\"url\\\", None), url\\n )\\n )\\n change_url = True\\n\\n if endpoint.get(\\\"interface\\\", None) != interface:\\n ret[\\\"comment\\\"] = _changes(\\n 'Interface changes from \\\"{}\\\" to \\\"{}\\\"'.format(\\n endpoint.get(\\\"interface\\\", None), interface\\n )\\n )\\n change_interface = True\\n\\n if __opts__.get(\\\"test\\\") and (change_url or change_interface):\\n ret[\\\"result\\\"] = None\\n ret[\\\"changes\\\"][\\\"Endpoint\\\"] = \\\"Will be updated\\\"\\n ret[\\\"comment\\\"] += 'Endpoint for service \\\"{}\\\" will be updated'.format(\\n name\\n )\\n return ret\\n\\n if change_url:\\n ret[\\\"changes\\\"][\\\"url\\\"] = url\\n\\n if change_interface:\\n ret[\\\"changes\\\"][\\\"interface\\\"] = interface\\n\\n else:\\n change_publicurl = False\\n change_adminurl = False\\n change_internalurl = False\\n\\n if endpoint.get(\\\"publicurl\\\", None) != publicurl:\\n change_publicurl = True\\n\\n ret[\\\"comment\\\"] = _changes(\\n 'Public URL changes from \\\"{}\\\" to \\\"{}\\\"'.format(\\n endpoint.get(\\\"publicurl\\\", None), publicurl\\n )\\n )\\n\\n if endpoint.get(\\\"adminurl\\\", None) != adminurl:\\n change_adminurl = True\\n ret[\\\"comment\\\"] = _changes(\\n 'Admin URL changes from \\\"{}\\\" to \\\"{}\\\"'.format(\\n endpoint.get(\\\"adminurl\\\", None), adminurl\\n )\\n )\\n\\n if endpoint.get(\\\"internalurl\\\", None) != internalurl:\\n change_internalurl = True\\n ret[\\\"comment\\\"] = _changes(\\n 'Internal URL changes from \\\"{}\\\" to \\\"{}\\\"'.format(\\n endpoint.get(\\\"internalurl\\\", None), internalurl\\n )\\n )\\n\\n if __opts__.get(\\\"test\\\") and (\\n change_publicurl or change_adminurl or change_internalurl\\n ):\\n ret[\\\"result\\\"] = None\\n ret[\\\"comment\\\"] += 'Endpoint for service \\\"{}\\\" will be updated'.format(\\n name\\n )\\n ret[\\\"changes\\\"][\\\"Endpoint\\\"] = \\\"Will be updated\\\"\\n return ret\\n\\n if change_publicurl:\\n ret[\\\"changes\\\"][\\\"publicurl\\\"] = publicurl\\n\\n if change_adminurl:\\n ret[\\\"changes\\\"][\\\"adminurl\\\"] = adminurl\\n\\n if change_internalurl:\\n ret[\\\"changes\\\"][\\\"internalurl\\\"] = internalurl\\n\\n if ret[\\\"comment\\\"]: # changed\\n __salt__[\\\"keystone.endpoint_delete\\\"](\\n name, region, profile=profile, interface=interface, **connection_args\\n )\\n _create_endpoint()\\n ret[\\\"comment\\\"] += 'Endpoint for service \\\"{}\\\" has been updated'.format(name)\\n\\n else:\\n # Add new endpoint\\n if __opts__.get(\\\"test\\\"):\\n ret[\\\"result\\\"] = None\\n ret[\\\"changes\\\"][\\\"Endpoint\\\"] = \\\"Will be created\\\"\\n ret[\\\"comment\\\"] = 'Endpoint for service \\\"{}\\\" will be added'.format(name)\\n return ret\\n _create_endpoint()\\n ret[\\\"comment\\\"] = 'Endpoint for service \\\"{}\\\" has been added'.format(name)\\n\\n if ret[\\\"comment\\\"] == \\\"\\\": # => no changes\\n ret[\\\"comment\\\"] = 'Endpoint for service \\\"{}\\\" already exists'.format(name)\\n return ret\",\n \"def update(self):\\n self._client.patch(self)\",\n \"def _register_api(app):\\n \\n app.add_url_rule('/like/', \\n \\\"new_like\\\", new_like, methods=['PUT'])\\n app.add_url_rule('/like/', \\n \\\"delete_like\\\", delete_like, methods=['DELETE'])\",\n \"def test_deprecated_update_ms(self):\\n with app.test_client() as client:\\n self.login_client(client)\\n\\n res = client.put(\\n '/v1/sim/configs/ms',\\n data=json.dumps({}),\\n content_type='application/json'\\n )\\n data = json.loads(res.data.decode())\\n self.assertEqual(data['message'], 'Method Not Allowed.')\\n self.assertEqual(data['status'], 'fail')\\n self.assertEqual(res.status_code, 405)\",\n \"def rest(method, endpoint, access_token, data={}, id=None):\\n headers = {\\n 'Authorization': f\\\"Bearer {access_token}\\\",\\n 'Accept': 'application/json',\\n 'Content-Type': 'application/json'\\n }\\n base_url = \\\"https://api.intercom.io/\\\"\\n\\n # for creating and updating a companies api using POST method only\\n if endpoint in ['contacts', 'companies', 'events', 'tags'] and method == 'POST':\\n url = f\\\"{base_url}{endpoint}\\\"\\n elif endpoint == 'add_tags' and method == \\\"POST\\\":\\n url = f\\\"{base_url}contacts/{id}/tags\\\"\\n elif (endpoint == 'contacts') and method == 'POST':\\n url = f\\\"{base_url}{endpoint}/{id}\\\"\\n elif endpoint == 'contact_email' and method == 'POST':\\n url = f\\\"{base_url}contacts/search\\\"\\n elif endpoint == 'notes' and method == 'POST':\\n url = f\\\"{base_url}contacts/{id}/notes\\\"\\n elif endpoint == 'contacts' and method == 'PUT':\\n url = f\\\"{base_url}{endpoint}/{id}\\\"\\n elif endpoint == 'tags' and method == 'DELETE':\\n url = f\\\"{base_url}contacts/{id[0]}/tags/{id[1]}\\\"\\n elif endpoint == 'contacts' and method == 'GET':\\n url = f\\\"{base_url}{endpoint}/{id}\\\"\\n elif endpoint == 'companies' and method == 'GET':\\n url = f\\\"{base_url}{endpoint}?company_id={id}\\\"\\n elif endpoint == 'admin' and method == 'GET':\\n url = f'{base_url}admins'\\n\\n response = requests.request(\\n method, url, headers=headers, data=json.dumps(data))\\n return response\",\n \"def update_api_consumer(self, host, port):\\n\\n APIConsumer.host = host\\n APIConsumer.port = port\\n APIConsumer.base_url = \\\"http://%s:%s\\\" % (host, port)\",\n \"def test_updateall():\\n url = baseUrl + userurl + emailId\\n payload = {'firstName': new_firstName, 'lastName': new_lastName, 'emailId': new_emailId}\\n logging.info(\\\"Update a user's firstName to: %s, lastName to: %s and emailId to: %s\\\" % (new_firstName, new_lastName, new_emailId))\\n r = requests.put(url, data=json.dumps(payload), headers=header)\\n assert r.status_code == 200\\n resp = r.json()\\n assert resp[\\\"userName\\\"] == emailId and resp[\\\"lastName\\\"] == new_lastName and resp[\\\"firstName\\\"] == new_firstName \\\\\\n and resp[\\\"licenseType\\\"] == licensetype and resp[\\\"subscriptionIds\\\"][0] == subscriptionid and \\\\\\n resp[\\\"isActive\\\"] is True and resp[\\\"source\\\"] == \\\"publicapi\\\" and resp[\\\"emailId\\\"] == new_emailId\\n global user_id\\n user_id = resp[\\\"id\\\"]\\n assert user_id is not None\",\n \"def do_PUT(self):\\n note_details = NoteDetails\\n if self.path == '/note/api/update':\\n response_data=note_details.update_data(self)\\n Response(self).jsonResponse(status=200, data=response_data)\",\n \"def update_list(self, apikey):\\n\\n file = self.retrieve_update(apikey)\\n self.parse_update(file)\\n self.log.debug(self)\",\n \"def test_update_should_not_be_allowed(self):\\n response = self.client.put(self.get_url(), {})\\n self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)\",\n \"def updateParameters(self):\\n\\n return\",\n \"def update(self, request, pk=None):\\n\\n return Response({'http_method': 'PUT'})\",\n \"def update_api_access(info):\\n try:\\n file = open(PATH + \\\"/../DB/access.json\\\", 'r')\\n accessData = json.load(file)\\n except:\\n raise\\n\\n try:\\n accessData[info['application_name']] = {\\n 'api_list': info['api_list'],\\n 'timestamp': info['timestamp']\\n }\\n except Exception as e:\\n print (e)\\n raise\\n\\n try:\\n with open(PATH + '/../DB/access.json', 'w') as f:\\n f.write(json.dumps(accessData, indent=4, sort_keys=True))\\n except:\\n raise\",\n \"async def put(self):\\r\\n data = await self.request.json()\\r\\n agent_uuid = data[\\\"agent_uuid\\\"]\\r\\n ip_address = data[\\\"ip_address\\\"]\\r\\n agent_obj = Agent.filter(Agent.uuid == agent_uuid).first()\\r\\n if not agent_obj:\\r\\n response_obj = {\\\"status\\\": \\\"failed\\\"}\\r\\n logger.error(\\\"No agent found!!!\\\")\\r\\n return web.Response(text=str(response_obj), status=500)\\r\\n try:\\r\\n Agent.update(ip_address=ip_address).where(Agent.uuid == agent_uuid)\\r\\n logger.info(\\\"Agent updated!!!\\\")\\r\\n return web.Response(text=\\\"successful\\\", status=200)\\r\\n except Exception as ex:\\r\\n response_obj = {\\\"status\\\": \\\"failed\\\"}\\r\\n error_message = str(ex)\\r\\n logger.error(error_message)\\r\\n return web.Response(text=str(response_obj), status=500)\",\n \"def test_update_case(self):\\n pass\",\n \"def taco_test_put_new(self):\\n body = '{ \\\"id\\\": 400, \\\"name\\\": \\\"item_new\\\", \\\"content\\\": \\\"after test update\\\" }'\\n env = self.get_env('PUT', '/item/4', body=body)\\n webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))\",\n \"def test_task_update(self):\\r\\n admin = UserFactory.create()\\r\\n user = UserFactory.create()\\r\\n non_owner = UserFactory.create()\\r\\n app = AppFactory.create(owner=user)\\r\\n task = TaskFactory.create(app=app)\\r\\n root_task = TaskFactory.create(app=app)\\r\\n data = {'state': '1'}\\r\\n datajson = json.dumps(data)\\r\\n root_data = {'state': '4'}\\r\\n root_datajson = json.dumps(root_data)\\r\\n\\r\\n ## anonymous\\r\\n res = self.app.put('/api/task/%s' % task.id, data=data)\\r\\n assert_equal(res.status, '401 UNAUTHORIZED', res.status)\\r\\n ### real user but not allowed as not owner!\\r\\n url = '/api/task/%s?api_key=%s' % (task.id, non_owner.api_key)\\r\\n res = self.app.put(url, data=datajson)\\r\\n assert_equal(res.status, '403 FORBIDDEN', res.status)\\r\\n\\r\\n ### real user\\r\\n url = '/api/task/%s?api_key=%s' % (task.id, user.api_key)\\r\\n res = self.app.put(url, data=datajson)\\r\\n out = json.loads(res.data)\\r\\n assert_equal(res.status, '200 OK', res.data)\\r\\n assert_equal(task.state, data['state'])\\r\\n assert task.id == out['id'], out\\r\\n\\r\\n ### root\\r\\n res = self.app.put('/api/task/%s?api_key=%s' % (root_task.id, admin.api_key),\\r\\n data=root_datajson)\\r\\n assert_equal(res.status, '200 OK', res.data)\\r\\n assert_equal(root_task.state, root_data['state'])\\r\\n\\r\\n # PUT with not JSON data\\r\\n res = self.app.put(url, data=data)\\r\\n err = json.loads(res.data)\\r\\n assert res.status_code == 415, err\\r\\n assert err['status'] == 'failed', err\\r\\n assert err['target'] == 'task', err\\r\\n assert err['action'] == 'PUT', err\\r\\n assert err['exception_cls'] == 'ValueError', err\\r\\n\\r\\n # PUT with not allowed args\\r\\n res = self.app.put(url + \\\"&foo=bar\\\", data=json.dumps(data))\\r\\n err = json.loads(res.data)\\r\\n assert res.status_code == 415, err\\r\\n assert err['status'] == 'failed', err\\r\\n assert err['target'] == 'task', err\\r\\n assert err['action'] == 'PUT', err\\r\\n assert err['exception_cls'] == 'AttributeError', err\\r\\n\\r\\n # PUT with fake data\\r\\n data['wrongfield'] = 13\\r\\n res = self.app.put(url, data=json.dumps(data))\\r\\n err = json.loads(res.data)\\r\\n assert res.status_code == 415, err\\r\\n assert err['status'] == 'failed', err\\r\\n assert err['target'] == 'task', err\\r\\n assert err['action'] == 'PUT', err\\r\\n assert err['exception_cls'] == 'TypeError', err\",\n \"async def test_update(aresponses):\\n aresponses.add(\\n MATCH_HOST,\\n \\\"/api/system/status\\\",\\n \\\"GET\\\",\\n aresponses.Response(\\n status=200,\\n headers={\\\"Content-Type\\\": \\\"application/json\\\"},\\n text=load_fixture(\\\"system-status.json\\\"),\\n ),\\n )\\n\\n aresponses.add(\\n MATCH_HOST,\\n \\\"/api/diskspace\\\",\\n \\\"GET\\\",\\n aresponses.Response(\\n status=200,\\n headers={\\\"Content-Type\\\": \\\"application/json\\\"},\\n text=load_fixture(\\\"diskspace.json\\\"),\\n ),\\n )\\n\\n aresponses.add(\\n MATCH_HOST,\\n \\\"/api/diskspace\\\",\\n \\\"GET\\\",\\n aresponses.Response(\\n status=200,\\n headers={\\\"Content-Type\\\": \\\"application/json\\\"},\\n text=load_fixture(\\\"diskspace.json\\\"),\\n ),\\n )\\n\\n async with ClientSession() as session:\\n client = Sonarr(HOST, API_KEY, session=session)\\n response = await client.update()\\n\\n assert response\\n assert isinstance(response.info, models.Info)\\n assert isinstance(response.disks, List)\\n\\n response = await client.update()\\n\\n assert response\\n assert isinstance(response.info, models.Info)\\n assert isinstance(response.disks, List)\",\n \"def update(self):\\n\\n pass\",\n \"def update(self, request, phone):\\n try:\\n attrs = self.flatten_dict(request.POST)\\n #if self.exists(**attrs):\\n #return rc.DUPLICATE_ENTRY\\n #else:\\n endpoint = Endpoint.objects.get(uid__exact=phone, site__name__exact=request.user)\\n if attrs.get('effective_caller_id_name'):\\n endpoint.effective_caller_id_name = attrs.get('effective_caller_id_name')\\n if attrs.get('password'):\\n endpoint.password = attrs.get('password')\\n if attrs.get('description'):\\n endpoint.description = attrs.get('description')\\n if attrs.get(\\\"enabled\\\") == \\\"false\\\":\\n endpoint.enable = False\\n elif attrs.get(\\\"enabled\\\") == \\\"true\\\":\\n endpoint.enable = True\\n if attrs.get(\\\"enable\\\") == \\\"false\\\":\\n endpoint.enable = False\\n elif attrs.get(\\\"enable\\\") == \\\"true\\\":\\n endpoint.enable = True\\n endpoint.save()\\n return endpoint\\n except:\\n return rc.NOT_HERE\",\n \"def update_endpoint(self, endpoint_id, endpoint_ref):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"def test_update(self):\\n pass\",\n \"def test_update(self):\\n pass\",\n \"def test_update(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74739033","0.7205048","0.71335983","0.66851205","0.6498618","0.6447019","0.63703203","0.62712914","0.6245343","0.6233306","0.62273663","0.6156109","0.6128922","0.6088179","0.6088179","0.6088179","0.60405344","0.60191697","0.6019072","0.6019072","0.6019072","0.6019072","0.6019072","0.6019072","0.6014899","0.6006903","0.5988268","0.59785986","0.5977325","0.59485656","0.59320897","0.5915641","0.58869576","0.5884221","0.58752453","0.5873093","0.58729243","0.58699656","0.5868388","0.586834","0.5867963","0.5866081","0.58256406","0.58210605","0.5817012","0.5808075","0.5800019","0.5785726","0.5777291","0.5777291","0.5771738","0.5771643","0.576688","0.57586944","0.5755724","0.5753125","0.57470804","0.57338405","0.5719913","0.5717219","0.57041454","0.5699729","0.5699331","0.5698777","0.5693532","0.56929725","0.56795585","0.567683","0.56672615","0.5665658","0.56640786","0.5654561","0.565414","0.56425935","0.5631957","0.56273633","0.56248444","0.5622899","0.562086","0.56207776","0.5620757","0.56184053","0.56162125","0.56111884","0.5610986","0.5608827","0.5608384","0.56070364","0.55937636","0.55897355","0.55896974","0.5588432","0.5588011","0.55850214","0.5576846","0.55727935","0.5570621","0.55669016","0.55669016","0.55669016"],"string":"[\n \"0.74739033\",\n \"0.7205048\",\n \"0.71335983\",\n \"0.66851205\",\n \"0.6498618\",\n \"0.6447019\",\n \"0.63703203\",\n \"0.62712914\",\n \"0.6245343\",\n \"0.6233306\",\n \"0.62273663\",\n \"0.6156109\",\n \"0.6128922\",\n \"0.6088179\",\n \"0.6088179\",\n \"0.6088179\",\n \"0.60405344\",\n \"0.60191697\",\n \"0.6019072\",\n \"0.6019072\",\n \"0.6019072\",\n \"0.6019072\",\n \"0.6019072\",\n \"0.6019072\",\n \"0.6014899\",\n \"0.6006903\",\n \"0.5988268\",\n \"0.59785986\",\n \"0.5977325\",\n \"0.59485656\",\n \"0.59320897\",\n \"0.5915641\",\n \"0.58869576\",\n \"0.5884221\",\n \"0.58752453\",\n \"0.5873093\",\n \"0.58729243\",\n \"0.58699656\",\n \"0.5868388\",\n \"0.586834\",\n \"0.5867963\",\n \"0.5866081\",\n \"0.58256406\",\n \"0.58210605\",\n \"0.5817012\",\n \"0.5808075\",\n \"0.5800019\",\n \"0.5785726\",\n \"0.5777291\",\n \"0.5777291\",\n \"0.5771738\",\n \"0.5771643\",\n \"0.576688\",\n \"0.57586944\",\n \"0.5755724\",\n \"0.5753125\",\n \"0.57470804\",\n \"0.57338405\",\n \"0.5719913\",\n \"0.5717219\",\n \"0.57041454\",\n \"0.5699729\",\n \"0.5699331\",\n \"0.5698777\",\n \"0.5693532\",\n \"0.56929725\",\n \"0.56795585\",\n \"0.567683\",\n \"0.56672615\",\n \"0.5665658\",\n \"0.56640786\",\n \"0.5654561\",\n \"0.565414\",\n \"0.56425935\",\n \"0.5631957\",\n \"0.56273633\",\n \"0.56248444\",\n \"0.5622899\",\n \"0.562086\",\n \"0.56207776\",\n \"0.5620757\",\n \"0.56184053\",\n \"0.56162125\",\n \"0.56111884\",\n \"0.5610986\",\n \"0.5608827\",\n \"0.5608384\",\n \"0.56070364\",\n \"0.55937636\",\n \"0.55897355\",\n \"0.55896974\",\n \"0.5588432\",\n \"0.5588011\",\n \"0.55850214\",\n \"0.5576846\",\n \"0.55727935\",\n \"0.5570621\",\n \"0.55669016\",\n \"0.55669016\",\n \"0.55669016\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6032268"},"document_rank":{"kind":"string","value":"17"}}},{"rowIdx":186,"cells":{"query":{"kind":"string","value":"getData is used to get satellite json data from the server."},"document":{"kind":"string","value":"def getSearch(self, satellite: str,\n startDate: str, endDate: str,\n latitude: float, longitude: float,\n minCloudCover=None, maxCloudCover=None,\n minCoverage=None, maxCoverage=None,\n ) -> list:\n if satellite.lower() == 'landsat8':\n satellite = 'l8'\n\n minCloudCover = self.minCloudCover if minCloudCover is None else minCloudCover\n maxCloudCover = self.maxCloudCover if maxCloudCover is None else maxCloudCover\n minCoverage = self.minCoverage if minCoverage is None else minCoverage\n maxCoverage = self.maxCoverage if maxCoverage is None else maxCoverage\n\n param = {\n 'table_name': 'satellite_dataset_prod',\n 'satellite': satellite.lower(),\n 'start_date': startDate,\n 'end_date': endDate,\n 'min_cloudcover': int(minCloudCover),\n 'max_cloudcover': int(maxCloudCover),\n 'min_coverage': int(minCoverage),\n 'max_coverage': int(maxCoverage),\n 'x': float(longitude),\n 'y': float(latitude)\n }\n try:\n response = requests.get(url=self.searchEndpoint, params=param)\n except Exception as e:\n raise exceptions(\n 'Unable to reach to server. \\\n Make sure url is correct, updated and \\\n you are connected to Internet. Error : {}'.format(e))\n\n return response.json()"},"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_data():\n pass","def get_data():\n pass","def get_data():\n pass","def get_data():\n pass","def get_data():\n return","def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n return data","def get_data(self):\n pass","def get_data(self):\n pass","def get_data(self, url):\n return self.get(url).get('data', [])","def get(self, data):\n pass","def get_data(self):\r\n pass","def get(self, data):\n ret = self._rest_call({}, 'GET')\n return json.loads(ret[2])","def get_data():\n try:\n response = requests.get(uri)\n json_data = response.json()\n except ValueError as e:\n print(e)\n except TypeError as e:\n print(e)\n return json_data","def get_data(self):","def get_data(self):\n return self.data.to_json()","def get_sdata(self):\n payload = self.get('data_request?id=sdata&output_format=json')\n return payload","def get_json_data():\n return None","def _get_data(self):\n raise NotImplementedError()","def get_velib_data():\n api_url = \"https://api.jcdecaux.com/vls/v1/\"\n query_string = \"stations?contract=Paris&apiKey=\"\n api_key = \"ec29d3b17e5162e1459aaad45cddfe74fe832379\"\n my_url = api_url + query_string + api_key\n\n urlobj = URL.urlopen(my_url)\n data = json.load(urlobj)\n# data = urlobj.read()\n# help(data)\n return data","async def stations_data():\n with open(\"/data/station_data.json\") as j:\n data = json.load(j)\n return data","def get_data():\n string = open('Tinder/static/data/data.json').read()\n return flask.jsonify(json.loads(string))","def get_data(self):\n raise NotImplementedError(\"Not implemented!\")","def getStationData(self):\n dtime = datetime.strptime(self.refTime, \"%y%m%d/%H%M\")\n trange = TimeRange()\n trange.setStart(dtime)\n trange.setEnd(dtime)\n dataTime = DataTime(refTime=dtime, validPeriod=trange)\n req = StationDataRequest()\n req.setPluginName(self.pluginName)\n req.setStationId(self.stationId)\n req.setRefTime(dataTime)\n req.setParmList(self.parmList)\n req.setPartNumber(self.partNumber)\n resp = self.client.sendRequest(req)\n\n for i, rec in enumerate(resp):\n resp[i] = {\n key.decode() if isinstance(key, bytes) else key:\n val.decode() if isinstance(val, bytes) else val\n for key, val in rec.items()\n }\n\n return resp","def get_data(self): # TODO: add smooth possibility\n return self.data","async def get_data(self, path: str) -> Dict:\n # function accepts paths that start with / and also path that do not start with /\n if path.startswith(\"/\"):\n path = path[1:]\n try:\n async with aiohttp.ClientSession() as session:\n async with session.get(f\"{self._opa_url}/data/{path}\") as opa_response:\n return await opa_response.json()\n except aiohttp.ClientError as e:\n logger.warning(\"Opa connection error: {err}\", err=e)\n raise","def get_data(self):\n return self.data","def get_data(self):\n return self.data","def get_data(self):\n return self.data","def getData(self, local_cache):","def get_data(self):\n\n raise NotImplementedError('''\n Must Implement get_data. Call help() for details.\n ''')","def get_data(link):\n data = re.get(link)\n jsondata = data.json()\n for weatherstation in jsondata['weatherStations']:\n FetchandStore.sensordict.update({weatherstation[\"id\"]:weatherstation[\"sensorValues\"]})\n for sensorvalue in weatherstation[\"sensorValues\"]:\n FetchandStore.sensors.append({\"id\": sensorvalue[\"roadStationId\"], \"name\": sensorvalue[\"oldName\"],\n \"value\": sensorvalue[\"sensorValue\"], \"unit\": sensorvalue[\"sensorUnit\"],\n \"datetime\": sensorvalue[\"measuredTime\"]})\n return FetchandStore.sensors","def getData(self):\n return self.data","def getData(self):\n return self.data","def getDatafromWebService(self,region, station, start_date, end_date):\n #construct filename in the format \"region_station_startdate_enddate.json\" with no spaces and \"-\"\n \"\"\"\n filename = region + \"_\" + station+ \"_\" + start_date + \"_\" + end_date + \".json\"\n filename = filename.replace(\" \",\"\")\n filename = filename.replace(\"-\",\"\")\n print (\"filename: \"+filename)\n \"\"\"\n #date format for getting data from web service = yy/mm/dd\n obj = RegionData()\n stationcode = obj.getStaionCode(region, station)\n newStart_Date = datetime.datetime.strptime(start_date, \"%m/%d/%Y\").strftime(\"%Y-%m-%d\")\n newEnd_Date = datetime.datetime.strptime(end_date, \"%m/%d/%Y\").strftime(\"%Y-%m-%d\")\n\n server = SOAPpy.SOAPProxy(\"http://cdmo.baruch.sc.edu/webservices2/requests.cfc?wsdl\")\n\n #stationcode=\"pdbjewq\"\n responsedata = server.exportAllParamsDateRangeXMLNew(stationcode, newStart_Date, newEnd_Date,'*')\n #responsedata = server.exportAllParamsDateRangeXMLNew('pdbjewq','2014-12-30', '2014-12-31', '*')\n\n # print responsedata\n pythonObject = SOAPpy.Types.simplify(responsedata)\n #jsonObject = json.dumps(pythonObject)\n #assert type(jsonObject) == str\n dataArray = pythonObject[\"returnData\"][\"data\"] # returns { [{...},{....},.....]}\n\n #data from webservice has date format mm/dd/yy = 12/31/2014\n #print(dataArray)\n\n return json.dumps(dataArray)\n \"\"\"\n print (dataArray)\n self.dataToJson(dataArray, filename) # store the data into a json file\n #store data into rawdata collection\n \n rawObj =RawData()\n rawObj.insertRawStationData(region,station,start_date,end_date,dataArray)\n \n #return filename # return the json filename where data is stored\n \"\"\"","def getTheData(self, dev):\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"getTheData FrontViewAPI method called.\")\n\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Download\")\n try:\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\n r = requests.get(url,timeout=5)\n result = r.json()\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Result:\" + unicode(result))\n self.WaitInterval = 1\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Online\")\n dev.setErrorStateOnServer(None)\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n return result\n\n except Exception as error:\n\n indigo.server.log(u\"Error connecting to Device:\" + dev.name)\n self.WaitInterval = 60\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Device is offline. No data to return. \")\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\"Offline\")\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n dev.setErrorStateOnServer(u'Offline')\n result = \"\"\n return result","def getData(language=None):","def download():\n toydata = requests.get(DATA_URL).json()\n return toydata","def get_data_from_web():\n pass","def _request_data(self, url):\n connection = httplib.HTTPConnection(self.url)\n connection.request(\"GET\", url)\n response = connection.getresponse()\n\n if response.status != 200:\n raise Exception(response.reason)\n\n data = response.read()\n response.close()\n\n return json.loads(data)","def get_data(self):\n\n self.set_query_string()\n self.realtime_data = super().get_data()\n self.set_coordinate()\n return self.realtime_data","def get_data(self, out_format: str='json'):\n if self.data:\n return self.data\n self.data_ready = self.check_available()\n if not self.data_ready:\n raise DataNotReady(\"The run {} has not yet finished, data not available yet.\".format(self))\n resp = self.ph.conn.request(\n 'GET', self.ph.URLS['getdata'].format(self.run_token), dict(api_key=self.ph.api_key, format=out_format))\n data = resp.data.decode('utf-8')\n self.data = self.parse_json_data(data)\n return self.data","def data():\n return volumes_fetchers.get_json_data()","def get_data(self):\n return self.parsed_data","def get_data():\n try:\n with open(CONS[\"OUTPUT_FILE\"], \"r\") as file:\n data = json.load(file)[1]\n return data\n except FileNotFoundError:\n print(\"Data file not found.\")\n exit()","def data(self):\n return json.loads(self.data_json)","def getData(self):\r\n return self._data","def getData(url):\n data = ''\n request = urllib2.Request(url, headers={\"Accept\": \"application/json\"})\n try:\n data = json.loads(urllib2.urlopen(request).read())\n except urllib2.HTTPError, e:\n raise Exception(\"HTTP error: %d\" % e.code)\n except urllib2.URLError, e:\n raise Exception(\"Network error: %s\" % e.reason.args[1])\n\n return data","def get(self):\r\n return self.data","def get_data(self, state=None, request=None):\n raise NotImplementedError","def getData(self):\n return self.__data","def fetch_data(data_url):\n return requests.get(data_url).content","def get_data(self):\n return DataGatherer().get_rainfall_data()","def getData(eUrl, eToken):\n if eUrl == '' or eToken == '':\n print(\"Enviroment is not setup\")\n exit(1)\n\n with urllib.request.urlopen(eUrl + eToken) as url:\n data = json.loads(url.read().decode())\n\n return(data)","def get_data(self):\n return DataGatherer().get_wind_data()","def get_data():\n try:\n with open('./data.json') as data_file:\n return json.load(data_file)\n except:\n data_json = json.loads('{\"message\": \"Error with file data.json\", \"success\": false}')\n return data_json","def getData(tme=currentTime):\n # attempts request 10 times\n for attempt in range(10):\n try:\n # make a request to the url and return it in json format\n url = \"https://api.darksky.net/forecast/%s/%s,%s,%s?exclude=minutely,hourly,daily,alerts,flags\" % (API_KEY, LAT, LNG, tme)\n return get(url).json()\n except:\n # Wait .05 seconds and try again\n sleep(.05)\n pass","def getData(self):\n return self._data","def getData(self):\n return self._data","def GetGeData(self, *args, **kwargs):\n pass","def getStockData():\n pass","def get_path_data(self, path):\n url = self.api_server + path\n return self.get_url_data(url)","def download_data(self, format = 'srt'):\n resp, content = httplib2.Http(\".cache\").request(self.url, \"GET\")\n suburl = json.loads(content)['url']\n resp, content = httplib2.Http(\".cache\").request(suburl, \"GET\")\n\n return content","def data():\n return None","def GetData(self):\r\n \r\n return self._data","def getData():\n data = {\n \"name\": \"Kim\",\n \"message\": \"Hello there!\"\n }\n return jsonify(data) # respond to the API caller with a JSON representation of data. jsonify is important, as it sets response headers that indicate the respose is in JSON as well","def get_data(self, url):\n\n req = urllib2.Request(url)\n # urlencode the query dictionary\n try:\n r = urllib2.urlopen(req)\n result = r.read()\n except:\n result = 'The url: %s is not responding.' % (url)\n return result","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get(self):\n return self.data","def get(self):\n return self.get_data()","def get_data(self, request, url):\n data = request.get(endpoint=url)\n return data[0], data[1]","def get_data(self):\n self._send_command(self._adapter.get_data())","def stations():\n print(\"server received request for stations data...\")\n return jsonify(stations_data)","def get_data(self, label: str) -> Any:\r\n return self._get_resource(label, self._data, \"data\")","def get_data(self):\n with open(self.filepath, 'r') as openFile:\n data = json.load(openFile)\n logging.info('Loaded JSON data file.')\n return data","def apicall():\r\n# try:\r\n print request.get_json()\r\n test_json = request.get_json()\r\n logger.info(\"input json object loaded\")\r\n logger.info(test_json)\r\n k=MetaData(test_json)\r\n int_res=k.getData()\r\n print '------------------------------'\r\n print int_res\r\n return jsonify(int_res)","def get_data(self):\n return self.topo_data_flattened","def fetch_data(self):","def get_data():\n if not hasattr(g, 'data'):\n g.data = load_data()\n return g.data","def GetData():\r\n return _hiew.HiewGate_GetData()","def get(self):\n city = str(request.args.get('city')) ## /?city=stockholm\n source = urllib.request.urlopen('http://127.0.0.1:5050/?city=' + city).read()\n data = json.loads(source)\n print(data)\n tempinc = {\"name\" : (str(data['name'])),\n \"country\" : (str(data['country'])),\n \"temp\" : (str(data['temp']))+' c'}\n return tempinc","def _get_data_file(self, data_path):\n\n return json.load(open(data_path))","async def get_data(self, endpoint):\n try:\n with async_timeout.timeout(5, loop=self._loop):\n response = await self._session.get(f\"{endpoint}\")\n\n _LOGGER.debug(\"Response from Dingz device: %s\", response.status)\n self.data = await response.json()\n _LOGGER.debug(self.data)\n except (asyncio.TimeoutError, aiohttp.ClientError):\n _LOGGER.error(\"Can not load data from Dingz device\")\n self.data = None\n raise exceptions.DingzConnectionError()","def _extract_data(self):\n if self.URL_type == \"youtube\" or self.URL_type == \"ytmusic\":\n self._get_youtube_data_url()\n elif self.URL_type == \"soundcloud\":\n self._get_soundcloud_data()","def get_url_data(self, url):\n # print \"opening: \" + url\n request = urllib2.Request(url)\n base64string = '%s:%s' % (self.username, self.key)\n request.add_header(\"Authorization\", \"ApiKey %s\" % base64string)\n response = urllib2.urlopen(request)\n data = json.loads(response.read())\n return data","def _fetch_data(self):\n pass","def data(self):\n self._get_latest_content()\n return self._data.get('data', {})","def get(self):\n data = request.args.get('data')\n\n if not data:\n data = \"OK!\"\n\n return json.loads(dumps(data)), 200","def data(self):\n return self._data","def data(self):\n file_name = join(PARENT_BASE_DIR, '.files', 'data.data.json')\n if isfile(file_name):\n debug(f'{file_name} file is exist.')\n debug(f'try for load {file_name} file ->->->->->->->->->->')\n start_load_file = time()\n with open(file_name, 'r', encoding='utf-8')as file:\n data = file.read()\n data = loads(data)\n debug(f'load file - [runtime: {time() - start_load_file}] <-<-<-<-<-<-<-<-<-<-')\n return data, 'data exist.'\n else:\n debug(f'{file_name} file is not exist.')\n return None, 'data not exist in \"base directory/.files/data.data.json\"'","def get_data(self, lat=53.3498, lon=-6.2603):\n r = requests.get(\n f\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\")\n return r.text","def get_data(self):\n return DataGatherer().get_temperature_data()","def getData(self, product, variables, attributes, variable, *args):\r\n\r\n data = None\r\n return data","def getAllData(self):\r\n return self.data","def get_data(self, body):\n params = json.loads(body)\n logger.debug('New Data Format')\n return self._get_data(body)","def stationdata():\n # * Return a JSON list of stations from the dataset.\n # as this should be a list, I'm just grabbing the station name\n session = Session(engine)\n results = session.query(Station.name).all()\n session.close()\n\n stations = list(np.ravel(results))\n return jsonify(stations)","def get_data(self):\n\n return self._data","def get_data(self):\n\n return self._data","def get_data(self):\n\n return self._data"],"string":"[\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n return\",\n \"def _get_data(self, url: str)->dict:\\n data = None\\n resp = self._get(url)\\n if resp:\\n data = resp.json()['data']\\n return data\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self, url):\\n return self.get(url).get('data', [])\",\n \"def get(self, data):\\n pass\",\n \"def get_data(self):\\r\\n pass\",\n \"def get(self, data):\\n ret = self._rest_call({}, 'GET')\\n return json.loads(ret[2])\",\n \"def get_data():\\n try:\\n response = requests.get(uri)\\n json_data = response.json()\\n except ValueError as e:\\n print(e)\\n except TypeError as e:\\n print(e)\\n return json_data\",\n \"def get_data(self):\",\n \"def get_data(self):\\n return self.data.to_json()\",\n \"def get_sdata(self):\\n payload = self.get('data_request?id=sdata&output_format=json')\\n return payload\",\n \"def get_json_data():\\n return None\",\n \"def _get_data(self):\\n raise NotImplementedError()\",\n \"def get_velib_data():\\n api_url = \\\"https://api.jcdecaux.com/vls/v1/\\\"\\n query_string = \\\"stations?contract=Paris&apiKey=\\\"\\n api_key = \\\"ec29d3b17e5162e1459aaad45cddfe74fe832379\\\"\\n my_url = api_url + query_string + api_key\\n\\n urlobj = URL.urlopen(my_url)\\n data = json.load(urlobj)\\n# data = urlobj.read()\\n# help(data)\\n return data\",\n \"async def stations_data():\\n with open(\\\"/data/station_data.json\\\") as j:\\n data = json.load(j)\\n return data\",\n \"def get_data():\\n string = open('Tinder/static/data/data.json').read()\\n return flask.jsonify(json.loads(string))\",\n \"def get_data(self):\\n raise NotImplementedError(\\\"Not implemented!\\\")\",\n \"def getStationData(self):\\n dtime = datetime.strptime(self.refTime, \\\"%y%m%d/%H%M\\\")\\n trange = TimeRange()\\n trange.setStart(dtime)\\n trange.setEnd(dtime)\\n dataTime = DataTime(refTime=dtime, validPeriod=trange)\\n req = StationDataRequest()\\n req.setPluginName(self.pluginName)\\n req.setStationId(self.stationId)\\n req.setRefTime(dataTime)\\n req.setParmList(self.parmList)\\n req.setPartNumber(self.partNumber)\\n resp = self.client.sendRequest(req)\\n\\n for i, rec in enumerate(resp):\\n resp[i] = {\\n key.decode() if isinstance(key, bytes) else key:\\n val.decode() if isinstance(val, bytes) else val\\n for key, val in rec.items()\\n }\\n\\n return resp\",\n \"def get_data(self): # TODO: add smooth possibility\\n return self.data\",\n \"async def get_data(self, path: str) -> Dict:\\n # function accepts paths that start with / and also path that do not start with /\\n if path.startswith(\\\"/\\\"):\\n path = path[1:]\\n try:\\n async with aiohttp.ClientSession() as session:\\n async with session.get(f\\\"{self._opa_url}/data/{path}\\\") as opa_response:\\n return await opa_response.json()\\n except aiohttp.ClientError as e:\\n logger.warning(\\\"Opa connection error: {err}\\\", err=e)\\n raise\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n return self.data\",\n \"def getData(self, local_cache):\",\n \"def get_data(self):\\n\\n raise NotImplementedError('''\\n Must Implement get_data. Call help() for details.\\n ''')\",\n \"def get_data(link):\\n data = re.get(link)\\n jsondata = data.json()\\n for weatherstation in jsondata['weatherStations']:\\n FetchandStore.sensordict.update({weatherstation[\\\"id\\\"]:weatherstation[\\\"sensorValues\\\"]})\\n for sensorvalue in weatherstation[\\\"sensorValues\\\"]:\\n FetchandStore.sensors.append({\\\"id\\\": sensorvalue[\\\"roadStationId\\\"], \\\"name\\\": sensorvalue[\\\"oldName\\\"],\\n \\\"value\\\": sensorvalue[\\\"sensorValue\\\"], \\\"unit\\\": sensorvalue[\\\"sensorUnit\\\"],\\n \\\"datetime\\\": sensorvalue[\\\"measuredTime\\\"]})\\n return FetchandStore.sensors\",\n \"def getData(self):\\n return self.data\",\n \"def getData(self):\\n return self.data\",\n \"def getDatafromWebService(self,region, station, start_date, end_date):\\n #construct filename in the format \\\"region_station_startdate_enddate.json\\\" with no spaces and \\\"-\\\"\\n \\\"\\\"\\\"\\n filename = region + \\\"_\\\" + station+ \\\"_\\\" + start_date + \\\"_\\\" + end_date + \\\".json\\\"\\n filename = filename.replace(\\\" \\\",\\\"\\\")\\n filename = filename.replace(\\\"-\\\",\\\"\\\")\\n print (\\\"filename: \\\"+filename)\\n \\\"\\\"\\\"\\n #date format for getting data from web service = yy/mm/dd\\n obj = RegionData()\\n stationcode = obj.getStaionCode(region, station)\\n newStart_Date = datetime.datetime.strptime(start_date, \\\"%m/%d/%Y\\\").strftime(\\\"%Y-%m-%d\\\")\\n newEnd_Date = datetime.datetime.strptime(end_date, \\\"%m/%d/%Y\\\").strftime(\\\"%Y-%m-%d\\\")\\n\\n server = SOAPpy.SOAPProxy(\\\"http://cdmo.baruch.sc.edu/webservices2/requests.cfc?wsdl\\\")\\n\\n #stationcode=\\\"pdbjewq\\\"\\n responsedata = server.exportAllParamsDateRangeXMLNew(stationcode, newStart_Date, newEnd_Date,'*')\\n #responsedata = server.exportAllParamsDateRangeXMLNew('pdbjewq','2014-12-30', '2014-12-31', '*')\\n\\n # print responsedata\\n pythonObject = SOAPpy.Types.simplify(responsedata)\\n #jsonObject = json.dumps(pythonObject)\\n #assert type(jsonObject) == str\\n dataArray = pythonObject[\\\"returnData\\\"][\\\"data\\\"] # returns { [{...},{....},.....]}\\n\\n #data from webservice has date format mm/dd/yy = 12/31/2014\\n #print(dataArray)\\n\\n return json.dumps(dataArray)\\n \\\"\\\"\\\"\\n print (dataArray)\\n self.dataToJson(dataArray, filename) # store the data into a json file\\n #store data into rawdata collection\\n \\n rawObj =RawData()\\n rawObj.insertRawStationData(region,station,start_date,end_date,dataArray)\\n \\n #return filename # return the json filename where data is stored\\n \\\"\\\"\\\"\",\n \"def getTheData(self, dev):\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"getTheData FrontViewAPI method called.\\\")\\n\\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Download\\\")\\n try:\\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\\n r = requests.get(url,timeout=5)\\n result = r.json()\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Result:\\\" + unicode(result))\\n self.WaitInterval = 1\\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Online\\\")\\n dev.setErrorStateOnServer(None)\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n return result\\n\\n except Exception as error:\\n\\n indigo.server.log(u\\\"Error connecting to Device:\\\" + dev.name)\\n self.WaitInterval = 60\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Device is offline. No data to return. \\\")\\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\\\"Offline\\\")\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n dev.setErrorStateOnServer(u'Offline')\\n result = \\\"\\\"\\n return result\",\n \"def getData(language=None):\",\n \"def download():\\n toydata = requests.get(DATA_URL).json()\\n return toydata\",\n \"def get_data_from_web():\\n pass\",\n \"def _request_data(self, url):\\n connection = httplib.HTTPConnection(self.url)\\n connection.request(\\\"GET\\\", url)\\n response = connection.getresponse()\\n\\n if response.status != 200:\\n raise Exception(response.reason)\\n\\n data = response.read()\\n response.close()\\n\\n return json.loads(data)\",\n \"def get_data(self):\\n\\n self.set_query_string()\\n self.realtime_data = super().get_data()\\n self.set_coordinate()\\n return self.realtime_data\",\n \"def get_data(self, out_format: str='json'):\\n if self.data:\\n return self.data\\n self.data_ready = self.check_available()\\n if not self.data_ready:\\n raise DataNotReady(\\\"The run {} has not yet finished, data not available yet.\\\".format(self))\\n resp = self.ph.conn.request(\\n 'GET', self.ph.URLS['getdata'].format(self.run_token), dict(api_key=self.ph.api_key, format=out_format))\\n data = resp.data.decode('utf-8')\\n self.data = self.parse_json_data(data)\\n return self.data\",\n \"def data():\\n return volumes_fetchers.get_json_data()\",\n \"def get_data(self):\\n return self.parsed_data\",\n \"def get_data():\\n try:\\n with open(CONS[\\\"OUTPUT_FILE\\\"], \\\"r\\\") as file:\\n data = json.load(file)[1]\\n return data\\n except FileNotFoundError:\\n print(\\\"Data file not found.\\\")\\n exit()\",\n \"def data(self):\\n return json.loads(self.data_json)\",\n \"def getData(self):\\r\\n return self._data\",\n \"def getData(url):\\n data = ''\\n request = urllib2.Request(url, headers={\\\"Accept\\\": \\\"application/json\\\"})\\n try:\\n data = json.loads(urllib2.urlopen(request).read())\\n except urllib2.HTTPError, e:\\n raise Exception(\\\"HTTP error: %d\\\" % e.code)\\n except urllib2.URLError, e:\\n raise Exception(\\\"Network error: %s\\\" % e.reason.args[1])\\n\\n return data\",\n \"def get(self):\\r\\n return self.data\",\n \"def get_data(self, state=None, request=None):\\n raise NotImplementedError\",\n \"def getData(self):\\n return self.__data\",\n \"def fetch_data(data_url):\\n return requests.get(data_url).content\",\n \"def get_data(self):\\n return DataGatherer().get_rainfall_data()\",\n \"def getData(eUrl, eToken):\\n if eUrl == '' or eToken == '':\\n print(\\\"Enviroment is not setup\\\")\\n exit(1)\\n\\n with urllib.request.urlopen(eUrl + eToken) as url:\\n data = json.loads(url.read().decode())\\n\\n return(data)\",\n \"def get_data(self):\\n return DataGatherer().get_wind_data()\",\n \"def get_data():\\n try:\\n with open('./data.json') as data_file:\\n return json.load(data_file)\\n except:\\n data_json = json.loads('{\\\"message\\\": \\\"Error with file data.json\\\", \\\"success\\\": false}')\\n return data_json\",\n \"def getData(tme=currentTime):\\n # attempts request 10 times\\n for attempt in range(10):\\n try:\\n # make a request to the url and return it in json format\\n url = \\\"https://api.darksky.net/forecast/%s/%s,%s,%s?exclude=minutely,hourly,daily,alerts,flags\\\" % (API_KEY, LAT, LNG, tme)\\n return get(url).json()\\n except:\\n # Wait .05 seconds and try again\\n sleep(.05)\\n pass\",\n \"def getData(self):\\n return self._data\",\n \"def getData(self):\\n return self._data\",\n \"def GetGeData(self, *args, **kwargs):\\n pass\",\n \"def getStockData():\\n pass\",\n \"def get_path_data(self, path):\\n url = self.api_server + path\\n return self.get_url_data(url)\",\n \"def download_data(self, format = 'srt'):\\n resp, content = httplib2.Http(\\\".cache\\\").request(self.url, \\\"GET\\\")\\n suburl = json.loads(content)['url']\\n resp, content = httplib2.Http(\\\".cache\\\").request(suburl, \\\"GET\\\")\\n\\n return content\",\n \"def data():\\n return None\",\n \"def GetData(self):\\r\\n \\r\\n return self._data\",\n \"def getData():\\n data = {\\n \\\"name\\\": \\\"Kim\\\",\\n \\\"message\\\": \\\"Hello there!\\\"\\n }\\n return jsonify(data) # respond to the API caller with a JSON representation of data. jsonify is important, as it sets response headers that indicate the respose is in JSON as well\",\n \"def get_data(self, url):\\n\\n req = urllib2.Request(url)\\n # urlencode the query dictionary\\n try:\\n r = urllib2.urlopen(req)\\n result = r.read()\\n except:\\n result = 'The url: %s is not responding.' % (url)\\n return result\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get(self):\\n return self.data\",\n \"def get(self):\\n return self.get_data()\",\n \"def get_data(self, request, url):\\n data = request.get(endpoint=url)\\n return data[0], data[1]\",\n \"def get_data(self):\\n self._send_command(self._adapter.get_data())\",\n \"def stations():\\n print(\\\"server received request for stations data...\\\")\\n return jsonify(stations_data)\",\n \"def get_data(self, label: str) -> Any:\\r\\n return self._get_resource(label, self._data, \\\"data\\\")\",\n \"def get_data(self):\\n with open(self.filepath, 'r') as openFile:\\n data = json.load(openFile)\\n logging.info('Loaded JSON data file.')\\n return data\",\n \"def apicall():\\r\\n# try:\\r\\n print request.get_json()\\r\\n test_json = request.get_json()\\r\\n logger.info(\\\"input json object loaded\\\")\\r\\n logger.info(test_json)\\r\\n k=MetaData(test_json)\\r\\n int_res=k.getData()\\r\\n print '------------------------------'\\r\\n print int_res\\r\\n return jsonify(int_res)\",\n \"def get_data(self):\\n return self.topo_data_flattened\",\n \"def fetch_data(self):\",\n \"def get_data():\\n if not hasattr(g, 'data'):\\n g.data = load_data()\\n return g.data\",\n \"def GetData():\\r\\n return _hiew.HiewGate_GetData()\",\n \"def get(self):\\n city = str(request.args.get('city')) ## /?city=stockholm\\n source = urllib.request.urlopen('http://127.0.0.1:5050/?city=' + city).read()\\n data = json.loads(source)\\n print(data)\\n tempinc = {\\\"name\\\" : (str(data['name'])),\\n \\\"country\\\" : (str(data['country'])),\\n \\\"temp\\\" : (str(data['temp']))+' c'}\\n return tempinc\",\n \"def _get_data_file(self, data_path):\\n\\n return json.load(open(data_path))\",\n \"async def get_data(self, endpoint):\\n try:\\n with async_timeout.timeout(5, loop=self._loop):\\n response = await self._session.get(f\\\"{endpoint}\\\")\\n\\n _LOGGER.debug(\\\"Response from Dingz device: %s\\\", response.status)\\n self.data = await response.json()\\n _LOGGER.debug(self.data)\\n except (asyncio.TimeoutError, aiohttp.ClientError):\\n _LOGGER.error(\\\"Can not load data from Dingz device\\\")\\n self.data = None\\n raise exceptions.DingzConnectionError()\",\n \"def _extract_data(self):\\n if self.URL_type == \\\"youtube\\\" or self.URL_type == \\\"ytmusic\\\":\\n self._get_youtube_data_url()\\n elif self.URL_type == \\\"soundcloud\\\":\\n self._get_soundcloud_data()\",\n \"def get_url_data(self, url):\\n # print \\\"opening: \\\" + url\\n request = urllib2.Request(url)\\n base64string = '%s:%s' % (self.username, self.key)\\n request.add_header(\\\"Authorization\\\", \\\"ApiKey %s\\\" % base64string)\\n response = urllib2.urlopen(request)\\n data = json.loads(response.read())\\n return data\",\n \"def _fetch_data(self):\\n pass\",\n \"def data(self):\\n self._get_latest_content()\\n return self._data.get('data', {})\",\n \"def get(self):\\n data = request.args.get('data')\\n\\n if not data:\\n data = \\\"OK!\\\"\\n\\n return json.loads(dumps(data)), 200\",\n \"def data(self):\\n return self._data\",\n \"def data(self):\\n file_name = join(PARENT_BASE_DIR, '.files', 'data.data.json')\\n if isfile(file_name):\\n debug(f'{file_name} file is exist.')\\n debug(f'try for load {file_name} file ->->->->->->->->->->')\\n start_load_file = time()\\n with open(file_name, 'r', encoding='utf-8')as file:\\n data = file.read()\\n data = loads(data)\\n debug(f'load file - [runtime: {time() - start_load_file}] <-<-<-<-<-<-<-<-<-<-')\\n return data, 'data exist.'\\n else:\\n debug(f'{file_name} file is not exist.')\\n return None, 'data not exist in \\\"base directory/.files/data.data.json\\\"'\",\n \"def get_data(self, lat=53.3498, lon=-6.2603):\\n r = requests.get(\\n f\\\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\\\")\\n return r.text\",\n \"def get_data(self):\\n return DataGatherer().get_temperature_data()\",\n \"def getData(self, product, variables, attributes, variable, *args):\\r\\n\\r\\n data = None\\r\\n return data\",\n \"def getAllData(self):\\r\\n return self.data\",\n \"def get_data(self, body):\\n params = json.loads(body)\\n logger.debug('New Data Format')\\n return self._get_data(body)\",\n \"def stationdata():\\n # * Return a JSON list of stations from the dataset.\\n # as this should be a list, I'm just grabbing the station name\\n session = Session(engine)\\n results = session.query(Station.name).all()\\n session.close()\\n\\n stations = list(np.ravel(results))\\n return jsonify(stations)\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def get_data(self):\\n\\n return self._data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7276632","0.7044919","0.7044919","0.7044919","0.6988719","0.6904598","0.67315245","0.67315245","0.6711421","0.6699119","0.66586465","0.6641715","0.65758157","0.65712667","0.6570018","0.6539462","0.6526975","0.64456314","0.64355475","0.6282369","0.6267849","0.62539583","0.62318444","0.62056994","0.6203443","0.61973894","0.61973894","0.61973894","0.61941123","0.6193835","0.6171375","0.61706764","0.61706764","0.61699045","0.613302","0.6105646","0.60901976","0.60713613","0.6064109","0.60600907","0.6059058","0.60442257","0.60441184","0.60246354","0.602411","0.6003093","0.59959054","0.59833884","0.5977262","0.59436166","0.5936724","0.5918368","0.5902448","0.5889219","0.5873394","0.5867444","0.58654165","0.58654165","0.5854547","0.58541197","0.584554","0.584539","0.5839185","0.5818117","0.578982","0.57875663","0.5783141","0.5783141","0.5783141","0.5783141","0.5777883","0.57754195","0.5767481","0.5762121","0.5746903","0.5734854","0.57335156","0.5730804","0.5727303","0.5726277","0.57260615","0.57227606","0.57018274","0.56889516","0.5685928","0.56830907","0.56817275","0.56644094","0.5659732","0.56545985","0.5647078","0.56387955","0.56344116","0.5630541","0.5630077","0.56223285","0.5616545","0.561541","0.5613653","0.5613653","0.5613653"],"string":"[\n \"0.7276632\",\n \"0.7044919\",\n \"0.7044919\",\n \"0.7044919\",\n \"0.6988719\",\n \"0.6904598\",\n \"0.67315245\",\n \"0.67315245\",\n \"0.6711421\",\n \"0.6699119\",\n \"0.66586465\",\n \"0.6641715\",\n \"0.65758157\",\n \"0.65712667\",\n \"0.6570018\",\n \"0.6539462\",\n \"0.6526975\",\n \"0.64456314\",\n \"0.64355475\",\n \"0.6282369\",\n \"0.6267849\",\n \"0.62539583\",\n \"0.62318444\",\n \"0.62056994\",\n \"0.6203443\",\n \"0.61973894\",\n \"0.61973894\",\n \"0.61973894\",\n \"0.61941123\",\n \"0.6193835\",\n \"0.6171375\",\n \"0.61706764\",\n \"0.61706764\",\n \"0.61699045\",\n \"0.613302\",\n \"0.6105646\",\n \"0.60901976\",\n \"0.60713613\",\n \"0.6064109\",\n \"0.60600907\",\n \"0.6059058\",\n \"0.60442257\",\n \"0.60441184\",\n \"0.60246354\",\n \"0.602411\",\n \"0.6003093\",\n \"0.59959054\",\n \"0.59833884\",\n \"0.5977262\",\n \"0.59436166\",\n \"0.5936724\",\n \"0.5918368\",\n \"0.5902448\",\n \"0.5889219\",\n \"0.5873394\",\n \"0.5867444\",\n \"0.58654165\",\n \"0.58654165\",\n \"0.5854547\",\n \"0.58541197\",\n \"0.584554\",\n \"0.584539\",\n \"0.5839185\",\n \"0.5818117\",\n \"0.578982\",\n \"0.57875663\",\n \"0.5783141\",\n \"0.5783141\",\n \"0.5783141\",\n \"0.5783141\",\n \"0.5777883\",\n \"0.57754195\",\n \"0.5767481\",\n \"0.5762121\",\n \"0.5746903\",\n \"0.5734854\",\n \"0.57335156\",\n \"0.5730804\",\n \"0.5727303\",\n \"0.5726277\",\n \"0.57260615\",\n \"0.57227606\",\n \"0.57018274\",\n \"0.56889516\",\n \"0.5685928\",\n \"0.56830907\",\n \"0.56817275\",\n \"0.56644094\",\n \"0.5659732\",\n \"0.56545985\",\n \"0.5647078\",\n \"0.56387955\",\n \"0.56344116\",\n \"0.5630541\",\n \"0.5630077\",\n \"0.56223285\",\n \"0.5616545\",\n \"0.561541\",\n \"0.5613653\",\n \"0.5613653\",\n \"0.5613653\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":187,"cells":{"query":{"kind":"string","value":"getData is used to get satellite json data from the server."},"document":{"kind":"string","value":"def getValue(self, url: str, latitude: list,\n longitude: list, satellite='l8', index='ndvi'):\n if type(latitude) is not list:\n latitude = [str(latitude)]\n else:\n latitude = [str(l) for l in latitude]\n\n if type(longitude) is not list:\n longitude = [str(longitude)]\n else:\n longitude = [str(l) for l in longitude]\n\n param = {\n 'url': url,\n 'x': ','.join(longitude),\n 'y': ','.join(latitude),\n 'satellite': satellite,\n 'index': index\n }\n\n try:\n response = requests.get(url=self.valueEndpoint, params=param)\n except Exception as e:\n raise exceptions(\n 'Unable to reach to value endpoint. Error: {}'.format(e))\n\n return response.json()"},"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_data():\n pass","def get_data():\n pass","def get_data():\n pass","def get_data():\n pass","def get_data():\n return","def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n return data","def get_data(self):\n pass","def get_data(self):\n pass","def get_data(self, url):\n return self.get(url).get('data', [])","def get(self, data):\n pass","def get_data(self):\r\n pass","def get(self, data):\n ret = self._rest_call({}, 'GET')\n return json.loads(ret[2])","def get_data():\n try:\n response = requests.get(uri)\n json_data = response.json()\n except ValueError as e:\n print(e)\n except TypeError as e:\n print(e)\n return json_data","def get_data(self):","def get_data(self):\n return self.data.to_json()","def get_sdata(self):\n payload = self.get('data_request?id=sdata&output_format=json')\n return payload","def get_json_data():\n return None","def _get_data(self):\n raise NotImplementedError()","def get_velib_data():\n api_url = \"https://api.jcdecaux.com/vls/v1/\"\n query_string = \"stations?contract=Paris&apiKey=\"\n api_key = \"ec29d3b17e5162e1459aaad45cddfe74fe832379\"\n my_url = api_url + query_string + api_key\n\n urlobj = URL.urlopen(my_url)\n data = json.load(urlobj)\n# data = urlobj.read()\n# help(data)\n return data","async def stations_data():\n with open(\"/data/station_data.json\") as j:\n data = json.load(j)\n return data","def get_data():\n string = open('Tinder/static/data/data.json').read()\n return flask.jsonify(json.loads(string))","def get_data(self):\n raise NotImplementedError(\"Not implemented!\")","def getStationData(self):\n dtime = datetime.strptime(self.refTime, \"%y%m%d/%H%M\")\n trange = TimeRange()\n trange.setStart(dtime)\n trange.setEnd(dtime)\n dataTime = DataTime(refTime=dtime, validPeriod=trange)\n req = StationDataRequest()\n req.setPluginName(self.pluginName)\n req.setStationId(self.stationId)\n req.setRefTime(dataTime)\n req.setParmList(self.parmList)\n req.setPartNumber(self.partNumber)\n resp = self.client.sendRequest(req)\n\n for i, rec in enumerate(resp):\n resp[i] = {\n key.decode() if isinstance(key, bytes) else key:\n val.decode() if isinstance(val, bytes) else val\n for key, val in rec.items()\n }\n\n return resp","def get_data(self): # TODO: add smooth possibility\n return self.data","async def get_data(self, path: str) -> Dict:\n # function accepts paths that start with / and also path that do not start with /\n if path.startswith(\"/\"):\n path = path[1:]\n try:\n async with aiohttp.ClientSession() as session:\n async with session.get(f\"{self._opa_url}/data/{path}\") as opa_response:\n return await opa_response.json()\n except aiohttp.ClientError as e:\n logger.warning(\"Opa connection error: {err}\", err=e)\n raise","def get_data(self):\n return self.data","def get_data(self):\n return self.data","def get_data(self):\n return self.data","def get_data(self):\n\n raise NotImplementedError('''\n Must Implement get_data. Call help() for details.\n ''')","def getData(self, local_cache):","def getData(self):\n return self.data","def getData(self):\n return self.data","def getDatafromWebService(self,region, station, start_date, end_date):\n #construct filename in the format \"region_station_startdate_enddate.json\" with no spaces and \"-\"\n \"\"\"\n filename = region + \"_\" + station+ \"_\" + start_date + \"_\" + end_date + \".json\"\n filename = filename.replace(\" \",\"\")\n filename = filename.replace(\"-\",\"\")\n print (\"filename: \"+filename)\n \"\"\"\n #date format for getting data from web service = yy/mm/dd\n obj = RegionData()\n stationcode = obj.getStaionCode(region, station)\n newStart_Date = datetime.datetime.strptime(start_date, \"%m/%d/%Y\").strftime(\"%Y-%m-%d\")\n newEnd_Date = datetime.datetime.strptime(end_date, \"%m/%d/%Y\").strftime(\"%Y-%m-%d\")\n\n server = SOAPpy.SOAPProxy(\"http://cdmo.baruch.sc.edu/webservices2/requests.cfc?wsdl\")\n\n #stationcode=\"pdbjewq\"\n responsedata = server.exportAllParamsDateRangeXMLNew(stationcode, newStart_Date, newEnd_Date,'*')\n #responsedata = server.exportAllParamsDateRangeXMLNew('pdbjewq','2014-12-30', '2014-12-31', '*')\n\n # print responsedata\n pythonObject = SOAPpy.Types.simplify(responsedata)\n #jsonObject = json.dumps(pythonObject)\n #assert type(jsonObject) == str\n dataArray = pythonObject[\"returnData\"][\"data\"] # returns { [{...},{....},.....]}\n\n #data from webservice has date format mm/dd/yy = 12/31/2014\n #print(dataArray)\n\n return json.dumps(dataArray)\n \"\"\"\n print (dataArray)\n self.dataToJson(dataArray, filename) # store the data into a json file\n #store data into rawdata collection\n \n rawObj =RawData()\n rawObj.insertRawStationData(region,station,start_date,end_date,dataArray)\n \n #return filename # return the json filename where data is stored\n \"\"\"","def get_data(link):\n data = re.get(link)\n jsondata = data.json()\n for weatherstation in jsondata['weatherStations']:\n FetchandStore.sensordict.update({weatherstation[\"id\"]:weatherstation[\"sensorValues\"]})\n for sensorvalue in weatherstation[\"sensorValues\"]:\n FetchandStore.sensors.append({\"id\": sensorvalue[\"roadStationId\"], \"name\": sensorvalue[\"oldName\"],\n \"value\": sensorvalue[\"sensorValue\"], \"unit\": sensorvalue[\"sensorUnit\"],\n \"datetime\": sensorvalue[\"measuredTime\"]})\n return FetchandStore.sensors","def getTheData(self, dev):\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"getTheData FrontViewAPI method called.\")\n\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Download\")\n try:\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\n r = requests.get(url,timeout=5)\n result = r.json()\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Result:\" + unicode(result))\n self.WaitInterval = 1\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Online\")\n dev.setErrorStateOnServer(None)\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n return result\n\n except Exception as error:\n\n indigo.server.log(u\"Error connecting to Device:\" + dev.name)\n self.WaitInterval = 60\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Device is offline. No data to return. \")\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\"Offline\")\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n dev.setErrorStateOnServer(u'Offline')\n result = \"\"\n return result","def getData(language=None):","def download():\n toydata = requests.get(DATA_URL).json()\n return toydata","def get_data_from_web():\n pass","def _request_data(self, url):\n connection = httplib.HTTPConnection(self.url)\n connection.request(\"GET\", url)\n response = connection.getresponse()\n\n if response.status != 200:\n raise Exception(response.reason)\n\n data = response.read()\n response.close()\n\n return json.loads(data)","def get_data(self):\n\n self.set_query_string()\n self.realtime_data = super().get_data()\n self.set_coordinate()\n return self.realtime_data","def get_data(self, out_format: str='json'):\n if self.data:\n return self.data\n self.data_ready = self.check_available()\n if not self.data_ready:\n raise DataNotReady(\"The run {} has not yet finished, data not available yet.\".format(self))\n resp = self.ph.conn.request(\n 'GET', self.ph.URLS['getdata'].format(self.run_token), dict(api_key=self.ph.api_key, format=out_format))\n data = resp.data.decode('utf-8')\n self.data = self.parse_json_data(data)\n return self.data","def get_data(self):\n return self.parsed_data","def data():\n return volumes_fetchers.get_json_data()","def get_data():\n try:\n with open(CONS[\"OUTPUT_FILE\"], \"r\") as file:\n data = json.load(file)[1]\n return data\n except FileNotFoundError:\n print(\"Data file not found.\")\n exit()","def data(self):\n return json.loads(self.data_json)","def getData(self):\r\n return self._data","def getData(url):\n data = ''\n request = urllib2.Request(url, headers={\"Accept\": \"application/json\"})\n try:\n data = json.loads(urllib2.urlopen(request).read())\n except urllib2.HTTPError, e:\n raise Exception(\"HTTP error: %d\" % e.code)\n except urllib2.URLError, e:\n raise Exception(\"Network error: %s\" % e.reason.args[1])\n\n return data","def get(self):\r\n return self.data","def get_data(self, state=None, request=None):\n raise NotImplementedError","def getData(self):\n return self.__data","def fetch_data(data_url):\n return requests.get(data_url).content","def get_data(self):\n return DataGatherer().get_rainfall_data()","def getData(eUrl, eToken):\n if eUrl == '' or eToken == '':\n print(\"Enviroment is not setup\")\n exit(1)\n\n with urllib.request.urlopen(eUrl + eToken) as url:\n data = json.loads(url.read().decode())\n\n return(data)","def get_data(self):\n return DataGatherer().get_wind_data()","def get_data():\n try:\n with open('./data.json') as data_file:\n return json.load(data_file)\n except:\n data_json = json.loads('{\"message\": \"Error with file data.json\", \"success\": false}')\n return data_json","def getData(tme=currentTime):\n # attempts request 10 times\n for attempt in range(10):\n try:\n # make a request to the url and return it in json format\n url = \"https://api.darksky.net/forecast/%s/%s,%s,%s?exclude=minutely,hourly,daily,alerts,flags\" % (API_KEY, LAT, LNG, tme)\n return get(url).json()\n except:\n # Wait .05 seconds and try again\n sleep(.05)\n pass","def getData(self):\n return self._data","def getData(self):\n return self._data","def GetGeData(self, *args, **kwargs):\n pass","def getStockData():\n pass","def download_data(self, format = 'srt'):\n resp, content = httplib2.Http(\".cache\").request(self.url, \"GET\")\n suburl = json.loads(content)['url']\n resp, content = httplib2.Http(\".cache\").request(suburl, \"GET\")\n\n return content","def get_path_data(self, path):\n url = self.api_server + path\n return self.get_url_data(url)","def data():\n return None","def GetData(self):\r\n \r\n return self._data","def getData():\n data = {\n \"name\": \"Kim\",\n \"message\": \"Hello there!\"\n }\n return jsonify(data) # respond to the API caller with a JSON representation of data. jsonify is important, as it sets response headers that indicate the respose is in JSON as well","def get_data(self, url):\n\n req = urllib2.Request(url)\n # urlencode the query dictionary\n try:\n r = urllib2.urlopen(req)\n result = r.read()\n except:\n result = 'The url: %s is not responding.' % (url)\n return result","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get(self):\n return self.data","def get(self):\n return self.get_data()","def get_data(self, request, url):\n data = request.get(endpoint=url)\n return data[0], data[1]","def get_data(self):\n self._send_command(self._adapter.get_data())","def stations():\n print(\"server received request for stations data...\")\n return jsonify(stations_data)","def get_data(self, label: str) -> Any:\r\n return self._get_resource(label, self._data, \"data\")","def get_data(self):\n with open(self.filepath, 'r') as openFile:\n data = json.load(openFile)\n logging.info('Loaded JSON data file.')\n return data","def apicall():\r\n# try:\r\n print request.get_json()\r\n test_json = request.get_json()\r\n logger.info(\"input json object loaded\")\r\n logger.info(test_json)\r\n k=MetaData(test_json)\r\n int_res=k.getData()\r\n print '------------------------------'\r\n print int_res\r\n return jsonify(int_res)","def get_data(self):\n return self.topo_data_flattened","def get_data():\n if not hasattr(g, 'data'):\n g.data = load_data()\n return g.data","def fetch_data(self):","def GetData():\r\n return _hiew.HiewGate_GetData()","def get(self):\n city = str(request.args.get('city')) ## /?city=stockholm\n source = urllib.request.urlopen('http://127.0.0.1:5050/?city=' + city).read()\n data = json.loads(source)\n print(data)\n tempinc = {\"name\" : (str(data['name'])),\n \"country\" : (str(data['country'])),\n \"temp\" : (str(data['temp']))+' c'}\n return tempinc","def _get_data_file(self, data_path):\n\n return json.load(open(data_path))","async def get_data(self, endpoint):\n try:\n with async_timeout.timeout(5, loop=self._loop):\n response = await self._session.get(f\"{endpoint}\")\n\n _LOGGER.debug(\"Response from Dingz device: %s\", response.status)\n self.data = await response.json()\n _LOGGER.debug(self.data)\n except (asyncio.TimeoutError, aiohttp.ClientError):\n _LOGGER.error(\"Can not load data from Dingz device\")\n self.data = None\n raise exceptions.DingzConnectionError()","def _extract_data(self):\n if self.URL_type == \"youtube\" or self.URL_type == \"ytmusic\":\n self._get_youtube_data_url()\n elif self.URL_type == \"soundcloud\":\n self._get_soundcloud_data()","def get_url_data(self, url):\n # print \"opening: \" + url\n request = urllib2.Request(url)\n base64string = '%s:%s' % (self.username, self.key)\n request.add_header(\"Authorization\", \"ApiKey %s\" % base64string)\n response = urllib2.urlopen(request)\n data = json.loads(response.read())\n return data","def _fetch_data(self):\n pass","def data(self):\n self._get_latest_content()\n return self._data.get('data', {})","def get(self):\n data = request.args.get('data')\n\n if not data:\n data = \"OK!\"\n\n return json.loads(dumps(data)), 200","def data(self):\n return self._data","def data(self):\n file_name = join(PARENT_BASE_DIR, '.files', 'data.data.json')\n if isfile(file_name):\n debug(f'{file_name} file is exist.')\n debug(f'try for load {file_name} file ->->->->->->->->->->')\n start_load_file = time()\n with open(file_name, 'r', encoding='utf-8')as file:\n data = file.read()\n data = loads(data)\n debug(f'load file - [runtime: {time() - start_load_file}] <-<-<-<-<-<-<-<-<-<-')\n return data, 'data exist.'\n else:\n debug(f'{file_name} file is not exist.')\n return None, 'data not exist in \"base directory/.files/data.data.json\"'","def get_data(self, lat=53.3498, lon=-6.2603):\n r = requests.get(\n f\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\")\n return r.text","def get_data(self):\n return DataGatherer().get_temperature_data()","def getData(self, product, variables, attributes, variable, *args):\r\n\r\n data = None\r\n return data","def getAllData(self):\r\n return self.data","def get_data(self, body):\n params = json.loads(body)\n logger.debug('New Data Format')\n return self._get_data(body)","def get_data(self):\n\n return self._data","def get_data(self):\n\n return self._data","def get_data(self):\n\n return self._data","def stationdata():\n # * Return a JSON list of stations from the dataset.\n # as this should be a list, I'm just grabbing the station name\n session = Session(engine)\n results = session.query(Station.name).all()\n session.close()\n\n stations = list(np.ravel(results))\n return jsonify(stations)"],"string":"[\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n return\",\n \"def _get_data(self, url: str)->dict:\\n data = None\\n resp = self._get(url)\\n if resp:\\n data = resp.json()['data']\\n return data\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self, url):\\n return self.get(url).get('data', [])\",\n \"def get(self, data):\\n pass\",\n \"def get_data(self):\\r\\n pass\",\n \"def get(self, data):\\n ret = self._rest_call({}, 'GET')\\n return json.loads(ret[2])\",\n \"def get_data():\\n try:\\n response = requests.get(uri)\\n json_data = response.json()\\n except ValueError as e:\\n print(e)\\n except TypeError as e:\\n print(e)\\n return json_data\",\n \"def get_data(self):\",\n \"def get_data(self):\\n return self.data.to_json()\",\n \"def get_sdata(self):\\n payload = self.get('data_request?id=sdata&output_format=json')\\n return payload\",\n \"def get_json_data():\\n return None\",\n \"def _get_data(self):\\n raise NotImplementedError()\",\n \"def get_velib_data():\\n api_url = \\\"https://api.jcdecaux.com/vls/v1/\\\"\\n query_string = \\\"stations?contract=Paris&apiKey=\\\"\\n api_key = \\\"ec29d3b17e5162e1459aaad45cddfe74fe832379\\\"\\n my_url = api_url + query_string + api_key\\n\\n urlobj = URL.urlopen(my_url)\\n data = json.load(urlobj)\\n# data = urlobj.read()\\n# help(data)\\n return data\",\n \"async def stations_data():\\n with open(\\\"/data/station_data.json\\\") as j:\\n data = json.load(j)\\n return data\",\n \"def get_data():\\n string = open('Tinder/static/data/data.json').read()\\n return flask.jsonify(json.loads(string))\",\n \"def get_data(self):\\n raise NotImplementedError(\\\"Not implemented!\\\")\",\n \"def getStationData(self):\\n dtime = datetime.strptime(self.refTime, \\\"%y%m%d/%H%M\\\")\\n trange = TimeRange()\\n trange.setStart(dtime)\\n trange.setEnd(dtime)\\n dataTime = DataTime(refTime=dtime, validPeriod=trange)\\n req = StationDataRequest()\\n req.setPluginName(self.pluginName)\\n req.setStationId(self.stationId)\\n req.setRefTime(dataTime)\\n req.setParmList(self.parmList)\\n req.setPartNumber(self.partNumber)\\n resp = self.client.sendRequest(req)\\n\\n for i, rec in enumerate(resp):\\n resp[i] = {\\n key.decode() if isinstance(key, bytes) else key:\\n val.decode() if isinstance(val, bytes) else val\\n for key, val in rec.items()\\n }\\n\\n return resp\",\n \"def get_data(self): # TODO: add smooth possibility\\n return self.data\",\n \"async def get_data(self, path: str) -> Dict:\\n # function accepts paths that start with / and also path that do not start with /\\n if path.startswith(\\\"/\\\"):\\n path = path[1:]\\n try:\\n async with aiohttp.ClientSession() as session:\\n async with session.get(f\\\"{self._opa_url}/data/{path}\\\") as opa_response:\\n return await opa_response.json()\\n except aiohttp.ClientError as e:\\n logger.warning(\\\"Opa connection error: {err}\\\", err=e)\\n raise\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n\\n raise NotImplementedError('''\\n Must Implement get_data. Call help() for details.\\n ''')\",\n \"def getData(self, local_cache):\",\n \"def getData(self):\\n return self.data\",\n \"def getData(self):\\n return self.data\",\n \"def getDatafromWebService(self,region, station, start_date, end_date):\\n #construct filename in the format \\\"region_station_startdate_enddate.json\\\" with no spaces and \\\"-\\\"\\n \\\"\\\"\\\"\\n filename = region + \\\"_\\\" + station+ \\\"_\\\" + start_date + \\\"_\\\" + end_date + \\\".json\\\"\\n filename = filename.replace(\\\" \\\",\\\"\\\")\\n filename = filename.replace(\\\"-\\\",\\\"\\\")\\n print (\\\"filename: \\\"+filename)\\n \\\"\\\"\\\"\\n #date format for getting data from web service = yy/mm/dd\\n obj = RegionData()\\n stationcode = obj.getStaionCode(region, station)\\n newStart_Date = datetime.datetime.strptime(start_date, \\\"%m/%d/%Y\\\").strftime(\\\"%Y-%m-%d\\\")\\n newEnd_Date = datetime.datetime.strptime(end_date, \\\"%m/%d/%Y\\\").strftime(\\\"%Y-%m-%d\\\")\\n\\n server = SOAPpy.SOAPProxy(\\\"http://cdmo.baruch.sc.edu/webservices2/requests.cfc?wsdl\\\")\\n\\n #stationcode=\\\"pdbjewq\\\"\\n responsedata = server.exportAllParamsDateRangeXMLNew(stationcode, newStart_Date, newEnd_Date,'*')\\n #responsedata = server.exportAllParamsDateRangeXMLNew('pdbjewq','2014-12-30', '2014-12-31', '*')\\n\\n # print responsedata\\n pythonObject = SOAPpy.Types.simplify(responsedata)\\n #jsonObject = json.dumps(pythonObject)\\n #assert type(jsonObject) == str\\n dataArray = pythonObject[\\\"returnData\\\"][\\\"data\\\"] # returns { [{...},{....},.....]}\\n\\n #data from webservice has date format mm/dd/yy = 12/31/2014\\n #print(dataArray)\\n\\n return json.dumps(dataArray)\\n \\\"\\\"\\\"\\n print (dataArray)\\n self.dataToJson(dataArray, filename) # store the data into a json file\\n #store data into rawdata collection\\n \\n rawObj =RawData()\\n rawObj.insertRawStationData(region,station,start_date,end_date,dataArray)\\n \\n #return filename # return the json filename where data is stored\\n \\\"\\\"\\\"\",\n \"def get_data(link):\\n data = re.get(link)\\n jsondata = data.json()\\n for weatherstation in jsondata['weatherStations']:\\n FetchandStore.sensordict.update({weatherstation[\\\"id\\\"]:weatherstation[\\\"sensorValues\\\"]})\\n for sensorvalue in weatherstation[\\\"sensorValues\\\"]:\\n FetchandStore.sensors.append({\\\"id\\\": sensorvalue[\\\"roadStationId\\\"], \\\"name\\\": sensorvalue[\\\"oldName\\\"],\\n \\\"value\\\": sensorvalue[\\\"sensorValue\\\"], \\\"unit\\\": sensorvalue[\\\"sensorUnit\\\"],\\n \\\"datetime\\\": sensorvalue[\\\"measuredTime\\\"]})\\n return FetchandStore.sensors\",\n \"def getTheData(self, dev):\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"getTheData FrontViewAPI method called.\\\")\\n\\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Download\\\")\\n try:\\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\\n r = requests.get(url,timeout=5)\\n result = r.json()\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Result:\\\" + unicode(result))\\n self.WaitInterval = 1\\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Online\\\")\\n dev.setErrorStateOnServer(None)\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n return result\\n\\n except Exception as error:\\n\\n indigo.server.log(u\\\"Error connecting to Device:\\\" + dev.name)\\n self.WaitInterval = 60\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Device is offline. No data to return. \\\")\\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\\\"Offline\\\")\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n dev.setErrorStateOnServer(u'Offline')\\n result = \\\"\\\"\\n return result\",\n \"def getData(language=None):\",\n \"def download():\\n toydata = requests.get(DATA_URL).json()\\n return toydata\",\n \"def get_data_from_web():\\n pass\",\n \"def _request_data(self, url):\\n connection = httplib.HTTPConnection(self.url)\\n connection.request(\\\"GET\\\", url)\\n response = connection.getresponse()\\n\\n if response.status != 200:\\n raise Exception(response.reason)\\n\\n data = response.read()\\n response.close()\\n\\n return json.loads(data)\",\n \"def get_data(self):\\n\\n self.set_query_string()\\n self.realtime_data = super().get_data()\\n self.set_coordinate()\\n return self.realtime_data\",\n \"def get_data(self, out_format: str='json'):\\n if self.data:\\n return self.data\\n self.data_ready = self.check_available()\\n if not self.data_ready:\\n raise DataNotReady(\\\"The run {} has not yet finished, data not available yet.\\\".format(self))\\n resp = self.ph.conn.request(\\n 'GET', self.ph.URLS['getdata'].format(self.run_token), dict(api_key=self.ph.api_key, format=out_format))\\n data = resp.data.decode('utf-8')\\n self.data = self.parse_json_data(data)\\n return self.data\",\n \"def get_data(self):\\n return self.parsed_data\",\n \"def data():\\n return volumes_fetchers.get_json_data()\",\n \"def get_data():\\n try:\\n with open(CONS[\\\"OUTPUT_FILE\\\"], \\\"r\\\") as file:\\n data = json.load(file)[1]\\n return data\\n except FileNotFoundError:\\n print(\\\"Data file not found.\\\")\\n exit()\",\n \"def data(self):\\n return json.loads(self.data_json)\",\n \"def getData(self):\\r\\n return self._data\",\n \"def getData(url):\\n data = ''\\n request = urllib2.Request(url, headers={\\\"Accept\\\": \\\"application/json\\\"})\\n try:\\n data = json.loads(urllib2.urlopen(request).read())\\n except urllib2.HTTPError, e:\\n raise Exception(\\\"HTTP error: %d\\\" % e.code)\\n except urllib2.URLError, e:\\n raise Exception(\\\"Network error: %s\\\" % e.reason.args[1])\\n\\n return data\",\n \"def get(self):\\r\\n return self.data\",\n \"def get_data(self, state=None, request=None):\\n raise NotImplementedError\",\n \"def getData(self):\\n return self.__data\",\n \"def fetch_data(data_url):\\n return requests.get(data_url).content\",\n \"def get_data(self):\\n return DataGatherer().get_rainfall_data()\",\n \"def getData(eUrl, eToken):\\n if eUrl == '' or eToken == '':\\n print(\\\"Enviroment is not setup\\\")\\n exit(1)\\n\\n with urllib.request.urlopen(eUrl + eToken) as url:\\n data = json.loads(url.read().decode())\\n\\n return(data)\",\n \"def get_data(self):\\n return DataGatherer().get_wind_data()\",\n \"def get_data():\\n try:\\n with open('./data.json') as data_file:\\n return json.load(data_file)\\n except:\\n data_json = json.loads('{\\\"message\\\": \\\"Error with file data.json\\\", \\\"success\\\": false}')\\n return data_json\",\n \"def getData(tme=currentTime):\\n # attempts request 10 times\\n for attempt in range(10):\\n try:\\n # make a request to the url and return it in json format\\n url = \\\"https://api.darksky.net/forecast/%s/%s,%s,%s?exclude=minutely,hourly,daily,alerts,flags\\\" % (API_KEY, LAT, LNG, tme)\\n return get(url).json()\\n except:\\n # Wait .05 seconds and try again\\n sleep(.05)\\n pass\",\n \"def getData(self):\\n return self._data\",\n \"def getData(self):\\n return self._data\",\n \"def GetGeData(self, *args, **kwargs):\\n pass\",\n \"def getStockData():\\n pass\",\n \"def download_data(self, format = 'srt'):\\n resp, content = httplib2.Http(\\\".cache\\\").request(self.url, \\\"GET\\\")\\n suburl = json.loads(content)['url']\\n resp, content = httplib2.Http(\\\".cache\\\").request(suburl, \\\"GET\\\")\\n\\n return content\",\n \"def get_path_data(self, path):\\n url = self.api_server + path\\n return self.get_url_data(url)\",\n \"def data():\\n return None\",\n \"def GetData(self):\\r\\n \\r\\n return self._data\",\n \"def getData():\\n data = {\\n \\\"name\\\": \\\"Kim\\\",\\n \\\"message\\\": \\\"Hello there!\\\"\\n }\\n return jsonify(data) # respond to the API caller with a JSON representation of data. jsonify is important, as it sets response headers that indicate the respose is in JSON as well\",\n \"def get_data(self, url):\\n\\n req = urllib2.Request(url)\\n # urlencode the query dictionary\\n try:\\n r = urllib2.urlopen(req)\\n result = r.read()\\n except:\\n result = 'The url: %s is not responding.' % (url)\\n return result\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get(self):\\n return self.data\",\n \"def get(self):\\n return self.get_data()\",\n \"def get_data(self, request, url):\\n data = request.get(endpoint=url)\\n return data[0], data[1]\",\n \"def get_data(self):\\n self._send_command(self._adapter.get_data())\",\n \"def stations():\\n print(\\\"server received request for stations data...\\\")\\n return jsonify(stations_data)\",\n \"def get_data(self, label: str) -> Any:\\r\\n return self._get_resource(label, self._data, \\\"data\\\")\",\n \"def get_data(self):\\n with open(self.filepath, 'r') as openFile:\\n data = json.load(openFile)\\n logging.info('Loaded JSON data file.')\\n return data\",\n \"def apicall():\\r\\n# try:\\r\\n print request.get_json()\\r\\n test_json = request.get_json()\\r\\n logger.info(\\\"input json object loaded\\\")\\r\\n logger.info(test_json)\\r\\n k=MetaData(test_json)\\r\\n int_res=k.getData()\\r\\n print '------------------------------'\\r\\n print int_res\\r\\n return jsonify(int_res)\",\n \"def get_data(self):\\n return self.topo_data_flattened\",\n \"def get_data():\\n if not hasattr(g, 'data'):\\n g.data = load_data()\\n return g.data\",\n \"def fetch_data(self):\",\n \"def GetData():\\r\\n return _hiew.HiewGate_GetData()\",\n \"def get(self):\\n city = str(request.args.get('city')) ## /?city=stockholm\\n source = urllib.request.urlopen('http://127.0.0.1:5050/?city=' + city).read()\\n data = json.loads(source)\\n print(data)\\n tempinc = {\\\"name\\\" : (str(data['name'])),\\n \\\"country\\\" : (str(data['country'])),\\n \\\"temp\\\" : (str(data['temp']))+' c'}\\n return tempinc\",\n \"def _get_data_file(self, data_path):\\n\\n return json.load(open(data_path))\",\n \"async def get_data(self, endpoint):\\n try:\\n with async_timeout.timeout(5, loop=self._loop):\\n response = await self._session.get(f\\\"{endpoint}\\\")\\n\\n _LOGGER.debug(\\\"Response from Dingz device: %s\\\", response.status)\\n self.data = await response.json()\\n _LOGGER.debug(self.data)\\n except (asyncio.TimeoutError, aiohttp.ClientError):\\n _LOGGER.error(\\\"Can not load data from Dingz device\\\")\\n self.data = None\\n raise exceptions.DingzConnectionError()\",\n \"def _extract_data(self):\\n if self.URL_type == \\\"youtube\\\" or self.URL_type == \\\"ytmusic\\\":\\n self._get_youtube_data_url()\\n elif self.URL_type == \\\"soundcloud\\\":\\n self._get_soundcloud_data()\",\n \"def get_url_data(self, url):\\n # print \\\"opening: \\\" + url\\n request = urllib2.Request(url)\\n base64string = '%s:%s' % (self.username, self.key)\\n request.add_header(\\\"Authorization\\\", \\\"ApiKey %s\\\" % base64string)\\n response = urllib2.urlopen(request)\\n data = json.loads(response.read())\\n return data\",\n \"def _fetch_data(self):\\n pass\",\n \"def data(self):\\n self._get_latest_content()\\n return self._data.get('data', {})\",\n \"def get(self):\\n data = request.args.get('data')\\n\\n if not data:\\n data = \\\"OK!\\\"\\n\\n return json.loads(dumps(data)), 200\",\n \"def data(self):\\n return self._data\",\n \"def data(self):\\n file_name = join(PARENT_BASE_DIR, '.files', 'data.data.json')\\n if isfile(file_name):\\n debug(f'{file_name} file is exist.')\\n debug(f'try for load {file_name} file ->->->->->->->->->->')\\n start_load_file = time()\\n with open(file_name, 'r', encoding='utf-8')as file:\\n data = file.read()\\n data = loads(data)\\n debug(f'load file - [runtime: {time() - start_load_file}] <-<-<-<-<-<-<-<-<-<-')\\n return data, 'data exist.'\\n else:\\n debug(f'{file_name} file is not exist.')\\n return None, 'data not exist in \\\"base directory/.files/data.data.json\\\"'\",\n \"def get_data(self, lat=53.3498, lon=-6.2603):\\n r = requests.get(\\n f\\\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\\\")\\n return r.text\",\n \"def get_data(self):\\n return DataGatherer().get_temperature_data()\",\n \"def getData(self, product, variables, attributes, variable, *args):\\r\\n\\r\\n data = None\\r\\n return data\",\n \"def getAllData(self):\\r\\n return self.data\",\n \"def get_data(self, body):\\n params = json.loads(body)\\n logger.debug('New Data Format')\\n return self._get_data(body)\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def stationdata():\\n # * Return a JSON list of stations from the dataset.\\n # as this should be a list, I'm just grabbing the station name\\n session = Session(engine)\\n results = session.query(Station.name).all()\\n session.close()\\n\\n stations = list(np.ravel(results))\\n return jsonify(stations)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72779673","0.7046692","0.7046692","0.7046692","0.6990083","0.6905413","0.67326444","0.67326444","0.67116404","0.67000073","0.6659789","0.66423845","0.657657","0.65723705","0.6571265","0.6539489","0.6527483","0.64475584","0.6434517","0.6281322","0.62673676","0.6255409","0.6231226","0.6207303","0.6203103","0.61984956","0.61984956","0.61984956","0.6195434","0.61948794","0.61720955","0.61720955","0.61705697","0.61701906","0.61327624","0.61058617","0.6089856","0.60706997","0.6064289","0.60605884","0.6060254","0.6044793","0.60443103","0.6025632","0.6024497","0.6004558","0.5996323","0.59844005","0.5978183","0.5945097","0.59371924","0.59191114","0.5902455","0.58900607","0.5874524","0.5867122","0.58668286","0.58668286","0.58553886","0.58549976","0.5845742","0.58452636","0.58392817","0.5819086","0.5790499","0.5786983","0.57841724","0.57841724","0.57841724","0.57841724","0.5778774","0.57762915","0.5768052","0.57629234","0.5745028","0.57355803","0.57341474","0.5730678","0.57276666","0.5727472","0.5726741","0.5723196","0.5700075","0.5689483","0.568717","0.56825423","0.5682135","0.5665188","0.56594765","0.5654654","0.5648013","0.5639657","0.56337845","0.56318176","0.563108","0.5623548","0.56176","0.5614621","0.5614621","0.5614621","0.5614105"],"string":"[\n \"0.72779673\",\n \"0.7046692\",\n \"0.7046692\",\n \"0.7046692\",\n \"0.6990083\",\n \"0.6905413\",\n \"0.67326444\",\n \"0.67326444\",\n \"0.67116404\",\n \"0.67000073\",\n \"0.6659789\",\n \"0.66423845\",\n \"0.657657\",\n \"0.65723705\",\n \"0.6571265\",\n \"0.6539489\",\n \"0.6527483\",\n \"0.64475584\",\n \"0.6434517\",\n \"0.6281322\",\n \"0.62673676\",\n \"0.6255409\",\n \"0.6231226\",\n \"0.6207303\",\n \"0.6203103\",\n \"0.61984956\",\n \"0.61984956\",\n \"0.61984956\",\n \"0.6195434\",\n \"0.61948794\",\n \"0.61720955\",\n \"0.61720955\",\n \"0.61705697\",\n \"0.61701906\",\n \"0.61327624\",\n \"0.61058617\",\n \"0.6089856\",\n \"0.60706997\",\n \"0.6064289\",\n \"0.60605884\",\n \"0.6060254\",\n \"0.6044793\",\n \"0.60443103\",\n \"0.6025632\",\n \"0.6024497\",\n \"0.6004558\",\n \"0.5996323\",\n \"0.59844005\",\n \"0.5978183\",\n \"0.5945097\",\n \"0.59371924\",\n \"0.59191114\",\n \"0.5902455\",\n \"0.58900607\",\n \"0.5874524\",\n \"0.5867122\",\n \"0.58668286\",\n \"0.58668286\",\n \"0.58553886\",\n \"0.58549976\",\n \"0.5845742\",\n \"0.58452636\",\n \"0.58392817\",\n \"0.5819086\",\n \"0.5790499\",\n \"0.5786983\",\n \"0.57841724\",\n \"0.57841724\",\n \"0.57841724\",\n \"0.57841724\",\n \"0.5778774\",\n \"0.57762915\",\n \"0.5768052\",\n \"0.57629234\",\n \"0.5745028\",\n \"0.57355803\",\n \"0.57341474\",\n \"0.5730678\",\n \"0.57276666\",\n \"0.5727472\",\n \"0.5726741\",\n \"0.5723196\",\n \"0.5700075\",\n \"0.5689483\",\n \"0.568717\",\n \"0.56825423\",\n \"0.5682135\",\n \"0.5665188\",\n \"0.56594765\",\n \"0.5654654\",\n \"0.5648013\",\n \"0.5639657\",\n \"0.56337845\",\n \"0.56318176\",\n \"0.563108\",\n \"0.5623548\",\n \"0.56176\",\n \"0.5614621\",\n \"0.5614621\",\n \"0.5614621\",\n \"0.5614105\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":188,"cells":{"query":{"kind":"string","value":"getData is used to get satellite json data from the server."},"document":{"kind":"string","value":"def getStats(self, url: str, latitude: list,\n longitude: list, satellite='l8', index='ndvi'):\n\n if type(latitude) is not list:\n latitude = [str(latitude)]\n else:\n latitude = [str(l) for l in latitude]\n\n if type(longitude) is not list:\n longitude = [str(longitude)]\n else:\n longitude = [str(l) for l in longitude]\n\n param = {\n 'url': url,\n 'x': ','.join(longitude),\n 'y': ','.join(latitude),\n 'satellite': satellite,\n 'index': index\n }\n\n try:\n response = requests.get(url=self.statsEndpoint, params=param)\n except Exception as e:\n raise exceptions(\n 'Unable to reach to statistics endpoint. Error: {}'.format(e))\n\n return response.json()"},"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_data():\n pass","def get_data():\n pass","def get_data():\n pass","def get_data():\n pass","def get_data():\n return","def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n return data","def get_data(self):\n pass","def get_data(self):\n pass","def get_data(self, url):\n return self.get(url).get('data', [])","def get(self, data):\n pass","def get_data(self):\r\n pass","def get(self, data):\n ret = self._rest_call({}, 'GET')\n return json.loads(ret[2])","def get_data():\n try:\n response = requests.get(uri)\n json_data = response.json()\n except ValueError as e:\n print(e)\n except TypeError as e:\n print(e)\n return json_data","def get_data(self):","def get_data(self):\n return self.data.to_json()","def get_sdata(self):\n payload = self.get('data_request?id=sdata&output_format=json')\n return payload","def get_json_data():\n return None","def _get_data(self):\n raise NotImplementedError()","def get_velib_data():\n api_url = \"https://api.jcdecaux.com/vls/v1/\"\n query_string = \"stations?contract=Paris&apiKey=\"\n api_key = \"ec29d3b17e5162e1459aaad45cddfe74fe832379\"\n my_url = api_url + query_string + api_key\n\n urlobj = URL.urlopen(my_url)\n data = json.load(urlobj)\n# data = urlobj.read()\n# help(data)\n return data","async def stations_data():\n with open(\"/data/station_data.json\") as j:\n data = json.load(j)\n return data","def get_data():\n string = open('Tinder/static/data/data.json').read()\n return flask.jsonify(json.loads(string))","def get_data(self):\n raise NotImplementedError(\"Not implemented!\")","def getStationData(self):\n dtime = datetime.strptime(self.refTime, \"%y%m%d/%H%M\")\n trange = TimeRange()\n trange.setStart(dtime)\n trange.setEnd(dtime)\n dataTime = DataTime(refTime=dtime, validPeriod=trange)\n req = StationDataRequest()\n req.setPluginName(self.pluginName)\n req.setStationId(self.stationId)\n req.setRefTime(dataTime)\n req.setParmList(self.parmList)\n req.setPartNumber(self.partNumber)\n resp = self.client.sendRequest(req)\n\n for i, rec in enumerate(resp):\n resp[i] = {\n key.decode() if isinstance(key, bytes) else key:\n val.decode() if isinstance(val, bytes) else val\n for key, val in rec.items()\n }\n\n return resp","def get_data(self): # TODO: add smooth possibility\n return self.data","async def get_data(self, path: str) -> Dict:\n # function accepts paths that start with / and also path that do not start with /\n if path.startswith(\"/\"):\n path = path[1:]\n try:\n async with aiohttp.ClientSession() as session:\n async with session.get(f\"{self._opa_url}/data/{path}\") as opa_response:\n return await opa_response.json()\n except aiohttp.ClientError as e:\n logger.warning(\"Opa connection error: {err}\", err=e)\n raise","def get_data(self):\n return self.data","def get_data(self):\n return self.data","def get_data(self):\n return self.data","def get_data(self):\n\n raise NotImplementedError('''\n Must Implement get_data. Call help() for details.\n ''')","def getData(self, local_cache):","def getData(self):\n return self.data","def getData(self):\n return self.data","def getDatafromWebService(self,region, station, start_date, end_date):\n #construct filename in the format \"region_station_startdate_enddate.json\" with no spaces and \"-\"\n \"\"\"\n filename = region + \"_\" + station+ \"_\" + start_date + \"_\" + end_date + \".json\"\n filename = filename.replace(\" \",\"\")\n filename = filename.replace(\"-\",\"\")\n print (\"filename: \"+filename)\n \"\"\"\n #date format for getting data from web service = yy/mm/dd\n obj = RegionData()\n stationcode = obj.getStaionCode(region, station)\n newStart_Date = datetime.datetime.strptime(start_date, \"%m/%d/%Y\").strftime(\"%Y-%m-%d\")\n newEnd_Date = datetime.datetime.strptime(end_date, \"%m/%d/%Y\").strftime(\"%Y-%m-%d\")\n\n server = SOAPpy.SOAPProxy(\"http://cdmo.baruch.sc.edu/webservices2/requests.cfc?wsdl\")\n\n #stationcode=\"pdbjewq\"\n responsedata = server.exportAllParamsDateRangeXMLNew(stationcode, newStart_Date, newEnd_Date,'*')\n #responsedata = server.exportAllParamsDateRangeXMLNew('pdbjewq','2014-12-30', '2014-12-31', '*')\n\n # print responsedata\n pythonObject = SOAPpy.Types.simplify(responsedata)\n #jsonObject = json.dumps(pythonObject)\n #assert type(jsonObject) == str\n dataArray = pythonObject[\"returnData\"][\"data\"] # returns { [{...},{....},.....]}\n\n #data from webservice has date format mm/dd/yy = 12/31/2014\n #print(dataArray)\n\n return json.dumps(dataArray)\n \"\"\"\n print (dataArray)\n self.dataToJson(dataArray, filename) # store the data into a json file\n #store data into rawdata collection\n \n rawObj =RawData()\n rawObj.insertRawStationData(region,station,start_date,end_date,dataArray)\n \n #return filename # return the json filename where data is stored\n \"\"\"","def get_data(link):\n data = re.get(link)\n jsondata = data.json()\n for weatherstation in jsondata['weatherStations']:\n FetchandStore.sensordict.update({weatherstation[\"id\"]:weatherstation[\"sensorValues\"]})\n for sensorvalue in weatherstation[\"sensorValues\"]:\n FetchandStore.sensors.append({\"id\": sensorvalue[\"roadStationId\"], \"name\": sensorvalue[\"oldName\"],\n \"value\": sensorvalue[\"sensorValue\"], \"unit\": sensorvalue[\"sensorUnit\"],\n \"datetime\": sensorvalue[\"measuredTime\"]})\n return FetchandStore.sensors","def getTheData(self, dev):\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"getTheData FrontViewAPI method called.\")\n\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Download\")\n try:\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\n r = requests.get(url,timeout=5)\n result = r.json()\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Result:\" + unicode(result))\n self.WaitInterval = 1\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Online\")\n dev.setErrorStateOnServer(None)\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n return result\n\n except Exception as error:\n\n indigo.server.log(u\"Error connecting to Device:\" + dev.name)\n self.WaitInterval = 60\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Device is offline. No data to return. \")\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\"Offline\")\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n dev.setErrorStateOnServer(u'Offline')\n result = \"\"\n return result","def getData(language=None):","def download():\n toydata = requests.get(DATA_URL).json()\n return toydata","def get_data_from_web():\n pass","def _request_data(self, url):\n connection = httplib.HTTPConnection(self.url)\n connection.request(\"GET\", url)\n response = connection.getresponse()\n\n if response.status != 200:\n raise Exception(response.reason)\n\n data = response.read()\n response.close()\n\n return json.loads(data)","def get_data(self):\n\n self.set_query_string()\n self.realtime_data = super().get_data()\n self.set_coordinate()\n return self.realtime_data","def get_data(self, out_format: str='json'):\n if self.data:\n return self.data\n self.data_ready = self.check_available()\n if not self.data_ready:\n raise DataNotReady(\"The run {} has not yet finished, data not available yet.\".format(self))\n resp = self.ph.conn.request(\n 'GET', self.ph.URLS['getdata'].format(self.run_token), dict(api_key=self.ph.api_key, format=out_format))\n data = resp.data.decode('utf-8')\n self.data = self.parse_json_data(data)\n return self.data","def get_data(self):\n return self.parsed_data","def data():\n return volumes_fetchers.get_json_data()","def get_data():\n try:\n with open(CONS[\"OUTPUT_FILE\"], \"r\") as file:\n data = json.load(file)[1]\n return data\n except FileNotFoundError:\n print(\"Data file not found.\")\n exit()","def data(self):\n return json.loads(self.data_json)","def getData(self):\r\n return self._data","def getData(url):\n data = ''\n request = urllib2.Request(url, headers={\"Accept\": \"application/json\"})\n try:\n data = json.loads(urllib2.urlopen(request).read())\n except urllib2.HTTPError, e:\n raise Exception(\"HTTP error: %d\" % e.code)\n except urllib2.URLError, e:\n raise Exception(\"Network error: %s\" % e.reason.args[1])\n\n return data","def get(self):\r\n return self.data","def get_data(self, state=None, request=None):\n raise NotImplementedError","def getData(self):\n return self.__data","def fetch_data(data_url):\n return requests.get(data_url).content","def get_data(self):\n return DataGatherer().get_rainfall_data()","def getData(eUrl, eToken):\n if eUrl == '' or eToken == '':\n print(\"Enviroment is not setup\")\n exit(1)\n\n with urllib.request.urlopen(eUrl + eToken) as url:\n data = json.loads(url.read().decode())\n\n return(data)","def get_data(self):\n return DataGatherer().get_wind_data()","def get_data():\n try:\n with open('./data.json') as data_file:\n return json.load(data_file)\n except:\n data_json = json.loads('{\"message\": \"Error with file data.json\", \"success\": false}')\n return data_json","def getData(tme=currentTime):\n # attempts request 10 times\n for attempt in range(10):\n try:\n # make a request to the url and return it in json format\n url = \"https://api.darksky.net/forecast/%s/%s,%s,%s?exclude=minutely,hourly,daily,alerts,flags\" % (API_KEY, LAT, LNG, tme)\n return get(url).json()\n except:\n # Wait .05 seconds and try again\n sleep(.05)\n pass","def getData(self):\n return self._data","def getData(self):\n return self._data","def GetGeData(self, *args, **kwargs):\n pass","def getStockData():\n pass","def download_data(self, format = 'srt'):\n resp, content = httplib2.Http(\".cache\").request(self.url, \"GET\")\n suburl = json.loads(content)['url']\n resp, content = httplib2.Http(\".cache\").request(suburl, \"GET\")\n\n return content","def get_path_data(self, path):\n url = self.api_server + path\n return self.get_url_data(url)","def data():\n return None","def GetData(self):\r\n \r\n return self._data","def getData():\n data = {\n \"name\": \"Kim\",\n \"message\": \"Hello there!\"\n }\n return jsonify(data) # respond to the API caller with a JSON representation of data. jsonify is important, as it sets response headers that indicate the respose is in JSON as well","def get_data(self, url):\n\n req = urllib2.Request(url)\n # urlencode the query dictionary\n try:\n r = urllib2.urlopen(req)\n result = r.read()\n except:\n result = 'The url: %s is not responding.' % (url)\n return result","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get(self):\n return self.data","def get(self):\n return self.get_data()","def get_data(self, request, url):\n data = request.get(endpoint=url)\n return data[0], data[1]","def get_data(self):\n self._send_command(self._adapter.get_data())","def stations():\n print(\"server received request for stations data...\")\n return jsonify(stations_data)","def get_data(self, label: str) -> Any:\r\n return self._get_resource(label, self._data, \"data\")","def get_data(self):\n with open(self.filepath, 'r') as openFile:\n data = json.load(openFile)\n logging.info('Loaded JSON data file.')\n return data","def apicall():\r\n# try:\r\n print request.get_json()\r\n test_json = request.get_json()\r\n logger.info(\"input json object loaded\")\r\n logger.info(test_json)\r\n k=MetaData(test_json)\r\n int_res=k.getData()\r\n print '------------------------------'\r\n print int_res\r\n return jsonify(int_res)","def get_data(self):\n return self.topo_data_flattened","def get_data():\n if not hasattr(g, 'data'):\n g.data = load_data()\n return g.data","def fetch_data(self):","def GetData():\r\n return _hiew.HiewGate_GetData()","def get(self):\n city = str(request.args.get('city')) ## /?city=stockholm\n source = urllib.request.urlopen('http://127.0.0.1:5050/?city=' + city).read()\n data = json.loads(source)\n print(data)\n tempinc = {\"name\" : (str(data['name'])),\n \"country\" : (str(data['country'])),\n \"temp\" : (str(data['temp']))+' c'}\n return tempinc","def _get_data_file(self, data_path):\n\n return json.load(open(data_path))","async def get_data(self, endpoint):\n try:\n with async_timeout.timeout(5, loop=self._loop):\n response = await self._session.get(f\"{endpoint}\")\n\n _LOGGER.debug(\"Response from Dingz device: %s\", response.status)\n self.data = await response.json()\n _LOGGER.debug(self.data)\n except (asyncio.TimeoutError, aiohttp.ClientError):\n _LOGGER.error(\"Can not load data from Dingz device\")\n self.data = None\n raise exceptions.DingzConnectionError()","def _extract_data(self):\n if self.URL_type == \"youtube\" or self.URL_type == \"ytmusic\":\n self._get_youtube_data_url()\n elif self.URL_type == \"soundcloud\":\n self._get_soundcloud_data()","def get_url_data(self, url):\n # print \"opening: \" + url\n request = urllib2.Request(url)\n base64string = '%s:%s' % (self.username, self.key)\n request.add_header(\"Authorization\", \"ApiKey %s\" % base64string)\n response = urllib2.urlopen(request)\n data = json.loads(response.read())\n return data","def _fetch_data(self):\n pass","def data(self):\n self._get_latest_content()\n return self._data.get('data', {})","def get(self):\n data = request.args.get('data')\n\n if not data:\n data = \"OK!\"\n\n return json.loads(dumps(data)), 200","def data(self):\n return self._data","def data(self):\n file_name = join(PARENT_BASE_DIR, '.files', 'data.data.json')\n if isfile(file_name):\n debug(f'{file_name} file is exist.')\n debug(f'try for load {file_name} file ->->->->->->->->->->')\n start_load_file = time()\n with open(file_name, 'r', encoding='utf-8')as file:\n data = file.read()\n data = loads(data)\n debug(f'load file - [runtime: {time() - start_load_file}] <-<-<-<-<-<-<-<-<-<-')\n return data, 'data exist.'\n else:\n debug(f'{file_name} file is not exist.')\n return None, 'data not exist in \"base directory/.files/data.data.json\"'","def get_data(self, lat=53.3498, lon=-6.2603):\n r = requests.get(\n f\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\")\n return r.text","def get_data(self):\n return DataGatherer().get_temperature_data()","def getData(self, product, variables, attributes, variable, *args):\r\n\r\n data = None\r\n return data","def getAllData(self):\r\n return self.data","def get_data(self, body):\n params = json.loads(body)\n logger.debug('New Data Format')\n return self._get_data(body)","def get_data(self):\n\n return self._data","def get_data(self):\n\n return self._data","def get_data(self):\n\n return self._data","def stationdata():\n # * Return a JSON list of stations from the dataset.\n # as this should be a list, I'm just grabbing the station name\n session = Session(engine)\n results = session.query(Station.name).all()\n session.close()\n\n stations = list(np.ravel(results))\n return jsonify(stations)"],"string":"[\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n return\",\n \"def _get_data(self, url: str)->dict:\\n data = None\\n resp = self._get(url)\\n if resp:\\n data = resp.json()['data']\\n return data\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self, url):\\n return self.get(url).get('data', [])\",\n \"def get(self, data):\\n pass\",\n \"def get_data(self):\\r\\n pass\",\n \"def get(self, data):\\n ret = self._rest_call({}, 'GET')\\n return json.loads(ret[2])\",\n \"def get_data():\\n try:\\n response = requests.get(uri)\\n json_data = response.json()\\n except ValueError as e:\\n print(e)\\n except TypeError as e:\\n print(e)\\n return json_data\",\n \"def get_data(self):\",\n \"def get_data(self):\\n return self.data.to_json()\",\n \"def get_sdata(self):\\n payload = self.get('data_request?id=sdata&output_format=json')\\n return payload\",\n \"def get_json_data():\\n return None\",\n \"def _get_data(self):\\n raise NotImplementedError()\",\n \"def get_velib_data():\\n api_url = \\\"https://api.jcdecaux.com/vls/v1/\\\"\\n query_string = \\\"stations?contract=Paris&apiKey=\\\"\\n api_key = \\\"ec29d3b17e5162e1459aaad45cddfe74fe832379\\\"\\n my_url = api_url + query_string + api_key\\n\\n urlobj = URL.urlopen(my_url)\\n data = json.load(urlobj)\\n# data = urlobj.read()\\n# help(data)\\n return data\",\n \"async def stations_data():\\n with open(\\\"/data/station_data.json\\\") as j:\\n data = json.load(j)\\n return data\",\n \"def get_data():\\n string = open('Tinder/static/data/data.json').read()\\n return flask.jsonify(json.loads(string))\",\n \"def get_data(self):\\n raise NotImplementedError(\\\"Not implemented!\\\")\",\n \"def getStationData(self):\\n dtime = datetime.strptime(self.refTime, \\\"%y%m%d/%H%M\\\")\\n trange = TimeRange()\\n trange.setStart(dtime)\\n trange.setEnd(dtime)\\n dataTime = DataTime(refTime=dtime, validPeriod=trange)\\n req = StationDataRequest()\\n req.setPluginName(self.pluginName)\\n req.setStationId(self.stationId)\\n req.setRefTime(dataTime)\\n req.setParmList(self.parmList)\\n req.setPartNumber(self.partNumber)\\n resp = self.client.sendRequest(req)\\n\\n for i, rec in enumerate(resp):\\n resp[i] = {\\n key.decode() if isinstance(key, bytes) else key:\\n val.decode() if isinstance(val, bytes) else val\\n for key, val in rec.items()\\n }\\n\\n return resp\",\n \"def get_data(self): # TODO: add smooth possibility\\n return self.data\",\n \"async def get_data(self, path: str) -> Dict:\\n # function accepts paths that start with / and also path that do not start with /\\n if path.startswith(\\\"/\\\"):\\n path = path[1:]\\n try:\\n async with aiohttp.ClientSession() as session:\\n async with session.get(f\\\"{self._opa_url}/data/{path}\\\") as opa_response:\\n return await opa_response.json()\\n except aiohttp.ClientError as e:\\n logger.warning(\\\"Opa connection error: {err}\\\", err=e)\\n raise\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n\\n raise NotImplementedError('''\\n Must Implement get_data. Call help() for details.\\n ''')\",\n \"def getData(self, local_cache):\",\n \"def getData(self):\\n return self.data\",\n \"def getData(self):\\n return self.data\",\n \"def getDatafromWebService(self,region, station, start_date, end_date):\\n #construct filename in the format \\\"region_station_startdate_enddate.json\\\" with no spaces and \\\"-\\\"\\n \\\"\\\"\\\"\\n filename = region + \\\"_\\\" + station+ \\\"_\\\" + start_date + \\\"_\\\" + end_date + \\\".json\\\"\\n filename = filename.replace(\\\" \\\",\\\"\\\")\\n filename = filename.replace(\\\"-\\\",\\\"\\\")\\n print (\\\"filename: \\\"+filename)\\n \\\"\\\"\\\"\\n #date format for getting data from web service = yy/mm/dd\\n obj = RegionData()\\n stationcode = obj.getStaionCode(region, station)\\n newStart_Date = datetime.datetime.strptime(start_date, \\\"%m/%d/%Y\\\").strftime(\\\"%Y-%m-%d\\\")\\n newEnd_Date = datetime.datetime.strptime(end_date, \\\"%m/%d/%Y\\\").strftime(\\\"%Y-%m-%d\\\")\\n\\n server = SOAPpy.SOAPProxy(\\\"http://cdmo.baruch.sc.edu/webservices2/requests.cfc?wsdl\\\")\\n\\n #stationcode=\\\"pdbjewq\\\"\\n responsedata = server.exportAllParamsDateRangeXMLNew(stationcode, newStart_Date, newEnd_Date,'*')\\n #responsedata = server.exportAllParamsDateRangeXMLNew('pdbjewq','2014-12-30', '2014-12-31', '*')\\n\\n # print responsedata\\n pythonObject = SOAPpy.Types.simplify(responsedata)\\n #jsonObject = json.dumps(pythonObject)\\n #assert type(jsonObject) == str\\n dataArray = pythonObject[\\\"returnData\\\"][\\\"data\\\"] # returns { [{...},{....},.....]}\\n\\n #data from webservice has date format mm/dd/yy = 12/31/2014\\n #print(dataArray)\\n\\n return json.dumps(dataArray)\\n \\\"\\\"\\\"\\n print (dataArray)\\n self.dataToJson(dataArray, filename) # store the data into a json file\\n #store data into rawdata collection\\n \\n rawObj =RawData()\\n rawObj.insertRawStationData(region,station,start_date,end_date,dataArray)\\n \\n #return filename # return the json filename where data is stored\\n \\\"\\\"\\\"\",\n \"def get_data(link):\\n data = re.get(link)\\n jsondata = data.json()\\n for weatherstation in jsondata['weatherStations']:\\n FetchandStore.sensordict.update({weatherstation[\\\"id\\\"]:weatherstation[\\\"sensorValues\\\"]})\\n for sensorvalue in weatherstation[\\\"sensorValues\\\"]:\\n FetchandStore.sensors.append({\\\"id\\\": sensorvalue[\\\"roadStationId\\\"], \\\"name\\\": sensorvalue[\\\"oldName\\\"],\\n \\\"value\\\": sensorvalue[\\\"sensorValue\\\"], \\\"unit\\\": sensorvalue[\\\"sensorUnit\\\"],\\n \\\"datetime\\\": sensorvalue[\\\"measuredTime\\\"]})\\n return FetchandStore.sensors\",\n \"def getTheData(self, dev):\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"getTheData FrontViewAPI method called.\\\")\\n\\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Download\\\")\\n try:\\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\\n r = requests.get(url,timeout=5)\\n result = r.json()\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Result:\\\" + unicode(result))\\n self.WaitInterval = 1\\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Online\\\")\\n dev.setErrorStateOnServer(None)\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n return result\\n\\n except Exception as error:\\n\\n indigo.server.log(u\\\"Error connecting to Device:\\\" + dev.name)\\n self.WaitInterval = 60\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Device is offline. No data to return. \\\")\\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\\\"Offline\\\")\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n dev.setErrorStateOnServer(u'Offline')\\n result = \\\"\\\"\\n return result\",\n \"def getData(language=None):\",\n \"def download():\\n toydata = requests.get(DATA_URL).json()\\n return toydata\",\n \"def get_data_from_web():\\n pass\",\n \"def _request_data(self, url):\\n connection = httplib.HTTPConnection(self.url)\\n connection.request(\\\"GET\\\", url)\\n response = connection.getresponse()\\n\\n if response.status != 200:\\n raise Exception(response.reason)\\n\\n data = response.read()\\n response.close()\\n\\n return json.loads(data)\",\n \"def get_data(self):\\n\\n self.set_query_string()\\n self.realtime_data = super().get_data()\\n self.set_coordinate()\\n return self.realtime_data\",\n \"def get_data(self, out_format: str='json'):\\n if self.data:\\n return self.data\\n self.data_ready = self.check_available()\\n if not self.data_ready:\\n raise DataNotReady(\\\"The run {} has not yet finished, data not available yet.\\\".format(self))\\n resp = self.ph.conn.request(\\n 'GET', self.ph.URLS['getdata'].format(self.run_token), dict(api_key=self.ph.api_key, format=out_format))\\n data = resp.data.decode('utf-8')\\n self.data = self.parse_json_data(data)\\n return self.data\",\n \"def get_data(self):\\n return self.parsed_data\",\n \"def data():\\n return volumes_fetchers.get_json_data()\",\n \"def get_data():\\n try:\\n with open(CONS[\\\"OUTPUT_FILE\\\"], \\\"r\\\") as file:\\n data = json.load(file)[1]\\n return data\\n except FileNotFoundError:\\n print(\\\"Data file not found.\\\")\\n exit()\",\n \"def data(self):\\n return json.loads(self.data_json)\",\n \"def getData(self):\\r\\n return self._data\",\n \"def getData(url):\\n data = ''\\n request = urllib2.Request(url, headers={\\\"Accept\\\": \\\"application/json\\\"})\\n try:\\n data = json.loads(urllib2.urlopen(request).read())\\n except urllib2.HTTPError, e:\\n raise Exception(\\\"HTTP error: %d\\\" % e.code)\\n except urllib2.URLError, e:\\n raise Exception(\\\"Network error: %s\\\" % e.reason.args[1])\\n\\n return data\",\n \"def get(self):\\r\\n return self.data\",\n \"def get_data(self, state=None, request=None):\\n raise NotImplementedError\",\n \"def getData(self):\\n return self.__data\",\n \"def fetch_data(data_url):\\n return requests.get(data_url).content\",\n \"def get_data(self):\\n return DataGatherer().get_rainfall_data()\",\n \"def getData(eUrl, eToken):\\n if eUrl == '' or eToken == '':\\n print(\\\"Enviroment is not setup\\\")\\n exit(1)\\n\\n with urllib.request.urlopen(eUrl + eToken) as url:\\n data = json.loads(url.read().decode())\\n\\n return(data)\",\n \"def get_data(self):\\n return DataGatherer().get_wind_data()\",\n \"def get_data():\\n try:\\n with open('./data.json') as data_file:\\n return json.load(data_file)\\n except:\\n data_json = json.loads('{\\\"message\\\": \\\"Error with file data.json\\\", \\\"success\\\": false}')\\n return data_json\",\n \"def getData(tme=currentTime):\\n # attempts request 10 times\\n for attempt in range(10):\\n try:\\n # make a request to the url and return it in json format\\n url = \\\"https://api.darksky.net/forecast/%s/%s,%s,%s?exclude=minutely,hourly,daily,alerts,flags\\\" % (API_KEY, LAT, LNG, tme)\\n return get(url).json()\\n except:\\n # Wait .05 seconds and try again\\n sleep(.05)\\n pass\",\n \"def getData(self):\\n return self._data\",\n \"def getData(self):\\n return self._data\",\n \"def GetGeData(self, *args, **kwargs):\\n pass\",\n \"def getStockData():\\n pass\",\n \"def download_data(self, format = 'srt'):\\n resp, content = httplib2.Http(\\\".cache\\\").request(self.url, \\\"GET\\\")\\n suburl = json.loads(content)['url']\\n resp, content = httplib2.Http(\\\".cache\\\").request(suburl, \\\"GET\\\")\\n\\n return content\",\n \"def get_path_data(self, path):\\n url = self.api_server + path\\n return self.get_url_data(url)\",\n \"def data():\\n return None\",\n \"def GetData(self):\\r\\n \\r\\n return self._data\",\n \"def getData():\\n data = {\\n \\\"name\\\": \\\"Kim\\\",\\n \\\"message\\\": \\\"Hello there!\\\"\\n }\\n return jsonify(data) # respond to the API caller with a JSON representation of data. jsonify is important, as it sets response headers that indicate the respose is in JSON as well\",\n \"def get_data(self, url):\\n\\n req = urllib2.Request(url)\\n # urlencode the query dictionary\\n try:\\n r = urllib2.urlopen(req)\\n result = r.read()\\n except:\\n result = 'The url: %s is not responding.' % (url)\\n return result\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get(self):\\n return self.data\",\n \"def get(self):\\n return self.get_data()\",\n \"def get_data(self, request, url):\\n data = request.get(endpoint=url)\\n return data[0], data[1]\",\n \"def get_data(self):\\n self._send_command(self._adapter.get_data())\",\n \"def stations():\\n print(\\\"server received request for stations data...\\\")\\n return jsonify(stations_data)\",\n \"def get_data(self, label: str) -> Any:\\r\\n return self._get_resource(label, self._data, \\\"data\\\")\",\n \"def get_data(self):\\n with open(self.filepath, 'r') as openFile:\\n data = json.load(openFile)\\n logging.info('Loaded JSON data file.')\\n return data\",\n \"def apicall():\\r\\n# try:\\r\\n print request.get_json()\\r\\n test_json = request.get_json()\\r\\n logger.info(\\\"input json object loaded\\\")\\r\\n logger.info(test_json)\\r\\n k=MetaData(test_json)\\r\\n int_res=k.getData()\\r\\n print '------------------------------'\\r\\n print int_res\\r\\n return jsonify(int_res)\",\n \"def get_data(self):\\n return self.topo_data_flattened\",\n \"def get_data():\\n if not hasattr(g, 'data'):\\n g.data = load_data()\\n return g.data\",\n \"def fetch_data(self):\",\n \"def GetData():\\r\\n return _hiew.HiewGate_GetData()\",\n \"def get(self):\\n city = str(request.args.get('city')) ## /?city=stockholm\\n source = urllib.request.urlopen('http://127.0.0.1:5050/?city=' + city).read()\\n data = json.loads(source)\\n print(data)\\n tempinc = {\\\"name\\\" : (str(data['name'])),\\n \\\"country\\\" : (str(data['country'])),\\n \\\"temp\\\" : (str(data['temp']))+' c'}\\n return tempinc\",\n \"def _get_data_file(self, data_path):\\n\\n return json.load(open(data_path))\",\n \"async def get_data(self, endpoint):\\n try:\\n with async_timeout.timeout(5, loop=self._loop):\\n response = await self._session.get(f\\\"{endpoint}\\\")\\n\\n _LOGGER.debug(\\\"Response from Dingz device: %s\\\", response.status)\\n self.data = await response.json()\\n _LOGGER.debug(self.data)\\n except (asyncio.TimeoutError, aiohttp.ClientError):\\n _LOGGER.error(\\\"Can not load data from Dingz device\\\")\\n self.data = None\\n raise exceptions.DingzConnectionError()\",\n \"def _extract_data(self):\\n if self.URL_type == \\\"youtube\\\" or self.URL_type == \\\"ytmusic\\\":\\n self._get_youtube_data_url()\\n elif self.URL_type == \\\"soundcloud\\\":\\n self._get_soundcloud_data()\",\n \"def get_url_data(self, url):\\n # print \\\"opening: \\\" + url\\n request = urllib2.Request(url)\\n base64string = '%s:%s' % (self.username, self.key)\\n request.add_header(\\\"Authorization\\\", \\\"ApiKey %s\\\" % base64string)\\n response = urllib2.urlopen(request)\\n data = json.loads(response.read())\\n return data\",\n \"def _fetch_data(self):\\n pass\",\n \"def data(self):\\n self._get_latest_content()\\n return self._data.get('data', {})\",\n \"def get(self):\\n data = request.args.get('data')\\n\\n if not data:\\n data = \\\"OK!\\\"\\n\\n return json.loads(dumps(data)), 200\",\n \"def data(self):\\n return self._data\",\n \"def data(self):\\n file_name = join(PARENT_BASE_DIR, '.files', 'data.data.json')\\n if isfile(file_name):\\n debug(f'{file_name} file is exist.')\\n debug(f'try for load {file_name} file ->->->->->->->->->->')\\n start_load_file = time()\\n with open(file_name, 'r', encoding='utf-8')as file:\\n data = file.read()\\n data = loads(data)\\n debug(f'load file - [runtime: {time() - start_load_file}] <-<-<-<-<-<-<-<-<-<-')\\n return data, 'data exist.'\\n else:\\n debug(f'{file_name} file is not exist.')\\n return None, 'data not exist in \\\"base directory/.files/data.data.json\\\"'\",\n \"def get_data(self, lat=53.3498, lon=-6.2603):\\n r = requests.get(\\n f\\\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\\\")\\n return r.text\",\n \"def get_data(self):\\n return DataGatherer().get_temperature_data()\",\n \"def getData(self, product, variables, attributes, variable, *args):\\r\\n\\r\\n data = None\\r\\n return data\",\n \"def getAllData(self):\\r\\n return self.data\",\n \"def get_data(self, body):\\n params = json.loads(body)\\n logger.debug('New Data Format')\\n return self._get_data(body)\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def stationdata():\\n # * Return a JSON list of stations from the dataset.\\n # as this should be a list, I'm just grabbing the station name\\n session = Session(engine)\\n results = session.query(Station.name).all()\\n session.close()\\n\\n stations = list(np.ravel(results))\\n return jsonify(stations)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72779673","0.7046692","0.7046692","0.7046692","0.6990083","0.6905413","0.67326444","0.67326444","0.67116404","0.67000073","0.6659789","0.66423845","0.657657","0.65723705","0.6571265","0.6539489","0.6527483","0.64475584","0.6434517","0.6281322","0.62673676","0.6255409","0.6231226","0.6207303","0.6203103","0.61984956","0.61984956","0.61984956","0.6195434","0.61948794","0.61720955","0.61720955","0.61705697","0.61701906","0.61327624","0.61058617","0.6089856","0.60706997","0.6064289","0.60605884","0.6060254","0.6044793","0.60443103","0.6025632","0.6024497","0.6004558","0.5996323","0.59844005","0.5978183","0.5945097","0.59371924","0.59191114","0.5902455","0.58900607","0.5874524","0.5867122","0.58668286","0.58668286","0.58553886","0.58549976","0.5845742","0.58452636","0.58392817","0.5819086","0.5790499","0.5786983","0.57841724","0.57841724","0.57841724","0.57841724","0.5778774","0.57762915","0.5768052","0.57629234","0.5745028","0.57355803","0.57341474","0.5730678","0.57276666","0.5727472","0.5726741","0.5723196","0.5700075","0.5689483","0.568717","0.56825423","0.5682135","0.5665188","0.56594765","0.5654654","0.5648013","0.5639657","0.56337845","0.56318176","0.563108","0.5623548","0.56176","0.5614621","0.5614621","0.5614621","0.5614105"],"string":"[\n \"0.72779673\",\n \"0.7046692\",\n \"0.7046692\",\n \"0.7046692\",\n \"0.6990083\",\n \"0.6905413\",\n \"0.67326444\",\n \"0.67326444\",\n \"0.67116404\",\n \"0.67000073\",\n \"0.6659789\",\n \"0.66423845\",\n \"0.657657\",\n \"0.65723705\",\n \"0.6571265\",\n \"0.6539489\",\n \"0.6527483\",\n \"0.64475584\",\n \"0.6434517\",\n \"0.6281322\",\n \"0.62673676\",\n \"0.6255409\",\n \"0.6231226\",\n \"0.6207303\",\n \"0.6203103\",\n \"0.61984956\",\n \"0.61984956\",\n \"0.61984956\",\n \"0.6195434\",\n \"0.61948794\",\n \"0.61720955\",\n \"0.61720955\",\n \"0.61705697\",\n \"0.61701906\",\n \"0.61327624\",\n \"0.61058617\",\n \"0.6089856\",\n \"0.60706997\",\n \"0.6064289\",\n \"0.60605884\",\n \"0.6060254\",\n \"0.6044793\",\n \"0.60443103\",\n \"0.6025632\",\n \"0.6024497\",\n \"0.6004558\",\n \"0.5996323\",\n \"0.59844005\",\n \"0.5978183\",\n \"0.5945097\",\n \"0.59371924\",\n \"0.59191114\",\n \"0.5902455\",\n \"0.58900607\",\n \"0.5874524\",\n \"0.5867122\",\n \"0.58668286\",\n \"0.58668286\",\n \"0.58553886\",\n \"0.58549976\",\n \"0.5845742\",\n \"0.58452636\",\n \"0.58392817\",\n \"0.5819086\",\n \"0.5790499\",\n \"0.5786983\",\n \"0.57841724\",\n \"0.57841724\",\n \"0.57841724\",\n \"0.57841724\",\n \"0.5778774\",\n \"0.57762915\",\n \"0.5768052\",\n \"0.57629234\",\n \"0.5745028\",\n \"0.57355803\",\n \"0.57341474\",\n \"0.5730678\",\n \"0.57276666\",\n \"0.5727472\",\n \"0.5726741\",\n \"0.5723196\",\n \"0.5700075\",\n \"0.5689483\",\n \"0.568717\",\n \"0.56825423\",\n \"0.5682135\",\n \"0.5665188\",\n \"0.56594765\",\n \"0.5654654\",\n \"0.5648013\",\n \"0.5639657\",\n \"0.56337845\",\n \"0.56318176\",\n \"0.563108\",\n \"0.5623548\",\n \"0.56176\",\n \"0.5614621\",\n \"0.5614621\",\n \"0.5614621\",\n \"0.5614105\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":189,"cells":{"query":{"kind":"string","value":"getData is used to get satellite json data from the server."},"document":{"kind":"string","value":"def getTimelineValue(self, url: str, latitude: float,\n longitude: float, startDate: str, endDate: str,\n minCloudCover=None, maxCloudCover=None,\n minCoverage=None, maxCoverage=None,\n satellite='l8', index='ndvi'):\n\n latitude = str(latitude)\n longitude = str(longitude)\n minCloudCover = self.minCloudCover if minCloudCover is None else minCloudCover\n maxCloudCover = self.maxCloudCover if maxCloudCover is None else maxCloudCover\n minCoverage = self.minCoverage if minCoverage is None else minCoverage\n maxCoverage = self.maxCoverage if maxCoverage is None else maxCoverage\n\n param = {\n 'url': url,\n 'x': str(longitude),\n 'y': str(latitude),\n 'satellite': satellite.lower(),\n 'index': index,\n 'start_date': startDate,\n 'end_date': endDate,\n 'min_cloudcover': int(minCloudCover),\n 'max_cloudcover': int(maxCloudCover),\n 'min_coverage': int(minCoverage),\n 'max_coverage': int(maxCoverage),\n }\n\n try:\n response = requests.get(url=self.timelineValueEndpoint, params=param)\n except Exception as e:\n raise exceptions(\n 'Unable to reach to value endpoint. Error: {}'.format(e))\n\n return response.json()"},"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_data():\n pass","def get_data():\n pass","def get_data():\n pass","def get_data():\n pass","def get_data():\n return","def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n return data","def get_data(self):\n pass","def get_data(self):\n pass","def get_data(self, url):\n return self.get(url).get('data', [])","def get(self, data):\n pass","def get_data(self):\r\n pass","def get(self, data):\n ret = self._rest_call({}, 'GET')\n return json.loads(ret[2])","def get_data():\n try:\n response = requests.get(uri)\n json_data = response.json()\n except ValueError as e:\n print(e)\n except TypeError as e:\n print(e)\n return json_data","def get_data(self):","def get_data(self):\n return self.data.to_json()","def get_sdata(self):\n payload = self.get('data_request?id=sdata&output_format=json')\n return payload","def get_json_data():\n return None","def _get_data(self):\n raise NotImplementedError()","def get_velib_data():\n api_url = \"https://api.jcdecaux.com/vls/v1/\"\n query_string = \"stations?contract=Paris&apiKey=\"\n api_key = \"ec29d3b17e5162e1459aaad45cddfe74fe832379\"\n my_url = api_url + query_string + api_key\n\n urlobj = URL.urlopen(my_url)\n data = json.load(urlobj)\n# data = urlobj.read()\n# help(data)\n return data","async def stations_data():\n with open(\"/data/station_data.json\") as j:\n data = json.load(j)\n return data","def get_data():\n string = open('Tinder/static/data/data.json').read()\n return flask.jsonify(json.loads(string))","def get_data(self):\n raise NotImplementedError(\"Not implemented!\")","def getStationData(self):\n dtime = datetime.strptime(self.refTime, \"%y%m%d/%H%M\")\n trange = TimeRange()\n trange.setStart(dtime)\n trange.setEnd(dtime)\n dataTime = DataTime(refTime=dtime, validPeriod=trange)\n req = StationDataRequest()\n req.setPluginName(self.pluginName)\n req.setStationId(self.stationId)\n req.setRefTime(dataTime)\n req.setParmList(self.parmList)\n req.setPartNumber(self.partNumber)\n resp = self.client.sendRequest(req)\n\n for i, rec in enumerate(resp):\n resp[i] = {\n key.decode() if isinstance(key, bytes) else key:\n val.decode() if isinstance(val, bytes) else val\n for key, val in rec.items()\n }\n\n return resp","def get_data(self): # TODO: add smooth possibility\n return self.data","async def get_data(self, path: str) -> Dict:\n # function accepts paths that start with / and also path that do not start with /\n if path.startswith(\"/\"):\n path = path[1:]\n try:\n async with aiohttp.ClientSession() as session:\n async with session.get(f\"{self._opa_url}/data/{path}\") as opa_response:\n return await opa_response.json()\n except aiohttp.ClientError as e:\n logger.warning(\"Opa connection error: {err}\", err=e)\n raise","def get_data(self):\n return self.data","def get_data(self):\n return self.data","def get_data(self):\n return self.data","def getData(self, local_cache):","def get_data(self):\n\n raise NotImplementedError('''\n Must Implement get_data. Call help() for details.\n ''')","def getData(self):\n return self.data","def getData(self):\n return self.data","def getDatafromWebService(self,region, station, start_date, end_date):\n #construct filename in the format \"region_station_startdate_enddate.json\" with no spaces and \"-\"\n \"\"\"\n filename = region + \"_\" + station+ \"_\" + start_date + \"_\" + end_date + \".json\"\n filename = filename.replace(\" \",\"\")\n filename = filename.replace(\"-\",\"\")\n print (\"filename: \"+filename)\n \"\"\"\n #date format for getting data from web service = yy/mm/dd\n obj = RegionData()\n stationcode = obj.getStaionCode(region, station)\n newStart_Date = datetime.datetime.strptime(start_date, \"%m/%d/%Y\").strftime(\"%Y-%m-%d\")\n newEnd_Date = datetime.datetime.strptime(end_date, \"%m/%d/%Y\").strftime(\"%Y-%m-%d\")\n\n server = SOAPpy.SOAPProxy(\"http://cdmo.baruch.sc.edu/webservices2/requests.cfc?wsdl\")\n\n #stationcode=\"pdbjewq\"\n responsedata = server.exportAllParamsDateRangeXMLNew(stationcode, newStart_Date, newEnd_Date,'*')\n #responsedata = server.exportAllParamsDateRangeXMLNew('pdbjewq','2014-12-30', '2014-12-31', '*')\n\n # print responsedata\n pythonObject = SOAPpy.Types.simplify(responsedata)\n #jsonObject = json.dumps(pythonObject)\n #assert type(jsonObject) == str\n dataArray = pythonObject[\"returnData\"][\"data\"] # returns { [{...},{....},.....]}\n\n #data from webservice has date format mm/dd/yy = 12/31/2014\n #print(dataArray)\n\n return json.dumps(dataArray)\n \"\"\"\n print (dataArray)\n self.dataToJson(dataArray, filename) # store the data into a json file\n #store data into rawdata collection\n \n rawObj =RawData()\n rawObj.insertRawStationData(region,station,start_date,end_date,dataArray)\n \n #return filename # return the json filename where data is stored\n \"\"\"","def get_data(link):\n data = re.get(link)\n jsondata = data.json()\n for weatherstation in jsondata['weatherStations']:\n FetchandStore.sensordict.update({weatherstation[\"id\"]:weatherstation[\"sensorValues\"]})\n for sensorvalue in weatherstation[\"sensorValues\"]:\n FetchandStore.sensors.append({\"id\": sensorvalue[\"roadStationId\"], \"name\": sensorvalue[\"oldName\"],\n \"value\": sensorvalue[\"sensorValue\"], \"unit\": sensorvalue[\"sensorUnit\"],\n \"datetime\": sensorvalue[\"measuredTime\"]})\n return FetchandStore.sensors","def getTheData(self, dev):\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"getTheData FrontViewAPI method called.\")\n\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Download\")\n try:\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\n r = requests.get(url,timeout=5)\n result = r.json()\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Result:\" + unicode(result))\n self.WaitInterval = 1\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Online\")\n dev.setErrorStateOnServer(None)\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n return result\n\n except Exception as error:\n\n indigo.server.log(u\"Error connecting to Device:\" + dev.name)\n self.WaitInterval = 60\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Device is offline. No data to return. \")\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\"Offline\")\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n dev.setErrorStateOnServer(u'Offline')\n result = \"\"\n return result","def getData(language=None):","def download():\n toydata = requests.get(DATA_URL).json()\n return toydata","def get_data_from_web():\n pass","def _request_data(self, url):\n connection = httplib.HTTPConnection(self.url)\n connection.request(\"GET\", url)\n response = connection.getresponse()\n\n if response.status != 200:\n raise Exception(response.reason)\n\n data = response.read()\n response.close()\n\n return json.loads(data)","def get_data(self):\n\n self.set_query_string()\n self.realtime_data = super().get_data()\n self.set_coordinate()\n return self.realtime_data","def get_data(self, out_format: str='json'):\n if self.data:\n return self.data\n self.data_ready = self.check_available()\n if not self.data_ready:\n raise DataNotReady(\"The run {} has not yet finished, data not available yet.\".format(self))\n resp = self.ph.conn.request(\n 'GET', self.ph.URLS['getdata'].format(self.run_token), dict(api_key=self.ph.api_key, format=out_format))\n data = resp.data.decode('utf-8')\n self.data = self.parse_json_data(data)\n return self.data","def get_data(self):\n return self.parsed_data","def data():\n return volumes_fetchers.get_json_data()","def data(self):\n return json.loads(self.data_json)","def get_data():\n try:\n with open(CONS[\"OUTPUT_FILE\"], \"r\") as file:\n data = json.load(file)[1]\n return data\n except FileNotFoundError:\n print(\"Data file not found.\")\n exit()","def getData(self):\r\n return self._data","def getData(url):\n data = ''\n request = urllib2.Request(url, headers={\"Accept\": \"application/json\"})\n try:\n data = json.loads(urllib2.urlopen(request).read())\n except urllib2.HTTPError, e:\n raise Exception(\"HTTP error: %d\" % e.code)\n except urllib2.URLError, e:\n raise Exception(\"Network error: %s\" % e.reason.args[1])\n\n return data","def get(self):\r\n return self.data","def get_data(self, state=None, request=None):\n raise NotImplementedError","def getData(self):\n return self.__data","def fetch_data(data_url):\n return requests.get(data_url).content","def get_data(self):\n return DataGatherer().get_rainfall_data()","def getData(eUrl, eToken):\n if eUrl == '' or eToken == '':\n print(\"Enviroment is not setup\")\n exit(1)\n\n with urllib.request.urlopen(eUrl + eToken) as url:\n data = json.loads(url.read().decode())\n\n return(data)","def get_data(self):\n return DataGatherer().get_wind_data()","def get_data():\n try:\n with open('./data.json') as data_file:\n return json.load(data_file)\n except:\n data_json = json.loads('{\"message\": \"Error with file data.json\", \"success\": false}')\n return data_json","def getData(tme=currentTime):\n # attempts request 10 times\n for attempt in range(10):\n try:\n # make a request to the url and return it in json format\n url = \"https://api.darksky.net/forecast/%s/%s,%s,%s?exclude=minutely,hourly,daily,alerts,flags\" % (API_KEY, LAT, LNG, tme)\n return get(url).json()\n except:\n # Wait .05 seconds and try again\n sleep(.05)\n pass","def getData(self):\n return self._data","def getData(self):\n return self._data","def GetGeData(self, *args, **kwargs):\n pass","def getStockData():\n pass","def download_data(self, format = 'srt'):\n resp, content = httplib2.Http(\".cache\").request(self.url, \"GET\")\n suburl = json.loads(content)['url']\n resp, content = httplib2.Http(\".cache\").request(suburl, \"GET\")\n\n return content","def get_path_data(self, path):\n url = self.api_server + path\n return self.get_url_data(url)","def data():\n return None","def GetData(self):\r\n \r\n return self._data","def getData():\n data = {\n \"name\": \"Kim\",\n \"message\": \"Hello there!\"\n }\n return jsonify(data) # respond to the API caller with a JSON representation of data. jsonify is important, as it sets response headers that indicate the respose is in JSON as well","def get_data(self, url):\n\n req = urllib2.Request(url)\n # urlencode the query dictionary\n try:\n r = urllib2.urlopen(req)\n result = r.read()\n except:\n result = 'The url: %s is not responding.' % (url)\n return result","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get(self):\n return self.data","def get(self):\n return self.get_data()","def get_data(self, request, url):\n data = request.get(endpoint=url)\n return data[0], data[1]","def get_data(self):\n self._send_command(self._adapter.get_data())","def stations():\n print(\"server received request for stations data...\")\n return jsonify(stations_data)","def get_data(self, label: str) -> Any:\r\n return self._get_resource(label, self._data, \"data\")","def get_data(self):\n with open(self.filepath, 'r') as openFile:\n data = json.load(openFile)\n logging.info('Loaded JSON data file.')\n return data","def apicall():\r\n# try:\r\n print request.get_json()\r\n test_json = request.get_json()\r\n logger.info(\"input json object loaded\")\r\n logger.info(test_json)\r\n k=MetaData(test_json)\r\n int_res=k.getData()\r\n print '------------------------------'\r\n print int_res\r\n return jsonify(int_res)","def get_data(self):\n return self.topo_data_flattened","def get_data():\n if not hasattr(g, 'data'):\n g.data = load_data()\n return g.data","def fetch_data(self):","def GetData():\r\n return _hiew.HiewGate_GetData()","def get(self):\n city = str(request.args.get('city')) ## /?city=stockholm\n source = urllib.request.urlopen('http://127.0.0.1:5050/?city=' + city).read()\n data = json.loads(source)\n print(data)\n tempinc = {\"name\" : (str(data['name'])),\n \"country\" : (str(data['country'])),\n \"temp\" : (str(data['temp']))+' c'}\n return tempinc","def _get_data_file(self, data_path):\n\n return json.load(open(data_path))","async def get_data(self, endpoint):\n try:\n with async_timeout.timeout(5, loop=self._loop):\n response = await self._session.get(f\"{endpoint}\")\n\n _LOGGER.debug(\"Response from Dingz device: %s\", response.status)\n self.data = await response.json()\n _LOGGER.debug(self.data)\n except (asyncio.TimeoutError, aiohttp.ClientError):\n _LOGGER.error(\"Can not load data from Dingz device\")\n self.data = None\n raise exceptions.DingzConnectionError()","def get_url_data(self, url):\n # print \"opening: \" + url\n request = urllib2.Request(url)\n base64string = '%s:%s' % (self.username, self.key)\n request.add_header(\"Authorization\", \"ApiKey %s\" % base64string)\n response = urllib2.urlopen(request)\n data = json.loads(response.read())\n return data","def _extract_data(self):\n if self.URL_type == \"youtube\" or self.URL_type == \"ytmusic\":\n self._get_youtube_data_url()\n elif self.URL_type == \"soundcloud\":\n self._get_soundcloud_data()","def _fetch_data(self):\n pass","def data(self):\n self._get_latest_content()\n return self._data.get('data', {})","def get(self):\n data = request.args.get('data')\n\n if not data:\n data = \"OK!\"\n\n return json.loads(dumps(data)), 200","def data(self):\n return self._data","def data(self):\n file_name = join(PARENT_BASE_DIR, '.files', 'data.data.json')\n if isfile(file_name):\n debug(f'{file_name} file is exist.')\n debug(f'try for load {file_name} file ->->->->->->->->->->')\n start_load_file = time()\n with open(file_name, 'r', encoding='utf-8')as file:\n data = file.read()\n data = loads(data)\n debug(f'load file - [runtime: {time() - start_load_file}] <-<-<-<-<-<-<-<-<-<-')\n return data, 'data exist.'\n else:\n debug(f'{file_name} file is not exist.')\n return None, 'data not exist in \"base directory/.files/data.data.json\"'","def get_data(self, lat=53.3498, lon=-6.2603):\n r = requests.get(\n f\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\")\n return r.text","def get_data(self):\n return DataGatherer().get_temperature_data()","def getData(self, product, variables, attributes, variable, *args):\r\n\r\n data = None\r\n return data","def getAllData(self):\r\n return self.data","def get_data(self, body):\n params = json.loads(body)\n logger.debug('New Data Format')\n return self._get_data(body)","def stationdata():\n # * Return a JSON list of stations from the dataset.\n # as this should be a list, I'm just grabbing the station name\n session = Session(engine)\n results = session.query(Station.name).all()\n session.close()\n\n stations = list(np.ravel(results))\n return jsonify(stations)","def get_data(self):\n\n return self._data","def get_data(self):\n\n return self._data","def get_data(self):\n\n return self._data"],"string":"[\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n return\",\n \"def _get_data(self, url: str)->dict:\\n data = None\\n resp = self._get(url)\\n if resp:\\n data = resp.json()['data']\\n return data\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self, url):\\n return self.get(url).get('data', [])\",\n \"def get(self, data):\\n pass\",\n \"def get_data(self):\\r\\n pass\",\n \"def get(self, data):\\n ret = self._rest_call({}, 'GET')\\n return json.loads(ret[2])\",\n \"def get_data():\\n try:\\n response = requests.get(uri)\\n json_data = response.json()\\n except ValueError as e:\\n print(e)\\n except TypeError as e:\\n print(e)\\n return json_data\",\n \"def get_data(self):\",\n \"def get_data(self):\\n return self.data.to_json()\",\n \"def get_sdata(self):\\n payload = self.get('data_request?id=sdata&output_format=json')\\n return payload\",\n \"def get_json_data():\\n return None\",\n \"def _get_data(self):\\n raise NotImplementedError()\",\n \"def get_velib_data():\\n api_url = \\\"https://api.jcdecaux.com/vls/v1/\\\"\\n query_string = \\\"stations?contract=Paris&apiKey=\\\"\\n api_key = \\\"ec29d3b17e5162e1459aaad45cddfe74fe832379\\\"\\n my_url = api_url + query_string + api_key\\n\\n urlobj = URL.urlopen(my_url)\\n data = json.load(urlobj)\\n# data = urlobj.read()\\n# help(data)\\n return data\",\n \"async def stations_data():\\n with open(\\\"/data/station_data.json\\\") as j:\\n data = json.load(j)\\n return data\",\n \"def get_data():\\n string = open('Tinder/static/data/data.json').read()\\n return flask.jsonify(json.loads(string))\",\n \"def get_data(self):\\n raise NotImplementedError(\\\"Not implemented!\\\")\",\n \"def getStationData(self):\\n dtime = datetime.strptime(self.refTime, \\\"%y%m%d/%H%M\\\")\\n trange = TimeRange()\\n trange.setStart(dtime)\\n trange.setEnd(dtime)\\n dataTime = DataTime(refTime=dtime, validPeriod=trange)\\n req = StationDataRequest()\\n req.setPluginName(self.pluginName)\\n req.setStationId(self.stationId)\\n req.setRefTime(dataTime)\\n req.setParmList(self.parmList)\\n req.setPartNumber(self.partNumber)\\n resp = self.client.sendRequest(req)\\n\\n for i, rec in enumerate(resp):\\n resp[i] = {\\n key.decode() if isinstance(key, bytes) else key:\\n val.decode() if isinstance(val, bytes) else val\\n for key, val in rec.items()\\n }\\n\\n return resp\",\n \"def get_data(self): # TODO: add smooth possibility\\n return self.data\",\n \"async def get_data(self, path: str) -> Dict:\\n # function accepts paths that start with / and also path that do not start with /\\n if path.startswith(\\\"/\\\"):\\n path = path[1:]\\n try:\\n async with aiohttp.ClientSession() as session:\\n async with session.get(f\\\"{self._opa_url}/data/{path}\\\") as opa_response:\\n return await opa_response.json()\\n except aiohttp.ClientError as e:\\n logger.warning(\\\"Opa connection error: {err}\\\", err=e)\\n raise\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n return self.data\",\n \"def getData(self, local_cache):\",\n \"def get_data(self):\\n\\n raise NotImplementedError('''\\n Must Implement get_data. Call help() for details.\\n ''')\",\n \"def getData(self):\\n return self.data\",\n \"def getData(self):\\n return self.data\",\n \"def getDatafromWebService(self,region, station, start_date, end_date):\\n #construct filename in the format \\\"region_station_startdate_enddate.json\\\" with no spaces and \\\"-\\\"\\n \\\"\\\"\\\"\\n filename = region + \\\"_\\\" + station+ \\\"_\\\" + start_date + \\\"_\\\" + end_date + \\\".json\\\"\\n filename = filename.replace(\\\" \\\",\\\"\\\")\\n filename = filename.replace(\\\"-\\\",\\\"\\\")\\n print (\\\"filename: \\\"+filename)\\n \\\"\\\"\\\"\\n #date format for getting data from web service = yy/mm/dd\\n obj = RegionData()\\n stationcode = obj.getStaionCode(region, station)\\n newStart_Date = datetime.datetime.strptime(start_date, \\\"%m/%d/%Y\\\").strftime(\\\"%Y-%m-%d\\\")\\n newEnd_Date = datetime.datetime.strptime(end_date, \\\"%m/%d/%Y\\\").strftime(\\\"%Y-%m-%d\\\")\\n\\n server = SOAPpy.SOAPProxy(\\\"http://cdmo.baruch.sc.edu/webservices2/requests.cfc?wsdl\\\")\\n\\n #stationcode=\\\"pdbjewq\\\"\\n responsedata = server.exportAllParamsDateRangeXMLNew(stationcode, newStart_Date, newEnd_Date,'*')\\n #responsedata = server.exportAllParamsDateRangeXMLNew('pdbjewq','2014-12-30', '2014-12-31', '*')\\n\\n # print responsedata\\n pythonObject = SOAPpy.Types.simplify(responsedata)\\n #jsonObject = json.dumps(pythonObject)\\n #assert type(jsonObject) == str\\n dataArray = pythonObject[\\\"returnData\\\"][\\\"data\\\"] # returns { [{...},{....},.....]}\\n\\n #data from webservice has date format mm/dd/yy = 12/31/2014\\n #print(dataArray)\\n\\n return json.dumps(dataArray)\\n \\\"\\\"\\\"\\n print (dataArray)\\n self.dataToJson(dataArray, filename) # store the data into a json file\\n #store data into rawdata collection\\n \\n rawObj =RawData()\\n rawObj.insertRawStationData(region,station,start_date,end_date,dataArray)\\n \\n #return filename # return the json filename where data is stored\\n \\\"\\\"\\\"\",\n \"def get_data(link):\\n data = re.get(link)\\n jsondata = data.json()\\n for weatherstation in jsondata['weatherStations']:\\n FetchandStore.sensordict.update({weatherstation[\\\"id\\\"]:weatherstation[\\\"sensorValues\\\"]})\\n for sensorvalue in weatherstation[\\\"sensorValues\\\"]:\\n FetchandStore.sensors.append({\\\"id\\\": sensorvalue[\\\"roadStationId\\\"], \\\"name\\\": sensorvalue[\\\"oldName\\\"],\\n \\\"value\\\": sensorvalue[\\\"sensorValue\\\"], \\\"unit\\\": sensorvalue[\\\"sensorUnit\\\"],\\n \\\"datetime\\\": sensorvalue[\\\"measuredTime\\\"]})\\n return FetchandStore.sensors\",\n \"def getTheData(self, dev):\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"getTheData FrontViewAPI method called.\\\")\\n\\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Download\\\")\\n try:\\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\\n r = requests.get(url,timeout=5)\\n result = r.json()\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Result:\\\" + unicode(result))\\n self.WaitInterval = 1\\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Online\\\")\\n dev.setErrorStateOnServer(None)\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n return result\\n\\n except Exception as error:\\n\\n indigo.server.log(u\\\"Error connecting to Device:\\\" + dev.name)\\n self.WaitInterval = 60\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Device is offline. No data to return. \\\")\\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\\\"Offline\\\")\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n dev.setErrorStateOnServer(u'Offline')\\n result = \\\"\\\"\\n return result\",\n \"def getData(language=None):\",\n \"def download():\\n toydata = requests.get(DATA_URL).json()\\n return toydata\",\n \"def get_data_from_web():\\n pass\",\n \"def _request_data(self, url):\\n connection = httplib.HTTPConnection(self.url)\\n connection.request(\\\"GET\\\", url)\\n response = connection.getresponse()\\n\\n if response.status != 200:\\n raise Exception(response.reason)\\n\\n data = response.read()\\n response.close()\\n\\n return json.loads(data)\",\n \"def get_data(self):\\n\\n self.set_query_string()\\n self.realtime_data = super().get_data()\\n self.set_coordinate()\\n return self.realtime_data\",\n \"def get_data(self, out_format: str='json'):\\n if self.data:\\n return self.data\\n self.data_ready = self.check_available()\\n if not self.data_ready:\\n raise DataNotReady(\\\"The run {} has not yet finished, data not available yet.\\\".format(self))\\n resp = self.ph.conn.request(\\n 'GET', self.ph.URLS['getdata'].format(self.run_token), dict(api_key=self.ph.api_key, format=out_format))\\n data = resp.data.decode('utf-8')\\n self.data = self.parse_json_data(data)\\n return self.data\",\n \"def get_data(self):\\n return self.parsed_data\",\n \"def data():\\n return volumes_fetchers.get_json_data()\",\n \"def data(self):\\n return json.loads(self.data_json)\",\n \"def get_data():\\n try:\\n with open(CONS[\\\"OUTPUT_FILE\\\"], \\\"r\\\") as file:\\n data = json.load(file)[1]\\n return data\\n except FileNotFoundError:\\n print(\\\"Data file not found.\\\")\\n exit()\",\n \"def getData(self):\\r\\n return self._data\",\n \"def getData(url):\\n data = ''\\n request = urllib2.Request(url, headers={\\\"Accept\\\": \\\"application/json\\\"})\\n try:\\n data = json.loads(urllib2.urlopen(request).read())\\n except urllib2.HTTPError, e:\\n raise Exception(\\\"HTTP error: %d\\\" % e.code)\\n except urllib2.URLError, e:\\n raise Exception(\\\"Network error: %s\\\" % e.reason.args[1])\\n\\n return data\",\n \"def get(self):\\r\\n return self.data\",\n \"def get_data(self, state=None, request=None):\\n raise NotImplementedError\",\n \"def getData(self):\\n return self.__data\",\n \"def fetch_data(data_url):\\n return requests.get(data_url).content\",\n \"def get_data(self):\\n return DataGatherer().get_rainfall_data()\",\n \"def getData(eUrl, eToken):\\n if eUrl == '' or eToken == '':\\n print(\\\"Enviroment is not setup\\\")\\n exit(1)\\n\\n with urllib.request.urlopen(eUrl + eToken) as url:\\n data = json.loads(url.read().decode())\\n\\n return(data)\",\n \"def get_data(self):\\n return DataGatherer().get_wind_data()\",\n \"def get_data():\\n try:\\n with open('./data.json') as data_file:\\n return json.load(data_file)\\n except:\\n data_json = json.loads('{\\\"message\\\": \\\"Error with file data.json\\\", \\\"success\\\": false}')\\n return data_json\",\n \"def getData(tme=currentTime):\\n # attempts request 10 times\\n for attempt in range(10):\\n try:\\n # make a request to the url and return it in json format\\n url = \\\"https://api.darksky.net/forecast/%s/%s,%s,%s?exclude=minutely,hourly,daily,alerts,flags\\\" % (API_KEY, LAT, LNG, tme)\\n return get(url).json()\\n except:\\n # Wait .05 seconds and try again\\n sleep(.05)\\n pass\",\n \"def getData(self):\\n return self._data\",\n \"def getData(self):\\n return self._data\",\n \"def GetGeData(self, *args, **kwargs):\\n pass\",\n \"def getStockData():\\n pass\",\n \"def download_data(self, format = 'srt'):\\n resp, content = httplib2.Http(\\\".cache\\\").request(self.url, \\\"GET\\\")\\n suburl = json.loads(content)['url']\\n resp, content = httplib2.Http(\\\".cache\\\").request(suburl, \\\"GET\\\")\\n\\n return content\",\n \"def get_path_data(self, path):\\n url = self.api_server + path\\n return self.get_url_data(url)\",\n \"def data():\\n return None\",\n \"def GetData(self):\\r\\n \\r\\n return self._data\",\n \"def getData():\\n data = {\\n \\\"name\\\": \\\"Kim\\\",\\n \\\"message\\\": \\\"Hello there!\\\"\\n }\\n return jsonify(data) # respond to the API caller with a JSON representation of data. jsonify is important, as it sets response headers that indicate the respose is in JSON as well\",\n \"def get_data(self, url):\\n\\n req = urllib2.Request(url)\\n # urlencode the query dictionary\\n try:\\n r = urllib2.urlopen(req)\\n result = r.read()\\n except:\\n result = 'The url: %s is not responding.' % (url)\\n return result\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get(self):\\n return self.data\",\n \"def get(self):\\n return self.get_data()\",\n \"def get_data(self, request, url):\\n data = request.get(endpoint=url)\\n return data[0], data[1]\",\n \"def get_data(self):\\n self._send_command(self._adapter.get_data())\",\n \"def stations():\\n print(\\\"server received request for stations data...\\\")\\n return jsonify(stations_data)\",\n \"def get_data(self, label: str) -> Any:\\r\\n return self._get_resource(label, self._data, \\\"data\\\")\",\n \"def get_data(self):\\n with open(self.filepath, 'r') as openFile:\\n data = json.load(openFile)\\n logging.info('Loaded JSON data file.')\\n return data\",\n \"def apicall():\\r\\n# try:\\r\\n print request.get_json()\\r\\n test_json = request.get_json()\\r\\n logger.info(\\\"input json object loaded\\\")\\r\\n logger.info(test_json)\\r\\n k=MetaData(test_json)\\r\\n int_res=k.getData()\\r\\n print '------------------------------'\\r\\n print int_res\\r\\n return jsonify(int_res)\",\n \"def get_data(self):\\n return self.topo_data_flattened\",\n \"def get_data():\\n if not hasattr(g, 'data'):\\n g.data = load_data()\\n return g.data\",\n \"def fetch_data(self):\",\n \"def GetData():\\r\\n return _hiew.HiewGate_GetData()\",\n \"def get(self):\\n city = str(request.args.get('city')) ## /?city=stockholm\\n source = urllib.request.urlopen('http://127.0.0.1:5050/?city=' + city).read()\\n data = json.loads(source)\\n print(data)\\n tempinc = {\\\"name\\\" : (str(data['name'])),\\n \\\"country\\\" : (str(data['country'])),\\n \\\"temp\\\" : (str(data['temp']))+' c'}\\n return tempinc\",\n \"def _get_data_file(self, data_path):\\n\\n return json.load(open(data_path))\",\n \"async def get_data(self, endpoint):\\n try:\\n with async_timeout.timeout(5, loop=self._loop):\\n response = await self._session.get(f\\\"{endpoint}\\\")\\n\\n _LOGGER.debug(\\\"Response from Dingz device: %s\\\", response.status)\\n self.data = await response.json()\\n _LOGGER.debug(self.data)\\n except (asyncio.TimeoutError, aiohttp.ClientError):\\n _LOGGER.error(\\\"Can not load data from Dingz device\\\")\\n self.data = None\\n raise exceptions.DingzConnectionError()\",\n \"def get_url_data(self, url):\\n # print \\\"opening: \\\" + url\\n request = urllib2.Request(url)\\n base64string = '%s:%s' % (self.username, self.key)\\n request.add_header(\\\"Authorization\\\", \\\"ApiKey %s\\\" % base64string)\\n response = urllib2.urlopen(request)\\n data = json.loads(response.read())\\n return data\",\n \"def _extract_data(self):\\n if self.URL_type == \\\"youtube\\\" or self.URL_type == \\\"ytmusic\\\":\\n self._get_youtube_data_url()\\n elif self.URL_type == \\\"soundcloud\\\":\\n self._get_soundcloud_data()\",\n \"def _fetch_data(self):\\n pass\",\n \"def data(self):\\n self._get_latest_content()\\n return self._data.get('data', {})\",\n \"def get(self):\\n data = request.args.get('data')\\n\\n if not data:\\n data = \\\"OK!\\\"\\n\\n return json.loads(dumps(data)), 200\",\n \"def data(self):\\n return self._data\",\n \"def data(self):\\n file_name = join(PARENT_BASE_DIR, '.files', 'data.data.json')\\n if isfile(file_name):\\n debug(f'{file_name} file is exist.')\\n debug(f'try for load {file_name} file ->->->->->->->->->->')\\n start_load_file = time()\\n with open(file_name, 'r', encoding='utf-8')as file:\\n data = file.read()\\n data = loads(data)\\n debug(f'load file - [runtime: {time() - start_load_file}] <-<-<-<-<-<-<-<-<-<-')\\n return data, 'data exist.'\\n else:\\n debug(f'{file_name} file is not exist.')\\n return None, 'data not exist in \\\"base directory/.files/data.data.json\\\"'\",\n \"def get_data(self, lat=53.3498, lon=-6.2603):\\n r = requests.get(\\n f\\\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\\\")\\n return r.text\",\n \"def get_data(self):\\n return DataGatherer().get_temperature_data()\",\n \"def getData(self, product, variables, attributes, variable, *args):\\r\\n\\r\\n data = None\\r\\n return data\",\n \"def getAllData(self):\\r\\n return self.data\",\n \"def get_data(self, body):\\n params = json.loads(body)\\n logger.debug('New Data Format')\\n return self._get_data(body)\",\n \"def stationdata():\\n # * Return a JSON list of stations from the dataset.\\n # as this should be a list, I'm just grabbing the station name\\n session = Session(engine)\\n results = session.query(Station.name).all()\\n session.close()\\n\\n stations = list(np.ravel(results))\\n return jsonify(stations)\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def get_data(self):\\n\\n return self._data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72748417","0.7042909","0.7042909","0.7042909","0.6986527","0.69044787","0.6730157","0.6730157","0.67095935","0.6698002","0.6657195","0.66411364","0.6575214","0.65689933","0.6568993","0.6539387","0.6526602","0.64448017","0.643305","0.62808186","0.6266045","0.62530833","0.6230977","0.62047446","0.62023747","0.61962587","0.61962587","0.61962587","0.6193218","0.61930925","0.6169693","0.6169693","0.6169271","0.61692584","0.6132015","0.610331","0.6089289","0.60693574","0.60641956","0.6059549","0.60585314","0.60427296","0.60426944","0.6025194","0.6023156","0.60020524","0.59958684","0.59818995","0.5976509","0.594268","0.593523","0.59174246","0.59016556","0.58875465","0.5873129","0.58663595","0.58644193","0.58644193","0.58530504","0.5852787","0.58446234","0.584416","0.5837671","0.58164924","0.5789456","0.5785923","0.57820135","0.57820135","0.57820135","0.57820135","0.5776453","0.5773474","0.5765753","0.5760926","0.5745279","0.57353574","0.5733556","0.5729883","0.5726364","0.5724414","0.5723797","0.5719825","0.5699225","0.5688072","0.5686226","0.56823844","0.56817037","0.566298","0.5658644","0.56544554","0.5645314","0.56388634","0.5633947","0.5629257","0.56289667","0.562071","0.5616985","0.5613694","0.5612528","0.5612528","0.5612528"],"string":"[\n \"0.72748417\",\n \"0.7042909\",\n \"0.7042909\",\n \"0.7042909\",\n \"0.6986527\",\n \"0.69044787\",\n \"0.6730157\",\n \"0.6730157\",\n \"0.67095935\",\n \"0.6698002\",\n \"0.6657195\",\n \"0.66411364\",\n \"0.6575214\",\n \"0.65689933\",\n \"0.6568993\",\n \"0.6539387\",\n \"0.6526602\",\n \"0.64448017\",\n \"0.643305\",\n \"0.62808186\",\n \"0.6266045\",\n \"0.62530833\",\n \"0.6230977\",\n \"0.62047446\",\n \"0.62023747\",\n \"0.61962587\",\n \"0.61962587\",\n \"0.61962587\",\n \"0.6193218\",\n \"0.61930925\",\n \"0.6169693\",\n \"0.6169693\",\n \"0.6169271\",\n \"0.61692584\",\n \"0.6132015\",\n \"0.610331\",\n \"0.6089289\",\n \"0.60693574\",\n \"0.60641956\",\n \"0.6059549\",\n \"0.60585314\",\n \"0.60427296\",\n \"0.60426944\",\n \"0.6025194\",\n \"0.6023156\",\n \"0.60020524\",\n \"0.59958684\",\n \"0.59818995\",\n \"0.5976509\",\n \"0.594268\",\n \"0.593523\",\n \"0.59174246\",\n \"0.59016556\",\n \"0.58875465\",\n \"0.5873129\",\n \"0.58663595\",\n \"0.58644193\",\n \"0.58644193\",\n \"0.58530504\",\n \"0.5852787\",\n \"0.58446234\",\n \"0.584416\",\n \"0.5837671\",\n \"0.58164924\",\n \"0.5789456\",\n \"0.5785923\",\n \"0.57820135\",\n \"0.57820135\",\n \"0.57820135\",\n \"0.57820135\",\n \"0.5776453\",\n \"0.5773474\",\n \"0.5765753\",\n \"0.5760926\",\n \"0.5745279\",\n \"0.57353574\",\n \"0.5733556\",\n \"0.5729883\",\n \"0.5726364\",\n \"0.5724414\",\n \"0.5723797\",\n \"0.5719825\",\n \"0.5699225\",\n \"0.5688072\",\n \"0.5686226\",\n \"0.56823844\",\n \"0.56817037\",\n \"0.566298\",\n \"0.5658644\",\n \"0.56544554\",\n \"0.5645314\",\n \"0.56388634\",\n \"0.5633947\",\n \"0.5629257\",\n \"0.56289667\",\n \"0.562071\",\n \"0.5616985\",\n \"0.5613694\",\n \"0.5612528\",\n \"0.5612528\",\n \"0.5612528\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":190,"cells":{"query":{"kind":"string","value":"getData is used to get satellite json data from the server."},"document":{"kind":"string","value":"def getTimelineStats(self, url: str, latitude: list,\n longitude: list, startDate: str, endDate: str,\n minCloudCover=None, maxCloudCover=None,\n minCoverage=None, maxCoverage=None,\n satellite='l8', index='ndvi'):\n\n if type(latitude) is not list:\n latitude = [str(latitude)]\n else:\n latitude = [str(l) for l in latitude]\n\n if type(longitude) is not list:\n longitude = [str(longitude)]\n else:\n longitude = [str(l) for l in longitude]\n\n minCloudCover = self.minCloudCover if minCloudCover is None else minCloudCover\n maxCloudCover = self.maxCloudCover if maxCloudCover is None else maxCloudCover\n minCoverage = self.minCoverage if minCoverage is None else minCoverage\n maxCoverage = self.maxCoverage if maxCoverage is None else maxCoverage\n\n param = {\n 'url': url,\n 'x': ','.join(longitude),\n 'y': ','.join(latitude),\n 'satellite': satellite.lower(),\n 'index': index,\n 'start_date': startDate,\n 'end_date': endDate,\n 'min_cloudcover': int(minCloudCover),\n 'max_cloudcover': int(maxCloudCover),\n 'min_coverage': int(minCoverage),\n 'max_coverage': int(maxCoverage),\n }\n\n try:\n response = requests.get(url=self.timelineStatsEndpoint, params=param)\n except Exception as e:\n raise exceptions(\n 'Unable to reach to value endpoint. Error: {}'.format(e))\n\n return response.json()"},"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_data():\n pass","def get_data():\n pass","def get_data():\n pass","def get_data():\n pass","def get_data():\n return","def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n return data","def get_data(self):\n pass","def get_data(self):\n pass","def get_data(self, url):\n return self.get(url).get('data', [])","def get(self, data):\n pass","def get_data(self):\r\n pass","def get(self, data):\n ret = self._rest_call({}, 'GET')\n return json.loads(ret[2])","def get_data():\n try:\n response = requests.get(uri)\n json_data = response.json()\n except ValueError as e:\n print(e)\n except TypeError as e:\n print(e)\n return json_data","def get_data(self):","def get_data(self):\n return self.data.to_json()","def get_sdata(self):\n payload = self.get('data_request?id=sdata&output_format=json')\n return payload","def get_json_data():\n return None","def _get_data(self):\n raise NotImplementedError()","def get_velib_data():\n api_url = \"https://api.jcdecaux.com/vls/v1/\"\n query_string = \"stations?contract=Paris&apiKey=\"\n api_key = \"ec29d3b17e5162e1459aaad45cddfe74fe832379\"\n my_url = api_url + query_string + api_key\n\n urlobj = URL.urlopen(my_url)\n data = json.load(urlobj)\n# data = urlobj.read()\n# help(data)\n return data","async def stations_data():\n with open(\"/data/station_data.json\") as j:\n data = json.load(j)\n return data","def get_data():\n string = open('Tinder/static/data/data.json').read()\n return flask.jsonify(json.loads(string))","def get_data(self):\n raise NotImplementedError(\"Not implemented!\")","def getStationData(self):\n dtime = datetime.strptime(self.refTime, \"%y%m%d/%H%M\")\n trange = TimeRange()\n trange.setStart(dtime)\n trange.setEnd(dtime)\n dataTime = DataTime(refTime=dtime, validPeriod=trange)\n req = StationDataRequest()\n req.setPluginName(self.pluginName)\n req.setStationId(self.stationId)\n req.setRefTime(dataTime)\n req.setParmList(self.parmList)\n req.setPartNumber(self.partNumber)\n resp = self.client.sendRequest(req)\n\n for i, rec in enumerate(resp):\n resp[i] = {\n key.decode() if isinstance(key, bytes) else key:\n val.decode() if isinstance(val, bytes) else val\n for key, val in rec.items()\n }\n\n return resp","def get_data(self): # TODO: add smooth possibility\n return self.data","async def get_data(self, path: str) -> Dict:\n # function accepts paths that start with / and also path that do not start with /\n if path.startswith(\"/\"):\n path = path[1:]\n try:\n async with aiohttp.ClientSession() as session:\n async with session.get(f\"{self._opa_url}/data/{path}\") as opa_response:\n return await opa_response.json()\n except aiohttp.ClientError as e:\n logger.warning(\"Opa connection error: {err}\", err=e)\n raise","def get_data(self):\n return self.data","def get_data(self):\n return self.data","def get_data(self):\n return self.data","def getData(self, local_cache):","def get_data(self):\n\n raise NotImplementedError('''\n Must Implement get_data. Call help() for details.\n ''')","def get_data(link):\n data = re.get(link)\n jsondata = data.json()\n for weatherstation in jsondata['weatherStations']:\n FetchandStore.sensordict.update({weatherstation[\"id\"]:weatherstation[\"sensorValues\"]})\n for sensorvalue in weatherstation[\"sensorValues\"]:\n FetchandStore.sensors.append({\"id\": sensorvalue[\"roadStationId\"], \"name\": sensorvalue[\"oldName\"],\n \"value\": sensorvalue[\"sensorValue\"], \"unit\": sensorvalue[\"sensorUnit\"],\n \"datetime\": sensorvalue[\"measuredTime\"]})\n return FetchandStore.sensors","def getData(self):\n return self.data","def getData(self):\n return self.data","def getDatafromWebService(self,region, station, start_date, end_date):\n #construct filename in the format \"region_station_startdate_enddate.json\" with no spaces and \"-\"\n \"\"\"\n filename = region + \"_\" + station+ \"_\" + start_date + \"_\" + end_date + \".json\"\n filename = filename.replace(\" \",\"\")\n filename = filename.replace(\"-\",\"\")\n print (\"filename: \"+filename)\n \"\"\"\n #date format for getting data from web service = yy/mm/dd\n obj = RegionData()\n stationcode = obj.getStaionCode(region, station)\n newStart_Date = datetime.datetime.strptime(start_date, \"%m/%d/%Y\").strftime(\"%Y-%m-%d\")\n newEnd_Date = datetime.datetime.strptime(end_date, \"%m/%d/%Y\").strftime(\"%Y-%m-%d\")\n\n server = SOAPpy.SOAPProxy(\"http://cdmo.baruch.sc.edu/webservices2/requests.cfc?wsdl\")\n\n #stationcode=\"pdbjewq\"\n responsedata = server.exportAllParamsDateRangeXMLNew(stationcode, newStart_Date, newEnd_Date,'*')\n #responsedata = server.exportAllParamsDateRangeXMLNew('pdbjewq','2014-12-30', '2014-12-31', '*')\n\n # print responsedata\n pythonObject = SOAPpy.Types.simplify(responsedata)\n #jsonObject = json.dumps(pythonObject)\n #assert type(jsonObject) == str\n dataArray = pythonObject[\"returnData\"][\"data\"] # returns { [{...},{....},.....]}\n\n #data from webservice has date format mm/dd/yy = 12/31/2014\n #print(dataArray)\n\n return json.dumps(dataArray)\n \"\"\"\n print (dataArray)\n self.dataToJson(dataArray, filename) # store the data into a json file\n #store data into rawdata collection\n \n rawObj =RawData()\n rawObj.insertRawStationData(region,station,start_date,end_date,dataArray)\n \n #return filename # return the json filename where data is stored\n \"\"\"","def getTheData(self, dev):\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"getTheData FrontViewAPI method called.\")\n\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Download\")\n try:\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\n r = requests.get(url,timeout=5)\n result = r.json()\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Result:\" + unicode(result))\n self.WaitInterval = 1\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\"Online\")\n dev.setErrorStateOnServer(None)\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n return result\n\n except Exception as error:\n\n indigo.server.log(u\"Error connecting to Device:\" + dev.name)\n self.WaitInterval = 60\n if self.debugLevel >= 2 and self.debug:\n self.debugLog(u\"Device is offline. No data to return. \")\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\"Offline\")\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\n dev.setErrorStateOnServer(u'Offline')\n result = \"\"\n return result","def getData(language=None):","def download():\n toydata = requests.get(DATA_URL).json()\n return toydata","def get_data_from_web():\n pass","def _request_data(self, url):\n connection = httplib.HTTPConnection(self.url)\n connection.request(\"GET\", url)\n response = connection.getresponse()\n\n if response.status != 200:\n raise Exception(response.reason)\n\n data = response.read()\n response.close()\n\n return json.loads(data)","def get_data(self):\n\n self.set_query_string()\n self.realtime_data = super().get_data()\n self.set_coordinate()\n return self.realtime_data","def get_data(self, out_format: str='json'):\n if self.data:\n return self.data\n self.data_ready = self.check_available()\n if not self.data_ready:\n raise DataNotReady(\"The run {} has not yet finished, data not available yet.\".format(self))\n resp = self.ph.conn.request(\n 'GET', self.ph.URLS['getdata'].format(self.run_token), dict(api_key=self.ph.api_key, format=out_format))\n data = resp.data.decode('utf-8')\n self.data = self.parse_json_data(data)\n return self.data","def data():\n return volumes_fetchers.get_json_data()","def get_data(self):\n return self.parsed_data","def get_data():\n try:\n with open(CONS[\"OUTPUT_FILE\"], \"r\") as file:\n data = json.load(file)[1]\n return data\n except FileNotFoundError:\n print(\"Data file not found.\")\n exit()","def data(self):\n return json.loads(self.data_json)","def getData(self):\r\n return self._data","def getData(url):\n data = ''\n request = urllib2.Request(url, headers={\"Accept\": \"application/json\"})\n try:\n data = json.loads(urllib2.urlopen(request).read())\n except urllib2.HTTPError, e:\n raise Exception(\"HTTP error: %d\" % e.code)\n except urllib2.URLError, e:\n raise Exception(\"Network error: %s\" % e.reason.args[1])\n\n return data","def get(self):\r\n return self.data","def get_data(self, state=None, request=None):\n raise NotImplementedError","def getData(self):\n return self.__data","def fetch_data(data_url):\n return requests.get(data_url).content","def get_data(self):\n return DataGatherer().get_rainfall_data()","def getData(eUrl, eToken):\n if eUrl == '' or eToken == '':\n print(\"Enviroment is not setup\")\n exit(1)\n\n with urllib.request.urlopen(eUrl + eToken) as url:\n data = json.loads(url.read().decode())\n\n return(data)","def get_data(self):\n return DataGatherer().get_wind_data()","def get_data():\n try:\n with open('./data.json') as data_file:\n return json.load(data_file)\n except:\n data_json = json.loads('{\"message\": \"Error with file data.json\", \"success\": false}')\n return data_json","def getData(tme=currentTime):\n # attempts request 10 times\n for attempt in range(10):\n try:\n # make a request to the url and return it in json format\n url = \"https://api.darksky.net/forecast/%s/%s,%s,%s?exclude=minutely,hourly,daily,alerts,flags\" % (API_KEY, LAT, LNG, tme)\n return get(url).json()\n except:\n # Wait .05 seconds and try again\n sleep(.05)\n pass","def getData(self):\n return self._data","def getData(self):\n return self._data","def GetGeData(self, *args, **kwargs):\n pass","def getStockData():\n pass","def get_path_data(self, path):\n url = self.api_server + path\n return self.get_url_data(url)","def download_data(self, format = 'srt'):\n resp, content = httplib2.Http(\".cache\").request(self.url, \"GET\")\n suburl = json.loads(content)['url']\n resp, content = httplib2.Http(\".cache\").request(suburl, \"GET\")\n\n return content","def data():\n return None","def GetData(self):\r\n \r\n return self._data","def getData():\n data = {\n \"name\": \"Kim\",\n \"message\": \"Hello there!\"\n }\n return jsonify(data) # respond to the API caller with a JSON representation of data. jsonify is important, as it sets response headers that indicate the respose is in JSON as well","def get_data(self, url):\n\n req = urllib2.Request(url)\n # urlencode the query dictionary\n try:\n r = urllib2.urlopen(req)\n result = r.read()\n except:\n result = 'The url: %s is not responding.' % (url)\n return result","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get_data(self):\n return self._data","def get(self):\n return self.data","def get(self):\n return self.get_data()","def get_data(self, request, url):\n data = request.get(endpoint=url)\n return data[0], data[1]","def get_data(self):\n self._send_command(self._adapter.get_data())","def stations():\n print(\"server received request for stations data...\")\n return jsonify(stations_data)","def get_data(self, label: str) -> Any:\r\n return self._get_resource(label, self._data, \"data\")","def get_data(self):\n with open(self.filepath, 'r') as openFile:\n data = json.load(openFile)\n logging.info('Loaded JSON data file.')\n return data","def apicall():\r\n# try:\r\n print request.get_json()\r\n test_json = request.get_json()\r\n logger.info(\"input json object loaded\")\r\n logger.info(test_json)\r\n k=MetaData(test_json)\r\n int_res=k.getData()\r\n print '------------------------------'\r\n print int_res\r\n return jsonify(int_res)","def get_data(self):\n return self.topo_data_flattened","def fetch_data(self):","def get_data():\n if not hasattr(g, 'data'):\n g.data = load_data()\n return g.data","def GetData():\r\n return _hiew.HiewGate_GetData()","def get(self):\n city = str(request.args.get('city')) ## /?city=stockholm\n source = urllib.request.urlopen('http://127.0.0.1:5050/?city=' + city).read()\n data = json.loads(source)\n print(data)\n tempinc = {\"name\" : (str(data['name'])),\n \"country\" : (str(data['country'])),\n \"temp\" : (str(data['temp']))+' c'}\n return tempinc","def _get_data_file(self, data_path):\n\n return json.load(open(data_path))","async def get_data(self, endpoint):\n try:\n with async_timeout.timeout(5, loop=self._loop):\n response = await self._session.get(f\"{endpoint}\")\n\n _LOGGER.debug(\"Response from Dingz device: %s\", response.status)\n self.data = await response.json()\n _LOGGER.debug(self.data)\n except (asyncio.TimeoutError, aiohttp.ClientError):\n _LOGGER.error(\"Can not load data from Dingz device\")\n self.data = None\n raise exceptions.DingzConnectionError()","def _extract_data(self):\n if self.URL_type == \"youtube\" or self.URL_type == \"ytmusic\":\n self._get_youtube_data_url()\n elif self.URL_type == \"soundcloud\":\n self._get_soundcloud_data()","def get_url_data(self, url):\n # print \"opening: \" + url\n request = urllib2.Request(url)\n base64string = '%s:%s' % (self.username, self.key)\n request.add_header(\"Authorization\", \"ApiKey %s\" % base64string)\n response = urllib2.urlopen(request)\n data = json.loads(response.read())\n return data","def _fetch_data(self):\n pass","def data(self):\n self._get_latest_content()\n return self._data.get('data', {})","def get(self):\n data = request.args.get('data')\n\n if not data:\n data = \"OK!\"\n\n return json.loads(dumps(data)), 200","def data(self):\n return self._data","def data(self):\n file_name = join(PARENT_BASE_DIR, '.files', 'data.data.json')\n if isfile(file_name):\n debug(f'{file_name} file is exist.')\n debug(f'try for load {file_name} file ->->->->->->->->->->')\n start_load_file = time()\n with open(file_name, 'r', encoding='utf-8')as file:\n data = file.read()\n data = loads(data)\n debug(f'load file - [runtime: {time() - start_load_file}] <-<-<-<-<-<-<-<-<-<-')\n return data, 'data exist.'\n else:\n debug(f'{file_name} file is not exist.')\n return None, 'data not exist in \"base directory/.files/data.data.json\"'","def get_data(self, lat=53.3498, lon=-6.2603):\n r = requests.get(\n f\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\")\n return r.text","def get_data(self):\n return DataGatherer().get_temperature_data()","def getData(self, product, variables, attributes, variable, *args):\r\n\r\n data = None\r\n return data","def getAllData(self):\r\n return self.data","def get_data(self, body):\n params = json.loads(body)\n logger.debug('New Data Format')\n return self._get_data(body)","def stationdata():\n # * Return a JSON list of stations from the dataset.\n # as this should be a list, I'm just grabbing the station name\n session = Session(engine)\n results = session.query(Station.name).all()\n session.close()\n\n stations = list(np.ravel(results))\n return jsonify(stations)","def get_data(self):\n\n return self._data","def get_data(self):\n\n return self._data","def get_data(self):\n\n return self._data"],"string":"[\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n return\",\n \"def _get_data(self, url: str)->dict:\\n data = None\\n resp = self._get(url)\\n if resp:\\n data = resp.json()['data']\\n return data\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self, url):\\n return self.get(url).get('data', [])\",\n \"def get(self, data):\\n pass\",\n \"def get_data(self):\\r\\n pass\",\n \"def get(self, data):\\n ret = self._rest_call({}, 'GET')\\n return json.loads(ret[2])\",\n \"def get_data():\\n try:\\n response = requests.get(uri)\\n json_data = response.json()\\n except ValueError as e:\\n print(e)\\n except TypeError as e:\\n print(e)\\n return json_data\",\n \"def get_data(self):\",\n \"def get_data(self):\\n return self.data.to_json()\",\n \"def get_sdata(self):\\n payload = self.get('data_request?id=sdata&output_format=json')\\n return payload\",\n \"def get_json_data():\\n return None\",\n \"def _get_data(self):\\n raise NotImplementedError()\",\n \"def get_velib_data():\\n api_url = \\\"https://api.jcdecaux.com/vls/v1/\\\"\\n query_string = \\\"stations?contract=Paris&apiKey=\\\"\\n api_key = \\\"ec29d3b17e5162e1459aaad45cddfe74fe832379\\\"\\n my_url = api_url + query_string + api_key\\n\\n urlobj = URL.urlopen(my_url)\\n data = json.load(urlobj)\\n# data = urlobj.read()\\n# help(data)\\n return data\",\n \"async def stations_data():\\n with open(\\\"/data/station_data.json\\\") as j:\\n data = json.load(j)\\n return data\",\n \"def get_data():\\n string = open('Tinder/static/data/data.json').read()\\n return flask.jsonify(json.loads(string))\",\n \"def get_data(self):\\n raise NotImplementedError(\\\"Not implemented!\\\")\",\n \"def getStationData(self):\\n dtime = datetime.strptime(self.refTime, \\\"%y%m%d/%H%M\\\")\\n trange = TimeRange()\\n trange.setStart(dtime)\\n trange.setEnd(dtime)\\n dataTime = DataTime(refTime=dtime, validPeriod=trange)\\n req = StationDataRequest()\\n req.setPluginName(self.pluginName)\\n req.setStationId(self.stationId)\\n req.setRefTime(dataTime)\\n req.setParmList(self.parmList)\\n req.setPartNumber(self.partNumber)\\n resp = self.client.sendRequest(req)\\n\\n for i, rec in enumerate(resp):\\n resp[i] = {\\n key.decode() if isinstance(key, bytes) else key:\\n val.decode() if isinstance(val, bytes) else val\\n for key, val in rec.items()\\n }\\n\\n return resp\",\n \"def get_data(self): # TODO: add smooth possibility\\n return self.data\",\n \"async def get_data(self, path: str) -> Dict:\\n # function accepts paths that start with / and also path that do not start with /\\n if path.startswith(\\\"/\\\"):\\n path = path[1:]\\n try:\\n async with aiohttp.ClientSession() as session:\\n async with session.get(f\\\"{self._opa_url}/data/{path}\\\") as opa_response:\\n return await opa_response.json()\\n except aiohttp.ClientError as e:\\n logger.warning(\\\"Opa connection error: {err}\\\", err=e)\\n raise\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n return self.data\",\n \"def get_data(self):\\n return self.data\",\n \"def getData(self, local_cache):\",\n \"def get_data(self):\\n\\n raise NotImplementedError('''\\n Must Implement get_data. Call help() for details.\\n ''')\",\n \"def get_data(link):\\n data = re.get(link)\\n jsondata = data.json()\\n for weatherstation in jsondata['weatherStations']:\\n FetchandStore.sensordict.update({weatherstation[\\\"id\\\"]:weatherstation[\\\"sensorValues\\\"]})\\n for sensorvalue in weatherstation[\\\"sensorValues\\\"]:\\n FetchandStore.sensors.append({\\\"id\\\": sensorvalue[\\\"roadStationId\\\"], \\\"name\\\": sensorvalue[\\\"oldName\\\"],\\n \\\"value\\\": sensorvalue[\\\"sensorValue\\\"], \\\"unit\\\": sensorvalue[\\\"sensorUnit\\\"],\\n \\\"datetime\\\": sensorvalue[\\\"measuredTime\\\"]})\\n return FetchandStore.sensors\",\n \"def getData(self):\\n return self.data\",\n \"def getData(self):\\n return self.data\",\n \"def getDatafromWebService(self,region, station, start_date, end_date):\\n #construct filename in the format \\\"region_station_startdate_enddate.json\\\" with no spaces and \\\"-\\\"\\n \\\"\\\"\\\"\\n filename = region + \\\"_\\\" + station+ \\\"_\\\" + start_date + \\\"_\\\" + end_date + \\\".json\\\"\\n filename = filename.replace(\\\" \\\",\\\"\\\")\\n filename = filename.replace(\\\"-\\\",\\\"\\\")\\n print (\\\"filename: \\\"+filename)\\n \\\"\\\"\\\"\\n #date format for getting data from web service = yy/mm/dd\\n obj = RegionData()\\n stationcode = obj.getStaionCode(region, station)\\n newStart_Date = datetime.datetime.strptime(start_date, \\\"%m/%d/%Y\\\").strftime(\\\"%Y-%m-%d\\\")\\n newEnd_Date = datetime.datetime.strptime(end_date, \\\"%m/%d/%Y\\\").strftime(\\\"%Y-%m-%d\\\")\\n\\n server = SOAPpy.SOAPProxy(\\\"http://cdmo.baruch.sc.edu/webservices2/requests.cfc?wsdl\\\")\\n\\n #stationcode=\\\"pdbjewq\\\"\\n responsedata = server.exportAllParamsDateRangeXMLNew(stationcode, newStart_Date, newEnd_Date,'*')\\n #responsedata = server.exportAllParamsDateRangeXMLNew('pdbjewq','2014-12-30', '2014-12-31', '*')\\n\\n # print responsedata\\n pythonObject = SOAPpy.Types.simplify(responsedata)\\n #jsonObject = json.dumps(pythonObject)\\n #assert type(jsonObject) == str\\n dataArray = pythonObject[\\\"returnData\\\"][\\\"data\\\"] # returns { [{...},{....},.....]}\\n\\n #data from webservice has date format mm/dd/yy = 12/31/2014\\n #print(dataArray)\\n\\n return json.dumps(dataArray)\\n \\\"\\\"\\\"\\n print (dataArray)\\n self.dataToJson(dataArray, filename) # store the data into a json file\\n #store data into rawdata collection\\n \\n rawObj =RawData()\\n rawObj.insertRawStationData(region,station,start_date,end_date,dataArray)\\n \\n #return filename # return the json filename where data is stored\\n \\\"\\\"\\\"\",\n \"def getTheData(self, dev):\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"getTheData FrontViewAPI method called.\\\")\\n\\n # dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Download\\\")\\n try:\\n url = 'http://' + dev.pluginProps['sourceXML'] + '/FrontView'\\n r = requests.get(url,timeout=5)\\n result = r.json()\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Result:\\\" + unicode(result))\\n self.WaitInterval = 1\\n dev.updateStateOnServer('deviceIsOnline', value=True, uiValue=\\\"Online\\\")\\n dev.setErrorStateOnServer(None)\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n return result\\n\\n except Exception as error:\\n\\n indigo.server.log(u\\\"Error connecting to Device:\\\" + dev.name)\\n self.WaitInterval = 60\\n if self.debugLevel >= 2 and self.debug:\\n self.debugLog(u\\\"Device is offline. No data to return. \\\")\\n dev.updateStateOnServer('deviceIsOnline', value=False, uiValue=\\\"Offline\\\")\\n # dev.updateStateOnServer('deviceTimestamp', value=t.time())\\n dev.setErrorStateOnServer(u'Offline')\\n result = \\\"\\\"\\n return result\",\n \"def getData(language=None):\",\n \"def download():\\n toydata = requests.get(DATA_URL).json()\\n return toydata\",\n \"def get_data_from_web():\\n pass\",\n \"def _request_data(self, url):\\n connection = httplib.HTTPConnection(self.url)\\n connection.request(\\\"GET\\\", url)\\n response = connection.getresponse()\\n\\n if response.status != 200:\\n raise Exception(response.reason)\\n\\n data = response.read()\\n response.close()\\n\\n return json.loads(data)\",\n \"def get_data(self):\\n\\n self.set_query_string()\\n self.realtime_data = super().get_data()\\n self.set_coordinate()\\n return self.realtime_data\",\n \"def get_data(self, out_format: str='json'):\\n if self.data:\\n return self.data\\n self.data_ready = self.check_available()\\n if not self.data_ready:\\n raise DataNotReady(\\\"The run {} has not yet finished, data not available yet.\\\".format(self))\\n resp = self.ph.conn.request(\\n 'GET', self.ph.URLS['getdata'].format(self.run_token), dict(api_key=self.ph.api_key, format=out_format))\\n data = resp.data.decode('utf-8')\\n self.data = self.parse_json_data(data)\\n return self.data\",\n \"def data():\\n return volumes_fetchers.get_json_data()\",\n \"def get_data(self):\\n return self.parsed_data\",\n \"def get_data():\\n try:\\n with open(CONS[\\\"OUTPUT_FILE\\\"], \\\"r\\\") as file:\\n data = json.load(file)[1]\\n return data\\n except FileNotFoundError:\\n print(\\\"Data file not found.\\\")\\n exit()\",\n \"def data(self):\\n return json.loads(self.data_json)\",\n \"def getData(self):\\r\\n return self._data\",\n \"def getData(url):\\n data = ''\\n request = urllib2.Request(url, headers={\\\"Accept\\\": \\\"application/json\\\"})\\n try:\\n data = json.loads(urllib2.urlopen(request).read())\\n except urllib2.HTTPError, e:\\n raise Exception(\\\"HTTP error: %d\\\" % e.code)\\n except urllib2.URLError, e:\\n raise Exception(\\\"Network error: %s\\\" % e.reason.args[1])\\n\\n return data\",\n \"def get(self):\\r\\n return self.data\",\n \"def get_data(self, state=None, request=None):\\n raise NotImplementedError\",\n \"def getData(self):\\n return self.__data\",\n \"def fetch_data(data_url):\\n return requests.get(data_url).content\",\n \"def get_data(self):\\n return DataGatherer().get_rainfall_data()\",\n \"def getData(eUrl, eToken):\\n if eUrl == '' or eToken == '':\\n print(\\\"Enviroment is not setup\\\")\\n exit(1)\\n\\n with urllib.request.urlopen(eUrl + eToken) as url:\\n data = json.loads(url.read().decode())\\n\\n return(data)\",\n \"def get_data(self):\\n return DataGatherer().get_wind_data()\",\n \"def get_data():\\n try:\\n with open('./data.json') as data_file:\\n return json.load(data_file)\\n except:\\n data_json = json.loads('{\\\"message\\\": \\\"Error with file data.json\\\", \\\"success\\\": false}')\\n return data_json\",\n \"def getData(tme=currentTime):\\n # attempts request 10 times\\n for attempt in range(10):\\n try:\\n # make a request to the url and return it in json format\\n url = \\\"https://api.darksky.net/forecast/%s/%s,%s,%s?exclude=minutely,hourly,daily,alerts,flags\\\" % (API_KEY, LAT, LNG, tme)\\n return get(url).json()\\n except:\\n # Wait .05 seconds and try again\\n sleep(.05)\\n pass\",\n \"def getData(self):\\n return self._data\",\n \"def getData(self):\\n return self._data\",\n \"def GetGeData(self, *args, **kwargs):\\n pass\",\n \"def getStockData():\\n pass\",\n \"def get_path_data(self, path):\\n url = self.api_server + path\\n return self.get_url_data(url)\",\n \"def download_data(self, format = 'srt'):\\n resp, content = httplib2.Http(\\\".cache\\\").request(self.url, \\\"GET\\\")\\n suburl = json.loads(content)['url']\\n resp, content = httplib2.Http(\\\".cache\\\").request(suburl, \\\"GET\\\")\\n\\n return content\",\n \"def data():\\n return None\",\n \"def GetData(self):\\r\\n \\r\\n return self._data\",\n \"def getData():\\n data = {\\n \\\"name\\\": \\\"Kim\\\",\\n \\\"message\\\": \\\"Hello there!\\\"\\n }\\n return jsonify(data) # respond to the API caller with a JSON representation of data. jsonify is important, as it sets response headers that indicate the respose is in JSON as well\",\n \"def get_data(self, url):\\n\\n req = urllib2.Request(url)\\n # urlencode the query dictionary\\n try:\\n r = urllib2.urlopen(req)\\n result = r.read()\\n except:\\n result = 'The url: %s is not responding.' % (url)\\n return result\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get_data(self):\\n return self._data\",\n \"def get(self):\\n return self.data\",\n \"def get(self):\\n return self.get_data()\",\n \"def get_data(self, request, url):\\n data = request.get(endpoint=url)\\n return data[0], data[1]\",\n \"def get_data(self):\\n self._send_command(self._adapter.get_data())\",\n \"def stations():\\n print(\\\"server received request for stations data...\\\")\\n return jsonify(stations_data)\",\n \"def get_data(self, label: str) -> Any:\\r\\n return self._get_resource(label, self._data, \\\"data\\\")\",\n \"def get_data(self):\\n with open(self.filepath, 'r') as openFile:\\n data = json.load(openFile)\\n logging.info('Loaded JSON data file.')\\n return data\",\n \"def apicall():\\r\\n# try:\\r\\n print request.get_json()\\r\\n test_json = request.get_json()\\r\\n logger.info(\\\"input json object loaded\\\")\\r\\n logger.info(test_json)\\r\\n k=MetaData(test_json)\\r\\n int_res=k.getData()\\r\\n print '------------------------------'\\r\\n print int_res\\r\\n return jsonify(int_res)\",\n \"def get_data(self):\\n return self.topo_data_flattened\",\n \"def fetch_data(self):\",\n \"def get_data():\\n if not hasattr(g, 'data'):\\n g.data = load_data()\\n return g.data\",\n \"def GetData():\\r\\n return _hiew.HiewGate_GetData()\",\n \"def get(self):\\n city = str(request.args.get('city')) ## /?city=stockholm\\n source = urllib.request.urlopen('http://127.0.0.1:5050/?city=' + city).read()\\n data = json.loads(source)\\n print(data)\\n tempinc = {\\\"name\\\" : (str(data['name'])),\\n \\\"country\\\" : (str(data['country'])),\\n \\\"temp\\\" : (str(data['temp']))+' c'}\\n return tempinc\",\n \"def _get_data_file(self, data_path):\\n\\n return json.load(open(data_path))\",\n \"async def get_data(self, endpoint):\\n try:\\n with async_timeout.timeout(5, loop=self._loop):\\n response = await self._session.get(f\\\"{endpoint}\\\")\\n\\n _LOGGER.debug(\\\"Response from Dingz device: %s\\\", response.status)\\n self.data = await response.json()\\n _LOGGER.debug(self.data)\\n except (asyncio.TimeoutError, aiohttp.ClientError):\\n _LOGGER.error(\\\"Can not load data from Dingz device\\\")\\n self.data = None\\n raise exceptions.DingzConnectionError()\",\n \"def _extract_data(self):\\n if self.URL_type == \\\"youtube\\\" or self.URL_type == \\\"ytmusic\\\":\\n self._get_youtube_data_url()\\n elif self.URL_type == \\\"soundcloud\\\":\\n self._get_soundcloud_data()\",\n \"def get_url_data(self, url):\\n # print \\\"opening: \\\" + url\\n request = urllib2.Request(url)\\n base64string = '%s:%s' % (self.username, self.key)\\n request.add_header(\\\"Authorization\\\", \\\"ApiKey %s\\\" % base64string)\\n response = urllib2.urlopen(request)\\n data = json.loads(response.read())\\n return data\",\n \"def _fetch_data(self):\\n pass\",\n \"def data(self):\\n self._get_latest_content()\\n return self._data.get('data', {})\",\n \"def get(self):\\n data = request.args.get('data')\\n\\n if not data:\\n data = \\\"OK!\\\"\\n\\n return json.loads(dumps(data)), 200\",\n \"def data(self):\\n return self._data\",\n \"def data(self):\\n file_name = join(PARENT_BASE_DIR, '.files', 'data.data.json')\\n if isfile(file_name):\\n debug(f'{file_name} file is exist.')\\n debug(f'try for load {file_name} file ->->->->->->->->->->')\\n start_load_file = time()\\n with open(file_name, 'r', encoding='utf-8')as file:\\n data = file.read()\\n data = loads(data)\\n debug(f'load file - [runtime: {time() - start_load_file}] <-<-<-<-<-<-<-<-<-<-')\\n return data, 'data exist.'\\n else:\\n debug(f'{file_name} file is not exist.')\\n return None, 'data not exist in \\\"base directory/.files/data.data.json\\\"'\",\n \"def get_data(self, lat=53.3498, lon=-6.2603):\\n r = requests.get(\\n f\\\"https://api.openweathermap.org/data/2.5/onecall?lat={lat}&lon={lon}&appid=92fb08f48a98e0f39b990060352ffebe\\\")\\n return r.text\",\n \"def get_data(self):\\n return DataGatherer().get_temperature_data()\",\n \"def getData(self, product, variables, attributes, variable, *args):\\r\\n\\r\\n data = None\\r\\n return data\",\n \"def getAllData(self):\\r\\n return self.data\",\n \"def get_data(self, body):\\n params = json.loads(body)\\n logger.debug('New Data Format')\\n return self._get_data(body)\",\n \"def stationdata():\\n # * Return a JSON list of stations from the dataset.\\n # as this should be a list, I'm just grabbing the station name\\n session = Session(engine)\\n results = session.query(Station.name).all()\\n session.close()\\n\\n stations = list(np.ravel(results))\\n return jsonify(stations)\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def get_data(self):\\n\\n return self._data\",\n \"def get_data(self):\\n\\n return self._data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7276632","0.7044919","0.7044919","0.7044919","0.6988719","0.6904598","0.67315245","0.67315245","0.6711421","0.6699119","0.66586465","0.6641715","0.65758157","0.65712667","0.6570018","0.6539462","0.6526975","0.64456314","0.64355475","0.6282369","0.6267849","0.62539583","0.62318444","0.62056994","0.6203443","0.61973894","0.61973894","0.61973894","0.61941123","0.6193835","0.6171375","0.61706764","0.61706764","0.61699045","0.613302","0.6105646","0.60901976","0.60713613","0.6064109","0.60600907","0.6059058","0.60442257","0.60441184","0.60246354","0.602411","0.6003093","0.59959054","0.59833884","0.5977262","0.59436166","0.5936724","0.5918368","0.5902448","0.5889219","0.5873394","0.5867444","0.58654165","0.58654165","0.5854547","0.58541197","0.584554","0.584539","0.5839185","0.5818117","0.578982","0.57875663","0.5783141","0.5783141","0.5783141","0.5783141","0.5777883","0.57754195","0.5767481","0.5762121","0.5746903","0.5734854","0.57335156","0.5730804","0.5727303","0.5726277","0.57260615","0.57227606","0.57018274","0.56889516","0.5685928","0.56830907","0.56817275","0.56644094","0.5659732","0.56545985","0.5647078","0.56387955","0.56344116","0.5630541","0.5630077","0.56223285","0.5616545","0.561541","0.5613653","0.5613653","0.5613653"],"string":"[\n \"0.7276632\",\n \"0.7044919\",\n \"0.7044919\",\n \"0.7044919\",\n \"0.6988719\",\n \"0.6904598\",\n \"0.67315245\",\n \"0.67315245\",\n \"0.6711421\",\n \"0.6699119\",\n \"0.66586465\",\n \"0.6641715\",\n \"0.65758157\",\n \"0.65712667\",\n \"0.6570018\",\n \"0.6539462\",\n \"0.6526975\",\n \"0.64456314\",\n \"0.64355475\",\n \"0.6282369\",\n \"0.6267849\",\n \"0.62539583\",\n \"0.62318444\",\n \"0.62056994\",\n \"0.6203443\",\n \"0.61973894\",\n \"0.61973894\",\n \"0.61973894\",\n \"0.61941123\",\n \"0.6193835\",\n \"0.6171375\",\n \"0.61706764\",\n \"0.61706764\",\n \"0.61699045\",\n \"0.613302\",\n \"0.6105646\",\n \"0.60901976\",\n \"0.60713613\",\n \"0.6064109\",\n \"0.60600907\",\n \"0.6059058\",\n \"0.60442257\",\n \"0.60441184\",\n \"0.60246354\",\n \"0.602411\",\n \"0.6003093\",\n \"0.59959054\",\n \"0.59833884\",\n \"0.5977262\",\n \"0.59436166\",\n \"0.5936724\",\n \"0.5918368\",\n \"0.5902448\",\n \"0.5889219\",\n \"0.5873394\",\n \"0.5867444\",\n \"0.58654165\",\n \"0.58654165\",\n \"0.5854547\",\n \"0.58541197\",\n \"0.584554\",\n \"0.584539\",\n \"0.5839185\",\n \"0.5818117\",\n \"0.578982\",\n \"0.57875663\",\n \"0.5783141\",\n \"0.5783141\",\n \"0.5783141\",\n \"0.5783141\",\n \"0.5777883\",\n \"0.57754195\",\n \"0.5767481\",\n \"0.5762121\",\n \"0.5746903\",\n \"0.5734854\",\n \"0.57335156\",\n \"0.5730804\",\n \"0.5727303\",\n \"0.5726277\",\n \"0.57260615\",\n \"0.57227606\",\n \"0.57018274\",\n \"0.56889516\",\n \"0.5685928\",\n \"0.56830907\",\n \"0.56817275\",\n \"0.56644094\",\n \"0.5659732\",\n \"0.56545985\",\n \"0.5647078\",\n \"0.56387955\",\n \"0.56344116\",\n \"0.5630541\",\n \"0.5630077\",\n \"0.56223285\",\n \"0.5616545\",\n \"0.561541\",\n \"0.5613653\",\n \"0.5613653\",\n \"0.5613653\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":191,"cells":{"query":{"kind":"string","value":"make the cosmos and DES meds files"},"document":{"kind":"string","value":"def make_all_cosmos_des(run, cosmos_config, des_config, catfile, tileid):\n\n flist = files.get_cosmos_flist(tileid)\n cosmos_meds = files.get_meds_file(run, tileid, 'cosmos','i')\n\n print('making cosmos MEDS:',cosmos_meds)\n maker = CosmosMEDSMaker(\n config_path=cosmos_config,\n catname=catfile,\n flistname=flist,\n )\n maker.write(cosmos_meds)\n\n for band in ['u','g','r','i','z']:\n\n band_flist = files.get_des_flist(band)\n band_meds = files.get_meds_file(run, tileid, 'des',band)\n\n print('making DES MEDS:',band_meds)\n maker = CosmosMEDSMaker(\n config_path=des_config,\n catname=cosmos_meds,\n flistname=band_flist,\n )\n maker.write(band_meds)"},"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_data_raw (mdp,do_makedata,filename):\n #\n fin = open(filename,'r')\n for line in fin:\n lsp = line.split(' ')\n if len(lsp) > 1: # skip empty lines\n if lsp[0] == \"for\": # indicates when to get correlator\n lsp.pop(0)\n update_params(mdp,lsp)\n ## -- do_makedata tells it to go ahead with generating a new data output file\n ## -- otherwise, just saves parameters to metadata\n if do_makedata:\n try:\n # open correlator file\n mdp.corr_file = open(mdp.input_path + '/' + mdp.input_fname,'r')\n except IOError:\n print \"Could not open file \",mdp.input_fname\n continue\n print mdp.input_fname,',',mdp.tag\n if not mdp.flag_out_open:\n try:\n if mdp.flag_overwrite:\n ## -- open save file for read+write\n try:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.save_file.seek(0) # go to beginning\n mdp.save_file.truncate() # delete whatever was there before\n except IOError:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'w')\n mdp.save_file.close()\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.flag_out_open = True\n # write first header\n #corr_key=uf.get_str_key(mdp.corr_file,\"correlator_key\",\\\n # int(mdp.corr_num.strip(\"[]\").split(',')[0]))\n #uf.write_header(mdp.save_file,corr_key,mdp.corr_len)\n #uf.write_section(mdp.save_file,mdp.key)\n for num,key in zip(mdp.corr_num,mdp.key):\n corr_key=uf.get_str_key(mdp.corr_file,\"correlator_key\",num)\n uf.write_header(mdp.save_file,corr_key,mdp.corr_len)\n uf.write_section(mdp.save_file,key)\n mdp.flag_overwrite= False\n else:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.save_file.seek(0,2) # seek the end of file\n mdp.flag_out_open = True\n # write another header\n #corr_key=uf.get_str_key(mdp.corr_file,\"correlator_key\",\\\n # int(mdp.corr_num.strip(\"[]\").split(',')[0]))\n #uf.write_header(mdp.save_file,corr_key,mdp.corr_len)\n #uf.write_section(mdp.save_file,mdp.key)\n for num,key in zip(mdp.corr_num,mdp.key):\n corr_key=uf.get_str_key(mdp.corr_file,\"correlator_key\",num)\n uf.write_header(mdp.save_file,corr_key,mdp.corr_len)\n uf.write_section(mdp.save_file,key)\n #except (IOError):\n # pass\n except (AttributeError):\n print \"Attempted to open invalid output file\"\n ##endif ! flag_out_open\n save_data(mdp)\n mdp.corr_file.close()\n ##endif do_makedata\n ##else \"for\" not found in control file\n else:\n update_params(mdp,lsp)\n ##endif lsp[0]==for\n ##endif len(lsp) > 1\n try:\n mdp.save_file.close()\n mdp.flag_out_open = False\n except (IOError,AttributeError):\n pass\n fin.close()\n return","def make_phys():\n for rn in dcm_dict.keys():\n # PPG\n if not dcm_dict[rn]['ppg_file'] == 'File missing':\n # Files\n ppg_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.tsv.gz')\n ppg_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.json')\n # TSV\n gzip_file(dcm_dict[rn]['ppg_file'],ppg_tsv)\n # JSON\n data = OrderedDict()\n data['SamplingFrequency'] = 100.0\n data['StartTime'] = -30.0\n data['Columns'] = 'cardiac'\n with open(ppg_json, 'w') as ff:\n json.dump(data, ff,sort_keys=False, indent=4)\n # Respiration\n if not dcm_dict[rn]['resp_file'] == 'File missing':\n # Files\n resp_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-respiratory.tsv.gz')\n resp_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-respiratory.json')\n # TSV\n gzip_file(dcm_dict[rn]['resp_file'],resp_tsv)\n # JSON\n data = OrderedDict()\n data['SamplingFrequency'] = 25.0\n data['StartTime'] = -30.0\n data['Columns'] = 'respiratory'\n with open(resp_json, 'w') as ff:\n json.dump(data, ff,sort_keys=False, indent=4)\n # ECG\n # What to do if they have PPG and ECG?\n if not dcm_dict[rn]['ecg_file'] == 'File missing':\n # Files\n ecg_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.tsv.gz')\n ecg_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.json')\n # TSV\n gzip_file(dcm_dict[rn]['resp_file'],resp_tsv)\n # JSON\n data = OrderedDict()\n data['SamplingFrequency'] = 1000.0\n data['StartTime'] = -30.0\n data['Columns'] = 'cardiac'\n with open(resp_json, 'w') as ff:\n json.dump(data, ff,sort_keys=False, indent=4)","def create_demo_dcm_data(dcm_dir):\n pet_fname = os.path.join(os.path.dirname(__file__), 'data', 'brainweb_06_osem.nii')\n mr_fname = os.path.join(os.path.dirname(__file__), 'data', 'brainweb_06_t1.nii')\n \n pet, pet_affine = flip_ras_lps(*load_nii_in_ras(pet_fname))\n mr, mr_affine = flip_ras_lps(*load_nii_in_ras(mr_fname))\n\n os.mkdir(dcm_dir)\n write_3d_static_dicom(pet, os.path.join(dcm_dir, 'PT'), pet_affine, modality = 'PT')\n write_3d_static_dicom(mr, os.path.join(dcm_dir, 'MR'), mr_affine, modality = 'MR')","def writeNMD(filename, modes, atoms, zeros=False):\n\n if not isinstance(modes, (NMA, ModeSet, Mode, Vector)):\n raise TypeError('modes must be NMA, ModeSet, Mode, or Vector, '\n 'not {0}'.format(type(modes)))\n if modes.numAtoms() != atoms.numAtoms():\n raise Exception('number of atoms do not match')\n out = openFile(addext(filename, '.nmd'), 'w')\n\n #out.write('#!{0} -e\\n'.format(VMDPATH))\n out.write('nmwiz_load {0}\\n'.format(abspath(filename)))\n name = modes.getTitle()\n name = name.replace(' ', '_').replace('.', '_')\n if not name.replace('_', '').isalnum() or len(name) > 30:\n name = str(atoms)\n name = name.replace(' ', '_').replace('.', '_')\n if not name.replace('_', '').isalnum() or len(name) > 30:\n name = splitext(split(filename)[1])[0]\n out.write('name {0}\\n'.format(name))\n try:\n coords = atoms.getCoords()\n except:\n raise ValueError('coordinates could not be retrieved from atoms')\n if coords is None:\n raise ValueError('atom coordinates are not set')\n\n try:\n data = atoms.getNames()\n if data is not None:\n out.write('atomnames {0}\\n'.format(' '.join(data)))\n except:\n pass\n try:\n data = atoms.getResnames()\n if data is not None:\n out.write('resnames {0}\\n'.format(' '.join(data)))\n except:\n pass\n try:\n data = atoms.getResnums()\n if data is not None:\n out.write('resids ')\n data.tofile(out, ' ')\n out.write('\\n')\n except:\n pass\n try:\n data = atoms.getChids()\n if data is not None:\n out.write('chainids {0}\\n'.format(' '.join(data)))\n except:\n pass\n try:\n data = atoms.getSegnames()\n if data is not None:\n out.write('segnames {0}\\n'.format(' '.join(data)))\n except:\n pass\n\n try:\n data = atoms.getBetas()\n if data is not None:\n out.write('bfactors ')\n data.tofile(out, ' ', '%.2f')\n out.write('\\n')\n except:\n pass\n\n format = '{0:.3f}'.format\n out.write('coordinates ')\n coords.tofile(out, ' ', '%.3f')\n out.write('\\n')\n count = 0\n if isinstance(modes, Vector):\n out.write('mode 1 {0:.2f} '.format(abs(modes)))\n modes.getNormed()._getArray().tofile(out, ' ', '%.3f')\n out.write('\\n')\n count += 1\n else:\n if isinstance(modes, Mode):\n modes = [modes]\n for mode in modes:\n if (mode.getEigval() < ZERO) and not zeros:\n continue\n elif (mode.getEigval() < ZERO) and zeros:\n out.write('mode {0} {1:.2f} '.format(\n mode.getIndex()+1, np.sqrt(1/(0.0001*(mode.getIndex()+1)))))\n else:\n out.write('mode {0} {1:.2f} '.format(\n mode.getIndex()+1, mode.getVariance()**0.5))\n arr = mode._getArray().tofile(out, ' ', '%.3f')\n out.write('\\n')\n count += 1\n if count == 0:\n LOGGER.warning('No normal mode data was written. '\n 'Given modes might have 0 eigenvalues.')\n out.close()\n return filename","def make_data_raw_fast(mdp,do_makedata,filename):\n #\n fin = open(filename,'r')\n for line in fin:\n lsp = line.split(' ')\n if len(lsp) > 1: # skip empty lines\n if lsp[0] == \"for\": # indicates when to get correlator\n lsp.pop(0)\n update_params(mdp,lsp)\n ## -- do_makedata tells it to go ahead with generating a new data output file\n ## -- otherwise, just saves parameters to metadata\n if do_makedata:\n try:\n # open correlator file\n mdp.corr_file = open(mdp.input_path + '/' + mdp.input_fname,'r')\n except IOError:\n print \"Could not open file \",mdp.input_fname\n continue\n print mdp.input_fname\n if not mdp.flag_out_open:\n try:\n if mdp.flag_overwrite:\n ## -- open save file for read+write\n try:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.save_file.seek(0) # go to beginning\n mdp.save_file.truncate() # delete whatever was there before\n except IOError:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'w')\n mdp.save_file.close()\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.flag_out_open = True\n #for num,key in zip(mdp.corr_num,mdp.key):\n # corr_key=uf.get_str_key(mdp.corr_file,\"correlator_key\",num)\n mdp.flag_overwrite= False\n else:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.save_file.seek(0,2) # seek the end of file\n mdp.flag_out_open = True\n #for num,key in zip(mdp.corr_num,mdp.key):\n # corr_key=uf.get_str_key(mdp.corr_file,\"correlator_key\",num)\n #except (IOError):\n # pass\n except (AttributeError):\n print \"Attempted to open invalid output file\"\n ##endif ! flag_out_open\n save_data_fast(mdp)\n mdp.corr_file.close()\n ##endif do_makedata\n ##else \"for\" not found in control file\n else:\n update_params(mdp,lsp)\n ##endif lsp[0]==for\n ##endif len(lsp) > 1\n try:\n mdp.save_file.close()\n mdp.flag_out_open = False\n except (IOError,AttributeError):\n pass\n fin.close()\n return","def writeDataCards(opt,sigExp,bkgExp,shapesURL):\n\n #create a card per category\n dcList=[]\n for icat in range(len(opt.categs)):\n cat='%s_a%d_%d'%(opt.chTag,opt.xangle,icat)\n dcTxt='%s/shapes-parametric.datacard_%s.dat'%(opt.output,cat)\n dcList.append(dcTxt)\n with open(dcTxt,'w') as dc:\n dc.write('#\\n')\n dc.write('# datacard was automatically generated with generateWorkspace.py\\n')\n dc.write('# the options passed are printed below\\n')\n dc.write('# %s\\n'%opt)\n dc.write('#\\n')\n dc.write('imax *\\n')\n dc.write('jmax *\\n')\n dc.write('kmax *\\n')\n dc.write('-'*50+'\\n')\n dc.write('shapes * * {0} $PROCESS_{1} $PROCESS_$SYSTEMATIC\\n'.format(shapesURL,cat))\n dc.write('shapes data_obs * {0} $PROCESS_{1}\\n'.format(shapesURL,cat))\n dc.write('-'*50+'\\n')\n dc.write('bin %s\\n'%cat)\n dc.write('observation -1\\n')\n dc.write('-'*50+'\\n')\n dc.write('%15s %15s %15s\\n'%('bin',cat,cat))\n dc.write('%15s %15s %15s\\n'%('process','sig','bkg'))\n dc.write('%15s %15s %15s\\n'%('process','0', '1'))\n dc.write('%15s %15s %15s\\n'%('rate','%3.2f'%sigExp[icat], '%3.2f'%bkgExp[icat]))\n dc.write('-'*50+'\\n')\n \n #float the background normalization as well as the signal\n dc.write('mu_bkg{0} rateParam {0} bkg 1\\n'.format(cat))\n\n #uncertainties\n dc.write('lumi %8s %15s %15s\\n'%('lnN','1.027','-'))\n dc.write('%s_sigShape %8s %15s %15s\\n'%(cat,'shape','1','-'))\n dc.write('%s_bkgShape %8s %15s %15s\\n'%(cat,'shape','-','1'))\n dc.write('{0} autoMCStats 0.0 1\\n'.format(cat))\n \n print '\\tshapes available @',shapesURL\n print '\\tgenerated the following datacards',dcList","def write_conformers(self, filename): # ccids):\n cnt = 0\n for confId in range(self.nconf): #ccids:\n w = Chem.SDWriter('%s_c%03d.sdf'%(filename,cnt+1))\n w.write(self.mol, confId=confId)\n w.flush()\n w.close()\n cnt += 1","def Construct3DMolToFile(fileName,writeFile):\r\n # Writing sets of molecules\r\n \r\n\r\n w = Chem.SDWriter(writeFile)\r\n suppl = Chem.SDMolSupplier(fileName)\r\n mols = [x for x in suppl]\r\n for mol in mols:\r\n \t# print(mol.GetProp(\"Solvent\"))\r\n \t# print(mol.GetPropNames)\r\n \tsignal.signal(signal.SIGALRM, handler)\r\n \tsignal.alarm(100)\r\n \ttry:\r\n \t\tmol3d = GetMolFromMol(mol,dimension=3)\r\n \t\tw.write(mol3d)\r\n \texcept Exception:\r\n \t\tmol3d = mol\r\n \t\tw.write(mol3d)\r\n \t\t# print(mol.GetPropsAsDict())\r\n\r\n\r\n w.close()","def generate_epics_db(self):\n if (self.verbose):\n # Generate digital application related databases and configuration files\n print(\"==================================================\")\n print(\"== Generating EPICS DB and configuration files: ==\")\n print(\"==================================================\")\n \n print(\"----------------------------\")\n print(\"-- Digital applications --\")\n print(\"----------------------------\")\n for app in self.digital_apps:\n app_path = '{}app_db/{}/{:04}/{:02}/'.format(self.dest_path, app[\"cpu_name\"], app[\"crate_id\"], app[\"slot_number\"])\n app_prefix = 'MPLN:{}:{}:{}'.format(app[\"link_node_area\"].upper(), app[\"link_node_location\"].upper(), app[\"card_index\"])\n if (self.verbose):\n print(\"Application path : {}\".format(app_path))\n print(\"Application prefix : {}\".format(app_prefix))\n \n self.__write_dig_app_id_confg(path=app_path, macros={\"ID\":str(app[\"app_id\"])})\n\n # Add the IOC name environmental variable for the Link Nodes\n self.__write_header_env(path=app_path, macros={\"MPS_LINK_NODE\":app[\"link_node_name\"],\n \"MPS_DB_VERSION\":self.config_version,\n \"DATE\":datetime.datetime.now().strftime('%Y.%m.%d-%H:%M:%S')})\n self.__write_iocinfo_env(path=app_path, macros={\"AREA\":app[\"link_node_area\"].upper(),\n \"LOCATION\":app[\"link_node_location\"].upper(),\n \"LOC_IDX\":app['link_node_location'].upper().replace('MP', ''),\n \"C_IDX\":unicode(app['card_index'])})\n if self.link_nodes[app[\"link_node_name\"]]['type'] == 'Digital':\n self.__write_prefix_env(path=app_path, macros={\"P\":app_prefix})\n self.__write_mps_db(path=app_path, macros={\"P\":app_prefix, \"THR_LOADED\":\"1\"})\n self.__write_app_id_config(path=app_path, macros={\"ID\":\"0\"}) # If there are no analog cards, set ID to invalid\n\n has_virtual = False\n for device in app[\"devices\"]:\n device_prefix = \"{}:{}:{}\".format(device[\"type_name\"], device[\"area\"], device[\"position\"])\n\n if (self.verbose):\n print(\" Device prefix : {}\".format(device_prefix))\n\n for input in device[\"inputs\"]:\n\n if app[\"virtual\"]:\n has_virtual = True\n if (input[\"bit_position\"]>=32):\n scan = \".2 second\"\n if (input['name'] == 'WDOG'):\n if (\"MPSHEARTBEAT\" in input[\"input_pv\"]):\n scan = \".1 second\"\n channel = input[\"bit_position\"] - 32\n vmacros = { \"P\":input[\"input_pv\"]+'_THR',\n \"R\":input[\"name\"],\n \"N\":self.mps_name.getDeviceInputNameFromId(input[\"db_id\"]),\n \"INPV\":input[\"input_pv\"],\n \"ALSTATE\":str(input[\"alarm_state\"]),\n \"NALSTATE\":str(to_bool(not input[\"alarm_state\"])),\n \"ZSV\":input[\"zero_severity\"],\n \"OSV\":input[\"one_severity\"],\n \"BIT\":\"{:02d}\".format(channel).format,\n \"ZNAM\":input[\"zero_name\"],\n \"ONAM\":input[\"one_name\"], \n \"GID\":str(app[\"app_id\"]),\n \"SCAN\":scan}\n if (input['name'] == 'WDOG'):\n self.__write_virtual_wdog_db(path=app_path, macros=vmacros)\n else:\n self.__write_virtual_db(path=app_path, macros=vmacros)\n\n\n macros = { \"P\":device_prefix,\n \"R\":input[\"name\"],\n \"BIT\":input[\"bit_position\"],\n \"ZNAM\":input[\"zero_name\"],\n \"ONAM\":input[\"one_name\"] }\n\n if (self.verbose):\n print(\" Digital Input : {}\".format(input[\"name\"]))\n\n if (self.verbose):\n print(\"----------------------------\")\n\n print(\"==================================================\")\n print(\"\")\n\n # Generates analog application related databases and configuration files\n if (self.verbose):\n print(\"--------------------------\")\n print(\"-- Analog applications --\")\n print(\"--------------------------\")\n for app in self.analog_apps:\n app_path = '{}app_db/{}/{:04}/{:02}/'.format(self.dest_path, app[\"cpu_name\"], app[\"crate_id\"], app[\"slot_number\"])\n app_prefix = 'MPLN:{}:{}:{}'.format(app[\"link_node_area\"].upper(), app[\"link_node_location\"].upper(), app[\"card_index\"])\n if (self.verbose):\n print(\"Application path : {}\".format(app_path))\n print(\"Application prefix : {}\".format(app_prefix))\n\n self.__write_mps_db(path=app_path, macros={\"P\":app_prefix, \"THR_LOADED\":\"0\"})\n self.__write_app_id_config(path=app_path, macros={\"ID\":str(app[\"app_id\"])})\n self.__write_thresholds_off_config(path=app_path)\n\n # Add the IOC name environmental variable for the Link Nodes\n if app[\"analog_link_node\"]:\n self.__write_header_env(path=app_path, macros={\"MPS_LINK_NODE\":app[\"link_node_name\"],\n \"MPS_DB_VERSION\":self.config_version,\n \"DATE\":datetime.datetime.now().strftime('%Y.%m.%d-%H:%M:%S')})\n\n self.__write_iocinfo_env(path=app_path, macros={\"AREA\":app[\"link_node_area\"].upper(),\n \"LOCATION\":app[\"link_node_location\"].upper(),\n \"LOC_IDX\":app['link_node_location'].upper().replace('MP', ''),\n \"C_IDX\":unicode(app['card_index'])})\n self.__write_prefix_env(path=app_path, macros={\"P\":app_prefix})\n\n spare_channels = range(0,6)\n for device in app[\"devices\"]:\n device_prefix = \"{}:{}:{}\".format(device[\"type_name\"], device[\"area\"], device[\"position\"])\n\n if (self.verbose):\n print(\" Device prefix : {}\".format(device_prefix))\n\n if (device[\"type_name\"] not in self.non_link_node_types):\n macros = { \"P\": app_prefix,\n \"CH\":str(device[\"channel_index\"]),\n \"CH_NAME\":device[\"device_name\"],\n \"CH_PVNAME\":device_prefix,\n \"CH_SPARE\":\"0\"\n }\n self.__write_link_node_channel_info_db(path=app_path, macros=macros)\n processing = 0\n ch = device['channel_index']\n if (device[\"type_name\"] == \"CBLM\"):\n processing = 1\n if (device[\"type_name\"] == \"KICK\"):\n processing = 1\n int0 = device['channel_index']*4\n int1 = device['channel_index']*4 + 1\n macros = { \"CH\":format(device['channel_index']),\n \"PROC\":format(processing),\n \"INT0\":format(int0),\n \"INT1\":format(int1)\n }\n self.__write_ana_config(path=app_path, macros=macros)\n spare_channels[device[\"channel_index\"]] = -1\n for fault in device[\"faults\"].values():\n bsa_slot = fault['integrators'][0]*6 + device[\"channel_index\"]\n macros = { \"P\":app_prefix,\n \"R\":'ANA_BSA_DATA_{}'.format(bsa_slot),\n \"P_DEV\":device_prefix,\n \"R_DEV\":self.get_analog_type_name(device[\"type_name\"]),\n \"FAULT\":fault['name'],\n \"EGU\":self.get_app_units(device[\"type_name\"],fault[\"name\"])\n }\n self.__write_analog_db(path=app_path, macros=macros)\n macros = { \"P\":device_prefix,\n \"BAY\":format(device[\"bay_number\"]),\n \"APP\":self.get_app_type_name(device[\"type_name\"]),\n \"FAULT\":fault[\"name\"],\n \"FAULT_INDEX\":self.get_fault_index(device[\"type_name\"], fault[\"name\"], device[\"channel_number\"]),\n \"DESC\":fault[\"description\"],\n \"EGU\":self.get_app_units(device[\"type_name\"],fault[\"name\"]),\n \"SLOPE\":unicode(self.get_slope(device[\"type_name\"])),\n \"OFFSET\":unicode(self.get_offset(device[\"type_name\"]))}\n self.__write_thr_base_db(path=app_path, macros=macros)\n # Generate PV for all possible thresholds, even if not defined in database\n for bit in range(0,8):#fault[\"bit_positions\"]:\n fault_prefix = \"{}_T{}\".format(fault[\"name\"], bit)\n macros[\"BIT_POSITION\"] = str(bit)\n self.__write_thr_db(path=app_path, macros=macros)\n if (self.verbose):\n print(\" Fault prefix : {}\".format(fault_prefix))\n\n\n for ch in spare_channels:\n if ch > -1:\n macros = { \"P\": app_prefix,\n \"CH\":str(ch),\n \"CH_NAME\":\"Spare\",\n \"CH_PVNAME\":\"None\",\n \"CH_SPARE\":\"1\"\n }\n self.__write_link_node_channel_info_db(path=app_path, macros=macros)\n\n #\n # Write db information about slots of each link node\n #\n for app in self.analog_apps + self.digital_apps:\n app_path = '{}app_db/{}/{:04}/{:02}/'.format(self.dest_path, app[\"cpu_name\"], app[\"crate_id\"], app[\"slot_number\"])\n link_node_info=self.link_nodes[app[\"link_node_name\"]]\n #print link_node_info\n if not 'exported' in link_node_info:\n for slot in range(2,8):\n if slot in link_node_info['slots']:\n macros = { \"P\": app[\"app_prefix\"],\n \"SLOT\": str(slot),\n \"SLOT_NAME\": link_node_info['slots'][slot]['type'],\n \"SLOT_PVNAME\": link_node_info['slots'][slot]['pv_base'],\n \"SLOT_SPARE\": \"0\"}\n else:\n macros = { \"P\": app[\"app_prefix\"],\n \"SLOT\": str(slot),\n \"SLOT_NAME\": \"Spare\",\n \"SLOT_PVNAME\": \"Spare\",\n \"SLOT_SPARE\": \"1\"}\n\n self.__write_link_node_slot_info_db(path=app_path, macros=macros)\n\n # Add CH_* PVs for digital-only link nodes. These are added before \n # only if the LN is Mixed or Analog\n if link_node_info['type'] == 'Digital':\n for ch in spare_channels:\n macros = { \"P\": app[\"app_prefix\"],\n \"CH\":str(ch),\n \"CH_NAME\":\"Not Available\",\n \"CH_PVNAME\":\"None\",\n \"CH_SPARE\":\"1\"\n }\n self.__write_link_node_channel_info_db(path=app_path, macros=macros)\n\n link_node_info['exported']=True\n\n #\n # Add Link Node related information\n #\n #for ln_name,ln in self.link_nodes.items():\n # if \"lc1_node_id\" not in ln:\n # continue\n # if \"dig_app_id\" not in ln:\n # continue\n # print ln[\"lc1_node_id\"] + ' ' + ln[\"type\"] + ' ' + ln[\"dig_app_id\"]\n for ln_name,ln in self.link_nodes.items():\n self.__write_lc1_info_config(ln)\n self.__write_link_node_info_db(ln_name, ln)\n\n if (self.verbose):\n print(\"--------------------------\")","def export_model_description(md: ModelDescription) -> bytes:\n\n # ---------------- write model description -------------------\n\n fmd = ET.Element(\"fmiModelDescription\")\n fmd.set(\"fmiVersion\", \"2.0\")\n fmd.set(\"modelName\", md.modelName)\n fmd.set(\"guid\", md.guid)\n fmd.set(\"author\", md.author)\n fmd.set(\"generationDateAndTime\", md.generationDateAndTime)\n fmd.set(\"variableNamingConvention\", md.variableNamingConvention)\n fmd.set(\"generationTool\", md.generationTool)\n fmd.set(\"description\", md.description)\n\n # CoSimulation\n cs = ET.SubElement(fmd, \"CoSimulation\")\n cs.set(\"modelIdentifier\", md.CoSimulation.modelIdentifier)\n cs.set(\n \"needsExecutionTool\", str(md.CoSimulation.needsExecutionTool).lower(),\n )\n cs.set(\n \"canHandleVariableCommunicationStepSize\",\n str(md.CoSimulation.canHandleVariableCommunicationStepSize).lower(),\n )\n cs.set(\n \"canInterpolateInputs\", str(md.CoSimulation.canInterpolateInputs).lower(),\n )\n\n cs.set(\n \"maxOutputDerivativeOrder\", str(md.CoSimulation.maxOutputDerivativeOrder),\n )\n cs.set(\n \"canRunAsynchronuously\", str(md.CoSimulation.canRunAsynchronuously).lower(),\n )\n cs.set(\n \"canBeInstantiatedOnlyOncePerProcess\",\n str(md.CoSimulation.canBeInstantiatedOnlyOncePerProcess).lower(),\n )\n cs.set(\n \"canNotUseMemoryManagementFunctions\",\n str(md.CoSimulation.canNotUseMemoryManagementFunctions).lower(),\n )\n cs.set(\n \"canGetAndSetFMUstate\", str(md.CoSimulation.canGetAndSetFMUstate).lower(),\n )\n cs.set(\n \"canSerializeFMUstate\", str(md.CoSimulation.canSerializeFMUstate).lower(),\n )\n cs.set(\n \"providesDirectionalDerivative\",\n str(md.CoSimulation.providesDirectionalDerivative).lower(),\n )\n\n # 2.2.4 p.42) Log categories:\n cs = ET.SubElement(fmd, \"LogCategories\")\n for ac in md.logCategories:\n c = ET.SubElement(cs, \"Category\")\n c.set(\"name\", ac)\n\n # 2.2.7 p.47) ModelVariables\n mvs = ET.SubElement(fmd, \"ModelVariables\")\n\n variable_index = 0\n\n for var in md.modelVariables:\n var.variability\n value_reference = str(var.value_reference)\n\n idx_comment = ET.Comment(f'Index of variable = \"{variable_index + 1}\"')\n mvs.append(idx_comment)\n sv = ET.SubElement(mvs, \"ScalarVariable\")\n sv.set(\"name\", var.name)\n sv.set(\"valueReference\", value_reference)\n sv.set(\"variability\", var.variability)\n sv.set(\"causality\", var.causality)\n\n if var.description:\n sv.set(\"description\", var.description)\n\n if var.initial:\n i = var.initial\n sv.set(\"initial\", i)\n\n val = ET.SubElement(sv, var.dataType)\n\n # 2.2.7. p.48) start values\n if var.initial in {\"exact\", \"approx\"} or var.causality == \"input\":\n assert (\n var.start != None\n ), \"a start value must be defined for intial ∈ {exact, approx}\"\n val.set(\"start\", var.start)\n\n variable_index += 1\n\n ms = ET.SubElement(fmd, \"ModelStructure\")\n\n # 2.2.8) For each output we must declare 'Outputs' and 'InitialUnknowns'\n outputs = [\n (idx + 1, o)\n for idx, o in enumerate(md.modelVariables)\n if o.causality == \"output\"\n ]\n\n if outputs:\n os = ET.SubElement(ms, \"Outputs\")\n for idx, o in outputs:\n ET.SubElement(os, \"Unknown\", {\"index\": str(idx), \"dependencies\": \"\"})\n\n os = ET.SubElement(ms, \"InitialUnknowns\")\n for idx, o in outputs:\n ET.SubElement(os, \"Unknown\", {\"index\": str(idx), \"dependencies\": \"\"})\n\n # FMI requires encoding to be encoded as UTF-8 and contain a header:\n #\n # See 2.2 p.28\n return ET.tostring(fmd, pretty_print=True, encoding=\"utf-8\", xml_declaration=True)","def make_database(num_files=10):\n for i in range(num_files):\n print('\\n\\n\\nCreating set', str(i), '\\n\\n\\n')\n s_file = 'set' + str(i) + '.hdf5' \n play_dominoes(save_file=s_file)","def write(self, filename):\n assert filename[-3:]=='.fz','name must end in .fz'\n\n files.makedir_fromfile(filename)\n\n ucfilename=filename[0:-3]\n bname = os.path.basename(ucfilename)\n\n tmp_path = os.path.join(\n files.get_temp_dir(),\n bname,\n )\n files.makedir_fromfile(tmp_path)\n\n with TempFile(tmp_path) as tfile:\n super(CosmosMEDSMaker,self).write(tfile.path)\n self._compress_meds_file(tfile.path, filename)","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 generateDataset(self):\n if self.outdir[-1] != \"/\": \n self.outdir += \"/\"\n self.outdir += \"dataset_trackml\"\n i = 1\n while os.path.exists(self.outdir):\n self.outdir.replace(\"_\"+str(i-1), \"\")\n self.outdir += (\"_\"+str(i))\n i += 1\n cmd = \"mkdir -p \"+ self.outdir\n os.system(cmd)\n\n cont = pc.particleController()\n cont.generateEvents(self.numevents, self.hpe, self.detectors)\n\n self.generateHits(cont)\n self.generateTruths(cont)\n self.generateSolution(cont)","def generate_file(material_id):\n apr=get_doc_from_MP(material_id)\n mat_list=generate_matrix(apr)\n formu=POSCAR_title(apr)\n cell_for=generate_cell_formula(apr)\n needed_dos=generate_dos_str(material_id)\n revise_dos=dos_into_string(needed_dos)\n ordered_list=generate_ordered_list(revise_dos)\n my_ordered_elements=generate_ordered_elements(revise_dos,ordered_list)\n my_ordered_numbers=generate_ordered_numbers(revise_dos,ordered_list,cell_for)\n generate_POSCAR(formu,mat_list,my_ordered_elements,my_ordered_numbers,revise_dos)","def createDataDescriptionTxtFile(pMassFile=[], pMassDcmpFile=[], pMassDcmpSpkesFile=[], pMassBrianFile=[]):\n\n if isinstance(pMassFile,str):\n if os.path.isfile(pMassFile):\n # Load in the data to see what the hell it is\n inputDataFile = open(pMassFile, \"rb\")\n dataOut = pickle.load(inputDataFile)\n inputDataFile.close()\n # Now we need to write a description of what the data is! [dataOut, xmin, xmax, vmin, vmax, amin, amax, dt, tmax]\n numbOfTrials = len(dataOut[0]) # This is the number of individual trails stored\n xmin = dataOut[1]\n xmax = dataOut[2]\n vmin = dataOut[3]\n vmax = dataOut[4]\n amin = dataOut[5]\n amax = dataOut[6]\n dt = dataOut[7]\n tmax = dataOut[8]\n descpFName = pMassFile[:-4]+'DESC.txt'\n file = open(descpFName,'w')\n file.write(\"1-D Moving Mass Data Description\\n\")\n file.write(\"\\nData here is generated from the genAndSaveMoving1DMassData() method\\n\")\n file.write(\"\\nFileName... \"+pMassFile)\n file.write(\"\\niterations. \"+str(numbOfTrials))\n file.write(\"\\nxmin....... \"+str(xmin))\n file.write(\"\\nxmax....... \"+str(xmax))\n file.write(\"\\nvmin........\"+str(vmin))\n file.write(\"\\nvmax........\"+str(vmax))\n file.write(\"\\namin........\"+str(amin))\n file.write(\"\\namax........\"+str(amax))\n file.write(\"\\ndt..........\"+str(dt))\n file.write(\"\\ntmax........\"+str(tmax))\n file.close\n if isinstance(pMassDcmpFile, str):\n if os.path.isfile(pMassDcmpFile):\n # Load in teh data to see what it has it there\n inputDataFile = open(pMassDcmpFile, \"rb\")\n dataOut = pickle.load(inputDataFile)\n inputDataFile.close()\n # Now we need to write a description of what the data is! [segmentedTrials, gCenters, b, dataFile, xStart, xStop, nGaus, bInitial, dt]\n numbOfTrials = len(dataOut[0])\n originatingDataFile = dataOut[3]\n numbGaus = dataOut[6]\n xStart = dataOut[4]\n xStop = dataOut[5]\n GausVarb = dataOut[2]\n dt = dataOut[8]\n descpFName = pMassDcmpFile[:-4]+\"DESC.txt\"\n file = open(descpFName,'w')\n file.write(\"1-D Moving Mass Decomposed Data Description\\n\")\n file.write(\"\\nData here is generated from the decomposeMoving1DMassData() method\\n\")\n file.write(\"\\nFileName.......\"+pMassDcmpFile)\n file.write(\"\\nInputDataFile..\"+originatingDataFile)\n file.write(\"\\niterations.....\"+str(numbOfTrials))\n file.write(\"\\nNumbOfGauss....\"+str(numbGaus))\n file.write(\"\\nxStart.........\"+str(xStart))\n file.write(\"\\nxStop..........\"+str(xStop))\n file.write(\"\\nGausVarbl_b....\"+str(GausVarb))\n file.write(\"\\ndt.............\"+str(dt))\n file.close()\n if isinstance(pMassDcmpSpkesFile, str):\n if os.path.isfile(pMassDcmpSpkesFile):\n # Load in teh data to see what it has it there\n inputDataFile = open(pMassDcmpSpkesFile, \"rb\")\n dataOut = pickle.load(inputDataFile)\n inputDataFile.close()\n # Now we need to write a description of what the data is! [segmentedSpikesList, dataFile, spikeGenType, analgSingnalScaling]\n numbOfTrials = len(dataOut[0])\n originatingDataFile = dataOut[1]\n spikeGenType = dataOut[2]\n analogScl = dataOut[3]\n descpFName = pMassDcmpSpkesFile[:-4]+\"DESC.txt\"\n file = open(descpFName,'w')\n file.write(\"1-D Moving mass Decomposed and Turned to Spikes Data Description\\n\")\n file.write(\"\\nData here is generated from the decompedToSpikes1DMassData\\n\")\n file.write(\"\\nFileName.........\"+pMassDcmpSpkesFile)\n file.write(\"\\nInputDataFile....\"+originatingDataFile)\n file.write(\"\\nIterations.......\"+str(numbOfTrials))\n file.write(\"\\nSpike-Gen-Type...\"+spikeGenType)\n file.write(\"\\nSignal-Scaling...\"+str(analogScl))\n file.close()\n if isinstance(pMassBrianFile, str):\n if os.path.isfile(pMassBrianFile):\n # Load in the data to see what it has in there\n inputDataFile = open(pMassBrianFile, \"rb\")\n dataOut = pickle.load(inputDataFile)\n inputDataFile.close()\n # Now we need to write a description of what the data is! [spikesInBrianForm, dataFile, origDataFile]\n descpFName = pMassBrianFile[:-4]+\"DESC.txt\"\n file = open(descpFName, 'w')\n file.write(\"1-D Moving mass data decomposed, turned into spikes, and then turned into a brain sim. compatible format\\n\")\n file.write(\"\\n Data here is generated from the convertSpikeseToBrainForm()\\n\")\n file.write(\"\\nFilename.............................\"+pMassBrianFile)\n file.write(\"\\nOriginating Decompled Data File .... \"+dataOut[1])\n file.close()","def handle_store(self, event):\n\n \n mode_prefixes = {'CT Image Storage' : 'CT',\n 'Enhanced CT Image Storage' : 'CTE',\n 'MR Image Storage' : 'MR',\n 'Enhanced MR Image Storage' : 'MRE',\n 'Positron Emission Tomography Image Storage' : 'PT',\n 'RT Plan Storage' : 'RP',\n 'RT Structure Set Storage' : 'RS',\n 'Computed Radiography Image Storage' : 'CR',\n 'Ultrasound Image Storage' : 'US',\n 'Enhanced Ultrasound Image Storage' : 'USE',\n 'X-Ray Angiographic Image Storage' : 'XA',\n 'Enhanced XA Image Storage' : 'XAE',\n 'Nuclear Medicine Image Storage' : 'NM',\n 'Secondary Capture Image Storage' : 'SC'\n }\n\n ds = event.dataset\n # Because pydicom uses deferred reads for its decoding, decoding errors\n # are hidden until encountered by accessing a faulty element\n try:\n sop_class = ds.SOPClassUID\n sop_instance = ds.SOPInstanceUID\n except Exception as exc:\n # Unable to decode dataset\n return 0xC210\n\n try:\n # Get the elements we need\n mode_prefix = mode_prefixes[sop_class.name]\n except KeyError:\n mode_prefix = 'UN'\n\n filename = os.path.join(self.config['output']['directory'],'tmp/{0!s}.dcm'.format(uuid.uuid4()))\n\n # Presentation context\n cx = event.context\n\n meta = Dataset()\n meta.MediaStorageSOPClassUID = sop_class\n meta.MediaStorageSOPInstanceUID = sop_instance\n \n meta.TransferSyntaxUID = cx.transfer_syntax\n \n\n ds.file_meta = meta\n ds.is_little_endian = cx.transfer_syntax.is_little_endian\n ds.is_implicit_VR = cx.transfer_syntax.is_implicit_VR\n\n status_ds = Dataset()\n \n try:\n ds.save_as(filename, write_like_original=False)\n self.file_count += 1\n self.writing_queue.put((filename, ds))\n status_ds.Status = 0x0000 # Success\n except IOError:\n # Failed - Out of Resources - IOError\n status_ds.Status = 0xA700\n except:\n # Failed - Out of Resources - Miscellaneous error\n status_ds.Status = 0xA701\n\n\n return status_ds","def create_dnz_file(args):\n\n file = open(args.o, 'w')\n\n file.write(\"% ----DATA VARIABLES----\\n\\n\")\n file.write(\"t=\" + str(args.t) + \";\" + \"%number of attributes\\n\")\n file.write(\"k=\" + str(args.k) + \";\" + \"%max length of the support set\\n\")\n file.write(\"n=\" + str(args.n) + \";\" + \"%number of positive instances\\n\")\n file.write(\"m=\" + str(args.m) + \";\" + \"%number of negative instances\\n\")\n file.write(\"c=\" + str(args.c) + \";\" + \"%number of atMostOne Constraints\\n\\n\")\n\n file.write(\"% ----OMEGAS----\\n\\n\")\n\n omega_p = generate_omega_data(args.t, args.n, args.b)\n file.write(\"omegap= \" + omega_to_mz(omega_p) + \"\\n\\n\")\n\n omega_n = generate_disjoint_omega_data(omega_p, args.m, args.b)\n file.write(\"omegan= \" + omega_to_mz(omega_n) + \"\\n\\n\")\n\n file.write(\"% ----CONSTRAINS----\\n\\n\")\n at_most_one = generate_at_most_one(int(args.t/2), args.c, 1, args.t)\n file.write(\"atMostOne=\" + at_most_one_to_mz(at_most_one))","def build(self):\n self.kwargs.pop('clobber', None)\n\n # Read in mock catalog with assigned photometric redshifts\n # and calculate the line-of-sight displacement between the \n # upweighted galaxy and the photometric redshift of the \n # collided galaxy \n photoz_cat_corr = {\n 'catalog': self.cat_corr['catalog'].copy(), \n 'correction': {'name': 'photoz'}\n }\n dataclass = Data('data', photoz_cat_corr) \n dataclass.read() \n\n cosmo = dataclass.cosmo()\n\n coll = np.where(dataclass.wfc == 0) \n \n dlos_actual = (cosmos.distance.comoving_distance(dataclass.z[coll], **cosmo) - \\\n cosmos.distance.comoving_distance(dataclass.zupw[coll], **cosmo)) * cosmo['h']\n dlos_photoz = (cosmos.distance.comoving_distance(dataclass.photoz[coll], **cosmo) - \\\n cosmos.distance.comoving_distance(dataclass.zupw[coll], **cosmo)) * cosmo['h']\n\n # each value of d_NN corresponds to a dLOS value \n # in dLOS file \n print self.file_name\n np.savetxt(self.file_name, \n np.c_[dlos_actual, dlos_photoz], \n fmt=['%10.5f', '%10.5f'],\n header='Columns : dLOS, dLOS_photoz'\n ) \n\n return None","def write_scram_toolfiles(self):\n from string import Template\n\n mkdirp(join_path(self.spec.prefix.etc, 'scram.d'))\n\n values = {}\n values['VER'] = self.spec.version\n values['PFX'] = self.spec.prefix\n\n fname = 'uuid-cms.xml'\n template = Template(\"\"\"<tool name=\"uuid\" version=\"$VER\">\n <lib name=\"uuid\"/>\n <client>\n <environment name=\"LIBUUID_BASE\" default=\"$PFX\"/>\n <environment name=\"LIBDIR\" default=\"$$LIBUUID_BASE/lib\"/>\n <environment name=\"INCLUDE\" default=\"$$LIBUUID_BASE/include\"/>\n </client>\n <runtime name=\"ROOT_INCLUDE_PATH\" value=\"$$INCLUDE\" type=\"path\"/>\n <use name=\"root_cxxdefaults\"/>\n <use name=\"sockets\"/>\n</tool>\"\"\")\n\n contents = template.substitute(values)\n self.write_scram_toolfile(contents, fname)\n\n fname = 'libuuid.xml'\n template = Template(\"\"\"<tool name=\"libuuid\" version=\"$VER\">\n <lib name=\"uuid\"/>\n <client>\n <environment name=\"LIBUUID_BASE\" default=\"$PFX\"/>\n <environment name=\"LIBDIR\" default=\"$$LIBUUID_BASE/lib\"/>\n <environment name=\"INCLUDE\" default=\"$$LIBUUID_BASE/include\"/>\n </client>\n <runtime name=\"ROOT_INCLUDE_PATH\" value=\"$$INCLUDE\" type=\"path\"/>\n <use name=\"root_cxxdefaults\"/>\n <use name=\"sockets\"/>\n</tool>\"\"\")\n\n contents = template.substitute(values)\n self.write_scram_toolfile(contents, fname)","def dict2file(dict, filename, foldername):\n if foldername:\n if not os.path.exists(\"../Created_QD/\" + foldername):\n os.makedirs(\"../Created_QD/\" + foldername)\n file = open(\"../Created_QD/\" + foldername + \"/\" + filename + \".xyz\", \"w\")\n else:\n file = open(\"../Created_QD/\" + filename + \".xyz\", \"w\")\n file.write(\" \\n\\n\")\n for atom, values in dict.items():\n file.write(values['element'] + \"\\t\" + str(values['coor'][0]) + \"\\t\\t\" +\n str(values['coor'][1]) + \"\\t\\t\" + str(values['coor'][2]) + \"\\n\")\n file.seek(0)\n file.write(str(len(dict)))\n file.close()\n print(\"\\nQuantum Dot created :)\")","def createckfk(self, observer, dbname, t0, field1, nfields, mk): \n\n observerint=self.mpc2internal(observer)\n instrumentint=observerint*1000\n\n with open(\"cksetupfile\", \"w\") as f:\n f.write(\"KPL/IK \\nComments describing the keywords and values \\nto follow, as well as any other pertinent \\ninformation.\\n\\\\begindata\\n\")\n f.write(\"LSK_FILE_NAME = '%s'\\n\" %(mk))\n f.write(\"\\n\")\n f.write(\"INTERNAL_FILE_NAME = 'Survey Sim Camera Orientation'\\n\")\n f.write(\"\\n\")\n f.write(\"MAKE_FAKE_SCLK = 'tmpsclk'\\n\")\n f.write(\"CK_TYPE = 3\\n\")\n f.write(\"CK_SEGMENT_ID = 'Instrument Orientation'\\n\")\n f.write(\"INSTRUMENT_ID = %i \\n\" %(instrumentint))\n f.write(\"REFERENCE_FRAME_NAME = 'J2000'\\n\")\n f.write(\"ANGULAR_RATE_PRESENT = 'NO'\\n\")\n f.write(\"\\n\")\n f.write(\"INPUT_DATA_TYPE = 'SPICE QUATERNIONS'\\n\")\n f.write(\"INPUT_TIME_TYPE = 'UTC'\\n\")\n f.write(\"MAXIMUM_VALID_INTERVAL = 60\\n\") \n f.write(\"\\n\")\n f.write(\"PRODUCER_ID = 'Survey Sim, JPL'\\n\")\n f.write(\"\\\\begintext\")\n f.close()\n\n\n self.readfields(dbname,field1,nfields, t0)\n with open(\"ckip\",\"w\") as f:\n\n for i in range(len(self.fieldRA)):\n quat=self.computerotmat(self.fieldRA[i], self.fieldDec[i], self.rotSkyPos[i])\n\n #This helps with duplicate entries. For example enigma_1189 can have same fieldID's under different propID's\n #Issue warning for duplicate time. Have a verbose mode for displaying that (true as default)\n if (self.fieldMJD[i] !=self.fieldMJD[i-1]):\n JD=self.fieldMJD[i]+shared.mjd2jd\n timestring= 'JD'+repr(JD)\n f.write(\"%s %f %f %f %f\\n\" %(timestring,quat[0],quat[1],quat[2],quat[3]))\n f.close()\n try:\n os.system('rm tmp.ck tmpsclk test.ck fakesclk >/dev/null')\n except:\n pass\n os.system('msopck cksetupfile ckip tmp.ck > /dev/null')\n\n os.system('rsync tmpsclk fakesclk > /dev/null')\n os.system('rsync tmp.ck test.ck > /dev/null')\n\n with open(\"tmp.fk\",\"w\") as f:\n f.write(\"\\\\begindata\\n\\n\")\n f.write(\"FRAME_CAMERA_FRAME = %i\\n\" %(instrumentint))\n f.write(\"FRAME_%i_NAME = 'CAMERA_FRAME'\\n\" %(instrumentint))\n f.write(\"FRAME_%i_CLASS = 3\\n\" %(instrumentint))\n f.write(\"FRAME_%i_CLASS_ID = %i\\n\" %(instrumentint, instrumentint))\n f.write(\"FRAME_%i_CENTER = %i\\n\" %(instrumentint, observerint))\n f.write(\"CK_%i_SCLK = %i\\n\" %(instrumentint, observerint))\n f.write(\"CK_%i_SPK = %i\\n\\n\" %(instrumentint, observerint))\n f.write(\"\\\\begintext\\n\")\n f.close()\n \n os.system('rsync tmp.fk test.fk')","def create_sdxmetadata(sdx_dir, output_dir):\n #define list to store SDX information\n instrument = []\n picks = [] \n phases = []\n \n #segment and store metadata \n #define SDX files to be read\n for root, dirs, files in os.walk(sdx_dir):\n for idx, file in enumerate(files):\n if file.endswith(\".sdx\"):\n \n print(\"Reading File: \" + file)\n \n #define list to store SDX information\n instrument = []\n picks = [] \n phases = []\n \n #scan for pick info\n with open(root + file,\"r\") as f:\n searchlines = f.readlines()\n for i, line in enumerate(searchlines):\n #strip whitespace/end-of-line characters for exact text matching\n line = line.rstrip()\n #find pick info\n if \"pick\" == line:\n for l in searchlines[i:i+16]: \n #print(l)\n #assign pick info/instrument info to variables and store\n instrument_info = searchlines[i+1]\n pick_info = searchlines[i+2]\n phase_info = searchlines[i+9:i+13]\n instrument.append(instrument_info)\n picks.append(pick_info)\n phases.append(phase_info)\n \n #create a .txt file for each seperate event to store pick info\n pathlib.Path(output_dir).mkdir(parents=True, exist_ok=True)\n\n f = open(output_dir + os.path.splitext(file)[0] + \".txt\",'w')\n #header information...\n f.write('Data read from correpsonding SDX file:' + '\\n')\n f.write(file + '\\n\\n')\n f.write('Instrument/component' + '\\t\\t\\t' + 'Pick information' '\\t\\t\\t' + 'Phase information\\n')\n \n # print both instrument and pick information to the \n # associated event file\n for item in zip(instrument, picks, phases):\n \n #remove preceding whitespace/formatting characters\n item0 = item[0].rstrip()\n item1 = item[1].rstrip()\n item2 = list(map(str.strip, item[2]))\n \n #remove associated list formatting\n item2 = (\", \".join( str(e) for e in item2))\n\n #print...\n #format | instrument info | pick info | phase info\n f.write(\"%s\\t\\t%s\\t\\t%s\\n\" % (item0,item1,item2))\n \n f.close()","def dump_to_disk(self, prefix):\n\n f = open(prefix + rpki.sundial.now().isoformat() + \"Z.cms\", \"wb\")\n f.write(self.get_DER())\n f.close()","def writeCADFile(self, filename):\n valid_filetypes = [\"brep\", \"bstl\", \"egads\", \"egg\", \"iges\", \"igs\", \"sens\", \"step\", \"stl\", \"stp\", \"tess\", \"grid\"]\n file_extension = filename.split(\".\")[-1]\n if file_extension.lower() not in valid_filetypes:\n raise OSError(\n \"CAD filename \"\n + filename\n + \" must have a valid exension. \"\n + \"Consult the EngineeringSketchPad docs for the DUMP function\"\n )\n if self.comm.rank == 0:\n modelCopy = self.espModel.Copy()\n n_branches, _, _ = modelCopy.Info()\n modelCopy.NewBrch(\n n_branches, modelCopy.GetCode(\"dump\"), \"<none>\", 0, filename, \"0\", \"0\", \"0\", \"\", \"\", \"\", \"\", \"\"\n )\n modelCopy.Build(0, 0)","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 prepare_dataset(sdffile, dest=None, overwrite=False):\n root, name = op.split(sdffile)\n name = op.splitext(name)[0]\n\n if not dest: dest = root\n\n dest_sdf = op.join(dest, name + '-prepared.sdf')\n master_table = op.join(dest, name + '-master.csv')\n sali_table = op.join(dest, name + '-saliviewer.csv')\n\n if op.exists(dest_sdf) and not overwrite:\n print '%s is already there and not overwriting requested' % dest_sdf\n else:\n print 'Reading %s' % sdffile\n mols = list(pybel.readfile('sdf', sdffile))\n\n print '\\tCreating dataset root: %s' % dest\n if not op.exists(dest):\n os.makedirs(dest)\n\n print '\\tRenaming the compounds to keep track of the provenance'\n rename_mols_by_index(mols, name + '-')\n\n print '\\tGenerating conformations'\n for mol in mols:\n if not any(name in mol.title for name in ('train-3988', 'train-4205')):\n try:\n print 'Conformation for %s' % mol.title\n mol.make3D()\n except Exception:\n print 'Error computing a 3D conformation for %s' % mol.title\n\n print '\\tSaving compounds'\n save_mols(mols, dest_sdf)\n\n print '\\tCreating \\\"master\\\" table: %s' % master_table\n create_master_table(dest_sdf, master_table, fields=['Activity'])\n\n print '\\tCreating \\\"saliviewer\\\" table: %s' % sali_table\n create_saliviewer_input(master_table, sali_table)\n\n return dest_sdf, master_table","def _build_meds_layout(self):\n\n\n nim = self.image_info.size\n nobj = self.obj_data.size\n\n trim_to_coadd = self.get('trim_to_coadd',False)\n if trim_to_coadd:\n print(' trimming to coadd')\n coadd_wcs, coadd_pos, coadd_bnds, coadd_q = \\\n self._get_pos_and_bounds(self.obj_data, 0)\n in_bnds = coadd_bnds.contains_points(coadd_pos['zrow'], coadd_pos['zcol'])\n w_in_bnds, = np.where(in_bnds == True)\n assert w_in_bnds.size > 0,\"none found in coadd\"\n\n w_in_bnds = coadd_q[w_in_bnds]\n self.obj_data = self.obj_data[w_in_bnds]\n\n self._do_psf_setup()\n\n # box sizes are even\n half_box_size = self.obj_data['box_size']//2\n\n for file_id in range(nim):\n\n wcs, pos, bnds, q = self._get_pos_and_bounds(self.obj_data, file_id)\n\n # do the test\n in_bnds = bnds.contains_points(pos['zrow'], pos['zcol'])\n q_rc, = np.where(in_bnds == True)\n print(' second cut: %6d of %6d objects' % (len(q_rc),len(q)))\n\n # now make sure everything is there\n if self['check_in_first_image']:\n if file_id == 0 and len(self.obj_data['ra']) != len(q_rc):\n raise MEDSCreationError('Not all objects were found in first image for '\n 'MEDS making (which is the coadd/detection '\n 'image by convention).')\n # compose them\n q = q[q_rc]\n\n # fill in the object_data structure\n\n # note q_rc since pos was created using obj_data[q]\n qrow = pos['zrow'][q_rc]\n qcol = pos['zcol'][q_rc]\n\n icut = self.obj_data['ncutout'][q]\n self.obj_data['file_id'][q,icut] = file_id\n self.obj_data['orig_row'][q,icut] = qrow\n self.obj_data['orig_col'][q,icut] = qcol\n\n # this results in the object center being close to\n # the natural center (dim-1.)/2.\n ostart_row = qrow.astype('i4') - half_box_size[q] + 1\n ostart_col = qcol.astype('i4') - half_box_size[q] + 1\n crow = qrow - ostart_row\n ccol = qcol - ostart_col\n\n self.obj_data['orig_start_row'][q,icut] = ostart_row\n self.obj_data['orig_start_col'][q,icut] = ostart_col\n self.obj_data['cutout_row'][q,icut] = crow\n self.obj_data['cutout_col'][q,icut] = ccol\n\n # do jacobian, in original, not-offset coords\n # note q_rc since pos was created using self.obj_data[q]\n jacob = wcs.get_jacobian(\n x=pos['wcs_col'][q_rc],\n y=pos['wcs_row'][q_rc])\n\n # jacob is a tuple of arrays\n self.obj_data['dudcol'][q,icut] = jacob[0]\n self.obj_data['dudrow'][q,icut] = jacob[1]\n self.obj_data['dvdcol'][q,icut] = jacob[2]\n self.obj_data['dvdrow'][q,icut] = jacob[3]\n\n # increment\n self.obj_data['ncutout'][q] += 1\n\n w,=np.where(self.obj_data['ncutout'] > 0)\n print('%d/%d had ncut > 0' % (w.size, self.obj_data.size))\n #self.obj_data = self.obj_data[w]\n\n self.obj_data = self._make_resized_data(self.obj_data)\n print('setting number field as sequential')\n self.obj_data['number'] = 1+np.arange(self.obj_data.size)\n\n\n self._set_start_rows_and_pixel_count()\n\n if self['survey']=='cosmos':\n self._set_psf_layout_hst()\n else:\n self._set_psf_layout_psfex()","def export_ctsdg(cfg):\n generator = Generator(\n image_in_channels=config.image_in_channels,\n edge_in_channels=config.edge_in_channels,\n out_channels=config.out_channels\n )\n generator.set_train(False)\n load_checkpoint(cfg.checkpoint_path, generator)\n\n ckpt_path = Path(cfg.checkpoint_path)\n output_file_name = (ckpt_path.parent / ckpt_path.stem).as_posix()\n file_format = config.file_format\n\n img_dummy = mnp.zeros([1, config.image_in_channels, *cfg.image_load_size],\n dtype=mstype.float32)\n edge_dummy = mnp.zeros([1, 2, *cfg.image_load_size], dtype=mstype.float32)\n mask_dummy = mnp.zeros([1, 1, *cfg.image_load_size], dtype=mstype.float32)\n\n export(generator, img_dummy, edge_dummy, mask_dummy,\n file_name=output_file_name, file_format=file_format)\n\n print(f'{output_file_name}.mindir exported successfully!', flush=True)","def _make_files(self):\n if not self.path.is_dir():\n raise FileNotFoundError(f\"Path {self.path} does not exist.\")\n\n # Make the filepaths\n self.file_points = self.path / \"point.dat\"\n self.file_lines = self.path / \"line.dat\"\n self.file_cadastre = self.path / \"cadastre.dat\"\n self.file_portals = self.path / \"portals.dat\"\n\n with open(self.file_points, \"w\") as f:\n # 2 lines ignored\n header = datetime.datetime.now().strftime(\"Generated: %d/%m/%Y %H:%M\\n\")\n f.write(header)\n self.points_dfs = []\n with open(self.file_lines, \"w\") as f:\n # 5 lines ignored\n header = (\n datetime.datetime.now().strftime(\"Generated: %d/%m/%Y %H:%M\\n\")\n + 3 * \"Generated: \\n\"\n + \"Name,Section,source_group,x1,y1,z1,x2,y2,z2,width,vert. ext.,-,-,\"\n \"emission_rate[kg/h/km],-,-,-,-\\n\"\n )\n f.write(header)\n with open(self.file_cadastre, \"w\") as f:\n # 1 line ignored\n header = \"x,y,z,dx,dy,dz,emission_rate[kg/h],-,-,-,source_group\\n\"\n f.write(header)\n with open(self.file_portals, \"w\") as f:\n # 2 lines ignored\n header = (\n datetime.datetime.now().strftime(\"Generated: %d/%m/%Y %H:%M\\n\")\n + \"x1,y1,x2,y2,z0,z1,emission_rate[kg/h],-,-,-,source_group\\n\"\n )\n f.write(header)\n\n\n # File to save the source groups values\n self.file_source_groups = self.path / \"source_groups.json\"\n with open(self.file_source_groups, \"w\") as f:\n # reverse the dict (items become keys and vice versa)\n reversed_source_groups = {v: k for k, v in self.source_groups.items()}\n json.dump(reversed_source_groups, f, indent=2)","def create_pythia_cmnd_files(self):\n \n for higgsname, higgspid in {'H': 35, 'A': 36}.iteritems():\n \n # Get mass and width from 2HDMC LHA file\n lha = LHA(self.lhafile)\n mass = lha.get_block('MASS').get_entry_by_key(higgspid)\n width = lha.get_decay(higgspid).width \n \n outname = self.lhafile.replace('.lha', '_%s.cmnd' % higgsname)\n self.cmndfiles[higgsname] = outname\n \n # Write command file\n with open(outname, 'w') as outfile:\n \n outfile.write('Beams:eCM = 13000.\\n')\n outfile.write('Higgs:useBSM = on\\n')\n \n if higgspid == 36:\n #outfile.write('HiggsBSM:allA3 = on\\n') # All production modes\n outfile.write('HiggsBSM:ffbar2A3 = on\\n') # quark fusion\n outfile.write('HiggsBSM:gg2A3 = on\\n') # gluon fusion\n elif higgspid == 35:\n #outfile.write('HiggsBSM:allH2 = on\\n') # All production modes\n outfile.write('HiggsBSM:ffbar2H2 = on\\n') # quark fusion\n outfile.write('HiggsBSM:gg2H2 = on\\n') # gluon fusion\n \n outfile.write('{}:all = A0 A0 1 0 0 {} {} 50.0 0.0\\n'.format(higgspid, mass, width))\n outfile.write('{}:onMode = off\\n'.format(higgspid))\n outfile.write('{}:onIfMatch = 15 -15\\n'.format(higgspid))\n \n outfile.write('15:onMode = off\\n')\n outfile.write('15:onIfMatch = 16 111 211\\n')\n outfile.write('\\n')\n outfile.write('Next:numberShowEvent = 0\\n')\n\n return 0","def write_to_md(dictData, outputDirectory):\n\tdic = prepare_hw_dict(dictData)\n\tfor hw in dic:\n\t\tfileout = os.path.join(outputDirectory, hw+'.md')\n\t\t# Prepare the output file\n\t\tfout = codecs.open(fileout, 'w', 'utf-8')\n\t\t# Write frontmatter\n\t\tfout.write('---\\ntitle: \"'+hw+'\"\\n---\\n\\n')\n\t\t# For each (headword, meanings, verseNumber, PageNum) tuples,\n\t\tfor (hw, meanings, verse, verseNumDetails, pageNumDetails) in dic[hw]:\n\t\t\tcommaed = ', '.join(meanings)\n\t\t\tverse = verse.replace('<BR>', '<br />')\n\t\t\t# Write in babylon format. <BR><BR> is to separate verses.\n\t\t\tfout.write('# ' + hw + '\\n## ' + commaed + '\\n' + verse + '<br />verse ' + verseNumDetails + '<br />page ' + pageNumDetails +'\\n\\n')\n\t\tfout.close()\n\n\t# Give some summary to the user\n\tprint('MD files generated. Success!')\n\tprint('{} separate .md files written, one per headword.'.format(len(dic)))","def _create_ID_files(self):\n for file, IDs in [(self._trn_IDs_file, self._trn_IDs), (self._val_IDs_file,\n self._val_IDs), (self._tst_IDs_file, self._tst_IDs)]:\n with open(file, 'w') as f:\n f.write('\\n'.join('{}###{}###{}'.format(ID[0], ID[1], ID[2]) for ID in IDs))","def generate(self):\n self._open_file()\n # copied from GenerateCSPEC.py\n self._write_header_and_defaults()\n self._write_source()\n self._write_sample()\n\n self._write_all_components()\n self._write_mantle_module()\n self._write_segment()\n self._write_all_ids()\n self._write_footer()\n self._close_file()","def build_plasticc_metadata(fname_meta: str, snana_dir: str, out_fname,\n screen=False, extragal=True, field='DDF'):\n\n # map between zenodo and SNANA types\n SNANA_types = {90:11, 62:{1:3, 2:13}, 42:{1:2, 2:12, 3:14},\n 67:41, 52:43, 64:51, 95:60, 994:61, 992:62,\n 993:63, 15:64, 88:70, 92:80, 65:81, 16:83,\n 53:84, 991:90, 6:{1:91, 2:93}}\n \n extragal_zenodo_types = [15, 42, 52, 62, 64, 67, 88, 90, 95]\n \n # read zenodo metadata\n meta = pd.read_csv(fname_meta)\n\n if field == 'DDF':\n # identify only DDF objects\n ddf_flag = meta['ddf_bool'].values == 1\n elif field == 'WFD':\n ddf_flag = meta['ddf_bool'].values == 0\n else:\n ddf_flag = np.array([True for i in range(meta.shape[0])])\n\n # get ids\n ids = meta['object_id'].values[ddf_flag] \n\n names = get_SNR_headers()\n\n if not os.path.isfile(out_fname):\n op = open(out_fname, 'w+')\n for item in names[:-1]:\n op.write(item + ',')\n op.write(names[-1] + '\\n')\n\n else: \n op = open(out_fname, 'a+')\n \n # which group to search for\n if extragal:\n search_group = extragal_zenodo_types\n else:\n search_group = list(SNANA_types.keys())\n \n for code_zenodo in search_group:\n \n if screen:\n print('code_zenodo: ', code_zenodo)\n\n if code_zenodo not in [62, 42, 6]:\n code_snana = SNANA_types[code_zenodo]\n\n for n in range(1, 11):\n fname2 = snana_dir + 'LSST_DDF_MODEL' + str(code_snana).zfill(2) + \\\n '/LSST_DDF_NONIa-00' + str(n).zfill(2) + '_PHOT.FITS.gz'\n\n photo = read_fits(fname2)\n\n for indx in range(photo[0].shape[0]):\n # read data for 1 object\n snid_raw = photo[0]['SNID'].values[indx]\n snid = int(re.sub(\"[^0-9]\", \"\", str(snid_raw)))\n\n if snid in ids: \n line = calculate_SNR(snid=snid, \n code_zenodo=code_zenodo,\n photo_data=photo[1],\n head_data=photo[0],\n snana_file_index=n,\n code_snana=code_snana)\n \n if len(line) > 0:\n for item in line[:-1]:\n op.write(str(item) + ',')\n op.write(str(line[-1]) + '\\n')\n \n del photo\n \n else:\n for subtype in SNANA_types[code_zenodo].keys():\n code_snana = SNANA_types[code_zenodo][subtype]\n \n for n in range(1, 11): \n fname2 = snana_dir + 'LSST_DDF_MODEL' + str(code_snana).zfill(2) + \\\n '/LSST_DDF_NONIa-00' + str(n).zfill(2) + '_PHOT.FITS.gz'\n\n photo = read_fits(fname2)\n\n for indx in range(photo[0].shape[0]):\n\n # read data for 1 object\n snid_raw = photo[0]['SNID'].values[indx]\n snid = int(re.sub(\"[^0-9]\", \"\", str(snid_raw)))\n\n if snid in ids:\n line = calculate_SNR(snid=snid, \n code_snana=code_snana,\n code_zenodo=code_zenodo,\n photo_data=photo[1], \n head_data=photo[0],\n snana_file_index=n)\n \n if len(line) > 0:\n for item in line[:-1]:\n op.write(str(item) + ',')\n op.write(str(line[-1]) + '\\n')\n \n del photo\n \n op.close()","def make_header_files():\n os.makedirs(DATA_DIR) if not os.path.exists(DATA_DIR) else None\n from dkistdataratemodel.units import frame\n from dkist_data_model.generator.dataproducts.visp import CalibratedVISP\n\n \"\"\"\n Generate VISP\n \"\"\"\n visp = CalibratedVISP(end_condition=20*frame)\n\n visp_files = visp.to_fits(\"sp_5_labelled\",\n path_template=os.path.join(DATA_DIR, 'visp_5d_{i:02d}.fits'))\n\n with ZipFile(os.path.join(DATA_DIR, \"visp.zip\"), \"w\") as myzip:\n for fname in visp_files:\n myzip.write(fname, os.path.split(fname)[1])\n os.remove(fname)\n\n \"\"\"\n Generate VTF\n \"\"\"\n from dkist_data_model.generator.dataproducts.vtf import CalibratedVTF\n vtf = CalibratedVTF(end_condition=96*frame)\n\n vtf_files = vtf.to_fits(\"5d_test\",\n path_template=os.path.join(DATA_DIR, 'vtf_5d_{i:02d}.fits'))\n\n with ZipFile(os.path.join(DATA_DIR, \"vtf.zip\"), \"w\") as myzip:\n for fname in vtf_files:\n myzip.write(fname, os.path.split(fname)[1])\n os.remove(fname)","def Generar_Claves():\n salida=Keypp()\n savekey(salida)\n savecomp(salida)","def generate():","def write_db_tables(self, datadir='.', do_com=False, do_angmom=False, \n do_totalcom=False, do_totalangmom=False, do_normals=False,\n do_sigmas=False, do_relmotion=False):\n\n filepath = Path(datadir)\n\n db = DB()\n cur = db.get_cursor()\n\n # CoM data\n if do_com:\n colheads = ','.join(['gal','snap','t','x','y','z','vx','vy','vz'])\n query = f\"\"\"\n INSERT INTO centerofmass( {colheads} ) \n VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s)\n ON CONFLICT DO NOTHING\n \"\"\"\n\n for gname in ('MW','M31','M33'):\n filename = f'com_{gname}.txt'\n fullname = filepath / filename\n data = self.read_file(fullname)\n \n for snap, d in enumerate(data):\n rec = [gname, snap,] + list(d)\n cur.execute(query, rec)\n\n # angular momentum data\n if do_angmom:\n colheads = ','.join(['gal','snap','t','x_hat','y_hat','z_hat','l_mag'])\n query = f\"\"\"\n INSERT INTO angmom( {colheads} ) \n VALUES (%s,%s,%s,%s,%s,%s,%s)\n ON CONFLICT DO NOTHING\n \"\"\"\n\n for gname in ('MW','M31','M33'):\n filename = f'angmom_{gname}.txt'\n fullname = filepath / filename\n data = self.read_file(fullname)\n \n for snap, d in enumerate(data):\n rec = [gname, snap,] + list(d)\n cur.execute(query, rec)\n\n # total CoM data\n if do_totalcom:\n colheads = ','.join(['snap','t','x','y','z','vx','vy','vz'])\n query = f\"\"\"\n INSERT INTO totalcom( {colheads} ) \n VALUES (%s,%s,%s,%s,%s,%s,%s,%s)\n ON CONFLICT DO NOTHING\n \"\"\"\n\n filename = 'total_com.txt'\n fullname = filepath / filename\n data = self.read_file(fullname)\n \n for snap, d in enumerate(data):\n rec = [snap,] + list(d)\n cur.execute(query, rec)\n\n # total angular momentum data\n if do_totalangmom:\n colheads = ','.join(['snap','t','Lx','Ly','Lz'])\n query = f\"\"\"\n INSERT INTO totalangmom( {colheads} ) \n VALUES (%s,%s,%s,%s,%s)\n ON CONFLICT DO NOTHING\n \"\"\"\n\n filename = 'total_angmom.txt'\n fullname = filepath / filename\n data = self.read_file(fullname)\n \n for snap, d in enumerate(data):\n rec = [snap,] + list(d)\n cur.execute(query, rec)\n\n # 3-galaxy normals data\n if do_normals:\n colheads = ','.join(['snap','t','x_hat','y_hat','z_hat'])\n query = f\"\"\"\n INSERT INTO normals( {colheads} ) \n VALUES (%s,%s,%s,%s,%s)\n ON CONFLICT DO NOTHING\n \"\"\"\n\n filename = 'normals.txt'\n fullname = filepath / filename\n data = self.read_file(fullname)\n \n for snap, d in enumerate(data):\n rec = [snap,] + list(d)\n cur.execute(query, rec)\n\n # velocity dispersions\n if do_sigmas:\n colheads = ','.join(['gal','snap','t','sigma'])\n query = f\"\"\"\n INSERT INTO sigmas( {colheads} ) \n VALUES (%s,%s,%s,%s)\n ON CONFLICT DO NOTHING\n \"\"\"\n\n for gname in ('MW','M31','M33'):\n filename = f'sigma_{gname}.txt'\n fullname = filepath / filename\n data = self.read_file(fullname)\n \n for snap, d in enumerate(data):\n rec = [gname, snap,] + list(d)\n cur.execute(query, rec)\n\n # relative motions\n if do_relmotion:\n colheads = ','.join(['snap','t','pos_MW_M31','pos_M33_M31','pos_M33_MW',\n 'vel_MW_M31','vel_M33_M31','vel_M33_MW'])\n query = f\"\"\"\n INSERT INTO relmotion( {colheads} ) \n VALUES (%s,%s,%s,%s,%s,%s,%s,%s)\n ON CONFLICT DO NOTHING\n \"\"\"\n\n filename = 'relmotion.txt'\n fullname = filepath / filename\n data = self.read_file(fullname)\n \n for snap, d in enumerate(data):\n rec = [snap,] + list(d)\n cur.execute(query, rec)","def opensslCmsDataCreate( conveyedInfoFile ):\n opensslCmdArgs = [ \"openssl\", \"cms\", \"-data_create\", \"-in\", conveyedInfoFile,\n \"-outform\", \"der\" ]\n conveyedInfoCmsDerBase64 = runOpensslCmd( opensslCmdArgs, [ \"base64\" ] )\n return conveyedInfoCmsDerBase64","def vacuum_cgmd(self):\n\n\t\texstring_dssp = 'except: cannot find dssp at '+gmxpaths['dssp']+\\\n\t\t\t'\\nconsider using the following syntax to download for 64-bit linux:'+\\\n\t\t\t'\\n\\twget ftp://ftp.cmbi.ru.nl/pub/software/dssp/dssp-2.0.4-linux-amd64'+\\\n\t\t\t'\\n\\tor navigate to ftp://ftp.cmbi.ru.nl/pub/software/dssp/'+\\\n\t\t\t'\\n\\tand make sure you add execute permissions'\n\t\t\t\n\t\texstring_martinize = 'except: cannot find martinize at '+gmxpaths['martinize']+\\\n\t\t\t'\\nconsider using the following syntax to download:'+\\\n\t\t\t'\\n\\twget http://md.chem.rug.nl/cgmartini/images/tools/martinize/martinize-2.4/martinize.py'+\\\n\t\t\t'\\n\\tor navigate to http://md.chem.rug.nl/cgmartini/index.php/tools2/proteins-and-bilayers'+\\\n\t\t\t'\\n\\tand make sure you add execute permissions'\n\t\n\t\t#---first test to see if executables are available\n\t\tif not os.path.isfile(os.path.expanduser(gmxpaths['dssp'])): raise Exception(exstring_dssp)\n\t\tif not os.path.isfile(os.path.expanduser(gmxpaths['martinize'])): raise Exception(exstring_martinize)\t\n\t\n\t\tcmd = [gmxpaths['martinize'],\n\t\t\t'-f system-input.pdb',\n\t\t\t'-o system-original.top',\n\t\t\t'-x protein-cg.pdb',\n\t\t\t'-ff martini22','-ed',\n\t\t\t'-dssp '+gmxpaths['dssp']]\n\t\tcall(cmd,logfile='log-martinize',cwd=self.rootdir)\n\t\t\n\t\twith open(self.rootdir+'system-original.top') as fp: lines = fp.readlines()\n\t\tself.itp_protein = [l.split()[0] for l in lines if l[:7] == 'Protein']\n\n\t\t#---note that this section leaves out lipids\n\t\tself.itp_lipid = []\n\t\t\n\t\t#---note that this method is currently set to only simulate one protein\n\t\tself.nprots = [1]\n\t\tself.write_topology_protein('vacuum.top')\n\t\t\n\t\tcmd = [gmxpaths['editconf'],\n\t\t\t'-f protein-cg.pdb',\n\t\t\t'-o vacuum-alone.gro']\n\t\tcall(cmd,logfile='log-editconf-convert',cwd=self.rootdir)\n\t\n\t\tprint \"building box with \"+str(self.settings['wbuffer'])+'nm of water'\n\t\tcmd = [gmxpaths['editconf'],\n\t\t\t'-f vacuum-alone.gro',\n\t\t\t'-d '+str(self.settings['wbuffer']),\n\t\t\t'-o vacuum.gro','-c']\n\t\tcall(cmd,logfile='log-editconf-vacuum',cwd=self.rootdir)\n\t\t\n\t\tself.minimization_method('vacuum')","def generate_files(self):\n\t\tapply_stemmer, xml_file, query_file, expected_file = self.read_config_file()\n\t\tself.generate_query_file(query_file, xml_file, apply_stemmer)\n\t\tself.generate_expected_file(expected_file, xml_file)\n\t\tlogging.info('FINALIZADO: MÓDULO PROCESSADOR DE CONSULTAS')","def writeNew(self,masters=[],mtime=0):\n tes3 = Tes3()\n tes3.hedr = Tes3_Hedr('HEDR',0)\n if self.isEsp(): tes3.hedr.fileType = 0\n elif self.isEsm(): tes3.hedr.fileType = 1\n elif self.isEss(): tes3.hedr.fileType = 32\n for master in masters:\n tes3.masters.append((master,modInfos[master].size))\n tes3.hedr.setChanged()\n tes3.setChanged()\n #--Write it\n path = os.path.join(self.dir,self.name)\n out = file(path,'wb')\n tes3.getSize()\n tes3.dump(out)\n out.close()\n self.setMTime(mtime)","def create_weka_mfcc_13():\n global ARGS\n\n ## ten thu muc can trich chon vector dac trung (RLS, LMS, NLMS, Kalman, Non)\n name = '';\n fout = open('weka/MFCC78_TUNNING_{}_dataset.arff'.format(name), 'w')\n fout.write('@RELATION {}_dataset\\n\\n'.format(name))\n\n fout.write('@ATTRIBUTE MEAN_MFCC1\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC2\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC3\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC4\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC5\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC6\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC7\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC8\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC9\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC10\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC11\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC12\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCC13\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD1\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD2\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD3\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD4\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD5\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD6\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD7\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD8\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD9\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD10\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD11\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD12\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCD13\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD1\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD2\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD3\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD4\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD5\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD6\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD7\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD8\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD9\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD10\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD11\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD12\tREAL\\n')\n fout.write('@ATTRIBUTE MEAN_MFCCDD13\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC1\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC2\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC3\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC4\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC5\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC6\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC7\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC8\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC9\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC10\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC11\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC12\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCC13\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD1\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD2\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD3\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD4\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD5\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD6\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD7\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD8\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD9\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD10\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD11\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD12\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCD13\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD1\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD2\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD3\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD4\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD5\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD6\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD7\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD8\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD9\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD10\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD11\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD12\tREAL\\n')\n fout.write('@ATTRIBUTE STD_MFCCDD13\tREAL\\n')\n fout.write('@ATTRIBUTE class \t{'+ARGS.labels+'}\\n\\n')\n \n fout.write('@DATA\\n')\n\n ## cua so\n windowing = Windowing(type='hamming',\n size=1104,\n zeroPhase=False)\n \n ## quang pho\n spectrum = Spectrum(size=1104)\n\n ##khoi tao MFCC\n mfcc = MFCC(highFrequencyBound=4000, ## gioi han tren cua tan so\n inputSize=201, \t\t\t ## kich thuoc pho dau vao\n lowFrequencyBound=0,\t ## gioi han duoi cua tan so\n numberBands=40,\t\t\t ## so luong cac dai Mels trong bo loc\n numberCoefficients=13, ## so luong dau ra cac he so Mel\n sampleRate=16000)\t\t ## tan so lay mau\n\n for label in ARGS.labels.split(','): ## duyet cac thu muc giong voi ten nhan\n\n ## dia chi thu muc\n dir = os.path.join(ARGS.dir, label)\n\n logging.info('Access folder <{}>'.format(dir))\n\n for file in sorted(os.listdir(dir)):\n\n \t## duyet cac file .wav\n if file.endswith('.wav'):\n logging.info('Process <{}>'.format(file))\n path = os.path.join(dir, file)\n \n ## doc file am thanh\n loader = MonoLoader(filename=path, sampleRate=ARGS.sampleRate)\n audio = loader()\n cnt = 0\n\n for window in FrameGenerator(audio, \n frameSize=ARGS.window_length*ARGS.sampleRate/1000, \n hopSize=ARGS.window_stride*ARGS.sampleRate/1000, \n startFromZero=True):\n mfccs = []\n for frame in FrameGenerator(window, \n frameSize=ARGS.frame_length*ARGS.sampleRate/1000, \n hopSize=ARGS.frame_stride*ARGS.sampleRate/1000, \n startFromZero=True):\n s = spectrum(windowing(frame))\n\n _, m = mfcc(s)\n\n m_delta = librosa.feature.delta(m, order=1) ## dao ham bac 1\n m_delta_delta = librosa.feature.delta(m, order=2) ## dao ham bac 2\n\n m_all = np.concatenate((m, m_delta, m_delta_delta), axis=0) ## them vao chuoi\n mfccs.append(m_all)\n mfccs = np.array(mfccs)\n mfccs_mean = np.mean(mfccs, axis=0)\n mfccs_std = np.std(mfccs, axis=0)\n feat = np.concatenate((mfccs_mean, mfccs_std), axis=0).tolist()\n str_feat = [str(x) for x in feat]\n line = ','.join(str_feat)+','+label\n fout.write(line+'\\n')\n cnt = cnt+1\n logging.info('{} samples'.format(cnt))","def make_libfile():\n # wfc3_obsmodes_uvis\n wfc3_uvis = [\n \"f218w\",\n \"f225w\",\n \"f275w\",\n \"f336w\",\n \"f390m\",\n \"f390w\",\n \"f410m\",\n \"f438w\",\n \"f467m\",\n \"f475w\",\n \"f547m\",\n \"f555w\",\n \"f606w\",\n \"f621m\",\n \"f625w\",\n \"f689m\",\n \"f763m\",\n \"f775w\",\n \"f814w\",\n \"f845m\",\n ]\n\n wfc3_ir = [\n \"f098m\",\n \"f105w\",\n \"f110w\",\n \"f125w\",\n \"f127m\",\n \"f139m\",\n \"f140w\",\n \"f153m\",\n \"f160w\",\n ]\n\n wfpc2 = [\n \"f122m\",\n \"f157w\",\n \"f336w\",\n \"f410m\",\n \"f467m\",\n \"f547m\",\n \"f439w\",\n \"f569w\",\n \"f675w\",\n \"f791w\",\n \"f170w\",\n \"f185w\",\n \"f218w\",\n \"f255w\",\n \"f300w\",\n \"f380w\",\n \"f555w\",\n \"f622w\",\n \"f450w\",\n \"f606w\",\n \"f702w\",\n \"f814w\",\n ]\n\n acs_wfc = [\n \"f435w\",\n \"f475w\",\n \"f550m\",\n \"f555w\",\n \"f606w\",\n \"f625w\",\n \"f775w\",\n \"f814w\",\n ]\n # galex\n galex = [\"fuv\", \"nuv\"]\n\n # Open hd5 file for writing\n hf = h5py.File(__ROOT__ + \"filters.hd5\", \"w\")\n\n # Create group for nice hierarchical structure\n f = hf.create_group(\"filters\")\n\n # Define arrays for \"contents\" / descriptive information\n tablenames = []\n observatories = []\n instruments = []\n names = []\n norms = []\n cwaves = []\n pwaves = []\n comments = []\n\n # Loop through WFC3_UVIS filters\n for filt in wfc3_uvis:\n\n # define uvis 1 and uvis2 modes\n mode_1 = \"wfc3, uvis1, \" + filt\n mode_2 = \"wfc3, uvis2, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_WFC3_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFC3\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of uvis1 and uvis2\")\n\n # Loop through WFC3_IR filters\n for filt in wfc3_ir:\n\n # define ir mode\n mode = \"wfc3, ir, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp = stsyn.band(mode)\n\n # extract the wavelength array\n wave = bp.waveset\n\n # define the filter name\n filter_name = \"HST_WFC3_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFC3\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"\")\n\n # Loop through WFPC2 filters\n for filt in wfpc2:\n\n # define chips 1, 2, 3, 4 modes\n mode_1 = \"wfpc2, 1, \" + filt\n mode_2 = \"wfpc2, 2, \" + filt\n mode_3 = \"wfpc2, 3, \" + filt\n mode_4 = \"wfpc2, 4, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n bp_3 = stsyn.band(mode_3)\n bp_4 = stsyn.band(mode_4)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave), bp_3(wave), bp_4(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_WFPC2_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFPC2\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of 1, 2, 3, 4\")\n\n # Loop through ACS filters\n for filt in acs_wfc:\n\n # define wfc1, wfc2 modes\n mode_1 = \"acs, wfc1, \" + filt\n mode_2 = \"acs, wfc2, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_ACS_WFC_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"ACS_WFC\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of wfc1 and wfc2\")\n\n # Loop through GALEX filters:\n for filt in galex:\n # define ir mode\n mode = \"galex,\" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp = stsyn.band(mode)\n\n # extract the wavelength array\n wave = bp.waveset\n\n # define the filter name\n filter_name = \"GALEX_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"GALEX\")\n instruments.append(\"GALEX\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"\")\n\n # smash the contents arrays together\n contents = np.array(\n list(\n zip(\n tablenames,\n observatories,\n instruments,\n names,\n norms,\n cwaves,\n pwaves,\n comments,\n )\n ),\n dtype=[\n (\"TABLENAME\", \"S40\"),\n (\"OBSERVATORY\", \"S30\"),\n (\"INSTRUMENT\", \"S30\"),\n (\"NAME\", \"S10\"),\n (\"NORM\", \"<f8\"),\n (\"CWAVE\", \"<f8\"),\n (\"PWAVE\", \"<f8\"),\n (\"COMMENT\", \"S100\"),\n ],\n )\n\n # add the contents array as an hd5 dataset\n hf.create_dataset(\"content\", data=contents)\n\n # close the file\n hf.close()","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 gen_metars(obs, filename, convids=False):\n mtime = datetime.datetime.utcnow().strftime(\"%d%H%M\")\n thres = datetime.datetime.utcnow() - datetime.timedelta(hours=3)\n thres = thres.replace(tzinfo=pytz.UTC)\n fp = open(filename, 'w')\n fp.write(\"\\001\\015\\015\\012001\\n\")\n fp.write(\"SAUS43 KDMX %s\\015\\015\\012METAR\\015\\015\\012\" % (mtime, ))\n for sid in obs:\n ob = obs[sid]\n if ob['valid'] < thres:\n continue\n if sid in [\"RIOI4\", \"ROSI4\", \"RSMI4\", 'RMCI4']:\n continue\n metarid = sid[:4]\n remoteid = NT.sts[sid]['remote_id']\n if convids:\n metarid = RWIS2METAR.get(\"%02i\" % (remoteid,), 'XXXX')\n temptxt = \"\"\n t_temptxt = \"\"\n windtxt = \"\"\n if ob.get('sknt') is not None and ob.get('drct') is not None:\n windtxt = METARwind(ob['sknt'], ob['drct'], ob.get('gust'))\n if obs.get('tmpf') is not None and obs.get('dwpf') is not None:\n m_tmpc, t_tmpc = METARtemp(temperature(ob['tmpf'], 'F').value('C'))\n m_dwpc, t_dwpc = METARtemp(temperature(ob['dwpf'], 'F').value('C'))\n temptxt = \"%s/%s\" % (m_tmpc, m_dwpc)\n t_temptxt = \"T%s%s \" % (t_tmpc, t_dwpc)\n fp.write((\"%s %s %s %s RMK AO2 %s%s\\015\\015\\012\"\n \"\") % (metarid, ob['valid'].strftime(\"%d%H%MZ\"),\n windtxt, temptxt, t_temptxt, \"=\"))\n\n fp.write(\"\\015\\015\\012\\003\")\n fp.close()","def make_log():\n log_file = os.path.join(phys_dir,'ge_phys2bids_'+datetime.now().strftime(\"%Y-%m-%d_%H-%M-%S\")+'.log')\n with open(log_file,'w') as log:\n log.write('-------- GE phys2bids --------\\n\\n')\n log.write('DICOM directory: %s\\n'%dcm_dir)\n log.write('Physiology directory: %s\\n'%phys_dir)\n log.write('Output directory: %s\\n\\n'%out_dir)\n log.write('%d EPI files were found\\n\\n'%len(dcm_dict))\n for rn in dcm_dict.keys():\n log.write('------------------------------\\n')\n log.write('%s\\n'%dcm_dict[rn]['out_name'])\n log.write('Start time: %s\\n'%dcm_dict[rn]['start_time'].strftime(\"%Y-%m-%d %H:%M:%S\"))\n log.write('End time: %s\\n'%dcm_dict[rn]['end_time'].strftime(\"%Y-%m-%d %H:%M:%S\"))\n log.write('PPG file: %s\\n'%dcm_dict[rn]['ppg_file'])\n log.write('Respiration file: %s\\n'%dcm_dict[rn]['resp_file'])\n log.write('ECG file: %s\\n'%dcm_dict[rn]['ecg_file'])\n log.write('------------------------------\\n\\n')","def make_data(self, verbose=False):\n if self.h0:\n self.make_cff(verbose)\n else:\n logger.info(\"Got h0=0, not writing an injection .cff file.\")\n self.run_makefakedata()","def create_CGfiles_using_martinizepy(Ctermini_type, set_charge, name):\n\n os.system('cp %s/%s ./'%(this_path,martini_itp))\n\n os.system('python2 %s/martinize.py -f %s_aa.pdb \\\n -o %s.top -x %s.pdb -name %s -ff martini22 \\\n -nt \\\n -ss CCCCCCCCCCCC '%(this_path,name,name,name,name))\n\n\n # Collect lines defining atoms\n lines_atoms = []\n break1,break2 = None,None\n with open('%s.itp'%name, 'r') as f:\n data = f.readlines()\n start = False\n for i,line in enumerate(data):\n if '[ atoms ]' in line:\n start = True\n break1 = i+1\n continue\n if start:\n if line.split()==[]:\n start = False\n break2 = i\n break\n lines_atoms = lines_atoms + [line]\n \n \n\n # Modify lines_atoms as per Ctermini\n charged_thusfar = 0\n if Ctermini_type.upper() == 'OH':\n for i in range(len(lines_atoms))[::-1]:\n if 'BB' in lines_atoms[i]:\n lines_atoms[i] = lines_atoms[i].replace(' 0.0', '-1.0')\n lines_atoms[i] = lines_atoms[i].replace('P5', 'Qa') \n charged_thusfar += -1\n break\n\n\n # modify charge of side chains,\n # CURRENTLY only neutralizes if Qd SC is found (deprotonation)\n neutralize_ahead = False\n if set_charge < 0: # deprotonation\n for i in range(len(lines_atoms))[::-1]:\n if charged_thusfar == set_charge:\n neutralize_ahead = True\n \n if ('SC' in lines_atoms[i]) and ('-1.0' in lines_atoms[i]):\n if 'Qa' not in lines_atoms[i]:\n raise RuntimeError('-1.0 charge without Qa bead is found')\n if neutralize_ahead:\n lines_atoms[i] = lines_atoms[i].replace('-1.0', ' 0.0')\n lines_atoms[i] = lines_atoms[i].replace('Qa', 'P1')\n else:\n charged_thusfar += -1\n\n if ('SC' in lines_atoms[i]) and (' 1.0' in lines_atoms[i]):\n if 'Qd' not in lines_atoms[i]:\n raise RuntimeError('1.0 charge without Qd bead is found')\n lines_atoms[i] = lines_atoms[i].replace('1.0', ' 0.0')\n lines_atoms[i] = lines_atoms[i].replace('Qd', 'P1')\n\n if charged_thusfar != set_charge:\n raise ValueError('Peptide sequence could not be used to achieve set_charge')\n\n elif set_charge == 0: # protonation-deprotonation\n if Ctermini_type == 'OH':\n raise ValueError('Protonation after deprotonation does not make sense')\n \n for i in range(len(lines_atoms))[::-1]:\n if ('SC' in lines_atoms[i]) and ('-1.0' in lines_atoms[i]):\n if 'Qa' not in lines_atoms[i]:\n raise RuntimeError('-1.0 charge without Qa bead is found')\n lines_atoms[i] = lines_atoms[i].replace('-1.0', ' 0.0')\n lines_atoms[i] = lines_atoms[i].replace('Qa', 'P1')\n\n if ('SC' in lines_atoms[i]) and (' 1.0' in lines_atoms[i]):\n if 'Qd' not in lines_atoms[i]:\n raise RuntimeError('1.0 charge without Qd bead is found')\n lines_atoms[i] = lines_atoms[i].replace('1.0', ' 0.0')\n lines_atoms[i] = lines_atoms[i].replace('Qd', 'P1')\n \n elif set_charge > 0: # protonation\n if Ctermini_type == 'OH':\n raise ValueError('Protonation after deprotonation does not make sense')\n\n for i in range(len(lines_atoms))[::-1]:\n if charged_thusfar == set_charge:\n neutralize_ahead = True\n\n if ('SC' in lines_atoms[i]) and ('-1.0' in lines_atoms[i]):\n if 'Qa' not in lines_atoms[i]:\n raise RuntimeError('-1.0 charge without Qa bead is found')\n lines_atoms[i] = lines_atoms[i].replace('-1.0', ' 0.0')\n lines_atoms[i] = lines_atoms[i].replace('Qa', 'P1')\n \n if ('SC' in lines_atoms[i]) and (' 1.0' in lines_atoms[i]):\n if 'Qd' not in lines_atoms[i]:\n raise RuntimeError('1.0 charge without Qd bead is found')\n if neutralize_ahead:\n lines_atoms[i] = lines_atoms[i].replace('1.0', ' 0.0')\n lines_atoms[i] = lines_atoms[i].replace('Qd', 'P1')\n else:\n charged_thusfar += 1\n \n if charged_thusfar != set_charge:\n raise ValueError('Peptide sequence could not be used to achieve set_charge')\n\n\n data_new = ''\n for line in data[:break1]:\n data_new += line\n for line in lines_atoms:\n data_new += line\n for line in data[break2:]:\n data_new += line\n \n \n with open('%s.itp'%name, 'w') as f:\n f.write(data_new)","def createCfg_prep_dcard(self, jobOptions):\n category_output = self.channel\n if jobOptions['label']:\n category_output += \"_%s\" % jobOptions['label']\n lines = []\n lines.append(\"process.fwliteInput.fileNames = cms.vstring('%s')\" % jobOptions['inputFile'])\n lines.append(\"process.fwliteOutput.fileName = cms.string('%s')\" % jobOptions['datacardFile'])\n lines.append(\"process.prepareDatacards.processesToCopy = cms.vstring(%s)\" % self.prep_dcard_processesToCopy)\n lines.append(\"process.prepareDatacards.signals = cms.vstring(%s)\" % self.prep_dcard_signals)\n lines.append(\"process.prepareDatacards.makeSubDir = cms.bool(True)\")\n lines.append(\"process.prepareDatacards.categories = cms.VPSet(\")\n for charge in [\"OS\", \"SS\"]:\n for ptEtaBin in [\n \"BB_LL\", \"BB_ML\", \"BB_MM\", \"BB_HL\", \"BB_HM\", \"BB_HH\",\n \"EE_LL\", \"EE_ML\", \"EE_MM\", \"EE_HL\", \"EE_HM\", \"EE_HH\",\n \"BE_LL\", \"BE_ML\", \"EB_ML\",\"BE_MM\", \"BE_HL\", \"EB_HL\",\n \"BE_HM\", \"EB_HM\", \"BE_HH\", \"total\",\n ]:\n lines.append(\" cms.PSet(\")\n lines.append(\" input = cms.string('%s/%s'),\" % (charge, ptEtaBin))\n lines.append(\" output = cms.string('ttH_%s_%s_%s')\" % (self.channel, charge, ptEtaBin))\n lines.append(\" ),\")\n lines.append(\")\")\n lines.append(\"process.prepareDatacards.histogramToFit = cms.string('%s')\" % jobOptions['histogramToFit'])\n lines.append(\"process.prepareDatacards.sysShifts = cms.vstring(%s)\" % systematics.muon_E)\n create_cfg(self.cfgFile_prep_dcard, jobOptions['cfgFile_modified'], lines)","def write_data_card(spec, data_card, channels, path):\n with open(path, \"w\") as f:\n f.write(f\"imax {str(size(data_card.bins))}\" + \"\\n\")\n f.write(\n \"jmax \"\n + str(size(data_card.processes) - size(data_card.isSignal.keys()))\n + \"\\n\"\n )\n f.write(f\"kmax {str(size(data_card.systs, 0))}\" + \"\\n\")\n\n if data_card.hasShapes:\n for channel in data_card.shapeMap.keys():\n for sample in data_card.shapeMap[channel].keys():\n f.write(\n f\"shapes {sample} {channel} {data_card.shapeMap[channel][sample][0]} {data_card.shapeMap[channel][sample][1]}\"\n )\n if size(data_card.shapeMap[channel][sample]) > 2:\n f.write(f\" {data_card.shapeMap[channel][sample][2]}\" + \"\\n\")\n else:\n f.write(\"\\n\")\n\n f.write(\"\\n---------------------------------\\n\")\n f.write(\"bin \")\n for bin in data_card.obs.keys():\n f.write(f\"{bin} \")\n f.write(\"\\n\")\n f.write(\"observation \")\n for channel in data_card.obs.keys():\n f.write(f\"{str(data_card.obs[channel])} \")\n f.write(\"\\n---------------------------------\\n\")\n f.write(\"bin \")\n for channel in data_card.obs.keys():\n for sample in data_card.exp[channel].keys():\n f.write(f\"{channel} \")\n f.write(\"\\n\")\n f.write(\"process \")\n for channel in data_card.bins:\n for sample in data_card.exp[channel].keys():\n f.write(f\"{sample} \")\n f.write(\"\\n\")\n f.write(\"process \")\n for channel in data_card.bins:\n for sample in data_card.exp[channel].keys():\n if sample in data_card.signals:\n f.write(f\"{str(-1 * data_card.processes.index(sample))} \")\n else:\n f.write(f\"{str(data_card.processes.index(sample) + 1)} \")\n f.write(\"\\n\")\n f.write(\"rate \")\n for channel in data_card.bins:\n for sample in data_card.exp[channel].keys():\n\n f.write(f\"{str(data_card.exp[channel][sample])} \")\n f.write(\"\\n---------------------------------\\n\")\n for syst in data_card.systs:\n f.write(f\"{syst[0]} {syst[2]} \")\n for bin in syst[4].keys():\n for sample in data_card.exp[bin].keys():\n if syst[4][bin][sample] != 0:\n f.write(f\"{str(syst[4][bin][sample])} \")\n else:\n f.write(\"- \")\n\n f.write(\"\\n\")\n f.write(\"\\n---------------------------------\\n\")\n for cAp in data_card.rateParams.keys():\n _dir = cAp.split(\"AND\")\n for i in range(size(data_card.rateParams[cAp], 0)):\n if size(data_card.rateParams[cAp][i][0]) > 3:\n f.write(\n f\"{str(data_card.rateParams[cAp][i][0][0])} rateParam {_dir[0]} {_dir[1]} {str(data_card.rateParams[cAp][i][0][1])} {data_card.rateParams[cAp][i][0][3]}\"\n )\n else:\n f.write(\n f\"{str(data_card.rateParams[cAp][i][0][0])} rateParam {_dir[0]} {_dir[1]} {str(data_card.rateParams[cAp][i][0][1])}\"\n )\n f.write(\"\\n\")\n f.write(\"\\n---------------------------------\\n\")\n for idxc, channel in enumerate(channels):\n if (\n channel in data_card.binParFlags.keys()\n and data_card.binParFlags[channel] == True\n ):\n # double check to be safe\n shapesys = False\n staterror = False\n for sample in spec[\"channels\"][idxc][\"samples\"]:\n mod_types = [mod[\"type\"] for mod in sample[\"modifiers\"]]\n if \"shapesys\" in mod_types:\n shapesys = True\n elif \"staterror\" in mod_types:\n staterror = True\n\n if shapesys:\n f.write(f\"{channel} autoMCStats 100000 0 2\" + \"\\n\")\n if staterror:\n f.write(f\"{channel} autoMCStats 0 0 2\" + \"\\n\")","def get_data(output_dir: Path = Path(\"raw_data\")) -> None:\n\n files = [\n \"alignment.sorted.bam\",\n \"names-mdmg.dmp\",\n \"nodes-mdmg.dmp\",\n \"acc2taxid.map.gz\",\n ]\n\n for file in files:\n with resources.path(\"metaDMG.data\", file) as p:\n file_path = p\n\n target_path = Path(output_dir) / file\n target_path.parent.mkdir(parents=True, exist_ok=True)\n shutil.copy(file_path, target_path)","def generate_setups(self,filename=DEFAULT_FILENAME):\n \n self._create_main_shape()\n self._create_margin_shape()\n\n for section, setup in self.setups.iteritems():\n self._generate_section_structures(setup['distance'],\n setup['radius'],\n setup['structure'],\n section)\n self.write(filename)","def writeFiles(self, directory = \"./\"):\n self.mass = []\n self.zero = 0\n self.natoms = self.numMonomer\n self.nangles = 0\n self.ndihedrals = 0\n\n self.ntypes = 4\n\n # set masses of all beads to be 1\n # in principle, the mass of counterions and salt ions should be smaller\n # expect this difference will no matter in terms of complexation of polyelectrolytes\n for i in range(self.ntypes):\n self.mass.append(1)\n\n\n\n self.bdtypes = 1\n self.angtypes = 0\n self.dihtypes = 0\n self.improtypes = 0\n\n iFileLammpsName = directory + \"data.pe.la{0}.na{1}.lc{2}.nc{3}.rho{4}.r{5}.lammps\".\\\n format(self.lenPa, self.numPa, self.lenPc, self.numPc, self.volRatio, self.chargeRepeat)\n iFileLammps = open(iFileLammpsName, 'w')\n\n iFileXYZName = directory + \"data.pe.la{0}.na{1}.lc{2}.nc{3}.rho{4}.r{5}.xyz\".\\\n format(self.lenPa, self.numPa, self.lenPc, self.numPc, self.volRatio, self.chargeRepeat)\n iFileXYZ = open(iFileXYZName, 'w' )\n\n iFileXYZ.write(\"{0}\\n\".format(self.natoms))\n iFileXYZ.write(\"data.polyelectrolyte.xyz\\n\")\n\n iFileLammpsHeader = \"data file for mixtures of charged polymer chains\\n\" + \\\n \"\\n\" + \\\n \"{0:10d} atoms\\n\".format(self.natoms) + \\\n \"{0:10d} bonds\\n\".format(self.numBonds) + \\\n \"{0:10d} angles\\n\".format(self.nangles) + \\\n \"{0:10d} dihedrals\\n\".format(self.ndihedrals) + \\\n \"{0:10d} impropers\\n\".format(self.zero) + \\\n \"\\n\" +\\\n \"{0:10d} atom types\\n\".format(self.ntypes) + \\\n \"{0:10d} bond types\\n\".format(self.bdtypes) + \\\n \"{0:10d} angle types\\n\".format(self.angtypes) + \\\n \"{0:10d} dihedral types\\n\".format(self.dihtypes) + \\\n \"{0:10d} improper types\\n\".format(self.improtypes) + \\\n \"\\n\" + \\\n \" {0:16.8f} {1:16.8f} xlo xhi\\n\".format(self.lx, self.hx) + \\\n \" {0:16.8f} {1:16.8f} ylo yhi\\n\".format(self.ly, self.hy) + \\\n \" {0:16.8f} {1:16.8f} zlo zhi\\n\".format(self.lz, self.hz) + \\\n \"\\n\" + \\\n \"Masses\\n\" + \\\n \"\\n\"\n\n iFileLammps.write(iFileLammpsHeader)\n for i in range(self.ntypes):\n iFileLammps.write( \"{0} {1:8.3f}\\n\".format(i+1, self.mass[i]))\n\n iFileLammps.write(\"\\nAtoms\\n\\n\")\n \n \n\n for i in range(self.natoms):\n if self.atomsType[i] == 1 or self.atomsType[i] == 3:\n iFileXYZ.write(\"S {0} {1} {2}\\n\".format(self.atomsCoords[i][0], \\\n self.atomsCoords[i][1], \\\n self.atomsCoords[i][2]))\n elif self.atomsType[i] == 2:\n iFileXYZ.write(\"P {0} {1} {2}\\n\".format(self.atomsCoords[i][0], \\\n self.atomsCoords[i][1], \\\n self.atomsCoords[i][2]))\n elif self.atomsType[i] == 4:\n iFileXYZ.write(\"N {0} {1} {2}\\n\".format(self.atomsCoords[i][0], \\\n self.atomsCoords[i][1], \\\n self.atomsCoords[i][2]))\n elif self.atomsType[i] == 5:\n iFileXYZ.write(\"A {0} {1} {2}\\n\".format(self.atomsCoords[i][0], \\\n self.atomsCoords[i][1], \\\n self.atomsCoords[i][2]))\n elif self.atomsType[i] == 6:\n iFileXYZ.write(\"C {0} {1} {2}\\n\".format(self.atomsCoords[i][0], \\\n self.atomsCoords[i][1], \\\n self.atomsCoords[i][2]))\n elif self.atomsType[i] == 7:\n iFileXYZ.write(\"I {0} {1} {2}\\n\".format(self.atomsCoords[i][0], \\\n self.atomsCoords[i][1], \\\n self.atomsCoords[i][2]))\n elif self.atomsType[i] == 8:\n iFileXYZ.write(\"K {0} {1} {2}\\n\".format(self.atomsCoords[i][0], \\\n self.atomsCoords[i][1], \\\n self.atomsCoords[i][2]))\n\n iFileLammps.write(\"{0} {1} {2} {3} {4} {5} {6}\\n\".format(i+1, \\\n self.molId[i], \\\n self.atomsType[i], \\\n self.atomsCharge[i], \\\n self.atomsCoords[i][0], \\\n self.atomsCoords[i][1], \\\n self.atomsCoords[i][2]))\n\n iFileLammps.write(\"\\nBonds\\n\\n\")\n for i in range(self.numBonds):\n iFileLammps.write(\"{0} 1 {1} {2}\\n\".format(i+1, self.bondList[i][0], self.bondList[i][1]))\n\n iFileXYZ.close()\n iFileLammps.close()","def dctCreateDD(pdct, dirName, msgBufSize):\n return _dctmcc.dctCreateDD(pdct, dirName, msgBufSize)","def save(cartesian, charge, name, comment='',\n mop_dir=str(os.getcwd()), csv_dir=str(os.getcwd()),\n mop_file=True, csv_file=True):\n # Preparation\n del cartesian['num']\n coordinates = 'x', 'y', 'z'\n columns = {'1_1': 2, '1_2': 4, '1_3': 6}\n for coord in coordinates:\n cartesian[coord] = cartesian[coord].astype(float)\n\n # .mop block\n if mop_file is True:\n cartesian = cartesian.round(decimals=5)\n for column in columns:\n cartesian.insert(columns[column], column, 0, True)\n\n # .mop constructor\n with open(mop_dir + 'sp_' + name + '.mop', 'a') as mop:\n mop.writelines('AUX LARGE CHARGE=' + charge + ' SINGLET NOOPT PM6-DH2X' + '\\n')\n mop.writelines(comment + '\\n'*2)\n mop.writelines(cartesian.to_string(header=False, index=False))\n mop.writelines('\\n'*2)\n\n # .csv block\n if csv_file is True:\n cartesian = cartesian.round(decimals=4)\n for column in columns:\n if mop_file is True:\n del cartesian[column]\n cartesian.insert(columns[column], column, 1, True)\n cartesian.to_csv(csv_dir + name + '.csv')","def CreateDirs(self):\n# First, create a list of directories.\n dnames = []\n tags = ['', '_m', '_mf']\n for entry in self.info.keys():\n if self.info[entry]['type'] == 'epi':\n for tag in tags:\n fname = self.info[entry].get('imgfile%s' % tag, None)\n if fname is not None:\n dnames.append(os.path.dirname(fname))\n else:\n if self.info[entry].get('outdir',None) is not None:\n dnames.append(self.info[entry]['outdir'])\n\n# Create them if they don't already exist.\n for dname in dnames:\n if not os.path.exists(dname):\n self.MakeDir(dname)\n if self.verbose:\n print 'mkdir %s' % dname","def export_md(clips):\n for book in clips:\n lines = []\n for pos in sorted(clips[book]):\n lines.append((clips[book][pos] + ' **P%s**' %pos).encode('utf-8'))\n\n filename = os.path.join(OUTPUT_DIR, u\"%s.md\" % book)\n with open(filename, 'w') as f:\n f.write(\"\\n\\n\".join(lines))","def main():\n\n classes = {\n \"rain\":0,\n \"rooster\":1,\n \"crying_baby\":2,\n \"sea_waves\":3,\n \"clock_tick\":4,\n \"sneezing\":5,\n \"dog\":6,\n \"crackling_fire\":7,\n \"helicopter\":8,\n \"chainsaw\":9,\n }\n\n with open(\"../data/audio/ESC-50-master/meta/esc50.csv\") as f:\n lines = [i[:-1] for i in f.readlines()]\n lines = lines[1:]\n\n os.system(\"rm -rf ../data/audio/ESC-10\")\n os.system(\"mkdir ../data/audio/ESC-10\")\n os.system(\"mkdir ../data/audio/ESC-10/audio\")\n\n meta = []\n for line in lines:\n t = line.split(\",\")\n if (t[-3] == 'True'):\n meta.append(\"../data/audio/ESC-10/audio/%s %d\" % (t[0],classes[t[3]]))\n src = \"../data/audio/ESC-50-master/audio/\"+t[0]\n dst = \"../data/audio/ESC-10/audio/\"+t[0]\n shutil.copy(src,dst)\n\n with open(\"../data/audio/ESC-10/filelist.txt\",\"w\") as f:\n for m in meta:\n f.write(m+\"\\n\")","def setup(self):\n\n if self.user is 'Daisy':\n import socket\n host = socket.gethostname()\n\n simName = self.name_prefix[:self.name_prefix.find('_')]\n\n if 'ursa' in host:\n self.raw_sim_dir = '/disk01/rad/sim/' + simName + '/' + self.feedback\n self.caesar_dir = '/disk01/rad/sim/' + simName + '/' + self.feedback + 'Groups/'\n self.redshiftFile = '/home/rad/gizmo-extra/outputs_boxspace50.info'\n self.d_data = '/home/dleung/Downloads/SIGAME_dev/sigame/temp/z' + str(int(self.zCloudy)) + '_data_files/'\n elif 'flatironinstitute.org' or 'worker' in host:\n self.raw_sim_dir = '/mnt/ceph/users/daisyleung/simba/sim/' + simName + '/' + self.feedback # dummy\n self.caesar_dir = '/mnt/ceph/users/daisyleung/simba/sim/' + simName + '/' + self.feedback + 'Groups/'\n self.redshiftFile = '/mnt/ceph/users/daisyleung/simba/gizmo-extra/outputs_boxspace50.info'\n self.d_data = '/mnt/home/daisyleung/Downloads/SIGAME_dev/sigame/temp/z' + str(int(self.zCloudy)) + '_data_files/'\n else:\n raise NotImplementedError","def save_data(dfin, outfile=\"./FPeng_prepped\"):\n dfin.to_csv(outfile+'.csv', sep='\\t', index=False)\n # s3.meta.client.upload_file(outfile+\".csv\", 'p3-engine', 'ETL/FPeng_prepped.csv')\n print(\"csv...\", end=\" \")\n\n dfin.to_pickle(outfile+'.pkl' ,protocol=4)\n # s3.meta.client.upload_file(outfile+'.pkl', 'p3-engine', 'ETL/FPeng_prepped.pkl')\n print(\"pkl...\", end=\" \")\n #dfin.to_msgpack(outfile+'.msg')\n #print(\"msg...\", end=\" \")\n\n #s3.meta.client.upload_file(outfile+\".msg\", 'p3-engine', 'ETL/FPeng_prepped.msg')\n\n # print(\"to s3 complete\", end=\" \")","def setUpClass(cls):\n import os\n for root in cls.prod_s2_ssc:\n os.makedirs(root)\n metadata = root.split(\".\")[0] + \".HDR\"\n TestFunctions.touch(metadata)\n for root in cls.prod_s2_mus:\n os.makedirs(root)\n metadata = os.path.join(root, root + \"_MTD_ALL.xml\")\n TestFunctions.touch(metadata)\n for root in cls.prod_s2_nat:\n os.makedirs(root)\n metadata = os.path.join(root, \"MTD_MSIL1C.xml\")\n TestFunctions.touch(metadata)","def make_master_flats(dc):\n\n\t## Make EXTcheck: is there always the same number of extensions in each file\n\tprint \"Making master flats\"\n\t\n\t## Choose extensions you are using\n\t\n\tfor flat_type in ['FFS']: # Currently FFD is unsupported. If you have FFDs, add them to the list but you must have ONLY FFDs or ONLY FFSs in the dir. Otherwise the first element in the list will get overwritten!\n\t\t#~ print \"\\n\", flat_type, \"\\n\"\n\t\tfor i in dc:\n\t\t\tTRIM, TRIM1, VR, PS, PS1, OS, OS1 = CCD_sections((i[0], i[1]))\n\t\t\tfilelist = []\n\t\t\tfor f in glob.glob(RAW+'*'+flat_type+'*fits'):\n\t\t\t\tccd_conf = []\n\t\t\t\theader0 = fits.getheader(f)\n\t\t\t\theader1 = fits.getheader(f, ext=1)\n\t\t\t\tif header0['OBSMODE']==flat_type:\n\t\t\t\t\tfor KW in ['BINX', 'BINY']:\n\t\t\t\t\t\tccd_conf.append(header0[KW])\n\t\t\t\t\tfor KW in ['NAXIS1', 'NAXIS2']:\n\t\t\t\t\t\tccd_conf.append(header1[KW])\n\t\t\t\t\t\tif tuple(ccd_conf)==i:\n\t\t\t\t\t\t\tfilelist.append(f)\n\t\t\tlfl = len(filelist)\n\t\t\tif lfl > 0:\n\t\t\t\tBIN=CD+'/'+str(i[0])+'x'+str(i[1])+'/'\n\t\t\t\tWD=BIN+str(i[-2])+'x'+str(i[-1])+'/' # Bottom level dir with calibrated and master frames\n\t\t\t\tB=check_exist(WD, 'MF.fits', i)\n\t\t\t\tif B=='n':\n\t\t\t\t\tpass\n\t\t\t\telse:\n\t\t\t\t\thdul = fits.HDUList()\n\t\t\t\t\thdul.append(fits.ImageHDU())\n\t\t\t\t\t#~ MB = fits.open(WD+'MB.fits')\n\t\t\t\t\tx = np.array(range(0,i[-1]))\n\t\t\t\t\tfor EXT in (extensions):\n\t\t\t\t\t\tprint \"##################################################\"\n\t\t\t\t\t\tprint \"Stacking \"+`lfl`+' '+`i[-2]`+'x'+`i[-1]`+' channel '+`EXT`+' flat frames!'\n\t\t\t\t\t\tif EXT==1:\n\t\t\t\t\t\t\tPSC=PS1\n\t\t\t\t\t\t\tOSC=OS1\n\t\t\t\t\t\t\tTR=TRIM1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tPSC=PS1\n\t\t\t\t\t\t\tOSC=OS\n\t\t\t\t\t\t\tTR=TRIM\n\t\t\t\t\t\tsc = -1 # counts how many flats have mean>limit\n\t\t\t\t\t\tfor n, fn in enumerate(filelist):\n\t\t\t\t\t\t\tprint \"Files left:\",`lfl-n`+'/'+`lfl`\n\t\t\t\t\t\t\tim = fits.getdata(fn, ext=EXT)\n\t\t\t\t\t\t\tmeanval = np.mean(im[VR[0]:VR[1], TR[0]:TR[1]])\n\t\t\t\t\t\t\t#~ maxval = np.max(im[VR[0]:VR[1], TR[0]:TR[1]])\n\t\t\t\t\t\t\tmaxval = stats.scoreatpercentile(im[VR[0]:VR[1], TR[0]:TR[1]], 90)\n\t\t\t\t\t\t\texptime = fits.getheader(fn)['EXPTIME']\n\t\t\t\t\t\t\t#~ if meanval > 15000. and meanval < 40000. and maxval < 50000. and exptime>5.:\n\t\t\t\t\t\t\tif meanval > 16000. and meanval < 40000. and exptime>=5.:\n\t\t\t\t\t\t\t\tsc+=1\n\t\t\t\t\t\t\t\t#~ im[im<1]=1\n\t\t\t\t\t\t\t\tmscrow, sigmarow = median_row(OSC, PSC, TR, im)\n\t\t\t\t\t\t\t\tsh = np.shape(im)\n\t\t\t\t\t\t\t\tfor y in range(0, sh[0]):\n\t\t\t\t\t\t\t\t\tim[y] = im[y]-mscrow[y]\n\t\t\t\t\t\t\t\tF=im\n\t\t\t\t\t\t\t\tnorm = np.median(F[VR[0]:VR[1], TR[0]:TR[1]])\n\t\t\t\t\t\t\t\tF = F/norm #+np.min(F)+0.0001\n\t\t\t\t\t\t\t\tif sc==0:\n\t\t\t\t\t\t\t\t\tstack_arr = F\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tstack_arr = np.dstack((stack_arr, F))\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tprint \"****************************************\"\n\t\t\t\t\t\t\t\tprint \"Rejected\", fn, \"AVG =\", meanval, \"EXPTIME =\", exptime\n\t\t\t\t\t\t\t\tprint \"****************************************\"\n\t\t\t\t\t\tprint 'Will stack a total of', np.shape(stack_arr)[2], 'flats'\n\t\t\t\t\t\tMF = np.median(stack_arr, axis=2)\n\t\t\t\t\t\thdul.append(fits.ImageHDU(MF))\n\t\t\t\t\t\thdul[EXT].header.set(\"NAXIS1\", np.shape(MF)[1])\n\t\t\t\t\t\thdul[EXT].header.set(\"NAXIS2\", np.shape(MF)[0])\n\t\t\t\t\thdul[0].header.set(\"CALIBR\", \"T\")\n\t\t\t\t\thdul[0].header.set(\"INSTRUME\", \"MAIA\")\n\t\t\t\t\thdul[0].header.set(\"BINX\", i[0])\n\t\t\t\t\thdul[0].header.set(\"BINY\", i[1])\n\t\t\t\t\thdul[0].header.set(\"CALMODE\", \"MASTER FLAT\")\n\t\t\t\t\thdul.writeto(WD+\"MF.fits\", clobber=True)\n\t\t\t\t\tprint \"############################################################\"\n\tprint \"Completed master flats\"","def creation_srcmdl(dir_cat,SourceRA,SourceDec,SourceROI,distmin,name,outputfile,emin,emax):\n\tf_liste_sour=\"a.txt\"\n\n\tlect_ca(dir_cat,SourceRA,SourceDec,SourceROI,distmin,name,f_liste_sour,name)\n\tXML_EC_PL(name, f_liste_sour, outputfile, emin,emax)\n\tos.system(\"rm -rf a.txt\")","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 create_fits_file(fits, cols, cdata):\n dlist = []\n for k in range(0, len(cols)):\n aent = numpy.array(cdata[k])\n dcol = pyfits.Column(name=cols[k], format='F', array=aent)\n dlist.append(dcol)\n\n dcols = pyfits.ColDefs(dlist)\n tbhdu = pyfits.BinTableHDU.from_columns(dcols)\n\n mcf.rm_files(fits)\n tbhdu.writeto(fits)","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","def dsinfomaker(compath, backpath, mwb, tcfs, SR=\"SR\"):#yrs, ves,\r\n\tdsinfo = OrderedDict()\r\n\t# ==========\r\n\tdsinfo[\"GFED\"] = ({\"alias\":\"GFED4.1\",\"long_name\":\"FRI\", \"units\":\"yrs\"})\r\n\tdsinfo[\"MODIS\"] = ({\"alias\":\"MCD64A1\", \"long_name\":\"FRI\",\"units\":\"yrs\", \"version\":\"v006\"})\r\n\tdsinfo[\"esacci\"] = ({\"alias\":\"FireCCI5.1\", \"long_name\":\"FRI\",\"units\":\"yrs\"})\r\n\tdsinfo[\"COPERN_BA\"] = ({\"alias\":\"CGLS\", \"long_name\":\"FRI\",\"units\":\"yrs\"})\r\n\tdsinfo[\"HANSEN_AFmask\"] = ({\"alias\":\"Hansen GFC & MCD14ML\", \"long_name\":f'FRI$_{{{SR}}}$',\"units\":\"yrs\"})\r\n\tdsinfo[\"HANSEN\"] = ({\"alias\":\"Hansen GFC\", \"long_name\":\"DRI\",\"units\":\"yrs\"})\r\n\tdsinfo[\"Risk\"] = ({\"alias\":\"Forest Loss Risk\"})\r\n\t# dsinfo[\"FutureRisk\"] = ({\"alias\":\"Forest Loss Risk\"})\r\n\tdsinfo[\"SRfrac\"] = ({\"alias\":\"Stand Replacing Fire Percentage\", \"long_name\":f'FRI$_{{{\"SR\"}}}$ %'})\r\n\r\n\tfor dsnm in dsinfo:\r\n\t\tif dsnm.startswith(\"H\"):\r\n\t\t\t# +++++ make a path +++++\r\n\t\t\tppath = compath + \"/BurntArea/HANSEN/FRI/\"\r\n\t\t\tfname = \"%s%s_annual_burns_MW_%ddegreeBox.nc\" % (dsnm, tcfs, mwb)\r\n\t\t\t# fname = \"%s%s_annual_burns_MW_%ddegreeBox.nc\" % (dsnm, mwb)\r\n\t\telif dsnm == \"Risk\":\r\n\t\t\tppath = compath + \"/BurntArea/Risk/FRI/\"\r\n\t\t\tfname = \"%s_annual_burns_MW_%ddegreeBox.nc\" % (dsnm, mwb)\r\n\t\t\tcf.pymkdir(ppath)\r\n\t\t# elif dsnm == \"FutureRisk\":\r\n\t\t# \tppath = compath + \"/BurntArea/Risk/FRI/\"\r\n\t\t# \tfname = f\"{dsnm}_annual_burns_MW_{mwb}degreeBox_{yrs}yrs_{ves}.nc\" \r\n\t\t# \tcf.pymkdir(ppath)\r\n\t\telse:\r\n\t\t\t# fname = \"Hansen_GFC-2018-v1.6_regrided_esacci_FRI_%ddegMW_SIBERIA\" % (mwb)\r\n\t\t\tppath = compath + \"/BurntArea/%s/FRI/\" % dsnm\r\n\t\t\tfname = \"%s_annual_burns_MW_%ddegreeBox.nc\" % (dsnm, mwb)\r\n\t\t# +++++ open the datasets +++++\r\n\t\tdsinfo[dsnm][\"fname\"] = ppath+fname\r\n\r\n\r\n\treturn dsinfo","def loader(filename,wdm=0,verbose=0,kmpers=1):\n with open(filename, 'rb') as f:\n if wdm == False:\n if verbose>1:\n print(filename)\n #file info\n info= np.fromfile(f,dtype=infodtype,count=1)\n infoBytes = f.tell()\n if verbose>2:\n print(infoBytes)\n #skip darkmatter\n #read the first dm line\n if verbose>2:\n print(f.tell())\n catd = np.fromfile(f,dtype= dmdtype, count=1) \n #get the bytes location and subtract off the bytes location after loading info to get n bytes a line for dm\n if verbose>2:\n print(f.tell())\n current = f.tell()\n dmBytes = current-infoBytes\n f.seek(dmBytes*(info['nd'][0]-1)+current)\n if verbose>2:\n print(f.tell())\n # stars setup \n cats= np.fromfile(f,dtype=stellardtype, count=info['ns'][0])\n if verbose>2:\n print('done')\n else:\n if verbose>1:\n print(filename)\n #file info\n info= np.fromfile(f,dtype=infodtype,count=1)\n if verbose>2:\n print(f.tell())\n # #dark matter setup count is reading the number of ?rows? \n catd= np.fromfile(f,dmdtype, count=info['nd'][0]) \n if verbose>2:\n print(f.tell()) \n # stars setup \n cats= np.fromfile(f,dtype=stellardtype, count=info['ns'][0])\n if verbose>2:\n print('done')\n \n \n #convert to physical units as found in README.md\n if wdm == True:\n catd['mass']*=2.324876e9\n if kmpers == 1:\n catd['vx']*=100.\n catd['vy']*=100.\n catd['vz']*=100.\n cats['mass']*=2.324876e9\n if kmpers == 1:\n cats['vx']*=100.\n cats['vy']*=100.\n cats['vz']*=100.\n \n if wdm == True:\n return(catd,cats,info)\n else:\n return(cats,info)","def MakeDataSetFiles(dirname):\n\n\n if not os.path.exists(dirname):\n os.mkdir(dirname)\n if not os.path.exists(os.path.join(dirname, 'train')):\n os.mkdir(os.path.join(dirname, 'train'))\n if not os.path.exists(os.path.join(dirname, 'test')):\n os.mkdir(os.path.join(dirname, 'test'))\n data_train = fetch_20newsgroups(subset='train', categories=None, shuffle=True, random_state=42)\n data_test = fetch_20newsgroups(subset='test', categories=None, shuffle=True, random_state=42)\n\n if dirname[-1] == '/' or dirname[-1] == '\\\\':\n dirname = dirname[:-1]\n \n Util.WriteClassFile(data_train.target, os.path.join(dirname, 'train_classes.txt'))\n Util.WriteClassFile(data_test.target,os.path.join(dirname, 'test_classes.txt'))\n\n\n train_counter = 0;\n for doc in data_train.data:\n filename = 'train_' + str(train_counter).zfill(5);\n f = file(os.path.join(dirname, 'train', filename), 'w');\n f.write(doc.encode('ascii', 'ignore'));\n f.close();\n train_counter = train_counter + 1;\n\n test_counter = 0;\n for doc in data_test.data:\n filename = 'test_' + str(test_counter).zfill(5);\n f = file(os.path.join(dirname, 'test', filename), 'w');\n f.write(doc.encode('ascii', 'ignore'));\n f.close();\n test_counter = test_counter + 1;\n\n class_index = file(os.path.join(dirname, 'class_label_index.txt'), 'w')\n for label in data_train.target_names:\n class_index.write(label + '\\n')\n class_index.close()","def dctCreateD(pdct, dirName, msgBufSize):\n return _dctmcc.dctCreateD(pdct, dirName, msgBufSize)","def file(self):\n\n corrdict = (self.cat_corr)['correction']\n specdict = (self.cat_corr)['spec'] \n \n fft_dir = direc('fft', self.cat_corr)\n \n if self.type == 'data': \n galdata = Data(self.type, self.cat_corr, **self.kwargs) # data class \n elif self.type == 'random': \n galdata = Random(self.type, self.cat_corr, **self.kwargs) # data class \n\n self.data_file = galdata.file_name # galaxy data file\n\n # FFT label \n fft_str = 'FFT_'\n if specdict['ell'] != 0: \n fft_str += 'Q_'\n \n fft_corr_str = ''\n if (corrdict['name'].lower() in ('floriansn', 'hectorsn')) & (self.type != 'random'):\n fft_corr_str = ''.join(['.', corrdict['name'].lower()])\n\n # FFTs from data file \n fft_file = ''.join([\n fft_dir, \n fft_str, (self.data_file).rsplit('/')[-1], \n fft_corr_str,\n '.grid', str(specdict['Ngrid']), \n '.P0', str(specdict['P0']), \n '.box', str(specdict['Lbox'])\n ])\n\n return fft_file","def make_tag_data_raw_fast(mdp,filename):\n #\n fin = open(filename,'r')\n iter = 0\n for line in fin:\n lsp = line.split(' ')\n if len(lsp) > 1: # skip empty lines\n if lsp[0] == \"comb_path\":\n update_params(mdp,lsp)\n if not mdp.flag_out_open: ## -- try to open output file\n try:\n if mdp.flag_overwrite == \"True\": ## check string value!\n ## -- open save file for read+write\n try:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.save_file.seek(0) # go to beginning\n mdp.save_file.truncate() # delete whatever was there before\n except IOError:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'w')\n mdp.save_file.close()\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.flag_out_open = True\n #for num,key in zip(mdp.corr_num,mdp.key):\n # corr_key=uf.get_str_key(mdp.corr_file,\"correlator_key\",num)\n mdp.flag_overwrite= False\n else:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.save_file.seek(0,2) # seek the end of file\n mdp.flag_out_open = True\n #for num,key in zip(mdp.corr_num,mdp.key):\n # corr_key=uf.get_str_key(mdp.corr_file,\"correlator_key\",num)\n except (AttributeError):\n print \"Attempted to open invalid output file\"\n ## -- try open output file\n for file in glob.glob(mdp.input_path):\n # get sign which corrects for boundary condition\n tvals = file.split('/')[-1].split('_')[3].split('t')\n try:\n ## flip sign if requested\n bcsign = ((int(tvals[1])+int(tvals[2])) != (int(tvals[1])+int(tvals[2])) % mdp.corr_len)\n except IndexError:\n ## 2-point function\n bcsign = False\n try:\n # open correlator file\n mdp.corr_file = open(file,'r')\n except IOError:\n print \"Could not open file \",file\n continue\n ## -- get tag\n ## baryons:\n #mdp.tag = '_'+file.split('/')[-1].split('_')[1][1:]+'_r'+file.split('/')[-1].split('_')[4][-1]\n ## with time source tag\n #mdp.tag = file.split('/')[-1].split('_')[3][:3]\\\n # +'_'+file.split('/')[-1].split('_')[1][1:]+'_'+file.split('/')[-1].split('_')[4][0]\\\n # +file.split('/')[-1].split('_')[4][3:]\n ## no time source tag\n mdp.tag = '_'+file.split('/')[-1].split('_')[1][1:]+'_'+file.split('/')[-1].split('_')[4][0]\\\n +file.split('/')[-1].split('_')[4][3:]\n #print file,',',mdp.tag\n iter+=1\n ##endif ! flag_out_open\n\n #save_data_fast(mdp)\n save_data_fast_bc(mdp,bcsign)\n mdp.corr_file.close()\n if iter%400 == 0:\n print \"file\",iter\n max_iter = None\n if not(max_iter is None) and iter==max_iter:\n print \"reached max file iterations, ending loop...\"\n break\n ## end comb_path\n pass\n\n elif lsp[0] == \"for\": # indicates when to get correlator\n lsp.pop(0)\n update_params(mdp,lsp)\n try:\n # open correlator file\n mdp.corr_file = open(mdp.input_path + '/' + mdp.input_fname,'r')\n except IOError:\n print \"Could not open file \",mdp.input_fname\n continue\n print mdp.input_fname\n if not mdp.flag_out_open:\n try:\n if mdp.flag_overwrite:\n ## -- open save file for read+write\n try:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.save_file.seek(0) # go to beginning\n mdp.save_file.truncate() # delete whatever was there before\n except IOError:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'w')\n mdp.save_file.close()\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.flag_out_open = True\n #for num,key in zip(mdp.corr_num,mdp.key):\n # corr_key=uf.get_str_key(mdp.corr_file,\"correlator_key\",num)\n mdp.flag_overwrite= False\n else:\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\n mdp.save_file.seek(0,2) # seek the end of file\n mdp.flag_out_open = True\n #for num,key in zip(mdp.corr_num,mdp.key):\n # corr_key=uf.get_str_key(mdp.corr_file,\"correlator_key\",num)\n #except (IOError):\n # pass\n except (AttributeError):\n print \"Attempted to open invalid output file\"\n ##endif ! flag_out_open\n save_data_fast(mdp)\n mdp.corr_file.close()\n ##else \"for\" not found in control file\n else:\n update_params(mdp,lsp)\n ##endif lsp[0]==for\n ##endif len(lsp) > 1\n try:\n mdp.save_file.close()\n mdp.flag_out_open = False\n except (IOError,AttributeError):\n pass\n fin.close()\n return","def write_catalog(format_list,study):\n\n o_format_list=sorted(format_list)\n\n fn=study.sas_file\n\n with open(fn, 'w') as f:\n f.write(f\"*{'-'*73}*\\n\")\n f.write(f\"| SAS Formats Catalog for: {study.display_name}\\n\")\n f.write(f\"| Path: {fn}\\n\")\n f.write(f\"| Autogenerated by Candid on: {datetime.datetime.now().strftime('%d-%b-%Y')}\\n\")\n f.write(f\"| {'-' * 10} Post-testing modifications {'-' * 10}\\n\")\n f.write(\"| Date User Modification\\n|\\n\")\n f.write(f\"*{'-'*73}*;\\n\")\n f.write(\"%include 'init.sas';\\n\\n\")\n\n # delete existing catalogs\n # f.write(\"proc datasets library=out memtype=catalog;\\n\\tdelete formats;\\nrun;\\n\\n\")\n\n f.write(\"proc format library=out;\\n\")\n\n for i in o_format_list:\n\n # Write the invalue statement\n f.write(Format.write_comment(i))\n\n # Write the invalue statement\n if i.fmt_value==Format_val.Invalue:\n f.write(\"\\tinvalue\")\n if i.fmt_type==Format_type.Numeric:\n f.write(f\" ${i.name + '_' + i.category}\\n\")\n else:\n f.write(f\" {i.name+ '_' + i.category}\\n\")\n\n # Write the value statement\n else:\n if i.fmt_type==Format_type.Char:\n f.write(f\"\\tvalue ${i.name + '_' + i.category}\\n\")\n else:\n f.write(f\"\\tvalue {i.name + '_' + i.category}\\n\")\n\n # Loop for each member of format catalog\n for j in i.listvals:\n # start\n if i.fmt_type==Format_type.Numeric:\n f.write(f\"\\t\\t{remove_cc(j[0])} = \")\n else:\n f.write(f\"\\t\\t\\\"{remove_cc(j[0])}\\\" = \")\n # label\n if i.fmt_value == Format_val.Invalue:\n f.write(f\"{remove_cc(j[1])}\\n\")\n else:\n f.write(f'\"{remove_cc(j[1])}\"\\n')\n f.write(\"\\t\\t;\\n\")\n f.write(\"run;\")\n\n return fn","def generate_all_files():\n for (name, fn) in lang_module.targets.items():\n path = of_g.options.install_dir + '/' + name\n os.system(\"mkdir -p %s\" % os.path.dirname(path))\n with open(path, \"w\") as outfile:\n fn(outfile, os.path.basename(name))\n print(\"Wrote contents for \" + name)","def generate_data():\n for subdir, dirs, files in os.walk(legend_images_dir):\n for _file in files:\n getTables(_file)\n\n file_list = []\n for subdir, dirs, files in os.walk(pdf_output_dir):\n for _file in files:\n if _file.endswith('.pdf'):\n file_list.append(_file)\n\n print (\"Writing merged output in Output.pdf...\")\n current_dir = os.getcwd()\n mergeOutput(file_list, current_dir + \"/Output.pdf\")\n\n clean()","def generate_database():\n database = {}\n\n for name in images:\n descriptors = []\n for path in images[name]:\n descriptors.append(ConvertToDescriptor.jpeg_to_descriptors(myPath + path))\n database[name] = person.Person(name, descriptors)\n\n output = open('database.p', 'wb')\n pickle.dump(database, output)\n output.close()","def main() :\n #fname = '/reg/d/psdm/CXI/cxi35711/hdf5/cxi35711-r0009.h5'\n #dsname = '/Configure:0000/Run:0000/CalibCycle:0000/CsPad::ElementV2/CxiDs1.0:Cspad.0/data'\n #event = 1\n\n fname = '/reg/d/psdm/CXI/cxi37411/hdf5/cxi37411-r0039.h5'\n dsname = '/Configure:0000/Run:0000/CalibCycle:0000/CsPad::ElementV2/CxiDsd.0:Cspad.0/data'\n event = 1\n\n print 'Default CSPad configuration pars:'\n cspadconfig.printCSPadConfigPars()\n\n print '\\nCSPad configuration pars: for fname, dsname, event =\\n', fname, '\\n', dsname, '\\n', event\n cspadconfig.setCSPadConfiguration( fname, dsname, event ) # This will set current CSPad configuration\n cspadconfig.printCSPadConfigPars()","def convert_to_dicom(file_name):\n\tpath = get_testdata_file(\"CT_small.dcm\")\n\tds = pydicom.dcmread(path)\n\timg = Image.open(file_name+\".bmp\")\n\tnpa = np.asarray(img)\n\tds.PixelData = img.tobytes()\n\tname = update_destination_file_name(file_name)\n\tds.save_as(name+'.dcm')\n\tprint(\"DONE\\t \"+name+\".dcm\")","def save(self, dest_dir):\n try:\n makedirs(dest_dir)\n except FileExistsError:\n pass\n suffix = '-%d-%d.h5' % (self.num_gen_steps, self.num_disc_steps)\n gen_path = path.join(dest_dir, 'gen' + suffix)\n disc_path = path.join(dest_dir, 'disc' + suffix)\n self.discriminator.save(disc_path)\n self.generator.save(gen_path)","def save(self, dest_dir):\n try:\n makedirs(dest_dir)\n except FileExistsError:\n pass\n suffix = '-%d-%d.h5' % (self.num_gen_steps, self.num_disc_steps)\n gen_path = path.join(dest_dir, 'gen' + suffix)\n disc_path = path.join(dest_dir, 'disc' + suffix)\n self.discriminator.save(disc_path)\n self.generator.save(gen_path)","def make_ctd_file():\n # Get the correct netCDF4 dataset\n __location__ = os.path.realpath(os.path.join(os.getcwd(),\n os.path.dirname(__file__),\n 'output'))\n nc_file = os.path.join(__location__,'test_BM54.nc')\n\n # Be sure to start with the original, unedited CTD data\n test_ambient.test_from_ctd()\n\n # Load the data into a netCDF file\n nc = Dataset(nc_file, 'a')\n\n return nc","def prepare_dibco(data_dir=DEFAULT_DATA_DIR,\n out_dir=None,\n force=False):\n if not os.path.exists(data_dir):\n os.makedirs(data_dir)\n if out_dir is None:\n out_dir = data_dir\n if not os.path.exists(out_dir):\n os.makedirs(out_dir)\n\n train_record = 'train.record'\n test_record = 'test.record'\n num_train = 'num_train'\n num_test = 'num_test'\n\n if not (os.path.exists(os.path.join(data_dir, train_record)) and\n os.path.exists(os.path.join(data_dir, test_record)) and\n os.path.exists(os.path.join(data_dir, num_train)) and\n os.path.exists(os.path.join(data_dir, num_test))) or force:\n maybe_download(get_dibco_meta_data(data_dir)['url'], data_dir, force=force)\n\n extracted_dir = os.path.join(data_dir, DATA_EXTRACTED_DIR)\n\n with open(os.path.join(extracted_dir, 'train.txt')) as i_f:\n with open(os.path.join(data_dir, num_train), mode='w') as o_f:\n o_f.write(str(len(i_f.readlines())))\n train_writer = tf.python_io.TFRecordWriter(\n os.path.join(out_dir, train_record))\n for data in get_label_map_dict(\n extracted_dir, os.path.join(extracted_dir, 'train.txt')):\n example = dict_to_example(data)\n train_writer.write(example.SerializeToString())\n train_writer.close()\n\n with open(os.path.join(extracted_dir, 'test.txt')) as i_f:\n with open(os.path.join(data_dir, num_test), mode='w') as o_f:\n o_f.write(str(len(i_f.readlines())))\n val_writer = tf.python_io.TFRecordWriter(os.path.join(out_dir, test_record))\n for data in get_label_map_dict(\n extracted_dir, os.path.join(extracted_dir, 'test.txt')):\n example = dict_to_example(data)\n val_writer.write(example.SerializeToString())\n val_writer.close()\n print()\n\n return get_dibco_meta_data(data_dir)","def make_one_d(prefile, ffile, opath, moddict):\n import codecs\n\n # List of modules used in input file\n imods = used_mods(prefile)\n\n # Query dictionary for filenames of modules used in fortran file.\n # Remove own file name for circular dependencies if more than one\n # module in fortran file.\n if imods:\n imodfiles = list()\n for d in imods:\n if d in moddict: # otherwise external module such as netcdf\n if moddict[d] != ffile:\n imodfiles.append(moddict[d])\n else:\n imodfiles = []\n\n # Write output .d file\n dfile = f2d(ffile, opath)\n ofile = f2o(ffile, opath)\n df = codecs.open(dfile, 'w', encoding='utf-8')\n print(dfile, ':', ffile, file=df)\n print(ofile, ':', ffile + ' ' + dfile, end='', file=df)\n for im in imodfiles:\n print('', f2o(im, opath), end='', file=df)\n print('', file=df)\n df.close()\n\n return","def create_samfile(self):","def create_obj(destination,mtl_name):\r\n\tshutil.copyfile(\"file_cube.obj\",destination)\r\n\tf=open(destination,\"r\")\r\n\tlines=f.readlines()\r\n\tlines[0]=\"mtllib \"+mtl_name+\"\\n\"\r\n\tf.close()\r\n\tf=open(destination,\"w\")\r\n\tf.writelines(lines)\r\n\tf.close()","def generate_data_set(args):\n if args.o is None:\n filename = \"test\"\n else:\n filename = args.o\n\n if args.b is None:\n args.b = 0.5\n if args.p is None:\n path = Path(\"\")\n else:\n path = Path(args.p)\n if args.nf is None:\n args.nf = 1\n\n for i in range(int(args.nf)):\n args.o = path / (filename + \"_t\"+str(args.t) + \"_k\" + str(args.k) + \"_n\"+str(args.n) + \"_m\"+str(args.m)\n + \"_c\"+str(args.c) + \"_\"+str(i) + \".dzn\")\n create_dnz_file(args)","def dump_dc():\n network = Network(pickle=True)\n skus = {}\n for i in range(0, len(network.dcs)):\n for j in network.dcs[i].inventory.keys():\n if j not in skus:\n skus[j] = [0, 0, 0, 0, 0]\n skus[j][i] += network.dcs[i].inventory[j]\n else:\n skus[j][i] += network.dcs[i].inventory[j]\n arr = []\n for i in skus.keys():\n arr.append([i,skus[i][0], skus[i][1], skus[i][2], skus[i][3], skus[i][4]])\n with open('dc_inv.csv', 'wb') as csv_file:\n writer = csv.writer(csv_file)\n writer.writerows(arr)","def write_scram_toolfile(self, contents, filename):\n with open(self.spec.prefix.etc + '/scram.d/' + filename, 'w') as f:\n f.write(contents)\n f.close()","def mkdirout():\n #pdbid=os.path.splitext(os.path.basename(PDB_PATH))[0]\n #outdir = os.path.join(OUTPUT_DIR, pdbid(),\"\") # OUTPUT DIRECTORY WHERE OUTPUT FILES WILL GO\n\n if os.path.exists(output_dir()):\n sys.exit(\"ERROR. Unable to create output directory. %s already exists. Please, make sure you choose an output path not containing former results.\" % output_dir() ) # LOGGING?\n else:\n try:\n os.mkdir(output_dir())\n except OSError:\n sys.exit(\"ERROR. Unable to create output directory %s.\" % output_dir() )\n os.mkdir(output_tmpdir())\n os.mkdir(output_tmpdir(\"pisacov\"))\n os.mkdir(output_tmpdir(\"pisa\"))\n os.mkdir(output_tmpdir(\"deepmetapsicov\"))","def collectInitialeccnStatistics_onefile(self, folder, databaseFilename, multiplicityFactor = 1.0, deformedNuclei = False):\n typeCollections = ((1, 'sn'), (2,'en'))\n for ecc_id, ecc_type_name in typeCollections:\n db = SqliteDB(path.join(folder, databaseFilename % ecc_type_name))\n # first write the ecc_id_lookup table, makes sure there is only one such table\n if db.createTableIfNotExists(\"ecc_id_lookup\", ((\"ecc_id\",\"integer\"), (\"ecc_type_name\",\"text\"))):\n db.insertIntoTable(\"ecc_id_lookup\", (ecc_id, ecc_type_name))\n\n # next create the eccentricities and collisionParameters table\n db.createTableIfNotExists(\"eccentricities\", ((\"event_id\",\"integer\"), (\"ecc_id\", \"integer\"), (\"n\",\"integer\"), (\"ecc_real\",\"real\"), (\"ecc_imag\",\"real\")))\n db.createTableIfNotExists(\"collisionParameters\", ((\"event_id\",\"integer\"), (\"Npart\", \"integer\"), (\"Ncoll\",\"integer\"), (\"b\",\"real\"), (\"total_entropy\",\"real\")))\n if(deformedNuclei):\n db.createTableIfNotExists(\"deformationParameters\", ((\"event_id\",\"integer\"), (\"cosTheta1\", \"real\"), (\"phi1\",\"real\"), (\"cosTheta2\",\"real\"), (\"phi2\",\"real\")))\n\n # the big loop\n data = loadtxt(path.join(folder, '%s_ecc_eccp_10.dat' %(ecc_type_name)))\n Npart = data[:, 36]\n Ncoll = data[:, 37]\n dSdy = data[:, 38]/multiplicityFactor #scale out the multiplicity factor used in superMC\n b = data[:, 39]\n for event_id in range(len(Npart)):\n db.insertIntoTable(\"collisionParameters\", (event_id, int(Npart[event_id]), int(Ncoll[event_id]), float(b[event_id]), float(dSdy[event_id])))\n if(deformedNuclei):\n cosTheta1 = data[:, 40]\n phi1 = data[:, 41]\n cosTheta2 = data[:, 42]\n phi2 = data[:, 43]\n for event_id in range(len(Npart)):\n db.insertIntoTable(\"deformationParameters\", (event_id, float(cosTheta1[event_id]), float(phi1[event_id]), float(cosTheta2[event_id]), float(phi2[event_id])))\n for iorder in range(1,10):\n eccReal = data[:, 4*iorder - 2]\n eccImag = data[:, 4*iorder - 1]\n for event_id in range(len(eccReal)):\n db.insertIntoTable(\"eccentricities\",(event_id, ecc_id, iorder, float(eccReal[event_id]), float(eccImag[event_id])))\n\n # close connection to commit changes\n db.closeConnection()","def create_mock_files(self,\n project_id=\"DEV-test\",\n count=3,\n prefix=\"mock_data_file\",\n file_format=\"dcm\",\n outdir=\".\",\n msg = \"This is a mock data file for testing purposes. Delete me!\",\n write_tsv = True\n ):\n prog,proj = project_id.split(\"-\")\n authz = [\"/programs/{}/projects/{}\".format(prog,proj)]\n acl = [prog,proj]\n\n mfiles = {'file_name':[],'md5sum':[],\"file_size\":[],\"object_id\":[],\"storage_urls\":[],\"acl\":[],\"authz\":[]}\n for i in range(count):\n file_name = \"{}_{}.{}\".format(prefix,i+1,file_format)\n object_id = str(uuid.uuid4())\n mfiles['file_name'].append(file_name)\n mfiles['object_id'].append(object_id)\n mfiles['authz'].append(authz)\n mfiles['acl'].append(acl)\n\n\n output = \"{}/{}\".format(outdir,file_name)\n os.system(\"touch {}\".format(output))\n file_msg =\"{} File {} of {}. {} with object_id {}.\".format(msg,i+1,count,file_name,object_id)\n cmd = 'echo \"{}\" > {}'.format(file_msg,file_name)\n os.system(cmd)\n\n with open(output, 'rb') as file_to_check:\n file_contents = file_to_check.read()\n #cmd = \"!md5 mock_data_file_{}.{}\".format(i+1,file_format))\n md5 = hashlib.md5(file_contents).hexdigest() #check in shell: !md5 mock_data_file_3.dcm\n\n mfiles['md5sum'].append(md5)\n mfiles['file_size'].append(os.stat(output).st_size)\n urls=\"s3://this-is-a-fake-url-for:{}\".format(file_name)\n mfiles['storage_urls'].append([urls])\n\n return mfiles","def write_all_patients():\n\n data_dir = sys.argv[1]\n output_dir = sys.argv[2]\n\n imgs, i_msks, o_msks = load_all_patients(data_dir=data_dir)\n\n for idx, array in enumerate(imgs):\n np.save(output_dir+'/img_'+str(idx), array)\n for idx, array in enumerate(i_msks):\n np.save(output_dir+'/i_msk_'+str(idx), array)\n for idx, array in enumerate(o_msks):\n np.save(output_dir + '/o_msk_' + str(idx), array)\n\n return None","def _make_image_info_des(self, flistname):\n\n flist=[]\n psfex_flist=[]\n magzp_list=[]\n with open(flistname) as fobj:\n for line in fobj:\n ls = line.split()\n fname = ls[0]\n magzp = float(ls[1])\n magzp_list.append(magzp)\n\n flist.append(fname)\n\n psfex_fname = fname.replace('.fits.fz','_psfcat.psf')\n psfex_flist.append(psfex_fname)\n\n nimage = len(flist)\n magzp = np.array(magzp_list)\n\n path_len = max([len(f) for f in flist])\n psfex_path_len = max([len(f) for f in psfex_flist])\n\n try:\n ext_len = len(self['image_ext'])\n except:\n ext_len=None\n\n extra_dtype = [\n ('psfex_path','U%d' % psfex_path_len),\n ]\n\n #image_info = meds.util.get_image_info_struct(\n image_info = get_image_info_struct(\n nimage,\n path_len,\n ext_len=ext_len,\n extra_dtype=extra_dtype,\n )\n image_info['position_offset'] = 1\n image_info['image_ext'] = self['image_ext']\n image_info['weight_ext'] = self['weight_ext']\n\n for i,f in enumerate(flist):\n image_info['image_id'][i] = i\n image_info['image_path'][i] = f\n image_info['weight_path'][i] = f\n image_info['psfex_path'][i] = psfex_flist[i]\n\n image_info['magzp'] = magzp\n image_info['scale'] = self._get_scale_from_magzp(magzp)\n return image_info","def write_all_data_tables( phasename, eos_prop_d, output_d ):\n\n dataio.write_data_table( 'temperature_' + phasename + '.dat',\n (eos_prop_d[key] for key in\n ('Pmesh_a', 'Smesh_a', 'Tmesh_a')),\n ('GPa', 'eV', 1), output_d )\n\n dataio.write_data_table( 'density_' + phasename + '.dat',\n (eos_prop_d[key] for key in\n ('Pmesh_a', 'Smesh_a', 'rhomesh_a')),\n ('GPa', 'eV','g_cc'), output_d )\n dataio.write_data_table( 'heat_capacity_' + phasename + '.dat',\n (eos_prop_d[key] for key in\n ('Pmesh_a', 'Smesh_a', 'Cpmesh_a')),\n ('GPa','eV','eV'), output_d )\n\n dataio.write_data_table( 'thermal_exp_' + phasename + '.dat',\n (eos_prop_d[key] for key in\n ('Pmesh_a', 'Smesh_a', 'alphamesh_a')),\n ('GPa','eV',1), output_d )\n\n dataio.write_data_table( 'adiabat_temp_grad_' + phasename + '.dat',\n (eos_prop_d[key] for key in\n ('Pmesh_a', 'Smesh_a', 'dTdP_Smesh_a')),\n ('GPa','eV','GPa-1'), output_d )\n pass","def create_normalization_file(use_controls, use_nofcd, mods):\n\n for j in range(1, mods + 1):\n fcd_paths = sorted(glob.glob(FCD_FOLDER + f'fcd_*.{j}.nii.gz'))\n nofcd_paths = sorted(glob.glob(FCD_FOLDER + f'nofcd_*.{j}.nii.gz'))\n control_paths = sorted(glob.glob(CONTROL_FOLDER + f'control_*.{j}.nii.gz'))\n\n mri_paths = fcd_paths\n if use_nofcd:\n mri_paths += nofcd_paths\n if use_controls:\n mri_paths += control_paths\n\n t1_landmarks_path = Path(f'./data/t1_landmarks_{j}.npy')\n\n if t1_landmarks_path.is_file():\n continue\n # os.remove(f'./data/t1_landmarks_{j}.npy')\n\n t1_landmarks = (\n t1_landmarks_path\n if t1_landmarks_path.is_file()\n else HistogramStandardization.train(mri_paths)\n )\n\n np.save(t1_landmarks_path, t1_landmarks, allow_pickle=True)","def generate_mos(laygen, objectname_pfix, placement_grid, routing_grid_m1m2, devname_mos_boundary, devname_mos_body,\n devname_mos_dmy, m=1, m_dmy=0, origin=np.array([0,0])):\n pg = placement_grid\n rg12 = routing_grid_m1m2\n pfix = objectname_pfix\n\n # placement\n imbl0 = laygen.relplace(name=\"I\" + pfix + 'BL0', templatename=devname_mos_boundary, gridname=pg, xy=origin)\n refi=imbl0\n if not m_dmy==0:\n imdmyl0 = laygen.relplace(name=\"I\" + pfix + 'DMYL0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\n refi=imdmyl0\n else:\n imdmyl0 = None\n im0 = laygen.relplace(name=\"I\" + pfix + '0', templatename=devname_mos_body, gridname=pg, refobj=refi, shape=[m, 1])\n refi=im0\n if not m_dmy==0:\n imdmyr0 = laygen.relplace(name=\"I\" + pfix + 'DMYR0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\n refi=imdmyr0\n else:\n imdmyr0 = None\n imbr0 = laygen.relplace(name=\"I\" + pfix + 'BR0', templatename=devname_mos_boundary, gridname=pg, refobj=imdmyr0)\n md=im0.elements[:, 0]\n #route\n #gate\n rg0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['G0'], refobj1=md[-1].pins['G0'])\n for _md in md:\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['G0'], gridname=rg12)\n #drain\n rdl0=laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=md[0].pins['D0'], refobj1=md[-1].pins['D0'])\n for _md in md:\n laygen.via(name=None, xy=[0, 1], refobj=_md.pins['D0'], gridname=rg12)\n #source\n rs0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['S0'], refobj1=md[-1].pins['S1'])\n for _md in md:\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['S0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=md[-1].pins['S1'], gridname=rg12)\n #dmy\n if m_dmy>=2:\n mdmyl=imdmyl0.elements[:, 0]\n mdmyr=imdmyr0.elements[:, 0]\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyl[0].pins['D0'], refobj1=mdmyl[-1].pins['D0'])\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyr[0].pins['D0'], refobj1=mdmyr[-1].pins['D0'])\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyl[0].pins['S0'], refobj1=mdmyl[-1].pins['S1'])\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyr[0].pins['S0'], refobj1=mdmyr[-1].pins['S1'])\n for _mdmyl in mdmyl:\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyl.pins['D0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyl.pins['S0'], gridname=rg12)\n for _mdmyr in mdmyr:\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyr.pins['D0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyr.pins['S1'], gridname=rg12)\n return [imbl0, imdmyl0, im0, imdmyr0, imbr0]","def write_mp_cards(bc_file, bc_class):\n mc = bc_class.model_constants\n bc_file.write('! Global Material Properties\\n')\n bc_file.write('MP MU {}\\n'.format(mc.kinematic_viscosity))\n bc_file.write('MP G {}\\n'.format(mc.gravity))\n bc_file.write('MP RHO {}\\n'.format(mc.density))\n if mc.enable_wetting_drying:\n bc_file.write('MP DTL {}\\n'.format(mc.wet_dry_limit))\n bc_file.write('MP MUC {}\\n'.format(mc.mannings_unit_constant))\n bc_file.write('\\n')\n\n bc_file.write('! Material Properties\\n')\n for id, mat_prop in bc_class.material_properties.items():\n if mat_prop.eddy_viscosity_method == 'Constant (EVS)':\n bc_file.write('MP EVS {} {} {} {}\\n'.format(id, mat_prop.vxx_eddy_viscosity, mat_prop.vyy_eddy_viscosity,\n mat_prop.vxy_eddy_viscosity))\n\n elif mat_prop.eddy_viscosity_method == 'Estimated (EEV)':\n objects = list(mat_prop.param.estimated_eddy_viscosity_method.get_range())\n bc_file.write('MP EEV {} {} {}\\n'.format(id, mat_prop.estimated_eddy_viscosity_weighting_factor,\n mat_prop.estimated_eddy_viscosity_method))\n if mat_prop.coriolis:\n bc_file.write('MP COR {} {}\\n'.format(id, mat_prop.coriolis_latitude))\n bc_file.write('MP SRT {} {}\\n'.format(id, mat_prop.refinement_tolerance))\n bc_file.write('MP ML {} {}\\n'.format(id, mat_prop.max_refinement_level))\n if bc_class.operation_parameters.transport != 0:\n for id1, tran_prop in mat_prop.transport_properties.items():\n bc_file.write('MP TRT {} {} {}\\n'.format(id, id1, tran_prop.refinement_tolerance))\n if tran_prop.refinement_tolerance > 0 and mat_prop.eddy_viscosity_method == 'Constant (EVS)':\n bc_file.write('MP DF {} {} {}\\n'.format(id, id1, tran_prop.turbulent_diffusion_rate))\n if bc_class.operation_parameters.wind:\n wnd = mat_prop.wind_properties\n bc_file.write('MP WND STR {} {}\\n'.format(id, wnd.stress_formulation))\n bc_file.write('MP WND ATT {} {}\\n'.format(id, wnd.attenuation))\n\n bc_file.write('\\n') # blank line at the end of the Material Properties","def sc2depictions(chromosome, root_name=\"output\", lot=0):\n mol_structure = sc2mol_structure(chromosome, lot=lot)\n mol2pdb(mol_structure, \"{0}.pdb\".format(root_name))\n mol2xyz(mol_structure, \"{0}.xyz\".format(root_name))\n Draw.MolToFile(mol_structure, \"{0}.png\".format(root_name))\n logger.info(\"Generated depictions with root name {0}\".format(root_name))"],"string":"[\n \"def make_data_raw (mdp,do_makedata,filename):\\n #\\n fin = open(filename,'r')\\n for line in fin:\\n lsp = line.split(' ')\\n if len(lsp) > 1: # skip empty lines\\n if lsp[0] == \\\"for\\\": # indicates when to get correlator\\n lsp.pop(0)\\n update_params(mdp,lsp)\\n ## -- do_makedata tells it to go ahead with generating a new data output file\\n ## -- otherwise, just saves parameters to metadata\\n if do_makedata:\\n try:\\n # open correlator file\\n mdp.corr_file = open(mdp.input_path + '/' + mdp.input_fname,'r')\\n except IOError:\\n print \\\"Could not open file \\\",mdp.input_fname\\n continue\\n print mdp.input_fname,',',mdp.tag\\n if not mdp.flag_out_open:\\n try:\\n if mdp.flag_overwrite:\\n ## -- open save file for read+write\\n try:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.save_file.seek(0) # go to beginning\\n mdp.save_file.truncate() # delete whatever was there before\\n except IOError:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'w')\\n mdp.save_file.close()\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.flag_out_open = True\\n # write first header\\n #corr_key=uf.get_str_key(mdp.corr_file,\\\"correlator_key\\\",\\\\\\n # int(mdp.corr_num.strip(\\\"[]\\\").split(',')[0]))\\n #uf.write_header(mdp.save_file,corr_key,mdp.corr_len)\\n #uf.write_section(mdp.save_file,mdp.key)\\n for num,key in zip(mdp.corr_num,mdp.key):\\n corr_key=uf.get_str_key(mdp.corr_file,\\\"correlator_key\\\",num)\\n uf.write_header(mdp.save_file,corr_key,mdp.corr_len)\\n uf.write_section(mdp.save_file,key)\\n mdp.flag_overwrite= False\\n else:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.save_file.seek(0,2) # seek the end of file\\n mdp.flag_out_open = True\\n # write another header\\n #corr_key=uf.get_str_key(mdp.corr_file,\\\"correlator_key\\\",\\\\\\n # int(mdp.corr_num.strip(\\\"[]\\\").split(',')[0]))\\n #uf.write_header(mdp.save_file,corr_key,mdp.corr_len)\\n #uf.write_section(mdp.save_file,mdp.key)\\n for num,key in zip(mdp.corr_num,mdp.key):\\n corr_key=uf.get_str_key(mdp.corr_file,\\\"correlator_key\\\",num)\\n uf.write_header(mdp.save_file,corr_key,mdp.corr_len)\\n uf.write_section(mdp.save_file,key)\\n #except (IOError):\\n # pass\\n except (AttributeError):\\n print \\\"Attempted to open invalid output file\\\"\\n ##endif ! flag_out_open\\n save_data(mdp)\\n mdp.corr_file.close()\\n ##endif do_makedata\\n ##else \\\"for\\\" not found in control file\\n else:\\n update_params(mdp,lsp)\\n ##endif lsp[0]==for\\n ##endif len(lsp) > 1\\n try:\\n mdp.save_file.close()\\n mdp.flag_out_open = False\\n except (IOError,AttributeError):\\n pass\\n fin.close()\\n return\",\n \"def make_phys():\\n for rn in dcm_dict.keys():\\n # PPG\\n if not dcm_dict[rn]['ppg_file'] == 'File missing':\\n # Files\\n ppg_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.tsv.gz')\\n ppg_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.json')\\n # TSV\\n gzip_file(dcm_dict[rn]['ppg_file'],ppg_tsv)\\n # JSON\\n data = OrderedDict()\\n data['SamplingFrequency'] = 100.0\\n data['StartTime'] = -30.0\\n data['Columns'] = 'cardiac'\\n with open(ppg_json, 'w') as ff:\\n json.dump(data, ff,sort_keys=False, indent=4)\\n # Respiration\\n if not dcm_dict[rn]['resp_file'] == 'File missing':\\n # Files\\n resp_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-respiratory.tsv.gz')\\n resp_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-respiratory.json')\\n # TSV\\n gzip_file(dcm_dict[rn]['resp_file'],resp_tsv)\\n # JSON\\n data = OrderedDict()\\n data['SamplingFrequency'] = 25.0\\n data['StartTime'] = -30.0\\n data['Columns'] = 'respiratory'\\n with open(resp_json, 'w') as ff:\\n json.dump(data, ff,sort_keys=False, indent=4)\\n # ECG\\n # What to do if they have PPG and ECG?\\n if not dcm_dict[rn]['ecg_file'] == 'File missing':\\n # Files\\n ecg_tsv = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.tsv.gz')\\n ecg_json = os.path.join(out_dir,subject+'_'+dcm_dict[rn]['out_name']+'_physio-cardiac.json')\\n # TSV\\n gzip_file(dcm_dict[rn]['resp_file'],resp_tsv)\\n # JSON\\n data = OrderedDict()\\n data['SamplingFrequency'] = 1000.0\\n data['StartTime'] = -30.0\\n data['Columns'] = 'cardiac'\\n with open(resp_json, 'w') as ff:\\n json.dump(data, ff,sort_keys=False, indent=4)\",\n \"def create_demo_dcm_data(dcm_dir):\\n pet_fname = os.path.join(os.path.dirname(__file__), 'data', 'brainweb_06_osem.nii')\\n mr_fname = os.path.join(os.path.dirname(__file__), 'data', 'brainweb_06_t1.nii')\\n \\n pet, pet_affine = flip_ras_lps(*load_nii_in_ras(pet_fname))\\n mr, mr_affine = flip_ras_lps(*load_nii_in_ras(mr_fname))\\n\\n os.mkdir(dcm_dir)\\n write_3d_static_dicom(pet, os.path.join(dcm_dir, 'PT'), pet_affine, modality = 'PT')\\n write_3d_static_dicom(mr, os.path.join(dcm_dir, 'MR'), mr_affine, modality = 'MR')\",\n \"def writeNMD(filename, modes, atoms, zeros=False):\\n\\n if not isinstance(modes, (NMA, ModeSet, Mode, Vector)):\\n raise TypeError('modes must be NMA, ModeSet, Mode, or Vector, '\\n 'not {0}'.format(type(modes)))\\n if modes.numAtoms() != atoms.numAtoms():\\n raise Exception('number of atoms do not match')\\n out = openFile(addext(filename, '.nmd'), 'w')\\n\\n #out.write('#!{0} -e\\\\n'.format(VMDPATH))\\n out.write('nmwiz_load {0}\\\\n'.format(abspath(filename)))\\n name = modes.getTitle()\\n name = name.replace(' ', '_').replace('.', '_')\\n if not name.replace('_', '').isalnum() or len(name) > 30:\\n name = str(atoms)\\n name = name.replace(' ', '_').replace('.', '_')\\n if not name.replace('_', '').isalnum() or len(name) > 30:\\n name = splitext(split(filename)[1])[0]\\n out.write('name {0}\\\\n'.format(name))\\n try:\\n coords = atoms.getCoords()\\n except:\\n raise ValueError('coordinates could not be retrieved from atoms')\\n if coords is None:\\n raise ValueError('atom coordinates are not set')\\n\\n try:\\n data = atoms.getNames()\\n if data is not None:\\n out.write('atomnames {0}\\\\n'.format(' '.join(data)))\\n except:\\n pass\\n try:\\n data = atoms.getResnames()\\n if data is not None:\\n out.write('resnames {0}\\\\n'.format(' '.join(data)))\\n except:\\n pass\\n try:\\n data = atoms.getResnums()\\n if data is not None:\\n out.write('resids ')\\n data.tofile(out, ' ')\\n out.write('\\\\n')\\n except:\\n pass\\n try:\\n data = atoms.getChids()\\n if data is not None:\\n out.write('chainids {0}\\\\n'.format(' '.join(data)))\\n except:\\n pass\\n try:\\n data = atoms.getSegnames()\\n if data is not None:\\n out.write('segnames {0}\\\\n'.format(' '.join(data)))\\n except:\\n pass\\n\\n try:\\n data = atoms.getBetas()\\n if data is not None:\\n out.write('bfactors ')\\n data.tofile(out, ' ', '%.2f')\\n out.write('\\\\n')\\n except:\\n pass\\n\\n format = '{0:.3f}'.format\\n out.write('coordinates ')\\n coords.tofile(out, ' ', '%.3f')\\n out.write('\\\\n')\\n count = 0\\n if isinstance(modes, Vector):\\n out.write('mode 1 {0:.2f} '.format(abs(modes)))\\n modes.getNormed()._getArray().tofile(out, ' ', '%.3f')\\n out.write('\\\\n')\\n count += 1\\n else:\\n if isinstance(modes, Mode):\\n modes = [modes]\\n for mode in modes:\\n if (mode.getEigval() < ZERO) and not zeros:\\n continue\\n elif (mode.getEigval() < ZERO) and zeros:\\n out.write('mode {0} {1:.2f} '.format(\\n mode.getIndex()+1, np.sqrt(1/(0.0001*(mode.getIndex()+1)))))\\n else:\\n out.write('mode {0} {1:.2f} '.format(\\n mode.getIndex()+1, mode.getVariance()**0.5))\\n arr = mode._getArray().tofile(out, ' ', '%.3f')\\n out.write('\\\\n')\\n count += 1\\n if count == 0:\\n LOGGER.warning('No normal mode data was written. '\\n 'Given modes might have 0 eigenvalues.')\\n out.close()\\n return filename\",\n \"def make_data_raw_fast(mdp,do_makedata,filename):\\n #\\n fin = open(filename,'r')\\n for line in fin:\\n lsp = line.split(' ')\\n if len(lsp) > 1: # skip empty lines\\n if lsp[0] == \\\"for\\\": # indicates when to get correlator\\n lsp.pop(0)\\n update_params(mdp,lsp)\\n ## -- do_makedata tells it to go ahead with generating a new data output file\\n ## -- otherwise, just saves parameters to metadata\\n if do_makedata:\\n try:\\n # open correlator file\\n mdp.corr_file = open(mdp.input_path + '/' + mdp.input_fname,'r')\\n except IOError:\\n print \\\"Could not open file \\\",mdp.input_fname\\n continue\\n print mdp.input_fname\\n if not mdp.flag_out_open:\\n try:\\n if mdp.flag_overwrite:\\n ## -- open save file for read+write\\n try:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.save_file.seek(0) # go to beginning\\n mdp.save_file.truncate() # delete whatever was there before\\n except IOError:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'w')\\n mdp.save_file.close()\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.flag_out_open = True\\n #for num,key in zip(mdp.corr_num,mdp.key):\\n # corr_key=uf.get_str_key(mdp.corr_file,\\\"correlator_key\\\",num)\\n mdp.flag_overwrite= False\\n else:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.save_file.seek(0,2) # seek the end of file\\n mdp.flag_out_open = True\\n #for num,key in zip(mdp.corr_num,mdp.key):\\n # corr_key=uf.get_str_key(mdp.corr_file,\\\"correlator_key\\\",num)\\n #except (IOError):\\n # pass\\n except (AttributeError):\\n print \\\"Attempted to open invalid output file\\\"\\n ##endif ! flag_out_open\\n save_data_fast(mdp)\\n mdp.corr_file.close()\\n ##endif do_makedata\\n ##else \\\"for\\\" not found in control file\\n else:\\n update_params(mdp,lsp)\\n ##endif lsp[0]==for\\n ##endif len(lsp) > 1\\n try:\\n mdp.save_file.close()\\n mdp.flag_out_open = False\\n except (IOError,AttributeError):\\n pass\\n fin.close()\\n return\",\n \"def writeDataCards(opt,sigExp,bkgExp,shapesURL):\\n\\n #create a card per category\\n dcList=[]\\n for icat in range(len(opt.categs)):\\n cat='%s_a%d_%d'%(opt.chTag,opt.xangle,icat)\\n dcTxt='%s/shapes-parametric.datacard_%s.dat'%(opt.output,cat)\\n dcList.append(dcTxt)\\n with open(dcTxt,'w') as dc:\\n dc.write('#\\\\n')\\n dc.write('# datacard was automatically generated with generateWorkspace.py\\\\n')\\n dc.write('# the options passed are printed below\\\\n')\\n dc.write('# %s\\\\n'%opt)\\n dc.write('#\\\\n')\\n dc.write('imax *\\\\n')\\n dc.write('jmax *\\\\n')\\n dc.write('kmax *\\\\n')\\n dc.write('-'*50+'\\\\n')\\n dc.write('shapes * * {0} $PROCESS_{1} $PROCESS_$SYSTEMATIC\\\\n'.format(shapesURL,cat))\\n dc.write('shapes data_obs * {0} $PROCESS_{1}\\\\n'.format(shapesURL,cat))\\n dc.write('-'*50+'\\\\n')\\n dc.write('bin %s\\\\n'%cat)\\n dc.write('observation -1\\\\n')\\n dc.write('-'*50+'\\\\n')\\n dc.write('%15s %15s %15s\\\\n'%('bin',cat,cat))\\n dc.write('%15s %15s %15s\\\\n'%('process','sig','bkg'))\\n dc.write('%15s %15s %15s\\\\n'%('process','0', '1'))\\n dc.write('%15s %15s %15s\\\\n'%('rate','%3.2f'%sigExp[icat], '%3.2f'%bkgExp[icat]))\\n dc.write('-'*50+'\\\\n')\\n \\n #float the background normalization as well as the signal\\n dc.write('mu_bkg{0} rateParam {0} bkg 1\\\\n'.format(cat))\\n\\n #uncertainties\\n dc.write('lumi %8s %15s %15s\\\\n'%('lnN','1.027','-'))\\n dc.write('%s_sigShape %8s %15s %15s\\\\n'%(cat,'shape','1','-'))\\n dc.write('%s_bkgShape %8s %15s %15s\\\\n'%(cat,'shape','-','1'))\\n dc.write('{0} autoMCStats 0.0 1\\\\n'.format(cat))\\n \\n print '\\\\tshapes available @',shapesURL\\n print '\\\\tgenerated the following datacards',dcList\",\n \"def write_conformers(self, filename): # ccids):\\n cnt = 0\\n for confId in range(self.nconf): #ccids:\\n w = Chem.SDWriter('%s_c%03d.sdf'%(filename,cnt+1))\\n w.write(self.mol, confId=confId)\\n w.flush()\\n w.close()\\n cnt += 1\",\n \"def Construct3DMolToFile(fileName,writeFile):\\r\\n # Writing sets of molecules\\r\\n \\r\\n\\r\\n w = Chem.SDWriter(writeFile)\\r\\n suppl = Chem.SDMolSupplier(fileName)\\r\\n mols = [x for x in suppl]\\r\\n for mol in mols:\\r\\n \\t# print(mol.GetProp(\\\"Solvent\\\"))\\r\\n \\t# print(mol.GetPropNames)\\r\\n \\tsignal.signal(signal.SIGALRM, handler)\\r\\n \\tsignal.alarm(100)\\r\\n \\ttry:\\r\\n \\t\\tmol3d = GetMolFromMol(mol,dimension=3)\\r\\n \\t\\tw.write(mol3d)\\r\\n \\texcept Exception:\\r\\n \\t\\tmol3d = mol\\r\\n \\t\\tw.write(mol3d)\\r\\n \\t\\t# print(mol.GetPropsAsDict())\\r\\n\\r\\n\\r\\n w.close()\",\n \"def generate_epics_db(self):\\n if (self.verbose):\\n # Generate digital application related databases and configuration files\\n print(\\\"==================================================\\\")\\n print(\\\"== Generating EPICS DB and configuration files: ==\\\")\\n print(\\\"==================================================\\\")\\n \\n print(\\\"----------------------------\\\")\\n print(\\\"-- Digital applications --\\\")\\n print(\\\"----------------------------\\\")\\n for app in self.digital_apps:\\n app_path = '{}app_db/{}/{:04}/{:02}/'.format(self.dest_path, app[\\\"cpu_name\\\"], app[\\\"crate_id\\\"], app[\\\"slot_number\\\"])\\n app_prefix = 'MPLN:{}:{}:{}'.format(app[\\\"link_node_area\\\"].upper(), app[\\\"link_node_location\\\"].upper(), app[\\\"card_index\\\"])\\n if (self.verbose):\\n print(\\\"Application path : {}\\\".format(app_path))\\n print(\\\"Application prefix : {}\\\".format(app_prefix))\\n \\n self.__write_dig_app_id_confg(path=app_path, macros={\\\"ID\\\":str(app[\\\"app_id\\\"])})\\n\\n # Add the IOC name environmental variable for the Link Nodes\\n self.__write_header_env(path=app_path, macros={\\\"MPS_LINK_NODE\\\":app[\\\"link_node_name\\\"],\\n \\\"MPS_DB_VERSION\\\":self.config_version,\\n \\\"DATE\\\":datetime.datetime.now().strftime('%Y.%m.%d-%H:%M:%S')})\\n self.__write_iocinfo_env(path=app_path, macros={\\\"AREA\\\":app[\\\"link_node_area\\\"].upper(),\\n \\\"LOCATION\\\":app[\\\"link_node_location\\\"].upper(),\\n \\\"LOC_IDX\\\":app['link_node_location'].upper().replace('MP', ''),\\n \\\"C_IDX\\\":unicode(app['card_index'])})\\n if self.link_nodes[app[\\\"link_node_name\\\"]]['type'] == 'Digital':\\n self.__write_prefix_env(path=app_path, macros={\\\"P\\\":app_prefix})\\n self.__write_mps_db(path=app_path, macros={\\\"P\\\":app_prefix, \\\"THR_LOADED\\\":\\\"1\\\"})\\n self.__write_app_id_config(path=app_path, macros={\\\"ID\\\":\\\"0\\\"}) # If there are no analog cards, set ID to invalid\\n\\n has_virtual = False\\n for device in app[\\\"devices\\\"]:\\n device_prefix = \\\"{}:{}:{}\\\".format(device[\\\"type_name\\\"], device[\\\"area\\\"], device[\\\"position\\\"])\\n\\n if (self.verbose):\\n print(\\\" Device prefix : {}\\\".format(device_prefix))\\n\\n for input in device[\\\"inputs\\\"]:\\n\\n if app[\\\"virtual\\\"]:\\n has_virtual = True\\n if (input[\\\"bit_position\\\"]>=32):\\n scan = \\\".2 second\\\"\\n if (input['name'] == 'WDOG'):\\n if (\\\"MPSHEARTBEAT\\\" in input[\\\"input_pv\\\"]):\\n scan = \\\".1 second\\\"\\n channel = input[\\\"bit_position\\\"] - 32\\n vmacros = { \\\"P\\\":input[\\\"input_pv\\\"]+'_THR',\\n \\\"R\\\":input[\\\"name\\\"],\\n \\\"N\\\":self.mps_name.getDeviceInputNameFromId(input[\\\"db_id\\\"]),\\n \\\"INPV\\\":input[\\\"input_pv\\\"],\\n \\\"ALSTATE\\\":str(input[\\\"alarm_state\\\"]),\\n \\\"NALSTATE\\\":str(to_bool(not input[\\\"alarm_state\\\"])),\\n \\\"ZSV\\\":input[\\\"zero_severity\\\"],\\n \\\"OSV\\\":input[\\\"one_severity\\\"],\\n \\\"BIT\\\":\\\"{:02d}\\\".format(channel).format,\\n \\\"ZNAM\\\":input[\\\"zero_name\\\"],\\n \\\"ONAM\\\":input[\\\"one_name\\\"], \\n \\\"GID\\\":str(app[\\\"app_id\\\"]),\\n \\\"SCAN\\\":scan}\\n if (input['name'] == 'WDOG'):\\n self.__write_virtual_wdog_db(path=app_path, macros=vmacros)\\n else:\\n self.__write_virtual_db(path=app_path, macros=vmacros)\\n\\n\\n macros = { \\\"P\\\":device_prefix,\\n \\\"R\\\":input[\\\"name\\\"],\\n \\\"BIT\\\":input[\\\"bit_position\\\"],\\n \\\"ZNAM\\\":input[\\\"zero_name\\\"],\\n \\\"ONAM\\\":input[\\\"one_name\\\"] }\\n\\n if (self.verbose):\\n print(\\\" Digital Input : {}\\\".format(input[\\\"name\\\"]))\\n\\n if (self.verbose):\\n print(\\\"----------------------------\\\")\\n\\n print(\\\"==================================================\\\")\\n print(\\\"\\\")\\n\\n # Generates analog application related databases and configuration files\\n if (self.verbose):\\n print(\\\"--------------------------\\\")\\n print(\\\"-- Analog applications --\\\")\\n print(\\\"--------------------------\\\")\\n for app in self.analog_apps:\\n app_path = '{}app_db/{}/{:04}/{:02}/'.format(self.dest_path, app[\\\"cpu_name\\\"], app[\\\"crate_id\\\"], app[\\\"slot_number\\\"])\\n app_prefix = 'MPLN:{}:{}:{}'.format(app[\\\"link_node_area\\\"].upper(), app[\\\"link_node_location\\\"].upper(), app[\\\"card_index\\\"])\\n if (self.verbose):\\n print(\\\"Application path : {}\\\".format(app_path))\\n print(\\\"Application prefix : {}\\\".format(app_prefix))\\n\\n self.__write_mps_db(path=app_path, macros={\\\"P\\\":app_prefix, \\\"THR_LOADED\\\":\\\"0\\\"})\\n self.__write_app_id_config(path=app_path, macros={\\\"ID\\\":str(app[\\\"app_id\\\"])})\\n self.__write_thresholds_off_config(path=app_path)\\n\\n # Add the IOC name environmental variable for the Link Nodes\\n if app[\\\"analog_link_node\\\"]:\\n self.__write_header_env(path=app_path, macros={\\\"MPS_LINK_NODE\\\":app[\\\"link_node_name\\\"],\\n \\\"MPS_DB_VERSION\\\":self.config_version,\\n \\\"DATE\\\":datetime.datetime.now().strftime('%Y.%m.%d-%H:%M:%S')})\\n\\n self.__write_iocinfo_env(path=app_path, macros={\\\"AREA\\\":app[\\\"link_node_area\\\"].upper(),\\n \\\"LOCATION\\\":app[\\\"link_node_location\\\"].upper(),\\n \\\"LOC_IDX\\\":app['link_node_location'].upper().replace('MP', ''),\\n \\\"C_IDX\\\":unicode(app['card_index'])})\\n self.__write_prefix_env(path=app_path, macros={\\\"P\\\":app_prefix})\\n\\n spare_channels = range(0,6)\\n for device in app[\\\"devices\\\"]:\\n device_prefix = \\\"{}:{}:{}\\\".format(device[\\\"type_name\\\"], device[\\\"area\\\"], device[\\\"position\\\"])\\n\\n if (self.verbose):\\n print(\\\" Device prefix : {}\\\".format(device_prefix))\\n\\n if (device[\\\"type_name\\\"] not in self.non_link_node_types):\\n macros = { \\\"P\\\": app_prefix,\\n \\\"CH\\\":str(device[\\\"channel_index\\\"]),\\n \\\"CH_NAME\\\":device[\\\"device_name\\\"],\\n \\\"CH_PVNAME\\\":device_prefix,\\n \\\"CH_SPARE\\\":\\\"0\\\"\\n }\\n self.__write_link_node_channel_info_db(path=app_path, macros=macros)\\n processing = 0\\n ch = device['channel_index']\\n if (device[\\\"type_name\\\"] == \\\"CBLM\\\"):\\n processing = 1\\n if (device[\\\"type_name\\\"] == \\\"KICK\\\"):\\n processing = 1\\n int0 = device['channel_index']*4\\n int1 = device['channel_index']*4 + 1\\n macros = { \\\"CH\\\":format(device['channel_index']),\\n \\\"PROC\\\":format(processing),\\n \\\"INT0\\\":format(int0),\\n \\\"INT1\\\":format(int1)\\n }\\n self.__write_ana_config(path=app_path, macros=macros)\\n spare_channels[device[\\\"channel_index\\\"]] = -1\\n for fault in device[\\\"faults\\\"].values():\\n bsa_slot = fault['integrators'][0]*6 + device[\\\"channel_index\\\"]\\n macros = { \\\"P\\\":app_prefix,\\n \\\"R\\\":'ANA_BSA_DATA_{}'.format(bsa_slot),\\n \\\"P_DEV\\\":device_prefix,\\n \\\"R_DEV\\\":self.get_analog_type_name(device[\\\"type_name\\\"]),\\n \\\"FAULT\\\":fault['name'],\\n \\\"EGU\\\":self.get_app_units(device[\\\"type_name\\\"],fault[\\\"name\\\"])\\n }\\n self.__write_analog_db(path=app_path, macros=macros)\\n macros = { \\\"P\\\":device_prefix,\\n \\\"BAY\\\":format(device[\\\"bay_number\\\"]),\\n \\\"APP\\\":self.get_app_type_name(device[\\\"type_name\\\"]),\\n \\\"FAULT\\\":fault[\\\"name\\\"],\\n \\\"FAULT_INDEX\\\":self.get_fault_index(device[\\\"type_name\\\"], fault[\\\"name\\\"], device[\\\"channel_number\\\"]),\\n \\\"DESC\\\":fault[\\\"description\\\"],\\n \\\"EGU\\\":self.get_app_units(device[\\\"type_name\\\"],fault[\\\"name\\\"]),\\n \\\"SLOPE\\\":unicode(self.get_slope(device[\\\"type_name\\\"])),\\n \\\"OFFSET\\\":unicode(self.get_offset(device[\\\"type_name\\\"]))}\\n self.__write_thr_base_db(path=app_path, macros=macros)\\n # Generate PV for all possible thresholds, even if not defined in database\\n for bit in range(0,8):#fault[\\\"bit_positions\\\"]:\\n fault_prefix = \\\"{}_T{}\\\".format(fault[\\\"name\\\"], bit)\\n macros[\\\"BIT_POSITION\\\"] = str(bit)\\n self.__write_thr_db(path=app_path, macros=macros)\\n if (self.verbose):\\n print(\\\" Fault prefix : {}\\\".format(fault_prefix))\\n\\n\\n for ch in spare_channels:\\n if ch > -1:\\n macros = { \\\"P\\\": app_prefix,\\n \\\"CH\\\":str(ch),\\n \\\"CH_NAME\\\":\\\"Spare\\\",\\n \\\"CH_PVNAME\\\":\\\"None\\\",\\n \\\"CH_SPARE\\\":\\\"1\\\"\\n }\\n self.__write_link_node_channel_info_db(path=app_path, macros=macros)\\n\\n #\\n # Write db information about slots of each link node\\n #\\n for app in self.analog_apps + self.digital_apps:\\n app_path = '{}app_db/{}/{:04}/{:02}/'.format(self.dest_path, app[\\\"cpu_name\\\"], app[\\\"crate_id\\\"], app[\\\"slot_number\\\"])\\n link_node_info=self.link_nodes[app[\\\"link_node_name\\\"]]\\n #print link_node_info\\n if not 'exported' in link_node_info:\\n for slot in range(2,8):\\n if slot in link_node_info['slots']:\\n macros = { \\\"P\\\": app[\\\"app_prefix\\\"],\\n \\\"SLOT\\\": str(slot),\\n \\\"SLOT_NAME\\\": link_node_info['slots'][slot]['type'],\\n \\\"SLOT_PVNAME\\\": link_node_info['slots'][slot]['pv_base'],\\n \\\"SLOT_SPARE\\\": \\\"0\\\"}\\n else:\\n macros = { \\\"P\\\": app[\\\"app_prefix\\\"],\\n \\\"SLOT\\\": str(slot),\\n \\\"SLOT_NAME\\\": \\\"Spare\\\",\\n \\\"SLOT_PVNAME\\\": \\\"Spare\\\",\\n \\\"SLOT_SPARE\\\": \\\"1\\\"}\\n\\n self.__write_link_node_slot_info_db(path=app_path, macros=macros)\\n\\n # Add CH_* PVs for digital-only link nodes. These are added before \\n # only if the LN is Mixed or Analog\\n if link_node_info['type'] == 'Digital':\\n for ch in spare_channels:\\n macros = { \\\"P\\\": app[\\\"app_prefix\\\"],\\n \\\"CH\\\":str(ch),\\n \\\"CH_NAME\\\":\\\"Not Available\\\",\\n \\\"CH_PVNAME\\\":\\\"None\\\",\\n \\\"CH_SPARE\\\":\\\"1\\\"\\n }\\n self.__write_link_node_channel_info_db(path=app_path, macros=macros)\\n\\n link_node_info['exported']=True\\n\\n #\\n # Add Link Node related information\\n #\\n #for ln_name,ln in self.link_nodes.items():\\n # if \\\"lc1_node_id\\\" not in ln:\\n # continue\\n # if \\\"dig_app_id\\\" not in ln:\\n # continue\\n # print ln[\\\"lc1_node_id\\\"] + ' ' + ln[\\\"type\\\"] + ' ' + ln[\\\"dig_app_id\\\"]\\n for ln_name,ln in self.link_nodes.items():\\n self.__write_lc1_info_config(ln)\\n self.__write_link_node_info_db(ln_name, ln)\\n\\n if (self.verbose):\\n print(\\\"--------------------------\\\")\",\n \"def export_model_description(md: ModelDescription) -> bytes:\\n\\n # ---------------- write model description -------------------\\n\\n fmd = ET.Element(\\\"fmiModelDescription\\\")\\n fmd.set(\\\"fmiVersion\\\", \\\"2.0\\\")\\n fmd.set(\\\"modelName\\\", md.modelName)\\n fmd.set(\\\"guid\\\", md.guid)\\n fmd.set(\\\"author\\\", md.author)\\n fmd.set(\\\"generationDateAndTime\\\", md.generationDateAndTime)\\n fmd.set(\\\"variableNamingConvention\\\", md.variableNamingConvention)\\n fmd.set(\\\"generationTool\\\", md.generationTool)\\n fmd.set(\\\"description\\\", md.description)\\n\\n # CoSimulation\\n cs = ET.SubElement(fmd, \\\"CoSimulation\\\")\\n cs.set(\\\"modelIdentifier\\\", md.CoSimulation.modelIdentifier)\\n cs.set(\\n \\\"needsExecutionTool\\\", str(md.CoSimulation.needsExecutionTool).lower(),\\n )\\n cs.set(\\n \\\"canHandleVariableCommunicationStepSize\\\",\\n str(md.CoSimulation.canHandleVariableCommunicationStepSize).lower(),\\n )\\n cs.set(\\n \\\"canInterpolateInputs\\\", str(md.CoSimulation.canInterpolateInputs).lower(),\\n )\\n\\n cs.set(\\n \\\"maxOutputDerivativeOrder\\\", str(md.CoSimulation.maxOutputDerivativeOrder),\\n )\\n cs.set(\\n \\\"canRunAsynchronuously\\\", str(md.CoSimulation.canRunAsynchronuously).lower(),\\n )\\n cs.set(\\n \\\"canBeInstantiatedOnlyOncePerProcess\\\",\\n str(md.CoSimulation.canBeInstantiatedOnlyOncePerProcess).lower(),\\n )\\n cs.set(\\n \\\"canNotUseMemoryManagementFunctions\\\",\\n str(md.CoSimulation.canNotUseMemoryManagementFunctions).lower(),\\n )\\n cs.set(\\n \\\"canGetAndSetFMUstate\\\", str(md.CoSimulation.canGetAndSetFMUstate).lower(),\\n )\\n cs.set(\\n \\\"canSerializeFMUstate\\\", str(md.CoSimulation.canSerializeFMUstate).lower(),\\n )\\n cs.set(\\n \\\"providesDirectionalDerivative\\\",\\n str(md.CoSimulation.providesDirectionalDerivative).lower(),\\n )\\n\\n # 2.2.4 p.42) Log categories:\\n cs = ET.SubElement(fmd, \\\"LogCategories\\\")\\n for ac in md.logCategories:\\n c = ET.SubElement(cs, \\\"Category\\\")\\n c.set(\\\"name\\\", ac)\\n\\n # 2.2.7 p.47) ModelVariables\\n mvs = ET.SubElement(fmd, \\\"ModelVariables\\\")\\n\\n variable_index = 0\\n\\n for var in md.modelVariables:\\n var.variability\\n value_reference = str(var.value_reference)\\n\\n idx_comment = ET.Comment(f'Index of variable = \\\"{variable_index + 1}\\\"')\\n mvs.append(idx_comment)\\n sv = ET.SubElement(mvs, \\\"ScalarVariable\\\")\\n sv.set(\\\"name\\\", var.name)\\n sv.set(\\\"valueReference\\\", value_reference)\\n sv.set(\\\"variability\\\", var.variability)\\n sv.set(\\\"causality\\\", var.causality)\\n\\n if var.description:\\n sv.set(\\\"description\\\", var.description)\\n\\n if var.initial:\\n i = var.initial\\n sv.set(\\\"initial\\\", i)\\n\\n val = ET.SubElement(sv, var.dataType)\\n\\n # 2.2.7. p.48) start values\\n if var.initial in {\\\"exact\\\", \\\"approx\\\"} or var.causality == \\\"input\\\":\\n assert (\\n var.start != None\\n ), \\\"a start value must be defined for intial ∈ {exact, approx}\\\"\\n val.set(\\\"start\\\", var.start)\\n\\n variable_index += 1\\n\\n ms = ET.SubElement(fmd, \\\"ModelStructure\\\")\\n\\n # 2.2.8) For each output we must declare 'Outputs' and 'InitialUnknowns'\\n outputs = [\\n (idx + 1, o)\\n for idx, o in enumerate(md.modelVariables)\\n if o.causality == \\\"output\\\"\\n ]\\n\\n if outputs:\\n os = ET.SubElement(ms, \\\"Outputs\\\")\\n for idx, o in outputs:\\n ET.SubElement(os, \\\"Unknown\\\", {\\\"index\\\": str(idx), \\\"dependencies\\\": \\\"\\\"})\\n\\n os = ET.SubElement(ms, \\\"InitialUnknowns\\\")\\n for idx, o in outputs:\\n ET.SubElement(os, \\\"Unknown\\\", {\\\"index\\\": str(idx), \\\"dependencies\\\": \\\"\\\"})\\n\\n # FMI requires encoding to be encoded as UTF-8 and contain a header:\\n #\\n # See 2.2 p.28\\n return ET.tostring(fmd, pretty_print=True, encoding=\\\"utf-8\\\", xml_declaration=True)\",\n \"def make_database(num_files=10):\\n for i in range(num_files):\\n print('\\\\n\\\\n\\\\nCreating set', str(i), '\\\\n\\\\n\\\\n')\\n s_file = 'set' + str(i) + '.hdf5' \\n play_dominoes(save_file=s_file)\",\n \"def write(self, filename):\\n assert filename[-3:]=='.fz','name must end in .fz'\\n\\n files.makedir_fromfile(filename)\\n\\n ucfilename=filename[0:-3]\\n bname = os.path.basename(ucfilename)\\n\\n tmp_path = os.path.join(\\n files.get_temp_dir(),\\n bname,\\n )\\n files.makedir_fromfile(tmp_path)\\n\\n with TempFile(tmp_path) as tfile:\\n super(CosmosMEDSMaker,self).write(tfile.path)\\n self._compress_meds_file(tfile.path, filename)\",\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 generateDataset(self):\\n if self.outdir[-1] != \\\"/\\\": \\n self.outdir += \\\"/\\\"\\n self.outdir += \\\"dataset_trackml\\\"\\n i = 1\\n while os.path.exists(self.outdir):\\n self.outdir.replace(\\\"_\\\"+str(i-1), \\\"\\\")\\n self.outdir += (\\\"_\\\"+str(i))\\n i += 1\\n cmd = \\\"mkdir -p \\\"+ self.outdir\\n os.system(cmd)\\n\\n cont = pc.particleController()\\n cont.generateEvents(self.numevents, self.hpe, self.detectors)\\n\\n self.generateHits(cont)\\n self.generateTruths(cont)\\n self.generateSolution(cont)\",\n \"def generate_file(material_id):\\n apr=get_doc_from_MP(material_id)\\n mat_list=generate_matrix(apr)\\n formu=POSCAR_title(apr)\\n cell_for=generate_cell_formula(apr)\\n needed_dos=generate_dos_str(material_id)\\n revise_dos=dos_into_string(needed_dos)\\n ordered_list=generate_ordered_list(revise_dos)\\n my_ordered_elements=generate_ordered_elements(revise_dos,ordered_list)\\n my_ordered_numbers=generate_ordered_numbers(revise_dos,ordered_list,cell_for)\\n generate_POSCAR(formu,mat_list,my_ordered_elements,my_ordered_numbers,revise_dos)\",\n \"def createDataDescriptionTxtFile(pMassFile=[], pMassDcmpFile=[], pMassDcmpSpkesFile=[], pMassBrianFile=[]):\\n\\n if isinstance(pMassFile,str):\\n if os.path.isfile(pMassFile):\\n # Load in the data to see what the hell it is\\n inputDataFile = open(pMassFile, \\\"rb\\\")\\n dataOut = pickle.load(inputDataFile)\\n inputDataFile.close()\\n # Now we need to write a description of what the data is! [dataOut, xmin, xmax, vmin, vmax, amin, amax, dt, tmax]\\n numbOfTrials = len(dataOut[0]) # This is the number of individual trails stored\\n xmin = dataOut[1]\\n xmax = dataOut[2]\\n vmin = dataOut[3]\\n vmax = dataOut[4]\\n amin = dataOut[5]\\n amax = dataOut[6]\\n dt = dataOut[7]\\n tmax = dataOut[8]\\n descpFName = pMassFile[:-4]+'DESC.txt'\\n file = open(descpFName,'w')\\n file.write(\\\"1-D Moving Mass Data Description\\\\n\\\")\\n file.write(\\\"\\\\nData here is generated from the genAndSaveMoving1DMassData() method\\\\n\\\")\\n file.write(\\\"\\\\nFileName... \\\"+pMassFile)\\n file.write(\\\"\\\\niterations. \\\"+str(numbOfTrials))\\n file.write(\\\"\\\\nxmin....... \\\"+str(xmin))\\n file.write(\\\"\\\\nxmax....... \\\"+str(xmax))\\n file.write(\\\"\\\\nvmin........\\\"+str(vmin))\\n file.write(\\\"\\\\nvmax........\\\"+str(vmax))\\n file.write(\\\"\\\\namin........\\\"+str(amin))\\n file.write(\\\"\\\\namax........\\\"+str(amax))\\n file.write(\\\"\\\\ndt..........\\\"+str(dt))\\n file.write(\\\"\\\\ntmax........\\\"+str(tmax))\\n file.close\\n if isinstance(pMassDcmpFile, str):\\n if os.path.isfile(pMassDcmpFile):\\n # Load in teh data to see what it has it there\\n inputDataFile = open(pMassDcmpFile, \\\"rb\\\")\\n dataOut = pickle.load(inputDataFile)\\n inputDataFile.close()\\n # Now we need to write a description of what the data is! [segmentedTrials, gCenters, b, dataFile, xStart, xStop, nGaus, bInitial, dt]\\n numbOfTrials = len(dataOut[0])\\n originatingDataFile = dataOut[3]\\n numbGaus = dataOut[6]\\n xStart = dataOut[4]\\n xStop = dataOut[5]\\n GausVarb = dataOut[2]\\n dt = dataOut[8]\\n descpFName = pMassDcmpFile[:-4]+\\\"DESC.txt\\\"\\n file = open(descpFName,'w')\\n file.write(\\\"1-D Moving Mass Decomposed Data Description\\\\n\\\")\\n file.write(\\\"\\\\nData here is generated from the decomposeMoving1DMassData() method\\\\n\\\")\\n file.write(\\\"\\\\nFileName.......\\\"+pMassDcmpFile)\\n file.write(\\\"\\\\nInputDataFile..\\\"+originatingDataFile)\\n file.write(\\\"\\\\niterations.....\\\"+str(numbOfTrials))\\n file.write(\\\"\\\\nNumbOfGauss....\\\"+str(numbGaus))\\n file.write(\\\"\\\\nxStart.........\\\"+str(xStart))\\n file.write(\\\"\\\\nxStop..........\\\"+str(xStop))\\n file.write(\\\"\\\\nGausVarbl_b....\\\"+str(GausVarb))\\n file.write(\\\"\\\\ndt.............\\\"+str(dt))\\n file.close()\\n if isinstance(pMassDcmpSpkesFile, str):\\n if os.path.isfile(pMassDcmpSpkesFile):\\n # Load in teh data to see what it has it there\\n inputDataFile = open(pMassDcmpSpkesFile, \\\"rb\\\")\\n dataOut = pickle.load(inputDataFile)\\n inputDataFile.close()\\n # Now we need to write a description of what the data is! [segmentedSpikesList, dataFile, spikeGenType, analgSingnalScaling]\\n numbOfTrials = len(dataOut[0])\\n originatingDataFile = dataOut[1]\\n spikeGenType = dataOut[2]\\n analogScl = dataOut[3]\\n descpFName = pMassDcmpSpkesFile[:-4]+\\\"DESC.txt\\\"\\n file = open(descpFName,'w')\\n file.write(\\\"1-D Moving mass Decomposed and Turned to Spikes Data Description\\\\n\\\")\\n file.write(\\\"\\\\nData here is generated from the decompedToSpikes1DMassData\\\\n\\\")\\n file.write(\\\"\\\\nFileName.........\\\"+pMassDcmpSpkesFile)\\n file.write(\\\"\\\\nInputDataFile....\\\"+originatingDataFile)\\n file.write(\\\"\\\\nIterations.......\\\"+str(numbOfTrials))\\n file.write(\\\"\\\\nSpike-Gen-Type...\\\"+spikeGenType)\\n file.write(\\\"\\\\nSignal-Scaling...\\\"+str(analogScl))\\n file.close()\\n if isinstance(pMassBrianFile, str):\\n if os.path.isfile(pMassBrianFile):\\n # Load in the data to see what it has in there\\n inputDataFile = open(pMassBrianFile, \\\"rb\\\")\\n dataOut = pickle.load(inputDataFile)\\n inputDataFile.close()\\n # Now we need to write a description of what the data is! [spikesInBrianForm, dataFile, origDataFile]\\n descpFName = pMassBrianFile[:-4]+\\\"DESC.txt\\\"\\n file = open(descpFName, 'w')\\n file.write(\\\"1-D Moving mass data decomposed, turned into spikes, and then turned into a brain sim. compatible format\\\\n\\\")\\n file.write(\\\"\\\\n Data here is generated from the convertSpikeseToBrainForm()\\\\n\\\")\\n file.write(\\\"\\\\nFilename.............................\\\"+pMassBrianFile)\\n file.write(\\\"\\\\nOriginating Decompled Data File .... \\\"+dataOut[1])\\n file.close()\",\n \"def handle_store(self, event):\\n\\n \\n mode_prefixes = {'CT Image Storage' : 'CT',\\n 'Enhanced CT Image Storage' : 'CTE',\\n 'MR Image Storage' : 'MR',\\n 'Enhanced MR Image Storage' : 'MRE',\\n 'Positron Emission Tomography Image Storage' : 'PT',\\n 'RT Plan Storage' : 'RP',\\n 'RT Structure Set Storage' : 'RS',\\n 'Computed Radiography Image Storage' : 'CR',\\n 'Ultrasound Image Storage' : 'US',\\n 'Enhanced Ultrasound Image Storage' : 'USE',\\n 'X-Ray Angiographic Image Storage' : 'XA',\\n 'Enhanced XA Image Storage' : 'XAE',\\n 'Nuclear Medicine Image Storage' : 'NM',\\n 'Secondary Capture Image Storage' : 'SC'\\n }\\n\\n ds = event.dataset\\n # Because pydicom uses deferred reads for its decoding, decoding errors\\n # are hidden until encountered by accessing a faulty element\\n try:\\n sop_class = ds.SOPClassUID\\n sop_instance = ds.SOPInstanceUID\\n except Exception as exc:\\n # Unable to decode dataset\\n return 0xC210\\n\\n try:\\n # Get the elements we need\\n mode_prefix = mode_prefixes[sop_class.name]\\n except KeyError:\\n mode_prefix = 'UN'\\n\\n filename = os.path.join(self.config['output']['directory'],'tmp/{0!s}.dcm'.format(uuid.uuid4()))\\n\\n # Presentation context\\n cx = event.context\\n\\n meta = Dataset()\\n meta.MediaStorageSOPClassUID = sop_class\\n meta.MediaStorageSOPInstanceUID = sop_instance\\n \\n meta.TransferSyntaxUID = cx.transfer_syntax\\n \\n\\n ds.file_meta = meta\\n ds.is_little_endian = cx.transfer_syntax.is_little_endian\\n ds.is_implicit_VR = cx.transfer_syntax.is_implicit_VR\\n\\n status_ds = Dataset()\\n \\n try:\\n ds.save_as(filename, write_like_original=False)\\n self.file_count += 1\\n self.writing_queue.put((filename, ds))\\n status_ds.Status = 0x0000 # Success\\n except IOError:\\n # Failed - Out of Resources - IOError\\n status_ds.Status = 0xA700\\n except:\\n # Failed - Out of Resources - Miscellaneous error\\n status_ds.Status = 0xA701\\n\\n\\n return status_ds\",\n \"def create_dnz_file(args):\\n\\n file = open(args.o, 'w')\\n\\n file.write(\\\"% ----DATA VARIABLES----\\\\n\\\\n\\\")\\n file.write(\\\"t=\\\" + str(args.t) + \\\";\\\" + \\\"%number of attributes\\\\n\\\")\\n file.write(\\\"k=\\\" + str(args.k) + \\\";\\\" + \\\"%max length of the support set\\\\n\\\")\\n file.write(\\\"n=\\\" + str(args.n) + \\\";\\\" + \\\"%number of positive instances\\\\n\\\")\\n file.write(\\\"m=\\\" + str(args.m) + \\\";\\\" + \\\"%number of negative instances\\\\n\\\")\\n file.write(\\\"c=\\\" + str(args.c) + \\\";\\\" + \\\"%number of atMostOne Constraints\\\\n\\\\n\\\")\\n\\n file.write(\\\"% ----OMEGAS----\\\\n\\\\n\\\")\\n\\n omega_p = generate_omega_data(args.t, args.n, args.b)\\n file.write(\\\"omegap= \\\" + omega_to_mz(omega_p) + \\\"\\\\n\\\\n\\\")\\n\\n omega_n = generate_disjoint_omega_data(omega_p, args.m, args.b)\\n file.write(\\\"omegan= \\\" + omega_to_mz(omega_n) + \\\"\\\\n\\\\n\\\")\\n\\n file.write(\\\"% ----CONSTRAINS----\\\\n\\\\n\\\")\\n at_most_one = generate_at_most_one(int(args.t/2), args.c, 1, args.t)\\n file.write(\\\"atMostOne=\\\" + at_most_one_to_mz(at_most_one))\",\n \"def build(self):\\n self.kwargs.pop('clobber', None)\\n\\n # Read in mock catalog with assigned photometric redshifts\\n # and calculate the line-of-sight displacement between the \\n # upweighted galaxy and the photometric redshift of the \\n # collided galaxy \\n photoz_cat_corr = {\\n 'catalog': self.cat_corr['catalog'].copy(), \\n 'correction': {'name': 'photoz'}\\n }\\n dataclass = Data('data', photoz_cat_corr) \\n dataclass.read() \\n\\n cosmo = dataclass.cosmo()\\n\\n coll = np.where(dataclass.wfc == 0) \\n \\n dlos_actual = (cosmos.distance.comoving_distance(dataclass.z[coll], **cosmo) - \\\\\\n cosmos.distance.comoving_distance(dataclass.zupw[coll], **cosmo)) * cosmo['h']\\n dlos_photoz = (cosmos.distance.comoving_distance(dataclass.photoz[coll], **cosmo) - \\\\\\n cosmos.distance.comoving_distance(dataclass.zupw[coll], **cosmo)) * cosmo['h']\\n\\n # each value of d_NN corresponds to a dLOS value \\n # in dLOS file \\n print self.file_name\\n np.savetxt(self.file_name, \\n np.c_[dlos_actual, dlos_photoz], \\n fmt=['%10.5f', '%10.5f'],\\n header='Columns : dLOS, dLOS_photoz'\\n ) \\n\\n return None\",\n \"def write_scram_toolfiles(self):\\n from string import Template\\n\\n mkdirp(join_path(self.spec.prefix.etc, 'scram.d'))\\n\\n values = {}\\n values['VER'] = self.spec.version\\n values['PFX'] = self.spec.prefix\\n\\n fname = 'uuid-cms.xml'\\n template = Template(\\\"\\\"\\\"<tool name=\\\"uuid\\\" version=\\\"$VER\\\">\\n <lib name=\\\"uuid\\\"/>\\n <client>\\n <environment name=\\\"LIBUUID_BASE\\\" default=\\\"$PFX\\\"/>\\n <environment name=\\\"LIBDIR\\\" default=\\\"$$LIBUUID_BASE/lib\\\"/>\\n <environment name=\\\"INCLUDE\\\" default=\\\"$$LIBUUID_BASE/include\\\"/>\\n </client>\\n <runtime name=\\\"ROOT_INCLUDE_PATH\\\" value=\\\"$$INCLUDE\\\" type=\\\"path\\\"/>\\n <use name=\\\"root_cxxdefaults\\\"/>\\n <use name=\\\"sockets\\\"/>\\n</tool>\\\"\\\"\\\")\\n\\n contents = template.substitute(values)\\n self.write_scram_toolfile(contents, fname)\\n\\n fname = 'libuuid.xml'\\n template = Template(\\\"\\\"\\\"<tool name=\\\"libuuid\\\" version=\\\"$VER\\\">\\n <lib name=\\\"uuid\\\"/>\\n <client>\\n <environment name=\\\"LIBUUID_BASE\\\" default=\\\"$PFX\\\"/>\\n <environment name=\\\"LIBDIR\\\" default=\\\"$$LIBUUID_BASE/lib\\\"/>\\n <environment name=\\\"INCLUDE\\\" default=\\\"$$LIBUUID_BASE/include\\\"/>\\n </client>\\n <runtime name=\\\"ROOT_INCLUDE_PATH\\\" value=\\\"$$INCLUDE\\\" type=\\\"path\\\"/>\\n <use name=\\\"root_cxxdefaults\\\"/>\\n <use name=\\\"sockets\\\"/>\\n</tool>\\\"\\\"\\\")\\n\\n contents = template.substitute(values)\\n self.write_scram_toolfile(contents, fname)\",\n \"def dict2file(dict, filename, foldername):\\n if foldername:\\n if not os.path.exists(\\\"../Created_QD/\\\" + foldername):\\n os.makedirs(\\\"../Created_QD/\\\" + foldername)\\n file = open(\\\"../Created_QD/\\\" + foldername + \\\"/\\\" + filename + \\\".xyz\\\", \\\"w\\\")\\n else:\\n file = open(\\\"../Created_QD/\\\" + filename + \\\".xyz\\\", \\\"w\\\")\\n file.write(\\\" \\\\n\\\\n\\\")\\n for atom, values in dict.items():\\n file.write(values['element'] + \\\"\\\\t\\\" + str(values['coor'][0]) + \\\"\\\\t\\\\t\\\" +\\n str(values['coor'][1]) + \\\"\\\\t\\\\t\\\" + str(values['coor'][2]) + \\\"\\\\n\\\")\\n file.seek(0)\\n file.write(str(len(dict)))\\n file.close()\\n print(\\\"\\\\nQuantum Dot created :)\\\")\",\n \"def createckfk(self, observer, dbname, t0, field1, nfields, mk): \\n\\n observerint=self.mpc2internal(observer)\\n instrumentint=observerint*1000\\n\\n with open(\\\"cksetupfile\\\", \\\"w\\\") as f:\\n f.write(\\\"KPL/IK \\\\nComments describing the keywords and values \\\\nto follow, as well as any other pertinent \\\\ninformation.\\\\n\\\\\\\\begindata\\\\n\\\")\\n f.write(\\\"LSK_FILE_NAME = '%s'\\\\n\\\" %(mk))\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"INTERNAL_FILE_NAME = 'Survey Sim Camera Orientation'\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"MAKE_FAKE_SCLK = 'tmpsclk'\\\\n\\\")\\n f.write(\\\"CK_TYPE = 3\\\\n\\\")\\n f.write(\\\"CK_SEGMENT_ID = 'Instrument Orientation'\\\\n\\\")\\n f.write(\\\"INSTRUMENT_ID = %i \\\\n\\\" %(instrumentint))\\n f.write(\\\"REFERENCE_FRAME_NAME = 'J2000'\\\\n\\\")\\n f.write(\\\"ANGULAR_RATE_PRESENT = 'NO'\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"INPUT_DATA_TYPE = 'SPICE QUATERNIONS'\\\\n\\\")\\n f.write(\\\"INPUT_TIME_TYPE = 'UTC'\\\\n\\\")\\n f.write(\\\"MAXIMUM_VALID_INTERVAL = 60\\\\n\\\") \\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"PRODUCER_ID = 'Survey Sim, JPL'\\\\n\\\")\\n f.write(\\\"\\\\\\\\begintext\\\")\\n f.close()\\n\\n\\n self.readfields(dbname,field1,nfields, t0)\\n with open(\\\"ckip\\\",\\\"w\\\") as f:\\n\\n for i in range(len(self.fieldRA)):\\n quat=self.computerotmat(self.fieldRA[i], self.fieldDec[i], self.rotSkyPos[i])\\n\\n #This helps with duplicate entries. For example enigma_1189 can have same fieldID's under different propID's\\n #Issue warning for duplicate time. Have a verbose mode for displaying that (true as default)\\n if (self.fieldMJD[i] !=self.fieldMJD[i-1]):\\n JD=self.fieldMJD[i]+shared.mjd2jd\\n timestring= 'JD'+repr(JD)\\n f.write(\\\"%s %f %f %f %f\\\\n\\\" %(timestring,quat[0],quat[1],quat[2],quat[3]))\\n f.close()\\n try:\\n os.system('rm tmp.ck tmpsclk test.ck fakesclk >/dev/null')\\n except:\\n pass\\n os.system('msopck cksetupfile ckip tmp.ck > /dev/null')\\n\\n os.system('rsync tmpsclk fakesclk > /dev/null')\\n os.system('rsync tmp.ck test.ck > /dev/null')\\n\\n with open(\\\"tmp.fk\\\",\\\"w\\\") as f:\\n f.write(\\\"\\\\\\\\begindata\\\\n\\\\n\\\")\\n f.write(\\\"FRAME_CAMERA_FRAME = %i\\\\n\\\" %(instrumentint))\\n f.write(\\\"FRAME_%i_NAME = 'CAMERA_FRAME'\\\\n\\\" %(instrumentint))\\n f.write(\\\"FRAME_%i_CLASS = 3\\\\n\\\" %(instrumentint))\\n f.write(\\\"FRAME_%i_CLASS_ID = %i\\\\n\\\" %(instrumentint, instrumentint))\\n f.write(\\\"FRAME_%i_CENTER = %i\\\\n\\\" %(instrumentint, observerint))\\n f.write(\\\"CK_%i_SCLK = %i\\\\n\\\" %(instrumentint, observerint))\\n f.write(\\\"CK_%i_SPK = %i\\\\n\\\\n\\\" %(instrumentint, observerint))\\n f.write(\\\"\\\\\\\\begintext\\\\n\\\")\\n f.close()\\n \\n os.system('rsync tmp.fk test.fk')\",\n \"def create_sdxmetadata(sdx_dir, output_dir):\\n #define list to store SDX information\\n instrument = []\\n picks = [] \\n phases = []\\n \\n #segment and store metadata \\n #define SDX files to be read\\n for root, dirs, files in os.walk(sdx_dir):\\n for idx, file in enumerate(files):\\n if file.endswith(\\\".sdx\\\"):\\n \\n print(\\\"Reading File: \\\" + file)\\n \\n #define list to store SDX information\\n instrument = []\\n picks = [] \\n phases = []\\n \\n #scan for pick info\\n with open(root + file,\\\"r\\\") as f:\\n searchlines = f.readlines()\\n for i, line in enumerate(searchlines):\\n #strip whitespace/end-of-line characters for exact text matching\\n line = line.rstrip()\\n #find pick info\\n if \\\"pick\\\" == line:\\n for l in searchlines[i:i+16]: \\n #print(l)\\n #assign pick info/instrument info to variables and store\\n instrument_info = searchlines[i+1]\\n pick_info = searchlines[i+2]\\n phase_info = searchlines[i+9:i+13]\\n instrument.append(instrument_info)\\n picks.append(pick_info)\\n phases.append(phase_info)\\n \\n #create a .txt file for each seperate event to store pick info\\n pathlib.Path(output_dir).mkdir(parents=True, exist_ok=True)\\n\\n f = open(output_dir + os.path.splitext(file)[0] + \\\".txt\\\",'w')\\n #header information...\\n f.write('Data read from correpsonding SDX file:' + '\\\\n')\\n f.write(file + '\\\\n\\\\n')\\n f.write('Instrument/component' + '\\\\t\\\\t\\\\t' + 'Pick information' '\\\\t\\\\t\\\\t' + 'Phase information\\\\n')\\n \\n # print both instrument and pick information to the \\n # associated event file\\n for item in zip(instrument, picks, phases):\\n \\n #remove preceding whitespace/formatting characters\\n item0 = item[0].rstrip()\\n item1 = item[1].rstrip()\\n item2 = list(map(str.strip, item[2]))\\n \\n #remove associated list formatting\\n item2 = (\\\", \\\".join( str(e) for e in item2))\\n\\n #print...\\n #format | instrument info | pick info | phase info\\n f.write(\\\"%s\\\\t\\\\t%s\\\\t\\\\t%s\\\\n\\\" % (item0,item1,item2))\\n \\n f.close()\",\n \"def dump_to_disk(self, prefix):\\n\\n f = open(prefix + rpki.sundial.now().isoformat() + \\\"Z.cms\\\", \\\"wb\\\")\\n f.write(self.get_DER())\\n f.close()\",\n \"def writeCADFile(self, filename):\\n valid_filetypes = [\\\"brep\\\", \\\"bstl\\\", \\\"egads\\\", \\\"egg\\\", \\\"iges\\\", \\\"igs\\\", \\\"sens\\\", \\\"step\\\", \\\"stl\\\", \\\"stp\\\", \\\"tess\\\", \\\"grid\\\"]\\n file_extension = filename.split(\\\".\\\")[-1]\\n if file_extension.lower() not in valid_filetypes:\\n raise OSError(\\n \\\"CAD filename \\\"\\n + filename\\n + \\\" must have a valid exension. \\\"\\n + \\\"Consult the EngineeringSketchPad docs for the DUMP function\\\"\\n )\\n if self.comm.rank == 0:\\n modelCopy = self.espModel.Copy()\\n n_branches, _, _ = modelCopy.Info()\\n modelCopy.NewBrch(\\n n_branches, modelCopy.GetCode(\\\"dump\\\"), \\\"<none>\\\", 0, filename, \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"\\\", \\\"\\\", \\\"\\\", \\\"\\\", \\\"\\\"\\n )\\n modelCopy.Build(0, 0)\",\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 prepare_dataset(sdffile, dest=None, overwrite=False):\\n root, name = op.split(sdffile)\\n name = op.splitext(name)[0]\\n\\n if not dest: dest = root\\n\\n dest_sdf = op.join(dest, name + '-prepared.sdf')\\n master_table = op.join(dest, name + '-master.csv')\\n sali_table = op.join(dest, name + '-saliviewer.csv')\\n\\n if op.exists(dest_sdf) and not overwrite:\\n print '%s is already there and not overwriting requested' % dest_sdf\\n else:\\n print 'Reading %s' % sdffile\\n mols = list(pybel.readfile('sdf', sdffile))\\n\\n print '\\\\tCreating dataset root: %s' % dest\\n if not op.exists(dest):\\n os.makedirs(dest)\\n\\n print '\\\\tRenaming the compounds to keep track of the provenance'\\n rename_mols_by_index(mols, name + '-')\\n\\n print '\\\\tGenerating conformations'\\n for mol in mols:\\n if not any(name in mol.title for name in ('train-3988', 'train-4205')):\\n try:\\n print 'Conformation for %s' % mol.title\\n mol.make3D()\\n except Exception:\\n print 'Error computing a 3D conformation for %s' % mol.title\\n\\n print '\\\\tSaving compounds'\\n save_mols(mols, dest_sdf)\\n\\n print '\\\\tCreating \\\\\\\"master\\\\\\\" table: %s' % master_table\\n create_master_table(dest_sdf, master_table, fields=['Activity'])\\n\\n print '\\\\tCreating \\\\\\\"saliviewer\\\\\\\" table: %s' % sali_table\\n create_saliviewer_input(master_table, sali_table)\\n\\n return dest_sdf, master_table\",\n \"def _build_meds_layout(self):\\n\\n\\n nim = self.image_info.size\\n nobj = self.obj_data.size\\n\\n trim_to_coadd = self.get('trim_to_coadd',False)\\n if trim_to_coadd:\\n print(' trimming to coadd')\\n coadd_wcs, coadd_pos, coadd_bnds, coadd_q = \\\\\\n self._get_pos_and_bounds(self.obj_data, 0)\\n in_bnds = coadd_bnds.contains_points(coadd_pos['zrow'], coadd_pos['zcol'])\\n w_in_bnds, = np.where(in_bnds == True)\\n assert w_in_bnds.size > 0,\\\"none found in coadd\\\"\\n\\n w_in_bnds = coadd_q[w_in_bnds]\\n self.obj_data = self.obj_data[w_in_bnds]\\n\\n self._do_psf_setup()\\n\\n # box sizes are even\\n half_box_size = self.obj_data['box_size']//2\\n\\n for file_id in range(nim):\\n\\n wcs, pos, bnds, q = self._get_pos_and_bounds(self.obj_data, file_id)\\n\\n # do the test\\n in_bnds = bnds.contains_points(pos['zrow'], pos['zcol'])\\n q_rc, = np.where(in_bnds == True)\\n print(' second cut: %6d of %6d objects' % (len(q_rc),len(q)))\\n\\n # now make sure everything is there\\n if self['check_in_first_image']:\\n if file_id == 0 and len(self.obj_data['ra']) != len(q_rc):\\n raise MEDSCreationError('Not all objects were found in first image for '\\n 'MEDS making (which is the coadd/detection '\\n 'image by convention).')\\n # compose them\\n q = q[q_rc]\\n\\n # fill in the object_data structure\\n\\n # note q_rc since pos was created using obj_data[q]\\n qrow = pos['zrow'][q_rc]\\n qcol = pos['zcol'][q_rc]\\n\\n icut = self.obj_data['ncutout'][q]\\n self.obj_data['file_id'][q,icut] = file_id\\n self.obj_data['orig_row'][q,icut] = qrow\\n self.obj_data['orig_col'][q,icut] = qcol\\n\\n # this results in the object center being close to\\n # the natural center (dim-1.)/2.\\n ostart_row = qrow.astype('i4') - half_box_size[q] + 1\\n ostart_col = qcol.astype('i4') - half_box_size[q] + 1\\n crow = qrow - ostart_row\\n ccol = qcol - ostart_col\\n\\n self.obj_data['orig_start_row'][q,icut] = ostart_row\\n self.obj_data['orig_start_col'][q,icut] = ostart_col\\n self.obj_data['cutout_row'][q,icut] = crow\\n self.obj_data['cutout_col'][q,icut] = ccol\\n\\n # do jacobian, in original, not-offset coords\\n # note q_rc since pos was created using self.obj_data[q]\\n jacob = wcs.get_jacobian(\\n x=pos['wcs_col'][q_rc],\\n y=pos['wcs_row'][q_rc])\\n\\n # jacob is a tuple of arrays\\n self.obj_data['dudcol'][q,icut] = jacob[0]\\n self.obj_data['dudrow'][q,icut] = jacob[1]\\n self.obj_data['dvdcol'][q,icut] = jacob[2]\\n self.obj_data['dvdrow'][q,icut] = jacob[3]\\n\\n # increment\\n self.obj_data['ncutout'][q] += 1\\n\\n w,=np.where(self.obj_data['ncutout'] > 0)\\n print('%d/%d had ncut > 0' % (w.size, self.obj_data.size))\\n #self.obj_data = self.obj_data[w]\\n\\n self.obj_data = self._make_resized_data(self.obj_data)\\n print('setting number field as sequential')\\n self.obj_data['number'] = 1+np.arange(self.obj_data.size)\\n\\n\\n self._set_start_rows_and_pixel_count()\\n\\n if self['survey']=='cosmos':\\n self._set_psf_layout_hst()\\n else:\\n self._set_psf_layout_psfex()\",\n \"def export_ctsdg(cfg):\\n generator = Generator(\\n image_in_channels=config.image_in_channels,\\n edge_in_channels=config.edge_in_channels,\\n out_channels=config.out_channels\\n )\\n generator.set_train(False)\\n load_checkpoint(cfg.checkpoint_path, generator)\\n\\n ckpt_path = Path(cfg.checkpoint_path)\\n output_file_name = (ckpt_path.parent / ckpt_path.stem).as_posix()\\n file_format = config.file_format\\n\\n img_dummy = mnp.zeros([1, config.image_in_channels, *cfg.image_load_size],\\n dtype=mstype.float32)\\n edge_dummy = mnp.zeros([1, 2, *cfg.image_load_size], dtype=mstype.float32)\\n mask_dummy = mnp.zeros([1, 1, *cfg.image_load_size], dtype=mstype.float32)\\n\\n export(generator, img_dummy, edge_dummy, mask_dummy,\\n file_name=output_file_name, file_format=file_format)\\n\\n print(f'{output_file_name}.mindir exported successfully!', flush=True)\",\n \"def _make_files(self):\\n if not self.path.is_dir():\\n raise FileNotFoundError(f\\\"Path {self.path} does not exist.\\\")\\n\\n # Make the filepaths\\n self.file_points = self.path / \\\"point.dat\\\"\\n self.file_lines = self.path / \\\"line.dat\\\"\\n self.file_cadastre = self.path / \\\"cadastre.dat\\\"\\n self.file_portals = self.path / \\\"portals.dat\\\"\\n\\n with open(self.file_points, \\\"w\\\") as f:\\n # 2 lines ignored\\n header = datetime.datetime.now().strftime(\\\"Generated: %d/%m/%Y %H:%M\\\\n\\\")\\n f.write(header)\\n self.points_dfs = []\\n with open(self.file_lines, \\\"w\\\") as f:\\n # 5 lines ignored\\n header = (\\n datetime.datetime.now().strftime(\\\"Generated: %d/%m/%Y %H:%M\\\\n\\\")\\n + 3 * \\\"Generated: \\\\n\\\"\\n + \\\"Name,Section,source_group,x1,y1,z1,x2,y2,z2,width,vert. ext.,-,-,\\\"\\n \\\"emission_rate[kg/h/km],-,-,-,-\\\\n\\\"\\n )\\n f.write(header)\\n with open(self.file_cadastre, \\\"w\\\") as f:\\n # 1 line ignored\\n header = \\\"x,y,z,dx,dy,dz,emission_rate[kg/h],-,-,-,source_group\\\\n\\\"\\n f.write(header)\\n with open(self.file_portals, \\\"w\\\") as f:\\n # 2 lines ignored\\n header = (\\n datetime.datetime.now().strftime(\\\"Generated: %d/%m/%Y %H:%M\\\\n\\\")\\n + \\\"x1,y1,x2,y2,z0,z1,emission_rate[kg/h],-,-,-,source_group\\\\n\\\"\\n )\\n f.write(header)\\n\\n\\n # File to save the source groups values\\n self.file_source_groups = self.path / \\\"source_groups.json\\\"\\n with open(self.file_source_groups, \\\"w\\\") as f:\\n # reverse the dict (items become keys and vice versa)\\n reversed_source_groups = {v: k for k, v in self.source_groups.items()}\\n json.dump(reversed_source_groups, f, indent=2)\",\n \"def create_pythia_cmnd_files(self):\\n \\n for higgsname, higgspid in {'H': 35, 'A': 36}.iteritems():\\n \\n # Get mass and width from 2HDMC LHA file\\n lha = LHA(self.lhafile)\\n mass = lha.get_block('MASS').get_entry_by_key(higgspid)\\n width = lha.get_decay(higgspid).width \\n \\n outname = self.lhafile.replace('.lha', '_%s.cmnd' % higgsname)\\n self.cmndfiles[higgsname] = outname\\n \\n # Write command file\\n with open(outname, 'w') as outfile:\\n \\n outfile.write('Beams:eCM = 13000.\\\\n')\\n outfile.write('Higgs:useBSM = on\\\\n')\\n \\n if higgspid == 36:\\n #outfile.write('HiggsBSM:allA3 = on\\\\n') # All production modes\\n outfile.write('HiggsBSM:ffbar2A3 = on\\\\n') # quark fusion\\n outfile.write('HiggsBSM:gg2A3 = on\\\\n') # gluon fusion\\n elif higgspid == 35:\\n #outfile.write('HiggsBSM:allH2 = on\\\\n') # All production modes\\n outfile.write('HiggsBSM:ffbar2H2 = on\\\\n') # quark fusion\\n outfile.write('HiggsBSM:gg2H2 = on\\\\n') # gluon fusion\\n \\n outfile.write('{}:all = A0 A0 1 0 0 {} {} 50.0 0.0\\\\n'.format(higgspid, mass, width))\\n outfile.write('{}:onMode = off\\\\n'.format(higgspid))\\n outfile.write('{}:onIfMatch = 15 -15\\\\n'.format(higgspid))\\n \\n outfile.write('15:onMode = off\\\\n')\\n outfile.write('15:onIfMatch = 16 111 211\\\\n')\\n outfile.write('\\\\n')\\n outfile.write('Next:numberShowEvent = 0\\\\n')\\n\\n return 0\",\n \"def write_to_md(dictData, outputDirectory):\\n\\tdic = prepare_hw_dict(dictData)\\n\\tfor hw in dic:\\n\\t\\tfileout = os.path.join(outputDirectory, hw+'.md')\\n\\t\\t# Prepare the output file\\n\\t\\tfout = codecs.open(fileout, 'w', 'utf-8')\\n\\t\\t# Write frontmatter\\n\\t\\tfout.write('---\\\\ntitle: \\\"'+hw+'\\\"\\\\n---\\\\n\\\\n')\\n\\t\\t# For each (headword, meanings, verseNumber, PageNum) tuples,\\n\\t\\tfor (hw, meanings, verse, verseNumDetails, pageNumDetails) in dic[hw]:\\n\\t\\t\\tcommaed = ', '.join(meanings)\\n\\t\\t\\tverse = verse.replace('<BR>', '<br />')\\n\\t\\t\\t# Write in babylon format. <BR><BR> is to separate verses.\\n\\t\\t\\tfout.write('# ' + hw + '\\\\n## ' + commaed + '\\\\n' + verse + '<br />verse ' + verseNumDetails + '<br />page ' + pageNumDetails +'\\\\n\\\\n')\\n\\t\\tfout.close()\\n\\n\\t# Give some summary to the user\\n\\tprint('MD files generated. Success!')\\n\\tprint('{} separate .md files written, one per headword.'.format(len(dic)))\",\n \"def _create_ID_files(self):\\n for file, IDs in [(self._trn_IDs_file, self._trn_IDs), (self._val_IDs_file,\\n self._val_IDs), (self._tst_IDs_file, self._tst_IDs)]:\\n with open(file, 'w') as f:\\n f.write('\\\\n'.join('{}###{}###{}'.format(ID[0], ID[1], ID[2]) for ID in IDs))\",\n \"def generate(self):\\n self._open_file()\\n # copied from GenerateCSPEC.py\\n self._write_header_and_defaults()\\n self._write_source()\\n self._write_sample()\\n\\n self._write_all_components()\\n self._write_mantle_module()\\n self._write_segment()\\n self._write_all_ids()\\n self._write_footer()\\n self._close_file()\",\n \"def build_plasticc_metadata(fname_meta: str, snana_dir: str, out_fname,\\n screen=False, extragal=True, field='DDF'):\\n\\n # map between zenodo and SNANA types\\n SNANA_types = {90:11, 62:{1:3, 2:13}, 42:{1:2, 2:12, 3:14},\\n 67:41, 52:43, 64:51, 95:60, 994:61, 992:62,\\n 993:63, 15:64, 88:70, 92:80, 65:81, 16:83,\\n 53:84, 991:90, 6:{1:91, 2:93}}\\n \\n extragal_zenodo_types = [15, 42, 52, 62, 64, 67, 88, 90, 95]\\n \\n # read zenodo metadata\\n meta = pd.read_csv(fname_meta)\\n\\n if field == 'DDF':\\n # identify only DDF objects\\n ddf_flag = meta['ddf_bool'].values == 1\\n elif field == 'WFD':\\n ddf_flag = meta['ddf_bool'].values == 0\\n else:\\n ddf_flag = np.array([True for i in range(meta.shape[0])])\\n\\n # get ids\\n ids = meta['object_id'].values[ddf_flag] \\n\\n names = get_SNR_headers()\\n\\n if not os.path.isfile(out_fname):\\n op = open(out_fname, 'w+')\\n for item in names[:-1]:\\n op.write(item + ',')\\n op.write(names[-1] + '\\\\n')\\n\\n else: \\n op = open(out_fname, 'a+')\\n \\n # which group to search for\\n if extragal:\\n search_group = extragal_zenodo_types\\n else:\\n search_group = list(SNANA_types.keys())\\n \\n for code_zenodo in search_group:\\n \\n if screen:\\n print('code_zenodo: ', code_zenodo)\\n\\n if code_zenodo not in [62, 42, 6]:\\n code_snana = SNANA_types[code_zenodo]\\n\\n for n in range(1, 11):\\n fname2 = snana_dir + 'LSST_DDF_MODEL' + str(code_snana).zfill(2) + \\\\\\n '/LSST_DDF_NONIa-00' + str(n).zfill(2) + '_PHOT.FITS.gz'\\n\\n photo = read_fits(fname2)\\n\\n for indx in range(photo[0].shape[0]):\\n # read data for 1 object\\n snid_raw = photo[0]['SNID'].values[indx]\\n snid = int(re.sub(\\\"[^0-9]\\\", \\\"\\\", str(snid_raw)))\\n\\n if snid in ids: \\n line = calculate_SNR(snid=snid, \\n code_zenodo=code_zenodo,\\n photo_data=photo[1],\\n head_data=photo[0],\\n snana_file_index=n,\\n code_snana=code_snana)\\n \\n if len(line) > 0:\\n for item in line[:-1]:\\n op.write(str(item) + ',')\\n op.write(str(line[-1]) + '\\\\n')\\n \\n del photo\\n \\n else:\\n for subtype in SNANA_types[code_zenodo].keys():\\n code_snana = SNANA_types[code_zenodo][subtype]\\n \\n for n in range(1, 11): \\n fname2 = snana_dir + 'LSST_DDF_MODEL' + str(code_snana).zfill(2) + \\\\\\n '/LSST_DDF_NONIa-00' + str(n).zfill(2) + '_PHOT.FITS.gz'\\n\\n photo = read_fits(fname2)\\n\\n for indx in range(photo[0].shape[0]):\\n\\n # read data for 1 object\\n snid_raw = photo[0]['SNID'].values[indx]\\n snid = int(re.sub(\\\"[^0-9]\\\", \\\"\\\", str(snid_raw)))\\n\\n if snid in ids:\\n line = calculate_SNR(snid=snid, \\n code_snana=code_snana,\\n code_zenodo=code_zenodo,\\n photo_data=photo[1], \\n head_data=photo[0],\\n snana_file_index=n)\\n \\n if len(line) > 0:\\n for item in line[:-1]:\\n op.write(str(item) + ',')\\n op.write(str(line[-1]) + '\\\\n')\\n \\n del photo\\n \\n op.close()\",\n \"def make_header_files():\\n os.makedirs(DATA_DIR) if not os.path.exists(DATA_DIR) else None\\n from dkistdataratemodel.units import frame\\n from dkist_data_model.generator.dataproducts.visp import CalibratedVISP\\n\\n \\\"\\\"\\\"\\n Generate VISP\\n \\\"\\\"\\\"\\n visp = CalibratedVISP(end_condition=20*frame)\\n\\n visp_files = visp.to_fits(\\\"sp_5_labelled\\\",\\n path_template=os.path.join(DATA_DIR, 'visp_5d_{i:02d}.fits'))\\n\\n with ZipFile(os.path.join(DATA_DIR, \\\"visp.zip\\\"), \\\"w\\\") as myzip:\\n for fname in visp_files:\\n myzip.write(fname, os.path.split(fname)[1])\\n os.remove(fname)\\n\\n \\\"\\\"\\\"\\n Generate VTF\\n \\\"\\\"\\\"\\n from dkist_data_model.generator.dataproducts.vtf import CalibratedVTF\\n vtf = CalibratedVTF(end_condition=96*frame)\\n\\n vtf_files = vtf.to_fits(\\\"5d_test\\\",\\n path_template=os.path.join(DATA_DIR, 'vtf_5d_{i:02d}.fits'))\\n\\n with ZipFile(os.path.join(DATA_DIR, \\\"vtf.zip\\\"), \\\"w\\\") as myzip:\\n for fname in vtf_files:\\n myzip.write(fname, os.path.split(fname)[1])\\n os.remove(fname)\",\n \"def Generar_Claves():\\n salida=Keypp()\\n savekey(salida)\\n savecomp(salida)\",\n \"def generate():\",\n \"def write_db_tables(self, datadir='.', do_com=False, do_angmom=False, \\n do_totalcom=False, do_totalangmom=False, do_normals=False,\\n do_sigmas=False, do_relmotion=False):\\n\\n filepath = Path(datadir)\\n\\n db = DB()\\n cur = db.get_cursor()\\n\\n # CoM data\\n if do_com:\\n colheads = ','.join(['gal','snap','t','x','y','z','vx','vy','vz'])\\n query = f\\\"\\\"\\\"\\n INSERT INTO centerofmass( {colheads} ) \\n VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s)\\n ON CONFLICT DO NOTHING\\n \\\"\\\"\\\"\\n\\n for gname in ('MW','M31','M33'):\\n filename = f'com_{gname}.txt'\\n fullname = filepath / filename\\n data = self.read_file(fullname)\\n \\n for snap, d in enumerate(data):\\n rec = [gname, snap,] + list(d)\\n cur.execute(query, rec)\\n\\n # angular momentum data\\n if do_angmom:\\n colheads = ','.join(['gal','snap','t','x_hat','y_hat','z_hat','l_mag'])\\n query = f\\\"\\\"\\\"\\n INSERT INTO angmom( {colheads} ) \\n VALUES (%s,%s,%s,%s,%s,%s,%s)\\n ON CONFLICT DO NOTHING\\n \\\"\\\"\\\"\\n\\n for gname in ('MW','M31','M33'):\\n filename = f'angmom_{gname}.txt'\\n fullname = filepath / filename\\n data = self.read_file(fullname)\\n \\n for snap, d in enumerate(data):\\n rec = [gname, snap,] + list(d)\\n cur.execute(query, rec)\\n\\n # total CoM data\\n if do_totalcom:\\n colheads = ','.join(['snap','t','x','y','z','vx','vy','vz'])\\n query = f\\\"\\\"\\\"\\n INSERT INTO totalcom( {colheads} ) \\n VALUES (%s,%s,%s,%s,%s,%s,%s,%s)\\n ON CONFLICT DO NOTHING\\n \\\"\\\"\\\"\\n\\n filename = 'total_com.txt'\\n fullname = filepath / filename\\n data = self.read_file(fullname)\\n \\n for snap, d in enumerate(data):\\n rec = [snap,] + list(d)\\n cur.execute(query, rec)\\n\\n # total angular momentum data\\n if do_totalangmom:\\n colheads = ','.join(['snap','t','Lx','Ly','Lz'])\\n query = f\\\"\\\"\\\"\\n INSERT INTO totalangmom( {colheads} ) \\n VALUES (%s,%s,%s,%s,%s)\\n ON CONFLICT DO NOTHING\\n \\\"\\\"\\\"\\n\\n filename = 'total_angmom.txt'\\n fullname = filepath / filename\\n data = self.read_file(fullname)\\n \\n for snap, d in enumerate(data):\\n rec = [snap,] + list(d)\\n cur.execute(query, rec)\\n\\n # 3-galaxy normals data\\n if do_normals:\\n colheads = ','.join(['snap','t','x_hat','y_hat','z_hat'])\\n query = f\\\"\\\"\\\"\\n INSERT INTO normals( {colheads} ) \\n VALUES (%s,%s,%s,%s,%s)\\n ON CONFLICT DO NOTHING\\n \\\"\\\"\\\"\\n\\n filename = 'normals.txt'\\n fullname = filepath / filename\\n data = self.read_file(fullname)\\n \\n for snap, d in enumerate(data):\\n rec = [snap,] + list(d)\\n cur.execute(query, rec)\\n\\n # velocity dispersions\\n if do_sigmas:\\n colheads = ','.join(['gal','snap','t','sigma'])\\n query = f\\\"\\\"\\\"\\n INSERT INTO sigmas( {colheads} ) \\n VALUES (%s,%s,%s,%s)\\n ON CONFLICT DO NOTHING\\n \\\"\\\"\\\"\\n\\n for gname in ('MW','M31','M33'):\\n filename = f'sigma_{gname}.txt'\\n fullname = filepath / filename\\n data = self.read_file(fullname)\\n \\n for snap, d in enumerate(data):\\n rec = [gname, snap,] + list(d)\\n cur.execute(query, rec)\\n\\n # relative motions\\n if do_relmotion:\\n colheads = ','.join(['snap','t','pos_MW_M31','pos_M33_M31','pos_M33_MW',\\n 'vel_MW_M31','vel_M33_M31','vel_M33_MW'])\\n query = f\\\"\\\"\\\"\\n INSERT INTO relmotion( {colheads} ) \\n VALUES (%s,%s,%s,%s,%s,%s,%s,%s)\\n ON CONFLICT DO NOTHING\\n \\\"\\\"\\\"\\n\\n filename = 'relmotion.txt'\\n fullname = filepath / filename\\n data = self.read_file(fullname)\\n \\n for snap, d in enumerate(data):\\n rec = [snap,] + list(d)\\n cur.execute(query, rec)\",\n \"def opensslCmsDataCreate( conveyedInfoFile ):\\n opensslCmdArgs = [ \\\"openssl\\\", \\\"cms\\\", \\\"-data_create\\\", \\\"-in\\\", conveyedInfoFile,\\n \\\"-outform\\\", \\\"der\\\" ]\\n conveyedInfoCmsDerBase64 = runOpensslCmd( opensslCmdArgs, [ \\\"base64\\\" ] )\\n return conveyedInfoCmsDerBase64\",\n \"def vacuum_cgmd(self):\\n\\n\\t\\texstring_dssp = 'except: cannot find dssp at '+gmxpaths['dssp']+\\\\\\n\\t\\t\\t'\\\\nconsider using the following syntax to download for 64-bit linux:'+\\\\\\n\\t\\t\\t'\\\\n\\\\twget ftp://ftp.cmbi.ru.nl/pub/software/dssp/dssp-2.0.4-linux-amd64'+\\\\\\n\\t\\t\\t'\\\\n\\\\tor navigate to ftp://ftp.cmbi.ru.nl/pub/software/dssp/'+\\\\\\n\\t\\t\\t'\\\\n\\\\tand make sure you add execute permissions'\\n\\t\\t\\t\\n\\t\\texstring_martinize = 'except: cannot find martinize at '+gmxpaths['martinize']+\\\\\\n\\t\\t\\t'\\\\nconsider using the following syntax to download:'+\\\\\\n\\t\\t\\t'\\\\n\\\\twget http://md.chem.rug.nl/cgmartini/images/tools/martinize/martinize-2.4/martinize.py'+\\\\\\n\\t\\t\\t'\\\\n\\\\tor navigate to http://md.chem.rug.nl/cgmartini/index.php/tools2/proteins-and-bilayers'+\\\\\\n\\t\\t\\t'\\\\n\\\\tand make sure you add execute permissions'\\n\\t\\n\\t\\t#---first test to see if executables are available\\n\\t\\tif not os.path.isfile(os.path.expanduser(gmxpaths['dssp'])): raise Exception(exstring_dssp)\\n\\t\\tif not os.path.isfile(os.path.expanduser(gmxpaths['martinize'])): raise Exception(exstring_martinize)\\t\\n\\t\\n\\t\\tcmd = [gmxpaths['martinize'],\\n\\t\\t\\t'-f system-input.pdb',\\n\\t\\t\\t'-o system-original.top',\\n\\t\\t\\t'-x protein-cg.pdb',\\n\\t\\t\\t'-ff martini22','-ed',\\n\\t\\t\\t'-dssp '+gmxpaths['dssp']]\\n\\t\\tcall(cmd,logfile='log-martinize',cwd=self.rootdir)\\n\\t\\t\\n\\t\\twith open(self.rootdir+'system-original.top') as fp: lines = fp.readlines()\\n\\t\\tself.itp_protein = [l.split()[0] for l in lines if l[:7] == 'Protein']\\n\\n\\t\\t#---note that this section leaves out lipids\\n\\t\\tself.itp_lipid = []\\n\\t\\t\\n\\t\\t#---note that this method is currently set to only simulate one protein\\n\\t\\tself.nprots = [1]\\n\\t\\tself.write_topology_protein('vacuum.top')\\n\\t\\t\\n\\t\\tcmd = [gmxpaths['editconf'],\\n\\t\\t\\t'-f protein-cg.pdb',\\n\\t\\t\\t'-o vacuum-alone.gro']\\n\\t\\tcall(cmd,logfile='log-editconf-convert',cwd=self.rootdir)\\n\\t\\n\\t\\tprint \\\"building box with \\\"+str(self.settings['wbuffer'])+'nm of water'\\n\\t\\tcmd = [gmxpaths['editconf'],\\n\\t\\t\\t'-f vacuum-alone.gro',\\n\\t\\t\\t'-d '+str(self.settings['wbuffer']),\\n\\t\\t\\t'-o vacuum.gro','-c']\\n\\t\\tcall(cmd,logfile='log-editconf-vacuum',cwd=self.rootdir)\\n\\t\\t\\n\\t\\tself.minimization_method('vacuum')\",\n \"def generate_files(self):\\n\\t\\tapply_stemmer, xml_file, query_file, expected_file = self.read_config_file()\\n\\t\\tself.generate_query_file(query_file, xml_file, apply_stemmer)\\n\\t\\tself.generate_expected_file(expected_file, xml_file)\\n\\t\\tlogging.info('FINALIZADO: MÓDULO PROCESSADOR DE CONSULTAS')\",\n \"def writeNew(self,masters=[],mtime=0):\\n tes3 = Tes3()\\n tes3.hedr = Tes3_Hedr('HEDR',0)\\n if self.isEsp(): tes3.hedr.fileType = 0\\n elif self.isEsm(): tes3.hedr.fileType = 1\\n elif self.isEss(): tes3.hedr.fileType = 32\\n for master in masters:\\n tes3.masters.append((master,modInfos[master].size))\\n tes3.hedr.setChanged()\\n tes3.setChanged()\\n #--Write it\\n path = os.path.join(self.dir,self.name)\\n out = file(path,'wb')\\n tes3.getSize()\\n tes3.dump(out)\\n out.close()\\n self.setMTime(mtime)\",\n \"def create_weka_mfcc_13():\\n global ARGS\\n\\n ## ten thu muc can trich chon vector dac trung (RLS, LMS, NLMS, Kalman, Non)\\n name = '';\\n fout = open('weka/MFCC78_TUNNING_{}_dataset.arff'.format(name), 'w')\\n fout.write('@RELATION {}_dataset\\\\n\\\\n'.format(name))\\n\\n fout.write('@ATTRIBUTE MEAN_MFCC1\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC2\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC3\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC4\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC5\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC6\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC7\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC8\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC9\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC10\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC11\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC12\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCC13\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD1\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD2\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD3\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD4\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD5\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD6\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD7\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD8\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD9\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD10\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD11\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD12\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCD13\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD1\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD2\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD3\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD4\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD5\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD6\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD7\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD8\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD9\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD10\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD11\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD12\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE MEAN_MFCCDD13\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC1\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC2\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC3\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC4\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC5\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC6\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC7\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC8\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC9\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC10\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC11\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC12\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCC13\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD1\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD2\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD3\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD4\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD5\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD6\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD7\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD8\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD9\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD10\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD11\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD12\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCD13\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD1\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD2\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD3\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD4\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD5\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD6\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD7\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD8\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD9\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD10\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD11\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD12\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE STD_MFCCDD13\\tREAL\\\\n')\\n fout.write('@ATTRIBUTE class \\t{'+ARGS.labels+'}\\\\n\\\\n')\\n \\n fout.write('@DATA\\\\n')\\n\\n ## cua so\\n windowing = Windowing(type='hamming',\\n size=1104,\\n zeroPhase=False)\\n \\n ## quang pho\\n spectrum = Spectrum(size=1104)\\n\\n ##khoi tao MFCC\\n mfcc = MFCC(highFrequencyBound=4000, ## gioi han tren cua tan so\\n inputSize=201, \\t\\t\\t ## kich thuoc pho dau vao\\n lowFrequencyBound=0,\\t ## gioi han duoi cua tan so\\n numberBands=40,\\t\\t\\t ## so luong cac dai Mels trong bo loc\\n numberCoefficients=13, ## so luong dau ra cac he so Mel\\n sampleRate=16000)\\t\\t ## tan so lay mau\\n\\n for label in ARGS.labels.split(','): ## duyet cac thu muc giong voi ten nhan\\n\\n ## dia chi thu muc\\n dir = os.path.join(ARGS.dir, label)\\n\\n logging.info('Access folder <{}>'.format(dir))\\n\\n for file in sorted(os.listdir(dir)):\\n\\n \\t## duyet cac file .wav\\n if file.endswith('.wav'):\\n logging.info('Process <{}>'.format(file))\\n path = os.path.join(dir, file)\\n \\n ## doc file am thanh\\n loader = MonoLoader(filename=path, sampleRate=ARGS.sampleRate)\\n audio = loader()\\n cnt = 0\\n\\n for window in FrameGenerator(audio, \\n frameSize=ARGS.window_length*ARGS.sampleRate/1000, \\n hopSize=ARGS.window_stride*ARGS.sampleRate/1000, \\n startFromZero=True):\\n mfccs = []\\n for frame in FrameGenerator(window, \\n frameSize=ARGS.frame_length*ARGS.sampleRate/1000, \\n hopSize=ARGS.frame_stride*ARGS.sampleRate/1000, \\n startFromZero=True):\\n s = spectrum(windowing(frame))\\n\\n _, m = mfcc(s)\\n\\n m_delta = librosa.feature.delta(m, order=1) ## dao ham bac 1\\n m_delta_delta = librosa.feature.delta(m, order=2) ## dao ham bac 2\\n\\n m_all = np.concatenate((m, m_delta, m_delta_delta), axis=0) ## them vao chuoi\\n mfccs.append(m_all)\\n mfccs = np.array(mfccs)\\n mfccs_mean = np.mean(mfccs, axis=0)\\n mfccs_std = np.std(mfccs, axis=0)\\n feat = np.concatenate((mfccs_mean, mfccs_std), axis=0).tolist()\\n str_feat = [str(x) for x in feat]\\n line = ','.join(str_feat)+','+label\\n fout.write(line+'\\\\n')\\n cnt = cnt+1\\n logging.info('{} samples'.format(cnt))\",\n \"def make_libfile():\\n # wfc3_obsmodes_uvis\\n wfc3_uvis = [\\n \\\"f218w\\\",\\n \\\"f225w\\\",\\n \\\"f275w\\\",\\n \\\"f336w\\\",\\n \\\"f390m\\\",\\n \\\"f390w\\\",\\n \\\"f410m\\\",\\n \\\"f438w\\\",\\n \\\"f467m\\\",\\n \\\"f475w\\\",\\n \\\"f547m\\\",\\n \\\"f555w\\\",\\n \\\"f606w\\\",\\n \\\"f621m\\\",\\n \\\"f625w\\\",\\n \\\"f689m\\\",\\n \\\"f763m\\\",\\n \\\"f775w\\\",\\n \\\"f814w\\\",\\n \\\"f845m\\\",\\n ]\\n\\n wfc3_ir = [\\n \\\"f098m\\\",\\n \\\"f105w\\\",\\n \\\"f110w\\\",\\n \\\"f125w\\\",\\n \\\"f127m\\\",\\n \\\"f139m\\\",\\n \\\"f140w\\\",\\n \\\"f153m\\\",\\n \\\"f160w\\\",\\n ]\\n\\n wfpc2 = [\\n \\\"f122m\\\",\\n \\\"f157w\\\",\\n \\\"f336w\\\",\\n \\\"f410m\\\",\\n \\\"f467m\\\",\\n \\\"f547m\\\",\\n \\\"f439w\\\",\\n \\\"f569w\\\",\\n \\\"f675w\\\",\\n \\\"f791w\\\",\\n \\\"f170w\\\",\\n \\\"f185w\\\",\\n \\\"f218w\\\",\\n \\\"f255w\\\",\\n \\\"f300w\\\",\\n \\\"f380w\\\",\\n \\\"f555w\\\",\\n \\\"f622w\\\",\\n \\\"f450w\\\",\\n \\\"f606w\\\",\\n \\\"f702w\\\",\\n \\\"f814w\\\",\\n ]\\n\\n acs_wfc = [\\n \\\"f435w\\\",\\n \\\"f475w\\\",\\n \\\"f550m\\\",\\n \\\"f555w\\\",\\n \\\"f606w\\\",\\n \\\"f625w\\\",\\n \\\"f775w\\\",\\n \\\"f814w\\\",\\n ]\\n # galex\\n galex = [\\\"fuv\\\", \\\"nuv\\\"]\\n\\n # Open hd5 file for writing\\n hf = h5py.File(__ROOT__ + \\\"filters.hd5\\\", \\\"w\\\")\\n\\n # Create group for nice hierarchical structure\\n f = hf.create_group(\\\"filters\\\")\\n\\n # Define arrays for \\\"contents\\\" / descriptive information\\n tablenames = []\\n observatories = []\\n instruments = []\\n names = []\\n norms = []\\n cwaves = []\\n pwaves = []\\n comments = []\\n\\n # Loop through WFC3_UVIS filters\\n for filt in wfc3_uvis:\\n\\n # define uvis 1 and uvis2 modes\\n mode_1 = \\\"wfc3, uvis1, \\\" + filt\\n mode_2 = \\\"wfc3, uvis2, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_WFC3_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFC3\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of uvis1 and uvis2\\\")\\n\\n # Loop through WFC3_IR filters\\n for filt in wfc3_ir:\\n\\n # define ir mode\\n mode = \\\"wfc3, ir, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp = stsyn.band(mode)\\n\\n # extract the wavelength array\\n wave = bp.waveset\\n\\n # define the filter name\\n filter_name = \\\"HST_WFC3_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFC3\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"\\\")\\n\\n # Loop through WFPC2 filters\\n for filt in wfpc2:\\n\\n # define chips 1, 2, 3, 4 modes\\n mode_1 = \\\"wfpc2, 1, \\\" + filt\\n mode_2 = \\\"wfpc2, 2, \\\" + filt\\n mode_3 = \\\"wfpc2, 3, \\\" + filt\\n mode_4 = \\\"wfpc2, 4, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n bp_3 = stsyn.band(mode_3)\\n bp_4 = stsyn.band(mode_4)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave), bp_3(wave), bp_4(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_WFPC2_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFPC2\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of 1, 2, 3, 4\\\")\\n\\n # Loop through ACS filters\\n for filt in acs_wfc:\\n\\n # define wfc1, wfc2 modes\\n mode_1 = \\\"acs, wfc1, \\\" + filt\\n mode_2 = \\\"acs, wfc2, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_ACS_WFC_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"ACS_WFC\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of wfc1 and wfc2\\\")\\n\\n # Loop through GALEX filters:\\n for filt in galex:\\n # define ir mode\\n mode = \\\"galex,\\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp = stsyn.band(mode)\\n\\n # extract the wavelength array\\n wave = bp.waveset\\n\\n # define the filter name\\n filter_name = \\\"GALEX_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"GALEX\\\")\\n instruments.append(\\\"GALEX\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"\\\")\\n\\n # smash the contents arrays together\\n contents = np.array(\\n list(\\n zip(\\n tablenames,\\n observatories,\\n instruments,\\n names,\\n norms,\\n cwaves,\\n pwaves,\\n comments,\\n )\\n ),\\n dtype=[\\n (\\\"TABLENAME\\\", \\\"S40\\\"),\\n (\\\"OBSERVATORY\\\", \\\"S30\\\"),\\n (\\\"INSTRUMENT\\\", \\\"S30\\\"),\\n (\\\"NAME\\\", \\\"S10\\\"),\\n (\\\"NORM\\\", \\\"<f8\\\"),\\n (\\\"CWAVE\\\", \\\"<f8\\\"),\\n (\\\"PWAVE\\\", \\\"<f8\\\"),\\n (\\\"COMMENT\\\", \\\"S100\\\"),\\n ],\\n )\\n\\n # add the contents array as an hd5 dataset\\n hf.create_dataset(\\\"content\\\", data=contents)\\n\\n # close the file\\n hf.close()\",\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 gen_metars(obs, filename, convids=False):\\n mtime = datetime.datetime.utcnow().strftime(\\\"%d%H%M\\\")\\n thres = datetime.datetime.utcnow() - datetime.timedelta(hours=3)\\n thres = thres.replace(tzinfo=pytz.UTC)\\n fp = open(filename, 'w')\\n fp.write(\\\"\\\\001\\\\015\\\\015\\\\012001\\\\n\\\")\\n fp.write(\\\"SAUS43 KDMX %s\\\\015\\\\015\\\\012METAR\\\\015\\\\015\\\\012\\\" % (mtime, ))\\n for sid in obs:\\n ob = obs[sid]\\n if ob['valid'] < thres:\\n continue\\n if sid in [\\\"RIOI4\\\", \\\"ROSI4\\\", \\\"RSMI4\\\", 'RMCI4']:\\n continue\\n metarid = sid[:4]\\n remoteid = NT.sts[sid]['remote_id']\\n if convids:\\n metarid = RWIS2METAR.get(\\\"%02i\\\" % (remoteid,), 'XXXX')\\n temptxt = \\\"\\\"\\n t_temptxt = \\\"\\\"\\n windtxt = \\\"\\\"\\n if ob.get('sknt') is not None and ob.get('drct') is not None:\\n windtxt = METARwind(ob['sknt'], ob['drct'], ob.get('gust'))\\n if obs.get('tmpf') is not None and obs.get('dwpf') is not None:\\n m_tmpc, t_tmpc = METARtemp(temperature(ob['tmpf'], 'F').value('C'))\\n m_dwpc, t_dwpc = METARtemp(temperature(ob['dwpf'], 'F').value('C'))\\n temptxt = \\\"%s/%s\\\" % (m_tmpc, m_dwpc)\\n t_temptxt = \\\"T%s%s \\\" % (t_tmpc, t_dwpc)\\n fp.write((\\\"%s %s %s %s RMK AO2 %s%s\\\\015\\\\015\\\\012\\\"\\n \\\"\\\") % (metarid, ob['valid'].strftime(\\\"%d%H%MZ\\\"),\\n windtxt, temptxt, t_temptxt, \\\"=\\\"))\\n\\n fp.write(\\\"\\\\015\\\\015\\\\012\\\\003\\\")\\n fp.close()\",\n \"def make_log():\\n log_file = os.path.join(phys_dir,'ge_phys2bids_'+datetime.now().strftime(\\\"%Y-%m-%d_%H-%M-%S\\\")+'.log')\\n with open(log_file,'w') as log:\\n log.write('-------- GE phys2bids --------\\\\n\\\\n')\\n log.write('DICOM directory: %s\\\\n'%dcm_dir)\\n log.write('Physiology directory: %s\\\\n'%phys_dir)\\n log.write('Output directory: %s\\\\n\\\\n'%out_dir)\\n log.write('%d EPI files were found\\\\n\\\\n'%len(dcm_dict))\\n for rn in dcm_dict.keys():\\n log.write('------------------------------\\\\n')\\n log.write('%s\\\\n'%dcm_dict[rn]['out_name'])\\n log.write('Start time: %s\\\\n'%dcm_dict[rn]['start_time'].strftime(\\\"%Y-%m-%d %H:%M:%S\\\"))\\n log.write('End time: %s\\\\n'%dcm_dict[rn]['end_time'].strftime(\\\"%Y-%m-%d %H:%M:%S\\\"))\\n log.write('PPG file: %s\\\\n'%dcm_dict[rn]['ppg_file'])\\n log.write('Respiration file: %s\\\\n'%dcm_dict[rn]['resp_file'])\\n log.write('ECG file: %s\\\\n'%dcm_dict[rn]['ecg_file'])\\n log.write('------------------------------\\\\n\\\\n')\",\n \"def make_data(self, verbose=False):\\n if self.h0:\\n self.make_cff(verbose)\\n else:\\n logger.info(\\\"Got h0=0, not writing an injection .cff file.\\\")\\n self.run_makefakedata()\",\n \"def create_CGfiles_using_martinizepy(Ctermini_type, set_charge, name):\\n\\n os.system('cp %s/%s ./'%(this_path,martini_itp))\\n\\n os.system('python2 %s/martinize.py -f %s_aa.pdb \\\\\\n -o %s.top -x %s.pdb -name %s -ff martini22 \\\\\\n -nt \\\\\\n -ss CCCCCCCCCCCC '%(this_path,name,name,name,name))\\n\\n\\n # Collect lines defining atoms\\n lines_atoms = []\\n break1,break2 = None,None\\n with open('%s.itp'%name, 'r') as f:\\n data = f.readlines()\\n start = False\\n for i,line in enumerate(data):\\n if '[ atoms ]' in line:\\n start = True\\n break1 = i+1\\n continue\\n if start:\\n if line.split()==[]:\\n start = False\\n break2 = i\\n break\\n lines_atoms = lines_atoms + [line]\\n \\n \\n\\n # Modify lines_atoms as per Ctermini\\n charged_thusfar = 0\\n if Ctermini_type.upper() == 'OH':\\n for i in range(len(lines_atoms))[::-1]:\\n if 'BB' in lines_atoms[i]:\\n lines_atoms[i] = lines_atoms[i].replace(' 0.0', '-1.0')\\n lines_atoms[i] = lines_atoms[i].replace('P5', 'Qa') \\n charged_thusfar += -1\\n break\\n\\n\\n # modify charge of side chains,\\n # CURRENTLY only neutralizes if Qd SC is found (deprotonation)\\n neutralize_ahead = False\\n if set_charge < 0: # deprotonation\\n for i in range(len(lines_atoms))[::-1]:\\n if charged_thusfar == set_charge:\\n neutralize_ahead = True\\n \\n if ('SC' in lines_atoms[i]) and ('-1.0' in lines_atoms[i]):\\n if 'Qa' not in lines_atoms[i]:\\n raise RuntimeError('-1.0 charge without Qa bead is found')\\n if neutralize_ahead:\\n lines_atoms[i] = lines_atoms[i].replace('-1.0', ' 0.0')\\n lines_atoms[i] = lines_atoms[i].replace('Qa', 'P1')\\n else:\\n charged_thusfar += -1\\n\\n if ('SC' in lines_atoms[i]) and (' 1.0' in lines_atoms[i]):\\n if 'Qd' not in lines_atoms[i]:\\n raise RuntimeError('1.0 charge without Qd bead is found')\\n lines_atoms[i] = lines_atoms[i].replace('1.0', ' 0.0')\\n lines_atoms[i] = lines_atoms[i].replace('Qd', 'P1')\\n\\n if charged_thusfar != set_charge:\\n raise ValueError('Peptide sequence could not be used to achieve set_charge')\\n\\n elif set_charge == 0: # protonation-deprotonation\\n if Ctermini_type == 'OH':\\n raise ValueError('Protonation after deprotonation does not make sense')\\n \\n for i in range(len(lines_atoms))[::-1]:\\n if ('SC' in lines_atoms[i]) and ('-1.0' in lines_atoms[i]):\\n if 'Qa' not in lines_atoms[i]:\\n raise RuntimeError('-1.0 charge without Qa bead is found')\\n lines_atoms[i] = lines_atoms[i].replace('-1.0', ' 0.0')\\n lines_atoms[i] = lines_atoms[i].replace('Qa', 'P1')\\n\\n if ('SC' in lines_atoms[i]) and (' 1.0' in lines_atoms[i]):\\n if 'Qd' not in lines_atoms[i]:\\n raise RuntimeError('1.0 charge without Qd bead is found')\\n lines_atoms[i] = lines_atoms[i].replace('1.0', ' 0.0')\\n lines_atoms[i] = lines_atoms[i].replace('Qd', 'P1')\\n \\n elif set_charge > 0: # protonation\\n if Ctermini_type == 'OH':\\n raise ValueError('Protonation after deprotonation does not make sense')\\n\\n for i in range(len(lines_atoms))[::-1]:\\n if charged_thusfar == set_charge:\\n neutralize_ahead = True\\n\\n if ('SC' in lines_atoms[i]) and ('-1.0' in lines_atoms[i]):\\n if 'Qa' not in lines_atoms[i]:\\n raise RuntimeError('-1.0 charge without Qa bead is found')\\n lines_atoms[i] = lines_atoms[i].replace('-1.0', ' 0.0')\\n lines_atoms[i] = lines_atoms[i].replace('Qa', 'P1')\\n \\n if ('SC' in lines_atoms[i]) and (' 1.0' in lines_atoms[i]):\\n if 'Qd' not in lines_atoms[i]:\\n raise RuntimeError('1.0 charge without Qd bead is found')\\n if neutralize_ahead:\\n lines_atoms[i] = lines_atoms[i].replace('1.0', ' 0.0')\\n lines_atoms[i] = lines_atoms[i].replace('Qd', 'P1')\\n else:\\n charged_thusfar += 1\\n \\n if charged_thusfar != set_charge:\\n raise ValueError('Peptide sequence could not be used to achieve set_charge')\\n\\n\\n data_new = ''\\n for line in data[:break1]:\\n data_new += line\\n for line in lines_atoms:\\n data_new += line\\n for line in data[break2:]:\\n data_new += line\\n \\n \\n with open('%s.itp'%name, 'w') as f:\\n f.write(data_new)\",\n \"def createCfg_prep_dcard(self, jobOptions):\\n category_output = self.channel\\n if jobOptions['label']:\\n category_output += \\\"_%s\\\" % jobOptions['label']\\n lines = []\\n lines.append(\\\"process.fwliteInput.fileNames = cms.vstring('%s')\\\" % jobOptions['inputFile'])\\n lines.append(\\\"process.fwliteOutput.fileName = cms.string('%s')\\\" % jobOptions['datacardFile'])\\n lines.append(\\\"process.prepareDatacards.processesToCopy = cms.vstring(%s)\\\" % self.prep_dcard_processesToCopy)\\n lines.append(\\\"process.prepareDatacards.signals = cms.vstring(%s)\\\" % self.prep_dcard_signals)\\n lines.append(\\\"process.prepareDatacards.makeSubDir = cms.bool(True)\\\")\\n lines.append(\\\"process.prepareDatacards.categories = cms.VPSet(\\\")\\n for charge in [\\\"OS\\\", \\\"SS\\\"]:\\n for ptEtaBin in [\\n \\\"BB_LL\\\", \\\"BB_ML\\\", \\\"BB_MM\\\", \\\"BB_HL\\\", \\\"BB_HM\\\", \\\"BB_HH\\\",\\n \\\"EE_LL\\\", \\\"EE_ML\\\", \\\"EE_MM\\\", \\\"EE_HL\\\", \\\"EE_HM\\\", \\\"EE_HH\\\",\\n \\\"BE_LL\\\", \\\"BE_ML\\\", \\\"EB_ML\\\",\\\"BE_MM\\\", \\\"BE_HL\\\", \\\"EB_HL\\\",\\n \\\"BE_HM\\\", \\\"EB_HM\\\", \\\"BE_HH\\\", \\\"total\\\",\\n ]:\\n lines.append(\\\" cms.PSet(\\\")\\n lines.append(\\\" input = cms.string('%s/%s'),\\\" % (charge, ptEtaBin))\\n lines.append(\\\" output = cms.string('ttH_%s_%s_%s')\\\" % (self.channel, charge, ptEtaBin))\\n lines.append(\\\" ),\\\")\\n lines.append(\\\")\\\")\\n lines.append(\\\"process.prepareDatacards.histogramToFit = cms.string('%s')\\\" % jobOptions['histogramToFit'])\\n lines.append(\\\"process.prepareDatacards.sysShifts = cms.vstring(%s)\\\" % systematics.muon_E)\\n create_cfg(self.cfgFile_prep_dcard, jobOptions['cfgFile_modified'], lines)\",\n \"def write_data_card(spec, data_card, channels, path):\\n with open(path, \\\"w\\\") as f:\\n f.write(f\\\"imax {str(size(data_card.bins))}\\\" + \\\"\\\\n\\\")\\n f.write(\\n \\\"jmax \\\"\\n + str(size(data_card.processes) - size(data_card.isSignal.keys()))\\n + \\\"\\\\n\\\"\\n )\\n f.write(f\\\"kmax {str(size(data_card.systs, 0))}\\\" + \\\"\\\\n\\\")\\n\\n if data_card.hasShapes:\\n for channel in data_card.shapeMap.keys():\\n for sample in data_card.shapeMap[channel].keys():\\n f.write(\\n f\\\"shapes {sample} {channel} {data_card.shapeMap[channel][sample][0]} {data_card.shapeMap[channel][sample][1]}\\\"\\n )\\n if size(data_card.shapeMap[channel][sample]) > 2:\\n f.write(f\\\" {data_card.shapeMap[channel][sample][2]}\\\" + \\\"\\\\n\\\")\\n else:\\n f.write(\\\"\\\\n\\\")\\n\\n f.write(\\\"\\\\n---------------------------------\\\\n\\\")\\n f.write(\\\"bin \\\")\\n for bin in data_card.obs.keys():\\n f.write(f\\\"{bin} \\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"observation \\\")\\n for channel in data_card.obs.keys():\\n f.write(f\\\"{str(data_card.obs[channel])} \\\")\\n f.write(\\\"\\\\n---------------------------------\\\\n\\\")\\n f.write(\\\"bin \\\")\\n for channel in data_card.obs.keys():\\n for sample in data_card.exp[channel].keys():\\n f.write(f\\\"{channel} \\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"process \\\")\\n for channel in data_card.bins:\\n for sample in data_card.exp[channel].keys():\\n f.write(f\\\"{sample} \\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"process \\\")\\n for channel in data_card.bins:\\n for sample in data_card.exp[channel].keys():\\n if sample in data_card.signals:\\n f.write(f\\\"{str(-1 * data_card.processes.index(sample))} \\\")\\n else:\\n f.write(f\\\"{str(data_card.processes.index(sample) + 1)} \\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"rate \\\")\\n for channel in data_card.bins:\\n for sample in data_card.exp[channel].keys():\\n\\n f.write(f\\\"{str(data_card.exp[channel][sample])} \\\")\\n f.write(\\\"\\\\n---------------------------------\\\\n\\\")\\n for syst in data_card.systs:\\n f.write(f\\\"{syst[0]} {syst[2]} \\\")\\n for bin in syst[4].keys():\\n for sample in data_card.exp[bin].keys():\\n if syst[4][bin][sample] != 0:\\n f.write(f\\\"{str(syst[4][bin][sample])} \\\")\\n else:\\n f.write(\\\"- \\\")\\n\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"\\\\n---------------------------------\\\\n\\\")\\n for cAp in data_card.rateParams.keys():\\n _dir = cAp.split(\\\"AND\\\")\\n for i in range(size(data_card.rateParams[cAp], 0)):\\n if size(data_card.rateParams[cAp][i][0]) > 3:\\n f.write(\\n f\\\"{str(data_card.rateParams[cAp][i][0][0])} rateParam {_dir[0]} {_dir[1]} {str(data_card.rateParams[cAp][i][0][1])} {data_card.rateParams[cAp][i][0][3]}\\\"\\n )\\n else:\\n f.write(\\n f\\\"{str(data_card.rateParams[cAp][i][0][0])} rateParam {_dir[0]} {_dir[1]} {str(data_card.rateParams[cAp][i][0][1])}\\\"\\n )\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"\\\\n---------------------------------\\\\n\\\")\\n for idxc, channel in enumerate(channels):\\n if (\\n channel in data_card.binParFlags.keys()\\n and data_card.binParFlags[channel] == True\\n ):\\n # double check to be safe\\n shapesys = False\\n staterror = False\\n for sample in spec[\\\"channels\\\"][idxc][\\\"samples\\\"]:\\n mod_types = [mod[\\\"type\\\"] for mod in sample[\\\"modifiers\\\"]]\\n if \\\"shapesys\\\" in mod_types:\\n shapesys = True\\n elif \\\"staterror\\\" in mod_types:\\n staterror = True\\n\\n if shapesys:\\n f.write(f\\\"{channel} autoMCStats 100000 0 2\\\" + \\\"\\\\n\\\")\\n if staterror:\\n f.write(f\\\"{channel} autoMCStats 0 0 2\\\" + \\\"\\\\n\\\")\",\n \"def get_data(output_dir: Path = Path(\\\"raw_data\\\")) -> None:\\n\\n files = [\\n \\\"alignment.sorted.bam\\\",\\n \\\"names-mdmg.dmp\\\",\\n \\\"nodes-mdmg.dmp\\\",\\n \\\"acc2taxid.map.gz\\\",\\n ]\\n\\n for file in files:\\n with resources.path(\\\"metaDMG.data\\\", file) as p:\\n file_path = p\\n\\n target_path = Path(output_dir) / file\\n target_path.parent.mkdir(parents=True, exist_ok=True)\\n shutil.copy(file_path, target_path)\",\n \"def generate_setups(self,filename=DEFAULT_FILENAME):\\n \\n self._create_main_shape()\\n self._create_margin_shape()\\n\\n for section, setup in self.setups.iteritems():\\n self._generate_section_structures(setup['distance'],\\n setup['radius'],\\n setup['structure'],\\n section)\\n self.write(filename)\",\n \"def writeFiles(self, directory = \\\"./\\\"):\\n self.mass = []\\n self.zero = 0\\n self.natoms = self.numMonomer\\n self.nangles = 0\\n self.ndihedrals = 0\\n\\n self.ntypes = 4\\n\\n # set masses of all beads to be 1\\n # in principle, the mass of counterions and salt ions should be smaller\\n # expect this difference will no matter in terms of complexation of polyelectrolytes\\n for i in range(self.ntypes):\\n self.mass.append(1)\\n\\n\\n\\n self.bdtypes = 1\\n self.angtypes = 0\\n self.dihtypes = 0\\n self.improtypes = 0\\n\\n iFileLammpsName = directory + \\\"data.pe.la{0}.na{1}.lc{2}.nc{3}.rho{4}.r{5}.lammps\\\".\\\\\\n format(self.lenPa, self.numPa, self.lenPc, self.numPc, self.volRatio, self.chargeRepeat)\\n iFileLammps = open(iFileLammpsName, 'w')\\n\\n iFileXYZName = directory + \\\"data.pe.la{0}.na{1}.lc{2}.nc{3}.rho{4}.r{5}.xyz\\\".\\\\\\n format(self.lenPa, self.numPa, self.lenPc, self.numPc, self.volRatio, self.chargeRepeat)\\n iFileXYZ = open(iFileXYZName, 'w' )\\n\\n iFileXYZ.write(\\\"{0}\\\\n\\\".format(self.natoms))\\n iFileXYZ.write(\\\"data.polyelectrolyte.xyz\\\\n\\\")\\n\\n iFileLammpsHeader = \\\"data file for mixtures of charged polymer chains\\\\n\\\" + \\\\\\n \\\"\\\\n\\\" + \\\\\\n \\\"{0:10d} atoms\\\\n\\\".format(self.natoms) + \\\\\\n \\\"{0:10d} bonds\\\\n\\\".format(self.numBonds) + \\\\\\n \\\"{0:10d} angles\\\\n\\\".format(self.nangles) + \\\\\\n \\\"{0:10d} dihedrals\\\\n\\\".format(self.ndihedrals) + \\\\\\n \\\"{0:10d} impropers\\\\n\\\".format(self.zero) + \\\\\\n \\\"\\\\n\\\" +\\\\\\n \\\"{0:10d} atom types\\\\n\\\".format(self.ntypes) + \\\\\\n \\\"{0:10d} bond types\\\\n\\\".format(self.bdtypes) + \\\\\\n \\\"{0:10d} angle types\\\\n\\\".format(self.angtypes) + \\\\\\n \\\"{0:10d} dihedral types\\\\n\\\".format(self.dihtypes) + \\\\\\n \\\"{0:10d} improper types\\\\n\\\".format(self.improtypes) + \\\\\\n \\\"\\\\n\\\" + \\\\\\n \\\" {0:16.8f} {1:16.8f} xlo xhi\\\\n\\\".format(self.lx, self.hx) + \\\\\\n \\\" {0:16.8f} {1:16.8f} ylo yhi\\\\n\\\".format(self.ly, self.hy) + \\\\\\n \\\" {0:16.8f} {1:16.8f} zlo zhi\\\\n\\\".format(self.lz, self.hz) + \\\\\\n \\\"\\\\n\\\" + \\\\\\n \\\"Masses\\\\n\\\" + \\\\\\n \\\"\\\\n\\\"\\n\\n iFileLammps.write(iFileLammpsHeader)\\n for i in range(self.ntypes):\\n iFileLammps.write( \\\"{0} {1:8.3f}\\\\n\\\".format(i+1, self.mass[i]))\\n\\n iFileLammps.write(\\\"\\\\nAtoms\\\\n\\\\n\\\")\\n \\n \\n\\n for i in range(self.natoms):\\n if self.atomsType[i] == 1 or self.atomsType[i] == 3:\\n iFileXYZ.write(\\\"S {0} {1} {2}\\\\n\\\".format(self.atomsCoords[i][0], \\\\\\n self.atomsCoords[i][1], \\\\\\n self.atomsCoords[i][2]))\\n elif self.atomsType[i] == 2:\\n iFileXYZ.write(\\\"P {0} {1} {2}\\\\n\\\".format(self.atomsCoords[i][0], \\\\\\n self.atomsCoords[i][1], \\\\\\n self.atomsCoords[i][2]))\\n elif self.atomsType[i] == 4:\\n iFileXYZ.write(\\\"N {0} {1} {2}\\\\n\\\".format(self.atomsCoords[i][0], \\\\\\n self.atomsCoords[i][1], \\\\\\n self.atomsCoords[i][2]))\\n elif self.atomsType[i] == 5:\\n iFileXYZ.write(\\\"A {0} {1} {2}\\\\n\\\".format(self.atomsCoords[i][0], \\\\\\n self.atomsCoords[i][1], \\\\\\n self.atomsCoords[i][2]))\\n elif self.atomsType[i] == 6:\\n iFileXYZ.write(\\\"C {0} {1} {2}\\\\n\\\".format(self.atomsCoords[i][0], \\\\\\n self.atomsCoords[i][1], \\\\\\n self.atomsCoords[i][2]))\\n elif self.atomsType[i] == 7:\\n iFileXYZ.write(\\\"I {0} {1} {2}\\\\n\\\".format(self.atomsCoords[i][0], \\\\\\n self.atomsCoords[i][1], \\\\\\n self.atomsCoords[i][2]))\\n elif self.atomsType[i] == 8:\\n iFileXYZ.write(\\\"K {0} {1} {2}\\\\n\\\".format(self.atomsCoords[i][0], \\\\\\n self.atomsCoords[i][1], \\\\\\n self.atomsCoords[i][2]))\\n\\n iFileLammps.write(\\\"{0} {1} {2} {3} {4} {5} {6}\\\\n\\\".format(i+1, \\\\\\n self.molId[i], \\\\\\n self.atomsType[i], \\\\\\n self.atomsCharge[i], \\\\\\n self.atomsCoords[i][0], \\\\\\n self.atomsCoords[i][1], \\\\\\n self.atomsCoords[i][2]))\\n\\n iFileLammps.write(\\\"\\\\nBonds\\\\n\\\\n\\\")\\n for i in range(self.numBonds):\\n iFileLammps.write(\\\"{0} 1 {1} {2}\\\\n\\\".format(i+1, self.bondList[i][0], self.bondList[i][1]))\\n\\n iFileXYZ.close()\\n iFileLammps.close()\",\n \"def dctCreateDD(pdct, dirName, msgBufSize):\\n return _dctmcc.dctCreateDD(pdct, dirName, msgBufSize)\",\n \"def save(cartesian, charge, name, comment='',\\n mop_dir=str(os.getcwd()), csv_dir=str(os.getcwd()),\\n mop_file=True, csv_file=True):\\n # Preparation\\n del cartesian['num']\\n coordinates = 'x', 'y', 'z'\\n columns = {'1_1': 2, '1_2': 4, '1_3': 6}\\n for coord in coordinates:\\n cartesian[coord] = cartesian[coord].astype(float)\\n\\n # .mop block\\n if mop_file is True:\\n cartesian = cartesian.round(decimals=5)\\n for column in columns:\\n cartesian.insert(columns[column], column, 0, True)\\n\\n # .mop constructor\\n with open(mop_dir + 'sp_' + name + '.mop', 'a') as mop:\\n mop.writelines('AUX LARGE CHARGE=' + charge + ' SINGLET NOOPT PM6-DH2X' + '\\\\n')\\n mop.writelines(comment + '\\\\n'*2)\\n mop.writelines(cartesian.to_string(header=False, index=False))\\n mop.writelines('\\\\n'*2)\\n\\n # .csv block\\n if csv_file is True:\\n cartesian = cartesian.round(decimals=4)\\n for column in columns:\\n if mop_file is True:\\n del cartesian[column]\\n cartesian.insert(columns[column], column, 1, True)\\n cartesian.to_csv(csv_dir + name + '.csv')\",\n \"def CreateDirs(self):\\n# First, create a list of directories.\\n dnames = []\\n tags = ['', '_m', '_mf']\\n for entry in self.info.keys():\\n if self.info[entry]['type'] == 'epi':\\n for tag in tags:\\n fname = self.info[entry].get('imgfile%s' % tag, None)\\n if fname is not None:\\n dnames.append(os.path.dirname(fname))\\n else:\\n if self.info[entry].get('outdir',None) is not None:\\n dnames.append(self.info[entry]['outdir'])\\n\\n# Create them if they don't already exist.\\n for dname in dnames:\\n if not os.path.exists(dname):\\n self.MakeDir(dname)\\n if self.verbose:\\n print 'mkdir %s' % dname\",\n \"def export_md(clips):\\n for book in clips:\\n lines = []\\n for pos in sorted(clips[book]):\\n lines.append((clips[book][pos] + ' **P%s**' %pos).encode('utf-8'))\\n\\n filename = os.path.join(OUTPUT_DIR, u\\\"%s.md\\\" % book)\\n with open(filename, 'w') as f:\\n f.write(\\\"\\\\n\\\\n\\\".join(lines))\",\n \"def main():\\n\\n classes = {\\n \\\"rain\\\":0,\\n \\\"rooster\\\":1,\\n \\\"crying_baby\\\":2,\\n \\\"sea_waves\\\":3,\\n \\\"clock_tick\\\":4,\\n \\\"sneezing\\\":5,\\n \\\"dog\\\":6,\\n \\\"crackling_fire\\\":7,\\n \\\"helicopter\\\":8,\\n \\\"chainsaw\\\":9,\\n }\\n\\n with open(\\\"../data/audio/ESC-50-master/meta/esc50.csv\\\") as f:\\n lines = [i[:-1] for i in f.readlines()]\\n lines = lines[1:]\\n\\n os.system(\\\"rm -rf ../data/audio/ESC-10\\\")\\n os.system(\\\"mkdir ../data/audio/ESC-10\\\")\\n os.system(\\\"mkdir ../data/audio/ESC-10/audio\\\")\\n\\n meta = []\\n for line in lines:\\n t = line.split(\\\",\\\")\\n if (t[-3] == 'True'):\\n meta.append(\\\"../data/audio/ESC-10/audio/%s %d\\\" % (t[0],classes[t[3]]))\\n src = \\\"../data/audio/ESC-50-master/audio/\\\"+t[0]\\n dst = \\\"../data/audio/ESC-10/audio/\\\"+t[0]\\n shutil.copy(src,dst)\\n\\n with open(\\\"../data/audio/ESC-10/filelist.txt\\\",\\\"w\\\") as f:\\n for m in meta:\\n f.write(m+\\\"\\\\n\\\")\",\n \"def setup(self):\\n\\n if self.user is 'Daisy':\\n import socket\\n host = socket.gethostname()\\n\\n simName = self.name_prefix[:self.name_prefix.find('_')]\\n\\n if 'ursa' in host:\\n self.raw_sim_dir = '/disk01/rad/sim/' + simName + '/' + self.feedback\\n self.caesar_dir = '/disk01/rad/sim/' + simName + '/' + self.feedback + 'Groups/'\\n self.redshiftFile = '/home/rad/gizmo-extra/outputs_boxspace50.info'\\n self.d_data = '/home/dleung/Downloads/SIGAME_dev/sigame/temp/z' + str(int(self.zCloudy)) + '_data_files/'\\n elif 'flatironinstitute.org' or 'worker' in host:\\n self.raw_sim_dir = '/mnt/ceph/users/daisyleung/simba/sim/' + simName + '/' + self.feedback # dummy\\n self.caesar_dir = '/mnt/ceph/users/daisyleung/simba/sim/' + simName + '/' + self.feedback + 'Groups/'\\n self.redshiftFile = '/mnt/ceph/users/daisyleung/simba/gizmo-extra/outputs_boxspace50.info'\\n self.d_data = '/mnt/home/daisyleung/Downloads/SIGAME_dev/sigame/temp/z' + str(int(self.zCloudy)) + '_data_files/'\\n else:\\n raise NotImplementedError\",\n \"def save_data(dfin, outfile=\\\"./FPeng_prepped\\\"):\\n dfin.to_csv(outfile+'.csv', sep='\\\\t', index=False)\\n # s3.meta.client.upload_file(outfile+\\\".csv\\\", 'p3-engine', 'ETL/FPeng_prepped.csv')\\n print(\\\"csv...\\\", end=\\\" \\\")\\n\\n dfin.to_pickle(outfile+'.pkl' ,protocol=4)\\n # s3.meta.client.upload_file(outfile+'.pkl', 'p3-engine', 'ETL/FPeng_prepped.pkl')\\n print(\\\"pkl...\\\", end=\\\" \\\")\\n #dfin.to_msgpack(outfile+'.msg')\\n #print(\\\"msg...\\\", end=\\\" \\\")\\n\\n #s3.meta.client.upload_file(outfile+\\\".msg\\\", 'p3-engine', 'ETL/FPeng_prepped.msg')\\n\\n # print(\\\"to s3 complete\\\", end=\\\" \\\")\",\n \"def setUpClass(cls):\\n import os\\n for root in cls.prod_s2_ssc:\\n os.makedirs(root)\\n metadata = root.split(\\\".\\\")[0] + \\\".HDR\\\"\\n TestFunctions.touch(metadata)\\n for root in cls.prod_s2_mus:\\n os.makedirs(root)\\n metadata = os.path.join(root, root + \\\"_MTD_ALL.xml\\\")\\n TestFunctions.touch(metadata)\\n for root in cls.prod_s2_nat:\\n os.makedirs(root)\\n metadata = os.path.join(root, \\\"MTD_MSIL1C.xml\\\")\\n TestFunctions.touch(metadata)\",\n \"def make_master_flats(dc):\\n\\n\\t## Make EXTcheck: is there always the same number of extensions in each file\\n\\tprint \\\"Making master flats\\\"\\n\\t\\n\\t## Choose extensions you are using\\n\\t\\n\\tfor flat_type in ['FFS']: # Currently FFD is unsupported. If you have FFDs, add them to the list but you must have ONLY FFDs or ONLY FFSs in the dir. Otherwise the first element in the list will get overwritten!\\n\\t\\t#~ print \\\"\\\\n\\\", flat_type, \\\"\\\\n\\\"\\n\\t\\tfor i in dc:\\n\\t\\t\\tTRIM, TRIM1, VR, PS, PS1, OS, OS1 = CCD_sections((i[0], i[1]))\\n\\t\\t\\tfilelist = []\\n\\t\\t\\tfor f in glob.glob(RAW+'*'+flat_type+'*fits'):\\n\\t\\t\\t\\tccd_conf = []\\n\\t\\t\\t\\theader0 = fits.getheader(f)\\n\\t\\t\\t\\theader1 = fits.getheader(f, ext=1)\\n\\t\\t\\t\\tif header0['OBSMODE']==flat_type:\\n\\t\\t\\t\\t\\tfor KW in ['BINX', 'BINY']:\\n\\t\\t\\t\\t\\t\\tccd_conf.append(header0[KW])\\n\\t\\t\\t\\t\\tfor KW in ['NAXIS1', 'NAXIS2']:\\n\\t\\t\\t\\t\\t\\tccd_conf.append(header1[KW])\\n\\t\\t\\t\\t\\t\\tif tuple(ccd_conf)==i:\\n\\t\\t\\t\\t\\t\\t\\tfilelist.append(f)\\n\\t\\t\\tlfl = len(filelist)\\n\\t\\t\\tif lfl > 0:\\n\\t\\t\\t\\tBIN=CD+'/'+str(i[0])+'x'+str(i[1])+'/'\\n\\t\\t\\t\\tWD=BIN+str(i[-2])+'x'+str(i[-1])+'/' # Bottom level dir with calibrated and master frames\\n\\t\\t\\t\\tB=check_exist(WD, 'MF.fits', i)\\n\\t\\t\\t\\tif B=='n':\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\thdul = fits.HDUList()\\n\\t\\t\\t\\t\\thdul.append(fits.ImageHDU())\\n\\t\\t\\t\\t\\t#~ MB = fits.open(WD+'MB.fits')\\n\\t\\t\\t\\t\\tx = np.array(range(0,i[-1]))\\n\\t\\t\\t\\t\\tfor EXT in (extensions):\\n\\t\\t\\t\\t\\t\\tprint \\\"##################################################\\\"\\n\\t\\t\\t\\t\\t\\tprint \\\"Stacking \\\"+`lfl`+' '+`i[-2]`+'x'+`i[-1]`+' channel '+`EXT`+' flat frames!'\\n\\t\\t\\t\\t\\t\\tif EXT==1:\\n\\t\\t\\t\\t\\t\\t\\tPSC=PS1\\n\\t\\t\\t\\t\\t\\t\\tOSC=OS1\\n\\t\\t\\t\\t\\t\\t\\tTR=TRIM1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tPSC=PS1\\n\\t\\t\\t\\t\\t\\t\\tOSC=OS\\n\\t\\t\\t\\t\\t\\t\\tTR=TRIM\\n\\t\\t\\t\\t\\t\\tsc = -1 # counts how many flats have mean>limit\\n\\t\\t\\t\\t\\t\\tfor n, fn in enumerate(filelist):\\n\\t\\t\\t\\t\\t\\t\\tprint \\\"Files left:\\\",`lfl-n`+'/'+`lfl`\\n\\t\\t\\t\\t\\t\\t\\tim = fits.getdata(fn, ext=EXT)\\n\\t\\t\\t\\t\\t\\t\\tmeanval = np.mean(im[VR[0]:VR[1], TR[0]:TR[1]])\\n\\t\\t\\t\\t\\t\\t\\t#~ maxval = np.max(im[VR[0]:VR[1], TR[0]:TR[1]])\\n\\t\\t\\t\\t\\t\\t\\tmaxval = stats.scoreatpercentile(im[VR[0]:VR[1], TR[0]:TR[1]], 90)\\n\\t\\t\\t\\t\\t\\t\\texptime = fits.getheader(fn)['EXPTIME']\\n\\t\\t\\t\\t\\t\\t\\t#~ if meanval > 15000. and meanval < 40000. and maxval < 50000. and exptime>5.:\\n\\t\\t\\t\\t\\t\\t\\tif meanval > 16000. and meanval < 40000. and exptime>=5.:\\n\\t\\t\\t\\t\\t\\t\\t\\tsc+=1\\n\\t\\t\\t\\t\\t\\t\\t\\t#~ im[im<1]=1\\n\\t\\t\\t\\t\\t\\t\\t\\tmscrow, sigmarow = median_row(OSC, PSC, TR, im)\\n\\t\\t\\t\\t\\t\\t\\t\\tsh = np.shape(im)\\n\\t\\t\\t\\t\\t\\t\\t\\tfor y in range(0, sh[0]):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tim[y] = im[y]-mscrow[y]\\n\\t\\t\\t\\t\\t\\t\\t\\tF=im\\n\\t\\t\\t\\t\\t\\t\\t\\tnorm = np.median(F[VR[0]:VR[1], TR[0]:TR[1]])\\n\\t\\t\\t\\t\\t\\t\\t\\tF = F/norm #+np.min(F)+0.0001\\n\\t\\t\\t\\t\\t\\t\\t\\tif sc==0:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tstack_arr = F\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tstack_arr = np.dstack((stack_arr, F))\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tprint \\\"****************************************\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\tprint \\\"Rejected\\\", fn, \\\"AVG =\\\", meanval, \\\"EXPTIME =\\\", exptime\\n\\t\\t\\t\\t\\t\\t\\t\\tprint \\\"****************************************\\\"\\n\\t\\t\\t\\t\\t\\tprint 'Will stack a total of', np.shape(stack_arr)[2], 'flats'\\n\\t\\t\\t\\t\\t\\tMF = np.median(stack_arr, axis=2)\\n\\t\\t\\t\\t\\t\\thdul.append(fits.ImageHDU(MF))\\n\\t\\t\\t\\t\\t\\thdul[EXT].header.set(\\\"NAXIS1\\\", np.shape(MF)[1])\\n\\t\\t\\t\\t\\t\\thdul[EXT].header.set(\\\"NAXIS2\\\", np.shape(MF)[0])\\n\\t\\t\\t\\t\\thdul[0].header.set(\\\"CALIBR\\\", \\\"T\\\")\\n\\t\\t\\t\\t\\thdul[0].header.set(\\\"INSTRUME\\\", \\\"MAIA\\\")\\n\\t\\t\\t\\t\\thdul[0].header.set(\\\"BINX\\\", i[0])\\n\\t\\t\\t\\t\\thdul[0].header.set(\\\"BINY\\\", i[1])\\n\\t\\t\\t\\t\\thdul[0].header.set(\\\"CALMODE\\\", \\\"MASTER FLAT\\\")\\n\\t\\t\\t\\t\\thdul.writeto(WD+\\\"MF.fits\\\", clobber=True)\\n\\t\\t\\t\\t\\tprint \\\"############################################################\\\"\\n\\tprint \\\"Completed master flats\\\"\",\n \"def creation_srcmdl(dir_cat,SourceRA,SourceDec,SourceROI,distmin,name,outputfile,emin,emax):\\n\\tf_liste_sour=\\\"a.txt\\\"\\n\\n\\tlect_ca(dir_cat,SourceRA,SourceDec,SourceROI,distmin,name,f_liste_sour,name)\\n\\tXML_EC_PL(name, f_liste_sour, outputfile, emin,emax)\\n\\tos.system(\\\"rm -rf a.txt\\\")\",\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 create_fits_file(fits, cols, cdata):\\n dlist = []\\n for k in range(0, len(cols)):\\n aent = numpy.array(cdata[k])\\n dcol = pyfits.Column(name=cols[k], format='F', array=aent)\\n dlist.append(dcol)\\n\\n dcols = pyfits.ColDefs(dlist)\\n tbhdu = pyfits.BinTableHDU.from_columns(dcols)\\n\\n mcf.rm_files(fits)\\n tbhdu.writeto(fits)\",\n \"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\",\n \"def dsinfomaker(compath, backpath, mwb, tcfs, SR=\\\"SR\\\"):#yrs, ves,\\r\\n\\tdsinfo = OrderedDict()\\r\\n\\t# ==========\\r\\n\\tdsinfo[\\\"GFED\\\"] = ({\\\"alias\\\":\\\"GFED4.1\\\",\\\"long_name\\\":\\\"FRI\\\", \\\"units\\\":\\\"yrs\\\"})\\r\\n\\tdsinfo[\\\"MODIS\\\"] = ({\\\"alias\\\":\\\"MCD64A1\\\", \\\"long_name\\\":\\\"FRI\\\",\\\"units\\\":\\\"yrs\\\", \\\"version\\\":\\\"v006\\\"})\\r\\n\\tdsinfo[\\\"esacci\\\"] = ({\\\"alias\\\":\\\"FireCCI5.1\\\", \\\"long_name\\\":\\\"FRI\\\",\\\"units\\\":\\\"yrs\\\"})\\r\\n\\tdsinfo[\\\"COPERN_BA\\\"] = ({\\\"alias\\\":\\\"CGLS\\\", \\\"long_name\\\":\\\"FRI\\\",\\\"units\\\":\\\"yrs\\\"})\\r\\n\\tdsinfo[\\\"HANSEN_AFmask\\\"] = ({\\\"alias\\\":\\\"Hansen GFC & MCD14ML\\\", \\\"long_name\\\":f'FRI$_{{{SR}}}$',\\\"units\\\":\\\"yrs\\\"})\\r\\n\\tdsinfo[\\\"HANSEN\\\"] = ({\\\"alias\\\":\\\"Hansen GFC\\\", \\\"long_name\\\":\\\"DRI\\\",\\\"units\\\":\\\"yrs\\\"})\\r\\n\\tdsinfo[\\\"Risk\\\"] = ({\\\"alias\\\":\\\"Forest Loss Risk\\\"})\\r\\n\\t# dsinfo[\\\"FutureRisk\\\"] = ({\\\"alias\\\":\\\"Forest Loss Risk\\\"})\\r\\n\\tdsinfo[\\\"SRfrac\\\"] = ({\\\"alias\\\":\\\"Stand Replacing Fire Percentage\\\", \\\"long_name\\\":f'FRI$_{{{\\\"SR\\\"}}}$ %'})\\r\\n\\r\\n\\tfor dsnm in dsinfo:\\r\\n\\t\\tif dsnm.startswith(\\\"H\\\"):\\r\\n\\t\\t\\t# +++++ make a path +++++\\r\\n\\t\\t\\tppath = compath + \\\"/BurntArea/HANSEN/FRI/\\\"\\r\\n\\t\\t\\tfname = \\\"%s%s_annual_burns_MW_%ddegreeBox.nc\\\" % (dsnm, tcfs, mwb)\\r\\n\\t\\t\\t# fname = \\\"%s%s_annual_burns_MW_%ddegreeBox.nc\\\" % (dsnm, mwb)\\r\\n\\t\\telif dsnm == \\\"Risk\\\":\\r\\n\\t\\t\\tppath = compath + \\\"/BurntArea/Risk/FRI/\\\"\\r\\n\\t\\t\\tfname = \\\"%s_annual_burns_MW_%ddegreeBox.nc\\\" % (dsnm, mwb)\\r\\n\\t\\t\\tcf.pymkdir(ppath)\\r\\n\\t\\t# elif dsnm == \\\"FutureRisk\\\":\\r\\n\\t\\t# \\tppath = compath + \\\"/BurntArea/Risk/FRI/\\\"\\r\\n\\t\\t# \\tfname = f\\\"{dsnm}_annual_burns_MW_{mwb}degreeBox_{yrs}yrs_{ves}.nc\\\" \\r\\n\\t\\t# \\tcf.pymkdir(ppath)\\r\\n\\t\\telse:\\r\\n\\t\\t\\t# fname = \\\"Hansen_GFC-2018-v1.6_regrided_esacci_FRI_%ddegMW_SIBERIA\\\" % (mwb)\\r\\n\\t\\t\\tppath = compath + \\\"/BurntArea/%s/FRI/\\\" % dsnm\\r\\n\\t\\t\\tfname = \\\"%s_annual_burns_MW_%ddegreeBox.nc\\\" % (dsnm, mwb)\\r\\n\\t\\t# +++++ open the datasets +++++\\r\\n\\t\\tdsinfo[dsnm][\\\"fname\\\"] = ppath+fname\\r\\n\\r\\n\\r\\n\\treturn dsinfo\",\n \"def loader(filename,wdm=0,verbose=0,kmpers=1):\\n with open(filename, 'rb') as f:\\n if wdm == False:\\n if verbose>1:\\n print(filename)\\n #file info\\n info= np.fromfile(f,dtype=infodtype,count=1)\\n infoBytes = f.tell()\\n if verbose>2:\\n print(infoBytes)\\n #skip darkmatter\\n #read the first dm line\\n if verbose>2:\\n print(f.tell())\\n catd = np.fromfile(f,dtype= dmdtype, count=1) \\n #get the bytes location and subtract off the bytes location after loading info to get n bytes a line for dm\\n if verbose>2:\\n print(f.tell())\\n current = f.tell()\\n dmBytes = current-infoBytes\\n f.seek(dmBytes*(info['nd'][0]-1)+current)\\n if verbose>2:\\n print(f.tell())\\n # stars setup \\n cats= np.fromfile(f,dtype=stellardtype, count=info['ns'][0])\\n if verbose>2:\\n print('done')\\n else:\\n if verbose>1:\\n print(filename)\\n #file info\\n info= np.fromfile(f,dtype=infodtype,count=1)\\n if verbose>2:\\n print(f.tell())\\n # #dark matter setup count is reading the number of ?rows? \\n catd= np.fromfile(f,dmdtype, count=info['nd'][0]) \\n if verbose>2:\\n print(f.tell()) \\n # stars setup \\n cats= np.fromfile(f,dtype=stellardtype, count=info['ns'][0])\\n if verbose>2:\\n print('done')\\n \\n \\n #convert to physical units as found in README.md\\n if wdm == True:\\n catd['mass']*=2.324876e9\\n if kmpers == 1:\\n catd['vx']*=100.\\n catd['vy']*=100.\\n catd['vz']*=100.\\n cats['mass']*=2.324876e9\\n if kmpers == 1:\\n cats['vx']*=100.\\n cats['vy']*=100.\\n cats['vz']*=100.\\n \\n if wdm == True:\\n return(catd,cats,info)\\n else:\\n return(cats,info)\",\n \"def MakeDataSetFiles(dirname):\\n\\n\\n if not os.path.exists(dirname):\\n os.mkdir(dirname)\\n if not os.path.exists(os.path.join(dirname, 'train')):\\n os.mkdir(os.path.join(dirname, 'train'))\\n if not os.path.exists(os.path.join(dirname, 'test')):\\n os.mkdir(os.path.join(dirname, 'test'))\\n data_train = fetch_20newsgroups(subset='train', categories=None, shuffle=True, random_state=42)\\n data_test = fetch_20newsgroups(subset='test', categories=None, shuffle=True, random_state=42)\\n\\n if dirname[-1] == '/' or dirname[-1] == '\\\\\\\\':\\n dirname = dirname[:-1]\\n \\n Util.WriteClassFile(data_train.target, os.path.join(dirname, 'train_classes.txt'))\\n Util.WriteClassFile(data_test.target,os.path.join(dirname, 'test_classes.txt'))\\n\\n\\n train_counter = 0;\\n for doc in data_train.data:\\n filename = 'train_' + str(train_counter).zfill(5);\\n f = file(os.path.join(dirname, 'train', filename), 'w');\\n f.write(doc.encode('ascii', 'ignore'));\\n f.close();\\n train_counter = train_counter + 1;\\n\\n test_counter = 0;\\n for doc in data_test.data:\\n filename = 'test_' + str(test_counter).zfill(5);\\n f = file(os.path.join(dirname, 'test', filename), 'w');\\n f.write(doc.encode('ascii', 'ignore'));\\n f.close();\\n test_counter = test_counter + 1;\\n\\n class_index = file(os.path.join(dirname, 'class_label_index.txt'), 'w')\\n for label in data_train.target_names:\\n class_index.write(label + '\\\\n')\\n class_index.close()\",\n \"def dctCreateD(pdct, dirName, msgBufSize):\\n return _dctmcc.dctCreateD(pdct, dirName, msgBufSize)\",\n \"def file(self):\\n\\n corrdict = (self.cat_corr)['correction']\\n specdict = (self.cat_corr)['spec'] \\n \\n fft_dir = direc('fft', self.cat_corr)\\n \\n if self.type == 'data': \\n galdata = Data(self.type, self.cat_corr, **self.kwargs) # data class \\n elif self.type == 'random': \\n galdata = Random(self.type, self.cat_corr, **self.kwargs) # data class \\n\\n self.data_file = galdata.file_name # galaxy data file\\n\\n # FFT label \\n fft_str = 'FFT_'\\n if specdict['ell'] != 0: \\n fft_str += 'Q_'\\n \\n fft_corr_str = ''\\n if (corrdict['name'].lower() in ('floriansn', 'hectorsn')) & (self.type != 'random'):\\n fft_corr_str = ''.join(['.', corrdict['name'].lower()])\\n\\n # FFTs from data file \\n fft_file = ''.join([\\n fft_dir, \\n fft_str, (self.data_file).rsplit('/')[-1], \\n fft_corr_str,\\n '.grid', str(specdict['Ngrid']), \\n '.P0', str(specdict['P0']), \\n '.box', str(specdict['Lbox'])\\n ])\\n\\n return fft_file\",\n \"def make_tag_data_raw_fast(mdp,filename):\\n #\\n fin = open(filename,'r')\\n iter = 0\\n for line in fin:\\n lsp = line.split(' ')\\n if len(lsp) > 1: # skip empty lines\\n if lsp[0] == \\\"comb_path\\\":\\n update_params(mdp,lsp)\\n if not mdp.flag_out_open: ## -- try to open output file\\n try:\\n if mdp.flag_overwrite == \\\"True\\\": ## check string value!\\n ## -- open save file for read+write\\n try:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.save_file.seek(0) # go to beginning\\n mdp.save_file.truncate() # delete whatever was there before\\n except IOError:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'w')\\n mdp.save_file.close()\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.flag_out_open = True\\n #for num,key in zip(mdp.corr_num,mdp.key):\\n # corr_key=uf.get_str_key(mdp.corr_file,\\\"correlator_key\\\",num)\\n mdp.flag_overwrite= False\\n else:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.save_file.seek(0,2) # seek the end of file\\n mdp.flag_out_open = True\\n #for num,key in zip(mdp.corr_num,mdp.key):\\n # corr_key=uf.get_str_key(mdp.corr_file,\\\"correlator_key\\\",num)\\n except (AttributeError):\\n print \\\"Attempted to open invalid output file\\\"\\n ## -- try open output file\\n for file in glob.glob(mdp.input_path):\\n # get sign which corrects for boundary condition\\n tvals = file.split('/')[-1].split('_')[3].split('t')\\n try:\\n ## flip sign if requested\\n bcsign = ((int(tvals[1])+int(tvals[2])) != (int(tvals[1])+int(tvals[2])) % mdp.corr_len)\\n except IndexError:\\n ## 2-point function\\n bcsign = False\\n try:\\n # open correlator file\\n mdp.corr_file = open(file,'r')\\n except IOError:\\n print \\\"Could not open file \\\",file\\n continue\\n ## -- get tag\\n ## baryons:\\n #mdp.tag = '_'+file.split('/')[-1].split('_')[1][1:]+'_r'+file.split('/')[-1].split('_')[4][-1]\\n ## with time source tag\\n #mdp.tag = file.split('/')[-1].split('_')[3][:3]\\\\\\n # +'_'+file.split('/')[-1].split('_')[1][1:]+'_'+file.split('/')[-1].split('_')[4][0]\\\\\\n # +file.split('/')[-1].split('_')[4][3:]\\n ## no time source tag\\n mdp.tag = '_'+file.split('/')[-1].split('_')[1][1:]+'_'+file.split('/')[-1].split('_')[4][0]\\\\\\n +file.split('/')[-1].split('_')[4][3:]\\n #print file,',',mdp.tag\\n iter+=1\\n ##endif ! flag_out_open\\n\\n #save_data_fast(mdp)\\n save_data_fast_bc(mdp,bcsign)\\n mdp.corr_file.close()\\n if iter%400 == 0:\\n print \\\"file\\\",iter\\n max_iter = None\\n if not(max_iter is None) and iter==max_iter:\\n print \\\"reached max file iterations, ending loop...\\\"\\n break\\n ## end comb_path\\n pass\\n\\n elif lsp[0] == \\\"for\\\": # indicates when to get correlator\\n lsp.pop(0)\\n update_params(mdp,lsp)\\n try:\\n # open correlator file\\n mdp.corr_file = open(mdp.input_path + '/' + mdp.input_fname,'r')\\n except IOError:\\n print \\\"Could not open file \\\",mdp.input_fname\\n continue\\n print mdp.input_fname\\n if not mdp.flag_out_open:\\n try:\\n if mdp.flag_overwrite:\\n ## -- open save file for read+write\\n try:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.save_file.seek(0) # go to beginning\\n mdp.save_file.truncate() # delete whatever was there before\\n except IOError:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'w')\\n mdp.save_file.close()\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.flag_out_open = True\\n #for num,key in zip(mdp.corr_num,mdp.key):\\n # corr_key=uf.get_str_key(mdp.corr_file,\\\"correlator_key\\\",num)\\n mdp.flag_overwrite= False\\n else:\\n mdp.save_file = open(mdp.output_path + '/' + mdp.output_fname,'r+')\\n mdp.save_file.seek(0,2) # seek the end of file\\n mdp.flag_out_open = True\\n #for num,key in zip(mdp.corr_num,mdp.key):\\n # corr_key=uf.get_str_key(mdp.corr_file,\\\"correlator_key\\\",num)\\n #except (IOError):\\n # pass\\n except (AttributeError):\\n print \\\"Attempted to open invalid output file\\\"\\n ##endif ! flag_out_open\\n save_data_fast(mdp)\\n mdp.corr_file.close()\\n ##else \\\"for\\\" not found in control file\\n else:\\n update_params(mdp,lsp)\\n ##endif lsp[0]==for\\n ##endif len(lsp) > 1\\n try:\\n mdp.save_file.close()\\n mdp.flag_out_open = False\\n except (IOError,AttributeError):\\n pass\\n fin.close()\\n return\",\n \"def write_catalog(format_list,study):\\n\\n o_format_list=sorted(format_list)\\n\\n fn=study.sas_file\\n\\n with open(fn, 'w') as f:\\n f.write(f\\\"*{'-'*73}*\\\\n\\\")\\n f.write(f\\\"| SAS Formats Catalog for: {study.display_name}\\\\n\\\")\\n f.write(f\\\"| Path: {fn}\\\\n\\\")\\n f.write(f\\\"| Autogenerated by Candid on: {datetime.datetime.now().strftime('%d-%b-%Y')}\\\\n\\\")\\n f.write(f\\\"| {'-' * 10} Post-testing modifications {'-' * 10}\\\\n\\\")\\n f.write(\\\"| Date User Modification\\\\n|\\\\n\\\")\\n f.write(f\\\"*{'-'*73}*;\\\\n\\\")\\n f.write(\\\"%include 'init.sas';\\\\n\\\\n\\\")\\n\\n # delete existing catalogs\\n # f.write(\\\"proc datasets library=out memtype=catalog;\\\\n\\\\tdelete formats;\\\\nrun;\\\\n\\\\n\\\")\\n\\n f.write(\\\"proc format library=out;\\\\n\\\")\\n\\n for i in o_format_list:\\n\\n # Write the invalue statement\\n f.write(Format.write_comment(i))\\n\\n # Write the invalue statement\\n if i.fmt_value==Format_val.Invalue:\\n f.write(\\\"\\\\tinvalue\\\")\\n if i.fmt_type==Format_type.Numeric:\\n f.write(f\\\" ${i.name + '_' + i.category}\\\\n\\\")\\n else:\\n f.write(f\\\" {i.name+ '_' + i.category}\\\\n\\\")\\n\\n # Write the value statement\\n else:\\n if i.fmt_type==Format_type.Char:\\n f.write(f\\\"\\\\tvalue ${i.name + '_' + i.category}\\\\n\\\")\\n else:\\n f.write(f\\\"\\\\tvalue {i.name + '_' + i.category}\\\\n\\\")\\n\\n # Loop for each member of format catalog\\n for j in i.listvals:\\n # start\\n if i.fmt_type==Format_type.Numeric:\\n f.write(f\\\"\\\\t\\\\t{remove_cc(j[0])} = \\\")\\n else:\\n f.write(f\\\"\\\\t\\\\t\\\\\\\"{remove_cc(j[0])}\\\\\\\" = \\\")\\n # label\\n if i.fmt_value == Format_val.Invalue:\\n f.write(f\\\"{remove_cc(j[1])}\\\\n\\\")\\n else:\\n f.write(f'\\\"{remove_cc(j[1])}\\\"\\\\n')\\n f.write(\\\"\\\\t\\\\t;\\\\n\\\")\\n f.write(\\\"run;\\\")\\n\\n return fn\",\n \"def generate_all_files():\\n for (name, fn) in lang_module.targets.items():\\n path = of_g.options.install_dir + '/' + name\\n os.system(\\\"mkdir -p %s\\\" % os.path.dirname(path))\\n with open(path, \\\"w\\\") as outfile:\\n fn(outfile, os.path.basename(name))\\n print(\\\"Wrote contents for \\\" + name)\",\n \"def generate_data():\\n for subdir, dirs, files in os.walk(legend_images_dir):\\n for _file in files:\\n getTables(_file)\\n\\n file_list = []\\n for subdir, dirs, files in os.walk(pdf_output_dir):\\n for _file in files:\\n if _file.endswith('.pdf'):\\n file_list.append(_file)\\n\\n print (\\\"Writing merged output in Output.pdf...\\\")\\n current_dir = os.getcwd()\\n mergeOutput(file_list, current_dir + \\\"/Output.pdf\\\")\\n\\n clean()\",\n \"def generate_database():\\n database = {}\\n\\n for name in images:\\n descriptors = []\\n for path in images[name]:\\n descriptors.append(ConvertToDescriptor.jpeg_to_descriptors(myPath + path))\\n database[name] = person.Person(name, descriptors)\\n\\n output = open('database.p', 'wb')\\n pickle.dump(database, output)\\n output.close()\",\n \"def main() :\\n #fname = '/reg/d/psdm/CXI/cxi35711/hdf5/cxi35711-r0009.h5'\\n #dsname = '/Configure:0000/Run:0000/CalibCycle:0000/CsPad::ElementV2/CxiDs1.0:Cspad.0/data'\\n #event = 1\\n\\n fname = '/reg/d/psdm/CXI/cxi37411/hdf5/cxi37411-r0039.h5'\\n dsname = '/Configure:0000/Run:0000/CalibCycle:0000/CsPad::ElementV2/CxiDsd.0:Cspad.0/data'\\n event = 1\\n\\n print 'Default CSPad configuration pars:'\\n cspadconfig.printCSPadConfigPars()\\n\\n print '\\\\nCSPad configuration pars: for fname, dsname, event =\\\\n', fname, '\\\\n', dsname, '\\\\n', event\\n cspadconfig.setCSPadConfiguration( fname, dsname, event ) # This will set current CSPad configuration\\n cspadconfig.printCSPadConfigPars()\",\n \"def convert_to_dicom(file_name):\\n\\tpath = get_testdata_file(\\\"CT_small.dcm\\\")\\n\\tds = pydicom.dcmread(path)\\n\\timg = Image.open(file_name+\\\".bmp\\\")\\n\\tnpa = np.asarray(img)\\n\\tds.PixelData = img.tobytes()\\n\\tname = update_destination_file_name(file_name)\\n\\tds.save_as(name+'.dcm')\\n\\tprint(\\\"DONE\\\\t \\\"+name+\\\".dcm\\\")\",\n \"def save(self, dest_dir):\\n try:\\n makedirs(dest_dir)\\n except FileExistsError:\\n pass\\n suffix = '-%d-%d.h5' % (self.num_gen_steps, self.num_disc_steps)\\n gen_path = path.join(dest_dir, 'gen' + suffix)\\n disc_path = path.join(dest_dir, 'disc' + suffix)\\n self.discriminator.save(disc_path)\\n self.generator.save(gen_path)\",\n \"def save(self, dest_dir):\\n try:\\n makedirs(dest_dir)\\n except FileExistsError:\\n pass\\n suffix = '-%d-%d.h5' % (self.num_gen_steps, self.num_disc_steps)\\n gen_path = path.join(dest_dir, 'gen' + suffix)\\n disc_path = path.join(dest_dir, 'disc' + suffix)\\n self.discriminator.save(disc_path)\\n self.generator.save(gen_path)\",\n \"def make_ctd_file():\\n # Get the correct netCDF4 dataset\\n __location__ = os.path.realpath(os.path.join(os.getcwd(),\\n os.path.dirname(__file__),\\n 'output'))\\n nc_file = os.path.join(__location__,'test_BM54.nc')\\n\\n # Be sure to start with the original, unedited CTD data\\n test_ambient.test_from_ctd()\\n\\n # Load the data into a netCDF file\\n nc = Dataset(nc_file, 'a')\\n\\n return nc\",\n \"def prepare_dibco(data_dir=DEFAULT_DATA_DIR,\\n out_dir=None,\\n force=False):\\n if not os.path.exists(data_dir):\\n os.makedirs(data_dir)\\n if out_dir is None:\\n out_dir = data_dir\\n if not os.path.exists(out_dir):\\n os.makedirs(out_dir)\\n\\n train_record = 'train.record'\\n test_record = 'test.record'\\n num_train = 'num_train'\\n num_test = 'num_test'\\n\\n if not (os.path.exists(os.path.join(data_dir, train_record)) and\\n os.path.exists(os.path.join(data_dir, test_record)) and\\n os.path.exists(os.path.join(data_dir, num_train)) and\\n os.path.exists(os.path.join(data_dir, num_test))) or force:\\n maybe_download(get_dibco_meta_data(data_dir)['url'], data_dir, force=force)\\n\\n extracted_dir = os.path.join(data_dir, DATA_EXTRACTED_DIR)\\n\\n with open(os.path.join(extracted_dir, 'train.txt')) as i_f:\\n with open(os.path.join(data_dir, num_train), mode='w') as o_f:\\n o_f.write(str(len(i_f.readlines())))\\n train_writer = tf.python_io.TFRecordWriter(\\n os.path.join(out_dir, train_record))\\n for data in get_label_map_dict(\\n extracted_dir, os.path.join(extracted_dir, 'train.txt')):\\n example = dict_to_example(data)\\n train_writer.write(example.SerializeToString())\\n train_writer.close()\\n\\n with open(os.path.join(extracted_dir, 'test.txt')) as i_f:\\n with open(os.path.join(data_dir, num_test), mode='w') as o_f:\\n o_f.write(str(len(i_f.readlines())))\\n val_writer = tf.python_io.TFRecordWriter(os.path.join(out_dir, test_record))\\n for data in get_label_map_dict(\\n extracted_dir, os.path.join(extracted_dir, 'test.txt')):\\n example = dict_to_example(data)\\n val_writer.write(example.SerializeToString())\\n val_writer.close()\\n print()\\n\\n return get_dibco_meta_data(data_dir)\",\n \"def make_one_d(prefile, ffile, opath, moddict):\\n import codecs\\n\\n # List of modules used in input file\\n imods = used_mods(prefile)\\n\\n # Query dictionary for filenames of modules used in fortran file.\\n # Remove own file name for circular dependencies if more than one\\n # module in fortran file.\\n if imods:\\n imodfiles = list()\\n for d in imods:\\n if d in moddict: # otherwise external module such as netcdf\\n if moddict[d] != ffile:\\n imodfiles.append(moddict[d])\\n else:\\n imodfiles = []\\n\\n # Write output .d file\\n dfile = f2d(ffile, opath)\\n ofile = f2o(ffile, opath)\\n df = codecs.open(dfile, 'w', encoding='utf-8')\\n print(dfile, ':', ffile, file=df)\\n print(ofile, ':', ffile + ' ' + dfile, end='', file=df)\\n for im in imodfiles:\\n print('', f2o(im, opath), end='', file=df)\\n print('', file=df)\\n df.close()\\n\\n return\",\n \"def create_samfile(self):\",\n \"def create_obj(destination,mtl_name):\\r\\n\\tshutil.copyfile(\\\"file_cube.obj\\\",destination)\\r\\n\\tf=open(destination,\\\"r\\\")\\r\\n\\tlines=f.readlines()\\r\\n\\tlines[0]=\\\"mtllib \\\"+mtl_name+\\\"\\\\n\\\"\\r\\n\\tf.close()\\r\\n\\tf=open(destination,\\\"w\\\")\\r\\n\\tf.writelines(lines)\\r\\n\\tf.close()\",\n \"def generate_data_set(args):\\n if args.o is None:\\n filename = \\\"test\\\"\\n else:\\n filename = args.o\\n\\n if args.b is None:\\n args.b = 0.5\\n if args.p is None:\\n path = Path(\\\"\\\")\\n else:\\n path = Path(args.p)\\n if args.nf is None:\\n args.nf = 1\\n\\n for i in range(int(args.nf)):\\n args.o = path / (filename + \\\"_t\\\"+str(args.t) + \\\"_k\\\" + str(args.k) + \\\"_n\\\"+str(args.n) + \\\"_m\\\"+str(args.m)\\n + \\\"_c\\\"+str(args.c) + \\\"_\\\"+str(i) + \\\".dzn\\\")\\n create_dnz_file(args)\",\n \"def dump_dc():\\n network = Network(pickle=True)\\n skus = {}\\n for i in range(0, len(network.dcs)):\\n for j in network.dcs[i].inventory.keys():\\n if j not in skus:\\n skus[j] = [0, 0, 0, 0, 0]\\n skus[j][i] += network.dcs[i].inventory[j]\\n else:\\n skus[j][i] += network.dcs[i].inventory[j]\\n arr = []\\n for i in skus.keys():\\n arr.append([i,skus[i][0], skus[i][1], skus[i][2], skus[i][3], skus[i][4]])\\n with open('dc_inv.csv', 'wb') as csv_file:\\n writer = csv.writer(csv_file)\\n writer.writerows(arr)\",\n \"def write_scram_toolfile(self, contents, filename):\\n with open(self.spec.prefix.etc + '/scram.d/' + filename, 'w') as f:\\n f.write(contents)\\n f.close()\",\n \"def mkdirout():\\n #pdbid=os.path.splitext(os.path.basename(PDB_PATH))[0]\\n #outdir = os.path.join(OUTPUT_DIR, pdbid(),\\\"\\\") # OUTPUT DIRECTORY WHERE OUTPUT FILES WILL GO\\n\\n if os.path.exists(output_dir()):\\n sys.exit(\\\"ERROR. Unable to create output directory. %s already exists. Please, make sure you choose an output path not containing former results.\\\" % output_dir() ) # LOGGING?\\n else:\\n try:\\n os.mkdir(output_dir())\\n except OSError:\\n sys.exit(\\\"ERROR. Unable to create output directory %s.\\\" % output_dir() )\\n os.mkdir(output_tmpdir())\\n os.mkdir(output_tmpdir(\\\"pisacov\\\"))\\n os.mkdir(output_tmpdir(\\\"pisa\\\"))\\n os.mkdir(output_tmpdir(\\\"deepmetapsicov\\\"))\",\n \"def collectInitialeccnStatistics_onefile(self, folder, databaseFilename, multiplicityFactor = 1.0, deformedNuclei = False):\\n typeCollections = ((1, 'sn'), (2,'en'))\\n for ecc_id, ecc_type_name in typeCollections:\\n db = SqliteDB(path.join(folder, databaseFilename % ecc_type_name))\\n # first write the ecc_id_lookup table, makes sure there is only one such table\\n if db.createTableIfNotExists(\\\"ecc_id_lookup\\\", ((\\\"ecc_id\\\",\\\"integer\\\"), (\\\"ecc_type_name\\\",\\\"text\\\"))):\\n db.insertIntoTable(\\\"ecc_id_lookup\\\", (ecc_id, ecc_type_name))\\n\\n # next create the eccentricities and collisionParameters table\\n db.createTableIfNotExists(\\\"eccentricities\\\", ((\\\"event_id\\\",\\\"integer\\\"), (\\\"ecc_id\\\", \\\"integer\\\"), (\\\"n\\\",\\\"integer\\\"), (\\\"ecc_real\\\",\\\"real\\\"), (\\\"ecc_imag\\\",\\\"real\\\")))\\n db.createTableIfNotExists(\\\"collisionParameters\\\", ((\\\"event_id\\\",\\\"integer\\\"), (\\\"Npart\\\", \\\"integer\\\"), (\\\"Ncoll\\\",\\\"integer\\\"), (\\\"b\\\",\\\"real\\\"), (\\\"total_entropy\\\",\\\"real\\\")))\\n if(deformedNuclei):\\n db.createTableIfNotExists(\\\"deformationParameters\\\", ((\\\"event_id\\\",\\\"integer\\\"), (\\\"cosTheta1\\\", \\\"real\\\"), (\\\"phi1\\\",\\\"real\\\"), (\\\"cosTheta2\\\",\\\"real\\\"), (\\\"phi2\\\",\\\"real\\\")))\\n\\n # the big loop\\n data = loadtxt(path.join(folder, '%s_ecc_eccp_10.dat' %(ecc_type_name)))\\n Npart = data[:, 36]\\n Ncoll = data[:, 37]\\n dSdy = data[:, 38]/multiplicityFactor #scale out the multiplicity factor used in superMC\\n b = data[:, 39]\\n for event_id in range(len(Npart)):\\n db.insertIntoTable(\\\"collisionParameters\\\", (event_id, int(Npart[event_id]), int(Ncoll[event_id]), float(b[event_id]), float(dSdy[event_id])))\\n if(deformedNuclei):\\n cosTheta1 = data[:, 40]\\n phi1 = data[:, 41]\\n cosTheta2 = data[:, 42]\\n phi2 = data[:, 43]\\n for event_id in range(len(Npart)):\\n db.insertIntoTable(\\\"deformationParameters\\\", (event_id, float(cosTheta1[event_id]), float(phi1[event_id]), float(cosTheta2[event_id]), float(phi2[event_id])))\\n for iorder in range(1,10):\\n eccReal = data[:, 4*iorder - 2]\\n eccImag = data[:, 4*iorder - 1]\\n for event_id in range(len(eccReal)):\\n db.insertIntoTable(\\\"eccentricities\\\",(event_id, ecc_id, iorder, float(eccReal[event_id]), float(eccImag[event_id])))\\n\\n # close connection to commit changes\\n db.closeConnection()\",\n \"def create_mock_files(self,\\n project_id=\\\"DEV-test\\\",\\n count=3,\\n prefix=\\\"mock_data_file\\\",\\n file_format=\\\"dcm\\\",\\n outdir=\\\".\\\",\\n msg = \\\"This is a mock data file for testing purposes. Delete me!\\\",\\n write_tsv = True\\n ):\\n prog,proj = project_id.split(\\\"-\\\")\\n authz = [\\\"/programs/{}/projects/{}\\\".format(prog,proj)]\\n acl = [prog,proj]\\n\\n mfiles = {'file_name':[],'md5sum':[],\\\"file_size\\\":[],\\\"object_id\\\":[],\\\"storage_urls\\\":[],\\\"acl\\\":[],\\\"authz\\\":[]}\\n for i in range(count):\\n file_name = \\\"{}_{}.{}\\\".format(prefix,i+1,file_format)\\n object_id = str(uuid.uuid4())\\n mfiles['file_name'].append(file_name)\\n mfiles['object_id'].append(object_id)\\n mfiles['authz'].append(authz)\\n mfiles['acl'].append(acl)\\n\\n\\n output = \\\"{}/{}\\\".format(outdir,file_name)\\n os.system(\\\"touch {}\\\".format(output))\\n file_msg =\\\"{} File {} of {}. {} with object_id {}.\\\".format(msg,i+1,count,file_name,object_id)\\n cmd = 'echo \\\"{}\\\" > {}'.format(file_msg,file_name)\\n os.system(cmd)\\n\\n with open(output, 'rb') as file_to_check:\\n file_contents = file_to_check.read()\\n #cmd = \\\"!md5 mock_data_file_{}.{}\\\".format(i+1,file_format))\\n md5 = hashlib.md5(file_contents).hexdigest() #check in shell: !md5 mock_data_file_3.dcm\\n\\n mfiles['md5sum'].append(md5)\\n mfiles['file_size'].append(os.stat(output).st_size)\\n urls=\\\"s3://this-is-a-fake-url-for:{}\\\".format(file_name)\\n mfiles['storage_urls'].append([urls])\\n\\n return mfiles\",\n \"def write_all_patients():\\n\\n data_dir = sys.argv[1]\\n output_dir = sys.argv[2]\\n\\n imgs, i_msks, o_msks = load_all_patients(data_dir=data_dir)\\n\\n for idx, array in enumerate(imgs):\\n np.save(output_dir+'/img_'+str(idx), array)\\n for idx, array in enumerate(i_msks):\\n np.save(output_dir+'/i_msk_'+str(idx), array)\\n for idx, array in enumerate(o_msks):\\n np.save(output_dir + '/o_msk_' + str(idx), array)\\n\\n return None\",\n \"def _make_image_info_des(self, flistname):\\n\\n flist=[]\\n psfex_flist=[]\\n magzp_list=[]\\n with open(flistname) as fobj:\\n for line in fobj:\\n ls = line.split()\\n fname = ls[0]\\n magzp = float(ls[1])\\n magzp_list.append(magzp)\\n\\n flist.append(fname)\\n\\n psfex_fname = fname.replace('.fits.fz','_psfcat.psf')\\n psfex_flist.append(psfex_fname)\\n\\n nimage = len(flist)\\n magzp = np.array(magzp_list)\\n\\n path_len = max([len(f) for f in flist])\\n psfex_path_len = max([len(f) for f in psfex_flist])\\n\\n try:\\n ext_len = len(self['image_ext'])\\n except:\\n ext_len=None\\n\\n extra_dtype = [\\n ('psfex_path','U%d' % psfex_path_len),\\n ]\\n\\n #image_info = meds.util.get_image_info_struct(\\n image_info = get_image_info_struct(\\n nimage,\\n path_len,\\n ext_len=ext_len,\\n extra_dtype=extra_dtype,\\n )\\n image_info['position_offset'] = 1\\n image_info['image_ext'] = self['image_ext']\\n image_info['weight_ext'] = self['weight_ext']\\n\\n for i,f in enumerate(flist):\\n image_info['image_id'][i] = i\\n image_info['image_path'][i] = f\\n image_info['weight_path'][i] = f\\n image_info['psfex_path'][i] = psfex_flist[i]\\n\\n image_info['magzp'] = magzp\\n image_info['scale'] = self._get_scale_from_magzp(magzp)\\n return image_info\",\n \"def write_all_data_tables( phasename, eos_prop_d, output_d ):\\n\\n dataio.write_data_table( 'temperature_' + phasename + '.dat',\\n (eos_prop_d[key] for key in\\n ('Pmesh_a', 'Smesh_a', 'Tmesh_a')),\\n ('GPa', 'eV', 1), output_d )\\n\\n dataio.write_data_table( 'density_' + phasename + '.dat',\\n (eos_prop_d[key] for key in\\n ('Pmesh_a', 'Smesh_a', 'rhomesh_a')),\\n ('GPa', 'eV','g_cc'), output_d )\\n dataio.write_data_table( 'heat_capacity_' + phasename + '.dat',\\n (eos_prop_d[key] for key in\\n ('Pmesh_a', 'Smesh_a', 'Cpmesh_a')),\\n ('GPa','eV','eV'), output_d )\\n\\n dataio.write_data_table( 'thermal_exp_' + phasename + '.dat',\\n (eos_prop_d[key] for key in\\n ('Pmesh_a', 'Smesh_a', 'alphamesh_a')),\\n ('GPa','eV',1), output_d )\\n\\n dataio.write_data_table( 'adiabat_temp_grad_' + phasename + '.dat',\\n (eos_prop_d[key] for key in\\n ('Pmesh_a', 'Smesh_a', 'dTdP_Smesh_a')),\\n ('GPa','eV','GPa-1'), output_d )\\n pass\",\n \"def create_normalization_file(use_controls, use_nofcd, mods):\\n\\n for j in range(1, mods + 1):\\n fcd_paths = sorted(glob.glob(FCD_FOLDER + f'fcd_*.{j}.nii.gz'))\\n nofcd_paths = sorted(glob.glob(FCD_FOLDER + f'nofcd_*.{j}.nii.gz'))\\n control_paths = sorted(glob.glob(CONTROL_FOLDER + f'control_*.{j}.nii.gz'))\\n\\n mri_paths = fcd_paths\\n if use_nofcd:\\n mri_paths += nofcd_paths\\n if use_controls:\\n mri_paths += control_paths\\n\\n t1_landmarks_path = Path(f'./data/t1_landmarks_{j}.npy')\\n\\n if t1_landmarks_path.is_file():\\n continue\\n # os.remove(f'./data/t1_landmarks_{j}.npy')\\n\\n t1_landmarks = (\\n t1_landmarks_path\\n if t1_landmarks_path.is_file()\\n else HistogramStandardization.train(mri_paths)\\n )\\n\\n np.save(t1_landmarks_path, t1_landmarks, allow_pickle=True)\",\n \"def generate_mos(laygen, objectname_pfix, placement_grid, routing_grid_m1m2, devname_mos_boundary, devname_mos_body,\\n devname_mos_dmy, m=1, m_dmy=0, origin=np.array([0,0])):\\n pg = placement_grid\\n rg12 = routing_grid_m1m2\\n pfix = objectname_pfix\\n\\n # placement\\n imbl0 = laygen.relplace(name=\\\"I\\\" + pfix + 'BL0', templatename=devname_mos_boundary, gridname=pg, xy=origin)\\n refi=imbl0\\n if not m_dmy==0:\\n imdmyl0 = laygen.relplace(name=\\\"I\\\" + pfix + 'DMYL0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\\n refi=imdmyl0\\n else:\\n imdmyl0 = None\\n im0 = laygen.relplace(name=\\\"I\\\" + pfix + '0', templatename=devname_mos_body, gridname=pg, refobj=refi, shape=[m, 1])\\n refi=im0\\n if not m_dmy==0:\\n imdmyr0 = laygen.relplace(name=\\\"I\\\" + pfix + 'DMYR0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\\n refi=imdmyr0\\n else:\\n imdmyr0 = None\\n imbr0 = laygen.relplace(name=\\\"I\\\" + pfix + 'BR0', templatename=devname_mos_boundary, gridname=pg, refobj=imdmyr0)\\n md=im0.elements[:, 0]\\n #route\\n #gate\\n rg0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['G0'], refobj1=md[-1].pins['G0'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['G0'], gridname=rg12)\\n #drain\\n rdl0=laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=md[0].pins['D0'], refobj1=md[-1].pins['D0'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 1], refobj=_md.pins['D0'], gridname=rg12)\\n #source\\n rs0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['S0'], refobj1=md[-1].pins['S1'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['S0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=md[-1].pins['S1'], gridname=rg12)\\n #dmy\\n if m_dmy>=2:\\n mdmyl=imdmyl0.elements[:, 0]\\n mdmyr=imdmyr0.elements[:, 0]\\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyl[0].pins['D0'], refobj1=mdmyl[-1].pins['D0'])\\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyr[0].pins['D0'], refobj1=mdmyr[-1].pins['D0'])\\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyl[0].pins['S0'], refobj1=mdmyl[-1].pins['S1'])\\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyr[0].pins['S0'], refobj1=mdmyr[-1].pins['S1'])\\n for _mdmyl in mdmyl:\\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyl.pins['D0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyl.pins['S0'], gridname=rg12)\\n for _mdmyr in mdmyr:\\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyr.pins['D0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyr.pins['S1'], gridname=rg12)\\n return [imbl0, imdmyl0, im0, imdmyr0, imbr0]\",\n \"def write_mp_cards(bc_file, bc_class):\\n mc = bc_class.model_constants\\n bc_file.write('! Global Material Properties\\\\n')\\n bc_file.write('MP MU {}\\\\n'.format(mc.kinematic_viscosity))\\n bc_file.write('MP G {}\\\\n'.format(mc.gravity))\\n bc_file.write('MP RHO {}\\\\n'.format(mc.density))\\n if mc.enable_wetting_drying:\\n bc_file.write('MP DTL {}\\\\n'.format(mc.wet_dry_limit))\\n bc_file.write('MP MUC {}\\\\n'.format(mc.mannings_unit_constant))\\n bc_file.write('\\\\n')\\n\\n bc_file.write('! Material Properties\\\\n')\\n for id, mat_prop in bc_class.material_properties.items():\\n if mat_prop.eddy_viscosity_method == 'Constant (EVS)':\\n bc_file.write('MP EVS {} {} {} {}\\\\n'.format(id, mat_prop.vxx_eddy_viscosity, mat_prop.vyy_eddy_viscosity,\\n mat_prop.vxy_eddy_viscosity))\\n\\n elif mat_prop.eddy_viscosity_method == 'Estimated (EEV)':\\n objects = list(mat_prop.param.estimated_eddy_viscosity_method.get_range())\\n bc_file.write('MP EEV {} {} {}\\\\n'.format(id, mat_prop.estimated_eddy_viscosity_weighting_factor,\\n mat_prop.estimated_eddy_viscosity_method))\\n if mat_prop.coriolis:\\n bc_file.write('MP COR {} {}\\\\n'.format(id, mat_prop.coriolis_latitude))\\n bc_file.write('MP SRT {} {}\\\\n'.format(id, mat_prop.refinement_tolerance))\\n bc_file.write('MP ML {} {}\\\\n'.format(id, mat_prop.max_refinement_level))\\n if bc_class.operation_parameters.transport != 0:\\n for id1, tran_prop in mat_prop.transport_properties.items():\\n bc_file.write('MP TRT {} {} {}\\\\n'.format(id, id1, tran_prop.refinement_tolerance))\\n if tran_prop.refinement_tolerance > 0 and mat_prop.eddy_viscosity_method == 'Constant (EVS)':\\n bc_file.write('MP DF {} {} {}\\\\n'.format(id, id1, tran_prop.turbulent_diffusion_rate))\\n if bc_class.operation_parameters.wind:\\n wnd = mat_prop.wind_properties\\n bc_file.write('MP WND STR {} {}\\\\n'.format(id, wnd.stress_formulation))\\n bc_file.write('MP WND ATT {} {}\\\\n'.format(id, wnd.attenuation))\\n\\n bc_file.write('\\\\n') # blank line at the end of the Material Properties\",\n \"def sc2depictions(chromosome, root_name=\\\"output\\\", lot=0):\\n mol_structure = sc2mol_structure(chromosome, lot=lot)\\n mol2pdb(mol_structure, \\\"{0}.pdb\\\".format(root_name))\\n mol2xyz(mol_structure, \\\"{0}.xyz\\\".format(root_name))\\n Draw.MolToFile(mol_structure, \\\"{0}.png\\\".format(root_name))\\n logger.info(\\\"Generated depictions with root name {0}\\\".format(root_name))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.637841","0.6184567","0.6101035","0.6063938","0.59966964","0.5898186","0.5831032","0.5792886","0.56806254","0.5673659","0.5642974","0.56186104","0.5612226","0.5589771","0.55712795","0.55688566","0.55426204","0.5509481","0.5476108","0.5453811","0.5441293","0.54330695","0.5431424","0.5414131","0.5385509","0.53829294","0.5375447","0.5328336","0.53228354","0.5321947","0.5318898","0.53159505","0.5315505","0.5307181","0.53003657","0.5295449","0.5292908","0.52909136","0.5288011","0.5272096","0.5265378","0.52650017","0.5255084","0.52498764","0.52448916","0.52421767","0.52316004","0.5228","0.52202857","0.5217112","0.52134454","0.5209725","0.52059","0.519917","0.51843125","0.51818025","0.51816076","0.5180873","0.5163552","0.5162943","0.51577324","0.51572305","0.5152732","0.51491064","0.5147658","0.5146195","0.51417404","0.5140839","0.5134263","0.5131696","0.5131328","0.51250607","0.5122811","0.5118456","0.5117493","0.51082325","0.510054","0.5098085","0.50858533","0.50854087","0.5084667","0.5084667","0.5081934","0.5075706","0.5075606","0.5072391","0.50701183","0.50694525","0.5066464","0.5064185","0.5063714","0.5058079","0.50527436","0.5052075","0.50463414","0.50453717","0.5038951","0.50357836","0.50346065","0.50335747"],"string":"[\n \"0.637841\",\n \"0.6184567\",\n \"0.6101035\",\n \"0.6063938\",\n \"0.59966964\",\n \"0.5898186\",\n \"0.5831032\",\n \"0.5792886\",\n \"0.56806254\",\n \"0.5673659\",\n \"0.5642974\",\n \"0.56186104\",\n \"0.5612226\",\n \"0.5589771\",\n \"0.55712795\",\n \"0.55688566\",\n \"0.55426204\",\n \"0.5509481\",\n \"0.5476108\",\n \"0.5453811\",\n \"0.5441293\",\n \"0.54330695\",\n \"0.5431424\",\n \"0.5414131\",\n \"0.5385509\",\n \"0.53829294\",\n \"0.5375447\",\n \"0.5328336\",\n \"0.53228354\",\n \"0.5321947\",\n \"0.5318898\",\n \"0.53159505\",\n \"0.5315505\",\n \"0.5307181\",\n \"0.53003657\",\n \"0.5295449\",\n \"0.5292908\",\n \"0.52909136\",\n \"0.5288011\",\n \"0.5272096\",\n \"0.5265378\",\n \"0.52650017\",\n \"0.5255084\",\n \"0.52498764\",\n \"0.52448916\",\n \"0.52421767\",\n \"0.52316004\",\n \"0.5228\",\n \"0.52202857\",\n \"0.5217112\",\n \"0.52134454\",\n \"0.5209725\",\n \"0.52059\",\n \"0.519917\",\n \"0.51843125\",\n \"0.51818025\",\n \"0.51816076\",\n \"0.5180873\",\n \"0.5163552\",\n \"0.5162943\",\n \"0.51577324\",\n \"0.51572305\",\n \"0.5152732\",\n \"0.51491064\",\n \"0.5147658\",\n \"0.5146195\",\n \"0.51417404\",\n \"0.5140839\",\n \"0.5134263\",\n \"0.5131696\",\n \"0.5131328\",\n \"0.51250607\",\n \"0.5122811\",\n \"0.5118456\",\n \"0.5117493\",\n \"0.51082325\",\n \"0.510054\",\n \"0.5098085\",\n \"0.50858533\",\n \"0.50854087\",\n \"0.5084667\",\n \"0.5084667\",\n \"0.5081934\",\n \"0.5075706\",\n \"0.5075606\",\n \"0.5072391\",\n \"0.50701183\",\n \"0.50694525\",\n \"0.5066464\",\n \"0.5064185\",\n \"0.5063714\",\n \"0.5058079\",\n \"0.50527436\",\n \"0.5052075\",\n \"0.50463414\",\n \"0.50453717\",\n \"0.5038951\",\n \"0.50357836\",\n \"0.50346065\",\n \"0.50335747\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7661663"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":192,"cells":{"query":{"kind":"string","value":"write compressed meds file"},"document":{"kind":"string","value":"def write(self, filename):\n assert filename[-3:]=='.fz','name must end in .fz'\n\n files.makedir_fromfile(filename)\n\n ucfilename=filename[0:-3]\n bname = os.path.basename(ucfilename)\n\n tmp_path = os.path.join(\n files.get_temp_dir(),\n bname,\n )\n files.makedir_fromfile(tmp_path)\n\n with TempFile(tmp_path) as tfile:\n super(CosmosMEDSMaker,self).write(tfile.path)\n self._compress_meds_file(tfile.path, 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 write_compressed(self, filename):\n\n # Define which molecules to use \n # (counting indices of processed data set)\n indices = np.arange(len(self))\n # All charges and position arrays have the same size\n # (the one of the biggest molecule)\n size = np.max( self.num_atoms )\n # Initialize arrays\n num_atoms = np.zeros(len(indices))\n labels = np.zeros(len(indices))\n charges = np.zeros([len(indices),size])\n positions = np.zeros([len(indices),size,3])\n # For each molecule ...\n for j,idx in enumerate(indices):\n # load the data\n sample = self[idx]\n # assign per-molecule data\n labels[j] = sample['data']\n num_atoms[j] = sample['num_atoms']\n # ... and for each atom:\n for ia in range(sample['num_atoms']):\n charges[j,ia] = sample['charges'][ia]\n positions[j,ia,0] = sample['positions'][ia][0] \n positions[j,ia,1] = sample['positions'][ia][1] \n positions[j,ia,2] = sample['positions'][ia][2]\n\n # Merge pairs\n print(labels.shape,charges.shape,positions.shape)\n labels = labels[0::2]\n charges = np.array([np.concatenate((charges[i],charges[i+1])) for i in indices[0::2]])\n positions = np.array([np.concatenate((positions[i],positions[i+1])) for i in indices[0::2]])\n print(labels.shape,charges.shape,positions.shape)\n \n # Create a dictionary with all the values to save\n save_dict = {}\n save_dict['label'] = labels\n save_dict['charges'] = charges\n save_dict['positions'] = positions\n\n # Save as a compressed array \n np.savez_compressed(filename,**save_dict)\n \n return","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 save_compressed(data, filename, compression_type='bz2', create_link=False):\n # write to compressed HDF5 file\n hdf5 = open_compressed(filename, 'w')\n save(data, hdf5)\n close_compressed(filename, hdf5, compression_type, create_link)","def write_chunk(self, outfile, tag, data):\n outfile.write(struct.pack(\"!i\", len(data)))\n outfile.write(tag)\n outfile.write(data)\n checksum = zlib.crc32(tag)\n checksum = zlib.crc32(data, checksum)\n outfile.write(struct.pack(\"!i\", checksum))","def save_to_gzip(data,fname):\n with gzip.open(fname + '.gz', 'wb',compresslevel = 9) as f:\n f.write(data.tobytes())","def saveToFile(fileName):\n outfile = open (fileName, \"w\")\n chunkInfoKeys = gChunkMap.keys()\n chunkInfoKeys.sort()\n\n for chunkInfo in chunkInfoKeys:\n c = gChunkMap[chunkInfo]\n outfile.write(c.printChunkInfo())\n outfile.write(\"\\n\");","def savez(d,file):\n np.savez(file,row=d.row,col=d.col,data=d.data,shape=d.shape)","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 _write_dx(self, FN, data):\n n_points = data['counts'][0] * data['counts'][1] * data['counts'][2]\n if FN.endswith('.dx'):\n F = open(FN, 'w')\n else:\n import gzip\n F = gzip.open(FN, 'w')\n\n F.write(\"\"\"object 1 class gridpositions counts {0[0]} {0[1]} {0[2]}\norigin {1[0]} {1[1]} {1[2]}\ndelta {2[0]} 0.0 0.0\ndelta 0.0 {2[1]} 0.0\ndelta 0.0 0.0 {2[2]}\nobject 2 class gridconnections counts {0[0]} {0[1]} {0[2]}\nobject 3 class array type double rank 0 items {3} data follows\n\"\"\".format(data['counts'], data['origin'], data['spacing'], n_points))\n\n for start_n in range(0, len(data['vals']), 3):\n F.write(' '.join(['%6e' % c\n for c in data['vals'][start_n:start_n + 3]]) + '\\n')\n\n F.write('object 4 class field\\n')\n F.write('component \"positions\" value 1\\n')\n F.write('component \"connections\" value 2\\n')\n F.write('component \"data\" value 3\\n')\n F.close()","def depth_write(filename, depth):\n height,width = depth.shape[:2]\n f = open(filename,'wb')\n # write the header\n f.write(TAG_CHAR)\n np.array(width).astype(np.int32).tofile(f)\n np.array(height).astype(np.int32).tofile(f)\n \n depth.astype(np.float32).tofile(f)\n f.close()","def write(obj, fpath, flag=jpegio.DECOMPRESSED):\r\n if flag is jpegio.DECOMPRESSED:\r\n obj.write(fpath)\r\n elif flag == jpegio.ZIGZAG_DCT_1D:\r\n raise ValueError(\"ZIGZAG_DCT_1D: not supported yet\")\r\n\r\n return obj","def write(self, cull=False):\n if cull:\n cull_prefixes(self).write()\n else:\n ser = self.g.serialize(format='nifttl', encoding='utf-8')\n with open(self.filename, 'wb') as f:\n f.write(ser)\n #print('yes we wrote the first version...', self.name)","def writexyz(self,fname):\n xyzfile = open(fname + \".xyz\",\"a+\")\n xyzfile.write(str(self.natoms) + \"\\n\\n\")\n for a in self.atoms:\n \tcxyz = a.xyz - np.array(self.pbc_correction(a.xyz))\n\t\t\txyzfile.write(str(a.type) + \"\\t\" + str(cxyz[0]) + \"\\t\" + str(cxyz[1]) + \"\\t\" + str(cxyz[2]) + \"\\n\")\n xyzfile.close()","def saveenergyfile(path, meta, data):\n def serializemeta(meta):\n \"\"\"Convert metadata object to list of comment strings\"\"\"\n return [u\"#CTE_%s: %s\" % (key, meta[key]) for key in meta]\n\n with io.open(path, 'w+') as ff:\n ff.write(u\"\\n\".join(serializemeta(meta)))\n ff.write(u\"\\nvector,tipo,src_dst\\n\")\n for c in data:\n carrier = c['carrier']\n ctype = c['ctype']\n originoruse = c['originoruse']\n values = u\", \".join(u\"%.2f\" % v for v in c['values'])\n comment = u\" # %s\" % c['comment'] if c['comment'] else u\"\"\n ff.write(u\"%s, %s, %s, %s%s\\n\" % (carrier, ctype, originoruse, values, comment))","def write(self, file):\n #write header\n self.ID.write(file)\n if (self.write_size): \n self.size.write(file)\n for variable in self.variables:\n variable.write(file)\n for subchunk in self.subchunks:\n subchunk.write(file)","def to_file(self, filename):\n self.header['n'] = self.n\n save_gyre(filename, self.header, self.data)","def save_file(map_, args): \n if args.segments:\n p = os.path.join(args.res_dir, 'compression_'+args.db+\"_seg\")\n else:\n p = os.path.join(args.res_dir, 'compression_'+args.db)\n with open(p, 'w') as f:\n for file in map_:\n f.write(\"{} {}\\n\".format(file, map_[file]))","def savemat(self, file_name):\n d = {'dG0_prime': self.dG0_prime,\n 'dG0': self.dG0,\n 'T': self.T,\n 'I': self.I,\n 'pH': self.pH,\n 'pMg': self.pMg,\n 'weight': self.weight,\n 'cids': self.cids,\n 'S': self.S.values}\n savemat(file_name, d, oned_as='row')","def save(self, fname, compression='blosc'):\n\n bo = {\n 'data': self.data.values,\n 'locs': self.locs,\n 'sessions': self.sessions,\n 'sample_rate': self.sample_rate,\n 'kurtosis': self.kurtosis,\n 'kurtosis_threshold' : self.kurtosis_threshold,\n 'meta': self.meta,\n 'date_created': self.date_created,\n 'minimum_voxel_size': self.minimum_voxel_size,\n 'maximum_voxel_size': self.maximum_voxel_size,\n 'label' : self.label,\n 'filter' : self.filter,\n }\n\n if fname[-3:] != '.bo':\n fname += '.bo'\n\n dd.io.save(fname, bo, compression=compression)","def write_uncompressed_skims(skims, directory, overwrite=False):\n os.makedirs(directory, exist_ok=True)\n for k in skims:\n filename = os.path.join(directory, f\"{k}.emx\")\n if not os.path.exists(filename) or overwrite:\n skims[k].values.tofile(filename)","def writepdb(self,fname):\n pdbfile = open(fname + \".pdb\", \"w\")\n for a in self.atoms:\n pdbfile.write(str(a.type) + \"\\t\" + str(a.x) + \"\\t\" + str(a.y) + \"\\t\" + str(a.z) + \"\\n\")\n pdbfile.close()","def dict2file(dict, filename, foldername):\n if foldername:\n if not os.path.exists(\"../Created_QD/\" + foldername):\n os.makedirs(\"../Created_QD/\" + foldername)\n file = open(\"../Created_QD/\" + foldername + \"/\" + filename + \".xyz\", \"w\")\n else:\n file = open(\"../Created_QD/\" + filename + \".xyz\", \"w\")\n file.write(\" \\n\\n\")\n for atom, values in dict.items():\n file.write(values['element'] + \"\\t\" + str(values['coor'][0]) + \"\\t\\t\" +\n str(values['coor'][1]) + \"\\t\\t\" + str(values['coor'][2]) + \"\\n\")\n file.seek(0)\n file.write(str(len(dict)))\n file.close()\n print(\"\\nQuantum Dot created :)\")","def _saveBinaryData_compressed(self, file, with_axis=None):\n if with_axis is not None:\n data = self._data_with_axis(with_axis)\n numpy.save_compressed(file, data=data)\n else:\n numpy.savez_compressed(file, data=self.data)","def write (self, file):\n\t\tfile.write (self.pack ())","def save_compression():\n added,comp_seq, binary_seq, seq, file = binary_to_utf8()\n huffman_code, binary_seq = huffman_construction(seq)\n \n #save the number of zeroes added to the dictionnary \n huffman_code[\"add\"]= added\n created_file = os.path.splitext(file)[0]\n file_comp = open(created_file + \"_compressed.txt\", \"w\") \n \n #save the dictionnary in the file and the compressed sequence\n json.dump(huffman_code, file_comp)\n file_comp.write(\"\\n\"+comp_seq) \n file_comp.close()\n \n messagebox.showinfo(\"Information\", \"Your compression has been saved in \"+created_file +\"_compressed.txt file.\")\n return comp_seq, binary_seq, seq","def write_multfile(image_coords, source_z, file_name = 'multfile.in'):\n print 'write_multfile'\n file_in = open(file_name, 'w')\n file_in.write('#REFERENCE 3 0.0 0.0\\n')\n\n for i in range(len(image_coords)):\n image_id = 'A' + str(i+1) + ' '\n data = str(image_coords[i][0]) + ' ' + str(image_coords[i][1]) \\\n + str(' 0.2 0.2 0 ') + str(source_z) + ' 0'\n final = image_id + data + '\\n'\n file_in.write(final)\n file_in.close()","def compressed_pickle(title, data):\n with bz2.BZ2File(title, 'w') as f:\n cPickle.dump(data, f)","def writeNMD(filename, modes, atoms, zeros=False):\n\n if not isinstance(modes, (NMA, ModeSet, Mode, Vector)):\n raise TypeError('modes must be NMA, ModeSet, Mode, or Vector, '\n 'not {0}'.format(type(modes)))\n if modes.numAtoms() != atoms.numAtoms():\n raise Exception('number of atoms do not match')\n out = openFile(addext(filename, '.nmd'), 'w')\n\n #out.write('#!{0} -e\\n'.format(VMDPATH))\n out.write('nmwiz_load {0}\\n'.format(abspath(filename)))\n name = modes.getTitle()\n name = name.replace(' ', '_').replace('.', '_')\n if not name.replace('_', '').isalnum() or len(name) > 30:\n name = str(atoms)\n name = name.replace(' ', '_').replace('.', '_')\n if not name.replace('_', '').isalnum() or len(name) > 30:\n name = splitext(split(filename)[1])[0]\n out.write('name {0}\\n'.format(name))\n try:\n coords = atoms.getCoords()\n except:\n raise ValueError('coordinates could not be retrieved from atoms')\n if coords is None:\n raise ValueError('atom coordinates are not set')\n\n try:\n data = atoms.getNames()\n if data is not None:\n out.write('atomnames {0}\\n'.format(' '.join(data)))\n except:\n pass\n try:\n data = atoms.getResnames()\n if data is not None:\n out.write('resnames {0}\\n'.format(' '.join(data)))\n except:\n pass\n try:\n data = atoms.getResnums()\n if data is not None:\n out.write('resids ')\n data.tofile(out, ' ')\n out.write('\\n')\n except:\n pass\n try:\n data = atoms.getChids()\n if data is not None:\n out.write('chainids {0}\\n'.format(' '.join(data)))\n except:\n pass\n try:\n data = atoms.getSegnames()\n if data is not None:\n out.write('segnames {0}\\n'.format(' '.join(data)))\n except:\n pass\n\n try:\n data = atoms.getBetas()\n if data is not None:\n out.write('bfactors ')\n data.tofile(out, ' ', '%.2f')\n out.write('\\n')\n except:\n pass\n\n format = '{0:.3f}'.format\n out.write('coordinates ')\n coords.tofile(out, ' ', '%.3f')\n out.write('\\n')\n count = 0\n if isinstance(modes, Vector):\n out.write('mode 1 {0:.2f} '.format(abs(modes)))\n modes.getNormed()._getArray().tofile(out, ' ', '%.3f')\n out.write('\\n')\n count += 1\n else:\n if isinstance(modes, Mode):\n modes = [modes]\n for mode in modes:\n if (mode.getEigval() < ZERO) and not zeros:\n continue\n elif (mode.getEigval() < ZERO) and zeros:\n out.write('mode {0} {1:.2f} '.format(\n mode.getIndex()+1, np.sqrt(1/(0.0001*(mode.getIndex()+1)))))\n else:\n out.write('mode {0} {1:.2f} '.format(\n mode.getIndex()+1, mode.getVariance()**0.5))\n arr = mode._getArray().tofile(out, ' ', '%.3f')\n out.write('\\n')\n count += 1\n if count == 0:\n LOGGER.warning('No normal mode data was written. '\n 'Given modes might have 0 eigenvalues.')\n out.close()\n return filename","def writeChunk(chunk):","def writeFFDFile(fileName, nBlocks, nx, ny, nz, points):\n\n f = open(fileName, \"w\")\n\n f.write(\"%d\\n\" % nBlocks)\n for i in range(nBlocks):\n f.write(\"%d %d %d \" % (nx[i], ny[i], nz[i]))\n # end\n f.write(\"\\n\")\n for block in range(nBlocks):\n for k in range(nz[block]):\n for j in range(ny[block]):\n for i in range(nx[block]):\n f.write(\"%f \" % points[block][i, j, k, 0])\n # end\n # end\n # end\n f.write(\"\\n\")\n\n for k in range(nz[block]):\n for j in range(ny[block]):\n for i in range(nx[block]):\n f.write(\"%f \" % points[block][i, j, k, 1])\n # end\n # end\n # end\n f.write(\"\\n\")\n\n for k in range(nz[block]):\n for j in range(ny[block]):\n for i in range(nx[block]):\n f.write(\"%f \" % points[block][i, j, k, 2])\n # end\n # end\n # end\n # end\n f.close()\n return","def write_data():","def Construct3DMolToFile(fileName,writeFile):\r\n # Writing sets of molecules\r\n \r\n\r\n w = Chem.SDWriter(writeFile)\r\n suppl = Chem.SDMolSupplier(fileName)\r\n mols = [x for x in suppl]\r\n for mol in mols:\r\n \t# print(mol.GetProp(\"Solvent\"))\r\n \t# print(mol.GetPropNames)\r\n \tsignal.signal(signal.SIGALRM, handler)\r\n \tsignal.alarm(100)\r\n \ttry:\r\n \t\tmol3d = GetMolFromMol(mol,dimension=3)\r\n \t\tw.write(mol3d)\r\n \texcept Exception:\r\n \t\tmol3d = mol\r\n \t\tw.write(mol3d)\r\n \t\t# print(mol.GetPropsAsDict())\r\n\r\n\r\n w.close()","def write(self, filename):\n f = open(filename, 'w')\n f.write(str(self.m) + \"\\n\")\n f.write(str(self.n) + \"\\n\")\n for i in self.values:\n for j in i:\n f.write(str(j)+\"\\n\")\n f.closed","def dumpData(self,out):\n #--Header\n out.packSub('MAPH','ii',512,9)\n #--Data\n out.pack('4si','MAPD',512*512*3)\n out.write(''.join(self.mapd))","def write(self, file):\n pos = file.tell()\n pickle.dump((self.index, self.meta, self.info), file)\n file.seek(0)\n\n # update the header with the position of the content index.\n file.write(struct.pack('<Q', pos))","def compress(in_file, out_file):\n with open(in_file, \"rb\") as f1:\n text = f1.read()\n freq = make_freq_dict(text)\n tree = huffman_tree(freq)\n codes = get_codes(tree)\n number_nodes(tree)\n print(\"Bits per symbol:\", avg_length(tree, freq))\n result = (num_nodes_to_bytes(tree) + tree_to_bytes(tree) +\n size_to_bytes(len(text)))\n result += generate_compressed(text, codes)\n with open(out_file, \"wb\") as f2:\n f2.write(result)","def save_decompression():\n dna_seq, bin_seq, comp_seq, file_comp = binary_to_seq()\n \n #create a new file containing the original sequence\n file_path = os.path.splitext(file_comp)[0]\n file = open(file_path+ \"_decompressed.txt\", \"w\")\n file.write(dna_seq)\n file.close()\n \n #show a message for saving\n messagebox.showinfo(\"Information\", \"Your decompression has been saved in \"\n +file_path+\"_decompressed.txt.\")\n \n #print(comp_seq, dna_seq, bin_seq)\n return comp_seq, dna_seq, bin_seq","def _write(self, out_file):\n out_file.write(' '.encode()) # pad byte\n out_file.write('{:4d}'.format(self.key).encode())\n out_file.write(self.code.encode())\n out_file.write((' '*18).encode()) # pad bytes\n out_file.write('{:12d}'.format(self.numnod).encode())\n out_file.write((' '*37).encode()) # pad bytes\n out_file.write('{:1d}'.format(self.format).encode())\n out_file.write('\\n'.encode())\n\n for node in self.nodes:\n if self.format < 2:\n out_file.write(' '.encode())\n out_file.write('-1'.encode())\n if self.format == 0:\n out_file.write('{:5d}'.format(node.number).encode())\n else:\n out_file.write('{:10d}'.format(node.number).encode())\n for i in range(3):\n out_file.write('{:12.5E}'.format(node.pos[i]).encode())\n out_file.write('\\n'.encode())\n else:\n out_file.write(struct.pack('i', node.number))\n if self.format == 2:\n out_file.write(struct.pack('fff', *node.pos))\n else:\n out_file.write(struct.pack('ddd', *node.pos))\n\n if self.format < 2:\n out_file.write(' -3\\n'.encode()) # last record for ascii only","def write_mat_file(self):\n mat_dict = {}\n mat_dict['Lx_p'] = self.Lx_p\n mat_dict['Ly_p'] = self.Ly_p\n mat_dict['Lz_p'] = self.Lz_p\n mat_dict['Lo'] = self.obst.get_Lo()\n mat_dict['Ny_divs'] = self.N_divs\n mat_dict['rho_p'] = self.rho_p\n mat_dict['nu_p'] = self.nu_p\n mat_dict['snl'] = list(np.union1d(self.obst_list[:],self.solid_list[:]))\n mat_dict['inl'] = list(self.inlet_list[:])\n mat_dict['onl'] = list(self.outlet_list[:])\n\n scipy.io.savemat('geometry_description',mat_dict)","def cam_write(filename, M, N):\n f = open(filename,'wb')\n # write the header\n f.write(TAG_CHAR)\n M.astype('float64').tofile(f)\n N.astype('float64').tofile(f)\n f.close()","def write_features_to_file(filename,locs,desc):\n savetxt(filename, hstack((locs, desc)))","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 writeMCToGR3File(filename, mc):\n nodes = np.vstack((mc.x, mc.y)).T\n nodalValues = mc.data[:, 0, 0].squeeze()[:, None]\n connectivity = mc.connectivity\n openBndNodes = []\n landBndNodes = []\n writeGR3File(filename, '', nodes, nodalValues, connectivity, mc.boundaries)","def write_megam_file(train_toks, encoding, stream, bernoulli: bool = ..., explicit: bool = ...):\n ...","def writeOutFileUMIs(barcode_dict, outFileName):\n with gzip.open(outFileName, 'wb') as out_file:\n \tfor barcode in barcode_dict:\n out_file.write(barcode)\n out_file.write(\"\\t\" + \"\\t\".join(barcode_dict[barcode]))\n out_file.write(\"\\n\")","def to_file(self, file_path, smirnoff_data):\n pass","def save_mb_obj(out_file, metaballs, vertices, vcolors=[], vnormals=[]):\n if out_file.endswith(\".gz\"):\n f_out = gzip.open(out_file, 'wt')\n else:\n f_out = open(out_file, 'w')\n\n f_out.write(\"####\\n\")\n f_out.write(\"#\\n\")\n f_out.write(\"# Metaballs: {}\\n\".format(len(metaballs.mbs)))\n f_out.write(\"#\\n\")\n f_out.write(\"# mth {}\\n\".format(str(metaballs.mth)))\n for mb in metaballs.mbs:\n mbstr = \"# \" + str(mb) + \"\\n\"\n f_out.write(mbstr)\n f_out.write(\"#\\n\")\n\n f_out.write(\"####\\n\")\n f_out.write(\"#\\n\")\n f_out.write(\"# Vertices: {}\\n\".format(len(vertices)))\n f_out.write(\"#\\n\")\n f_out.write(\"####\\n\")\n\n for vi, v in enumerate(vertices):\n vstr = \"v {} {} {}\".format(v[0], v[1], v[2])\n if len(vcolors) > 0:\n vc = vcolors[vi]\n vstr += \" {} {} {}\".format(vc[0], vc[1], vc[2])\n vstr += \"\\n\"\n f_out.write(vstr)\n\n f_out.write(\"# {} vertices\\n\\n\".format(len(vertices)))\n\n if len(vnormals) > 0:\n for vn in vnormals:\n vnstr = \"vn {} {} {}\\n\".format(vn[0], vn[1], vn[2])\n f_out.write(vnstr)\n\n f_out.write(\"# {} normals\\n\\n\".format(len(vnormals)))\n\n f_out.write(\"# End of File\")\n f_out.close()\n\n return True","def save(self, filename, compression=True, transpose=False,\n sparse=False, support=False, compression_opts=1):\n write_ga_file(filename, self.value, self[0].layout.metric, self[0].layout.basis_names,\n compression=compression, transpose=transpose,\n sparse=sparse, support=support, compression_opts=compression_opts)","def write_zfile(file_handle, data, compress=1):\r\n file_handle.write(_ZFILE_PREFIX)\r\n length = hex(len(data))\r\n if sys.version_info[0] < 3 and type(length) is long:\r\n # We need to remove the trailing 'L' in the hex representation\r\n length = length[:-1]\r\n # Store the length of the data\r\n file_handle.write(asbytes(length.ljust(_MAX_LEN)))\r\n file_handle.write(zlib.compress(asbytes(data), compress))","def write_density(fname, density):\n K, M, N = density.shape\n output = open(fname, \"w\")\n output.write(\"ARMA_CUB_TXT_FN008\\n\")\n output.write(\"%d %d %d\\n\" % (K, M, N))\n for i in range(N):\n for k in range(K):\n for m in range(M):\n output.write(\" %+.6e\" % density[k, m, i])\n output.write(\"\\n\")\n\n output.close()","def save_geneset_to_file(geneset, output_file):\n with gzip.open(output_file, \"w\") as handle:\n handle.write(\"\\n\".join(geneset).encode(\"utf-8\"))","def write_compressed_skims(skims, output=\"emmemat.zarr\"):\n known_exts = (\".zarr\", \".zarr.zip\")\n if not any(output.endswith(k) for k in known_exts):\n raise NotImplementedError(output)\n if output.endswith(\".zarr\"):\n skims.to_zarr(output, mode='a')\n elif output.endswith(\".zarr.zip\"):\n if os.path.exists(output):\n raise FileExistsError(output)\n with zarr.ZipStore(output, mode='w') as store:\n skims.to_zarr(store)","def write_mm(g, fn):\n f = open(fn, \"w\")\n f.write(\"%d %d %d\\n\" % (g.vcount(), g.vcount(), g.ecount()))\n\n if g.is_weighted():\n for e in g.es():\n f.write(\"%d %d %.4f\\n\" % (e.source, e.target, e[\"weight\"]))\n else:\n for e in g.es():\n f.write(\"%d %d 1\\n\" % (e.source, e.target))\n\n f.close()","def compress_file(in_file: str, out_file: str) -> None:\n with open(in_file, \"rb\") as f1:\n text = f1.read()\n freq = build_frequency_dict(text)\n tree = build_huffman_tree(freq)\n codes = get_codes(tree)\n number_nodes(tree)\n print(\"Bits per symbol:\", avg_length(tree, freq))\n result = (tree.num_nodes_to_bytes() + tree_to_bytes(tree) +\n int32_to_bytes(len(text)))\n result += compress_bytes(text, codes)\n with open(out_file, \"wb\") as f2:\n f2.write(result)","def write2hdf5(filename, dict2store, compression=\"lzf\"):\n\twith h5py.File(filename,'w') as hf:\n\t\tfor key,value in dict2store.iteritems():\n\t\t\thf.create_dataset(key, data=value,compression=compression)","def dumpData(self,out):\n #--Get sizes and dump into dataIO\n self.hedr.getSize()\n self.hedr.dump(out)\n for (name,size) in self.masters:\n out.packSub0('MAST',name)\n out.packSub('DATA','Q',size)\n if self.gmdt: \n self.gmdt.getSize()\n self.gmdt.dump(out)\n for other in self.others:\n other.getSize()\n other.dump(out)","def write_minisat(self):\n num_variables = len(self.label_encodings)\n num_clauses = self.num_clauses\n clauses = self.clauses\n outfile = MinisatRunner.temp_in\n out = open(outfile,\"w\")\n try:\n out.write(\"p cnf %3d %3d\\n\" % (num_variables,num_clauses))\n for clause in clauses:\n for clause_variable in clause:\n out.write(\" %3d\" % self.minisat_encode_label(clause_variable));\n out.write(\" 0\\n\")\n finally:\n out.close()","def dump_mat(filename, obj, **kwargs):\n return sio.savemat(filename, obj, **kwargs)","def savemodel(self, fname):\n if not fname.endswith('.gz'):\n fname += '.gz'\n D = {'clf':self.clf, 'vocab':self.vocab,\n 'idxlabelmap':self.labelmap}\n with gzip.open(fname, 'w') as fout:\n dump(D, fout)\n print 'Save model into file: {}'.format(fname)","def writeOutFileBarcodeCounts(barcode_dict_summary, outFileName):\n with gzip.open(outFileName, 'wb') as out_file:\n for barcode in barcode_dict_summary:\n out_file.write(barcode)\n out_file.write(\"\\t\" + \"\\t\".join(map(str,barcode_dict_summary[barcode])))\n out_file.write(\"\\n\")","def write_embeddings_to_file(self):\n modes = [self.generator, self.discriminator]\n for i in range(2):\n embedding_matrix = modes[i].embedding_matrix\n embedding_matrix = embedding_matrix.detach().to('cpu').numpy()\n index = np.array(range(self.n_node)).reshape(-1, 1)\n embedding_matrix = np.hstack([index, embedding_matrix])\n embedding_list = embedding_matrix.tolist()\n embedding_str = [str(int(emb[0])) + \"\\t\" + \"\\t\".join([str(x) for x in emb[1:]]) + \"\\n\" \n for emb in embedding_list]\n with open(config.emb_filenames[i], \"w+\") as f:\n lines = [str(self.n_node) + \"\\t\" + str(config.n_emb) + \"\\n\"] + embedding_str\n f.writelines(lines)","def save_nelder_mead_data(name, simplex, fvals, iters, evals):\n N = simplex.shape[0] # Number of points in simplex\n K = simplex.shape[1] # Total number of parameters\n\n with open(name + \".txt\", \"w\") as f:\n my_writer = csv.writer(f, delimiter=\",\")\n my_writer.writerow(simplex.shape)\n my_writer.writerow([iters, evals])\n for n in range(N):\n my_writer.writerow(simplex[n, :])\n my_writer.writerow(fvals)","def save_to_xyz(self, filename): \n with open( filename, 'a' ) as F:\n F = open( filename, 'a' )\n F.write( '%d\\n'%self.num_atoms )\n F.write( \"XYZ\\n\" )\n for num,row in enumerate(self.atoms):\n try:\n F.write('%s '%self.species[num])\n except:\n F.write('X%d '%num)\n F.write( mat2str( row, \"%16.10f\" ) )\n F.write( \"\\n\" )","def dump(self, file):\n if isinstance(file, basestring):\n file = open(file, 'w')\n metadb = self.metadb.dumps()\n file.write('v%s:%d\\n' % (self.VERSION, len(metadb)))\n file.write(metadb)\n file.write(self.datadb.dumps())","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 compress_image(filename,k):","def write_md_file(sip_uuid, filepath):\n sip = SIP.objects.get(pk=sip_uuid)\n md_object = load_file_data_from_db(sip, filepath)\n convert_md_object = json.dumps(\n md_object, sort_keys=True, ensure_ascii=False, indent=4\n )\n filename = os.path.join(filepath, \"metadata_output.json\")\n with open(filename, \"wb\") as f:\n f.write(six.ensure_binary(convert_md_object))","def write_metadata(metadata_buffer, meta_dir, meta_file_name):\n \n with open(os.path.join(meta_dir, meta_file_name), 'w+') as meta_file:\n writer = csv.writer(meta_file, delimiter=',', quotechar='\"')\n writer.writerows(metadata_buffer)","def compress(self, file):\n\t\t\n\t\ttext = file.read() \n\t\ttext = text.rstrip() #elimina los espacios en blanco del final\n\n\t\t\n\t\tfrequency = self.make_frequency_dict(text)#obtenemos la frencuencia de cada numero en el texto\n\t\tself.make_heap(frequency)\n\t\tself.merge_nodes()\n\t\tself.make_codes()\n\t\tencoded_text = self.get_encoded_text(text)\n\t\tpadded_encoded_text = self.pad_encoded_text(encoded_text)\n\n\t\tb = self.get_byte_array(padded_encoded_text)\n\n\t\treturn b","def WriteDataPack(resources, output_file, encoding):\n content = WriteDataPackToString(resources, encoding)\n with open(output_file, \"wb\") as file:\n file.write(content)","def compress_file(netcdf_file_name):\n\n radar_io.compress_file(netcdf_file_name)","def write_mir(self, filename):\n raise NotImplementedError","def close(self):\n # write META-INF\n self.zip.writestr(\"META-INF/container.xml\", str(self.xml))\n # write content.opf\n self.zip.writestr(\"OEBPS/content.opf\", str(self.opf))\n # write toc.ncx\n self.zip.writestr(\"OEBPS/toc.ncx\", str(self.ncx))\n self.zip.close()","def WriteDataPack(resources, output_file, encoding):\n content = WriteDataPackToString(resources, encoding)\n with open(output_file, 'wb') as file:\n file.write(content)","def write(self, fname):\n pass","def write(self, file):\n #write header\n for variable in self.variables:\n variable.write(file)\n for subchunk in self.subchunks:\n subchunk.write(file)","def compression(s):","def save_progress(filename, derm_counts):\n\n with open(filename, 'w') as f:\n f.write(\"zipcode,derms_within_%d_miles\\n\" % RADIUS)\n prefix = \"\"\n for key, val in derm_counts.iteritems():\n f.write(prefix)\n f.write(key)\n f.write(',')\n f.write(val)\n prefix= \"\\n\"","def write_xdmf(self, filename: str):\n\n mesh = UnstructuredMesh.from_h5(filename)\n mesh.write_h5(filename)","def save_as(self, filename: str) -> None:\n save_data = lzma.compress(pickle.dumps(self))\n with open(filename, \"wb\") as f:\n f.write(save_data)","def write(self, data: bytes, name: str, compress: bool = False):\n filepath = self.join(name)\n if compress:\n self.driver.write(gzip(data), filepath)\n else:\n self.driver.write(data, filepath)","def save_data(dfin, outfile=\"./FPeng_prepped\"):\n dfin.to_csv(outfile+'.csv', sep='\\t', index=False)\n # s3.meta.client.upload_file(outfile+\".csv\", 'p3-engine', 'ETL/FPeng_prepped.csv')\n print(\"csv...\", end=\" \")\n\n dfin.to_pickle(outfile+'.pkl' ,protocol=4)\n # s3.meta.client.upload_file(outfile+'.pkl', 'p3-engine', 'ETL/FPeng_prepped.pkl')\n print(\"pkl...\", end=\" \")\n #dfin.to_msgpack(outfile+'.msg')\n #print(\"msg...\", end=\" \")\n\n #s3.meta.client.upload_file(outfile+\".msg\", 'p3-engine', 'ETL/FPeng_prepped.msg')\n\n # print(\"to s3 complete\", end=\" \")","def write_cando_file(self, file_name):\n cando_writer = CandoWriter(self.dna_structure)\n cando_writer.write(file_name)","def tofile(self, filename:'Union[str, Path]',\n *args, **kwargs):\n\n self._data.tofile(filename, *args, **kwargs)\n dims_filename = filename + '.ini' # '.meta'\n self._dims.tofile(dims_filename)\n\n with open(dims_filename, mode='a') as file:\n file.write(f'dtype={self._data.dtype.name}\\n')","def write_structure_file(self, file_name):\n self.dna_structure.write(file_name,write_json_format=True)","def save(filename, points3, tris, metadata):\n logging.info(\"saving mesh: %s\"%filename)\n cells = {'triangle':tris}\n vtk_io.write(filename, points3, cells)\n with open(filename+'.readme','w') as fid:\n fid.write(metadata)","def write_data(data, filename):\n f = h5py.File(filename, 'w', libver='latest')\n dset = f.create_dataset('array', shape=(data.shape), data = data, compression='gzip', compression_opts=9)\n f.close()","def save(self, filename):\n target = open(filename, 'w')\n target.write(\"\\\\data\\\\\\n\")\n target.write(\"ngram 1=\" + str(len(self.f1)) + \"\\n\\n\")\n target.write(\"\\\\1-grams:\\n\")\n for w,p in sorted(self.f1.items()): \n target.write(str(p) + \" \" + w + \"\\n\")\n target.write(\"\\\\end\\\\\\n\")\n target.close()","def save(self, filename):\n with gzip.open(filename, \"w\") as f:\n f.write(pickle.dumps(self))","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 exportMmf(self, filename):\n self.matrix.export_mtx(filename)","def write(data):","def write_sigmf(data_file, data, buffer=None, append=True):\n\n packed = pack_bin(data)\n\n write_bin(data_file, packed, buffer, append)","def write_uem(uemf, uem, n_digits=3):\n with open(uemf, 'wb') as f:\n for file_id in sorted(iterkeys(uem)):\n for onset, offset in sorted(uem[file_id]):\n line = ' '.join([file_id,\n '1',\n format_float(onset, n_digits),\n format_float(offset, n_digits)\n ])\n f.write(line.encode('utf-8'))\n f.write(b'\\n')","def to_dat(self, **kwargs):\n return self.write(file_format=\"dat\", **kwargs)","def create_dnz_file(args):\n\n file = open(args.o, 'w')\n\n file.write(\"% ----DATA VARIABLES----\\n\\n\")\n file.write(\"t=\" + str(args.t) + \";\" + \"%number of attributes\\n\")\n file.write(\"k=\" + str(args.k) + \";\" + \"%max length of the support set\\n\")\n file.write(\"n=\" + str(args.n) + \";\" + \"%number of positive instances\\n\")\n file.write(\"m=\" + str(args.m) + \";\" + \"%number of negative instances\\n\")\n file.write(\"c=\" + str(args.c) + \";\" + \"%number of atMostOne Constraints\\n\\n\")\n\n file.write(\"% ----OMEGAS----\\n\\n\")\n\n omega_p = generate_omega_data(args.t, args.n, args.b)\n file.write(\"omegap= \" + omega_to_mz(omega_p) + \"\\n\\n\")\n\n omega_n = generate_disjoint_omega_data(omega_p, args.m, args.b)\n file.write(\"omegan= \" + omega_to_mz(omega_n) + \"\\n\\n\")\n\n file.write(\"% ----CONSTRAINS----\\n\\n\")\n at_most_one = generate_at_most_one(int(args.t/2), args.c, 1, args.t)\n file.write(\"atMostOne=\" + at_most_one_to_mz(at_most_one))","def save_compressed_image(self, filename):\n if filename[-5:] != '.pbz2':\n filename + '.pbz2'\n self.compressed_pickle(filename, self)","def write_shortfile_table(self):\n\n # KMEL actually removes duplicate short filenames from this\n # table.\n\n start_of_shortfiles = self.db_file.tell()\n\n shortfiles = {}\n for miEntry in self.mainIndex:\n short_filename = miEntry.encodedShortfile\n if short_filename in shortfiles:\n miEntry.set_shortfile_offset(\n shortfiles[short_filename])\n else:\n shortfiles[short_filename] = \\\n self.db_file.tell() - start_of_shortfiles\n\n miEntry.set_shortfile_offset(\n shortfiles[short_filename])\n self.db_file.write(short_filename)","def write(self, data, filename):\n id_ = 1\n weightlist_el = Element('weight-list')\n for dataset in data:\n weight_el = SubElement(weightlist_el, 'weight')\n id_el = SubElement(weight_el, 'id')\n id_el.text = str(id_)\n date_el = SubElement(weight_el, 'date')\n date_el.text = str(dataset.date) + 'T12:00:00'\n value_el = SubElement(weight_el, 'value')\n value_el.text = str(dataset.weight)\n comment_el = SubElement(weight_el, 'comment')\n comment_el.text = dataset.note\n id_ += 1\n st_tree = ElementTree(weightlist_el)\n st_tree.write(filename, encoding='UTF-8')","def write_out4fp(fname,specorder,nspcs,agr,nr,rmax,pairs,nperline=6):\n ndat = nr *len(pairs)\n data = np.zeros(ndat)\n n = 0\n for pair in pairs:\n isid,jsid = pair\n for i in range(nr):\n data[n] = agr[isid,jsid,i]\n n += 1\n\n with open(fname,'w') as f:\n f.write('# RDF for pairs: ')\n for pair in pairs:\n si = specorder[pair[0]-1]\n sj = specorder[pair[1]-1]\n f.write(' {0:s}-{1:s},'.format(si,sj))\n f.write('\\n')\n f.write('# rmax, nr = {0:.3f}, {1:d}\\n'.format(rmax,nr))\n f.write('#\\n')\n #...Num of data, weight for the data\n f.write(' {0:6d} {1:7.3f}\\n'.format(ndat, 1.0))\n j0 = 0\n while True:\n f.write(' '.join('{0:12.4e}'.format(data[j]) for j in range(j0,j0+nperline) if j < ndat))\n f.write('\\n')\n j0 += nperline\n if j0 >= ndat:\n break\n\n return None"],"string":"[\n \"def write_compressed(self, filename):\\n\\n # Define which molecules to use \\n # (counting indices of processed data set)\\n indices = np.arange(len(self))\\n # All charges and position arrays have the same size\\n # (the one of the biggest molecule)\\n size = np.max( self.num_atoms )\\n # Initialize arrays\\n num_atoms = np.zeros(len(indices))\\n labels = np.zeros(len(indices))\\n charges = np.zeros([len(indices),size])\\n positions = np.zeros([len(indices),size,3])\\n # For each molecule ...\\n for j,idx in enumerate(indices):\\n # load the data\\n sample = self[idx]\\n # assign per-molecule data\\n labels[j] = sample['data']\\n num_atoms[j] = sample['num_atoms']\\n # ... and for each atom:\\n for ia in range(sample['num_atoms']):\\n charges[j,ia] = sample['charges'][ia]\\n positions[j,ia,0] = sample['positions'][ia][0] \\n positions[j,ia,1] = sample['positions'][ia][1] \\n positions[j,ia,2] = sample['positions'][ia][2]\\n\\n # Merge pairs\\n print(labels.shape,charges.shape,positions.shape)\\n labels = labels[0::2]\\n charges = np.array([np.concatenate((charges[i],charges[i+1])) for i in indices[0::2]])\\n positions = np.array([np.concatenate((positions[i],positions[i+1])) for i in indices[0::2]])\\n print(labels.shape,charges.shape,positions.shape)\\n \\n # Create a dictionary with all the values to save\\n save_dict = {}\\n save_dict['label'] = labels\\n save_dict['charges'] = charges\\n save_dict['positions'] = positions\\n\\n # Save as a compressed array \\n np.savez_compressed(filename,**save_dict)\\n \\n return\",\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 save_compressed(data, filename, compression_type='bz2', create_link=False):\\n # write to compressed HDF5 file\\n hdf5 = open_compressed(filename, 'w')\\n save(data, hdf5)\\n close_compressed(filename, hdf5, compression_type, create_link)\",\n \"def write_chunk(self, outfile, tag, data):\\n outfile.write(struct.pack(\\\"!i\\\", len(data)))\\n outfile.write(tag)\\n outfile.write(data)\\n checksum = zlib.crc32(tag)\\n checksum = zlib.crc32(data, checksum)\\n outfile.write(struct.pack(\\\"!i\\\", checksum))\",\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 saveToFile(fileName):\\n outfile = open (fileName, \\\"w\\\")\\n chunkInfoKeys = gChunkMap.keys()\\n chunkInfoKeys.sort()\\n\\n for chunkInfo in chunkInfoKeys:\\n c = gChunkMap[chunkInfo]\\n outfile.write(c.printChunkInfo())\\n outfile.write(\\\"\\\\n\\\");\",\n \"def savez(d,file):\\n np.savez(file,row=d.row,col=d.col,data=d.data,shape=d.shape)\",\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 _write_dx(self, FN, data):\\n n_points = data['counts'][0] * data['counts'][1] * data['counts'][2]\\n if FN.endswith('.dx'):\\n F = open(FN, 'w')\\n else:\\n import gzip\\n F = gzip.open(FN, 'w')\\n\\n F.write(\\\"\\\"\\\"object 1 class gridpositions counts {0[0]} {0[1]} {0[2]}\\norigin {1[0]} {1[1]} {1[2]}\\ndelta {2[0]} 0.0 0.0\\ndelta 0.0 {2[1]} 0.0\\ndelta 0.0 0.0 {2[2]}\\nobject 2 class gridconnections counts {0[0]} {0[1]} {0[2]}\\nobject 3 class array type double rank 0 items {3} data follows\\n\\\"\\\"\\\".format(data['counts'], data['origin'], data['spacing'], n_points))\\n\\n for start_n in range(0, len(data['vals']), 3):\\n F.write(' '.join(['%6e' % c\\n for c in data['vals'][start_n:start_n + 3]]) + '\\\\n')\\n\\n F.write('object 4 class field\\\\n')\\n F.write('component \\\"positions\\\" value 1\\\\n')\\n F.write('component \\\"connections\\\" value 2\\\\n')\\n F.write('component \\\"data\\\" value 3\\\\n')\\n F.close()\",\n \"def depth_write(filename, depth):\\n height,width = depth.shape[:2]\\n f = open(filename,'wb')\\n # write the header\\n f.write(TAG_CHAR)\\n np.array(width).astype(np.int32).tofile(f)\\n np.array(height).astype(np.int32).tofile(f)\\n \\n depth.astype(np.float32).tofile(f)\\n f.close()\",\n \"def write(obj, fpath, flag=jpegio.DECOMPRESSED):\\r\\n if flag is jpegio.DECOMPRESSED:\\r\\n obj.write(fpath)\\r\\n elif flag == jpegio.ZIGZAG_DCT_1D:\\r\\n raise ValueError(\\\"ZIGZAG_DCT_1D: not supported yet\\\")\\r\\n\\r\\n return obj\",\n \"def write(self, cull=False):\\n if cull:\\n cull_prefixes(self).write()\\n else:\\n ser = self.g.serialize(format='nifttl', encoding='utf-8')\\n with open(self.filename, 'wb') as f:\\n f.write(ser)\\n #print('yes we wrote the first version...', self.name)\",\n \"def writexyz(self,fname):\\n xyzfile = open(fname + \\\".xyz\\\",\\\"a+\\\")\\n xyzfile.write(str(self.natoms) + \\\"\\\\n\\\\n\\\")\\n for a in self.atoms:\\n \\tcxyz = a.xyz - np.array(self.pbc_correction(a.xyz))\\n\\t\\t\\txyzfile.write(str(a.type) + \\\"\\\\t\\\" + str(cxyz[0]) + \\\"\\\\t\\\" + str(cxyz[1]) + \\\"\\\\t\\\" + str(cxyz[2]) + \\\"\\\\n\\\")\\n xyzfile.close()\",\n \"def saveenergyfile(path, meta, data):\\n def serializemeta(meta):\\n \\\"\\\"\\\"Convert metadata object to list of comment strings\\\"\\\"\\\"\\n return [u\\\"#CTE_%s: %s\\\" % (key, meta[key]) for key in meta]\\n\\n with io.open(path, 'w+') as ff:\\n ff.write(u\\\"\\\\n\\\".join(serializemeta(meta)))\\n ff.write(u\\\"\\\\nvector,tipo,src_dst\\\\n\\\")\\n for c in data:\\n carrier = c['carrier']\\n ctype = c['ctype']\\n originoruse = c['originoruse']\\n values = u\\\", \\\".join(u\\\"%.2f\\\" % v for v in c['values'])\\n comment = u\\\" # %s\\\" % c['comment'] if c['comment'] else u\\\"\\\"\\n ff.write(u\\\"%s, %s, %s, %s%s\\\\n\\\" % (carrier, ctype, originoruse, values, comment))\",\n \"def write(self, file):\\n #write header\\n self.ID.write(file)\\n if (self.write_size): \\n self.size.write(file)\\n for variable in self.variables:\\n variable.write(file)\\n for subchunk in self.subchunks:\\n subchunk.write(file)\",\n \"def to_file(self, filename):\\n self.header['n'] = self.n\\n save_gyre(filename, self.header, self.data)\",\n \"def save_file(map_, args): \\n if args.segments:\\n p = os.path.join(args.res_dir, 'compression_'+args.db+\\\"_seg\\\")\\n else:\\n p = os.path.join(args.res_dir, 'compression_'+args.db)\\n with open(p, 'w') as f:\\n for file in map_:\\n f.write(\\\"{} {}\\\\n\\\".format(file, map_[file]))\",\n \"def savemat(self, file_name):\\n d = {'dG0_prime': self.dG0_prime,\\n 'dG0': self.dG0,\\n 'T': self.T,\\n 'I': self.I,\\n 'pH': self.pH,\\n 'pMg': self.pMg,\\n 'weight': self.weight,\\n 'cids': self.cids,\\n 'S': self.S.values}\\n savemat(file_name, d, oned_as='row')\",\n \"def save(self, fname, compression='blosc'):\\n\\n bo = {\\n 'data': self.data.values,\\n 'locs': self.locs,\\n 'sessions': self.sessions,\\n 'sample_rate': self.sample_rate,\\n 'kurtosis': self.kurtosis,\\n 'kurtosis_threshold' : self.kurtosis_threshold,\\n 'meta': self.meta,\\n 'date_created': self.date_created,\\n 'minimum_voxel_size': self.minimum_voxel_size,\\n 'maximum_voxel_size': self.maximum_voxel_size,\\n 'label' : self.label,\\n 'filter' : self.filter,\\n }\\n\\n if fname[-3:] != '.bo':\\n fname += '.bo'\\n\\n dd.io.save(fname, bo, compression=compression)\",\n \"def write_uncompressed_skims(skims, directory, overwrite=False):\\n os.makedirs(directory, exist_ok=True)\\n for k in skims:\\n filename = os.path.join(directory, f\\\"{k}.emx\\\")\\n if not os.path.exists(filename) or overwrite:\\n skims[k].values.tofile(filename)\",\n \"def writepdb(self,fname):\\n pdbfile = open(fname + \\\".pdb\\\", \\\"w\\\")\\n for a in self.atoms:\\n pdbfile.write(str(a.type) + \\\"\\\\t\\\" + str(a.x) + \\\"\\\\t\\\" + str(a.y) + \\\"\\\\t\\\" + str(a.z) + \\\"\\\\n\\\")\\n pdbfile.close()\",\n \"def dict2file(dict, filename, foldername):\\n if foldername:\\n if not os.path.exists(\\\"../Created_QD/\\\" + foldername):\\n os.makedirs(\\\"../Created_QD/\\\" + foldername)\\n file = open(\\\"../Created_QD/\\\" + foldername + \\\"/\\\" + filename + \\\".xyz\\\", \\\"w\\\")\\n else:\\n file = open(\\\"../Created_QD/\\\" + filename + \\\".xyz\\\", \\\"w\\\")\\n file.write(\\\" \\\\n\\\\n\\\")\\n for atom, values in dict.items():\\n file.write(values['element'] + \\\"\\\\t\\\" + str(values['coor'][0]) + \\\"\\\\t\\\\t\\\" +\\n str(values['coor'][1]) + \\\"\\\\t\\\\t\\\" + str(values['coor'][2]) + \\\"\\\\n\\\")\\n file.seek(0)\\n file.write(str(len(dict)))\\n file.close()\\n print(\\\"\\\\nQuantum Dot created :)\\\")\",\n \"def _saveBinaryData_compressed(self, file, with_axis=None):\\n if with_axis is not None:\\n data = self._data_with_axis(with_axis)\\n numpy.save_compressed(file, data=data)\\n else:\\n numpy.savez_compressed(file, data=self.data)\",\n \"def write (self, file):\\n\\t\\tfile.write (self.pack ())\",\n \"def save_compression():\\n added,comp_seq, binary_seq, seq, file = binary_to_utf8()\\n huffman_code, binary_seq = huffman_construction(seq)\\n \\n #save the number of zeroes added to the dictionnary \\n huffman_code[\\\"add\\\"]= added\\n created_file = os.path.splitext(file)[0]\\n file_comp = open(created_file + \\\"_compressed.txt\\\", \\\"w\\\") \\n \\n #save the dictionnary in the file and the compressed sequence\\n json.dump(huffman_code, file_comp)\\n file_comp.write(\\\"\\\\n\\\"+comp_seq) \\n file_comp.close()\\n \\n messagebox.showinfo(\\\"Information\\\", \\\"Your compression has been saved in \\\"+created_file +\\\"_compressed.txt file.\\\")\\n return comp_seq, binary_seq, seq\",\n \"def write_multfile(image_coords, source_z, file_name = 'multfile.in'):\\n print 'write_multfile'\\n file_in = open(file_name, 'w')\\n file_in.write('#REFERENCE 3 0.0 0.0\\\\n')\\n\\n for i in range(len(image_coords)):\\n image_id = 'A' + str(i+1) + ' '\\n data = str(image_coords[i][0]) + ' ' + str(image_coords[i][1]) \\\\\\n + str(' 0.2 0.2 0 ') + str(source_z) + ' 0'\\n final = image_id + data + '\\\\n'\\n file_in.write(final)\\n file_in.close()\",\n \"def compressed_pickle(title, data):\\n with bz2.BZ2File(title, 'w') as f:\\n cPickle.dump(data, f)\",\n \"def writeNMD(filename, modes, atoms, zeros=False):\\n\\n if not isinstance(modes, (NMA, ModeSet, Mode, Vector)):\\n raise TypeError('modes must be NMA, ModeSet, Mode, or Vector, '\\n 'not {0}'.format(type(modes)))\\n if modes.numAtoms() != atoms.numAtoms():\\n raise Exception('number of atoms do not match')\\n out = openFile(addext(filename, '.nmd'), 'w')\\n\\n #out.write('#!{0} -e\\\\n'.format(VMDPATH))\\n out.write('nmwiz_load {0}\\\\n'.format(abspath(filename)))\\n name = modes.getTitle()\\n name = name.replace(' ', '_').replace('.', '_')\\n if not name.replace('_', '').isalnum() or len(name) > 30:\\n name = str(atoms)\\n name = name.replace(' ', '_').replace('.', '_')\\n if not name.replace('_', '').isalnum() or len(name) > 30:\\n name = splitext(split(filename)[1])[0]\\n out.write('name {0}\\\\n'.format(name))\\n try:\\n coords = atoms.getCoords()\\n except:\\n raise ValueError('coordinates could not be retrieved from atoms')\\n if coords is None:\\n raise ValueError('atom coordinates are not set')\\n\\n try:\\n data = atoms.getNames()\\n if data is not None:\\n out.write('atomnames {0}\\\\n'.format(' '.join(data)))\\n except:\\n pass\\n try:\\n data = atoms.getResnames()\\n if data is not None:\\n out.write('resnames {0}\\\\n'.format(' '.join(data)))\\n except:\\n pass\\n try:\\n data = atoms.getResnums()\\n if data is not None:\\n out.write('resids ')\\n data.tofile(out, ' ')\\n out.write('\\\\n')\\n except:\\n pass\\n try:\\n data = atoms.getChids()\\n if data is not None:\\n out.write('chainids {0}\\\\n'.format(' '.join(data)))\\n except:\\n pass\\n try:\\n data = atoms.getSegnames()\\n if data is not None:\\n out.write('segnames {0}\\\\n'.format(' '.join(data)))\\n except:\\n pass\\n\\n try:\\n data = atoms.getBetas()\\n if data is not None:\\n out.write('bfactors ')\\n data.tofile(out, ' ', '%.2f')\\n out.write('\\\\n')\\n except:\\n pass\\n\\n format = '{0:.3f}'.format\\n out.write('coordinates ')\\n coords.tofile(out, ' ', '%.3f')\\n out.write('\\\\n')\\n count = 0\\n if isinstance(modes, Vector):\\n out.write('mode 1 {0:.2f} '.format(abs(modes)))\\n modes.getNormed()._getArray().tofile(out, ' ', '%.3f')\\n out.write('\\\\n')\\n count += 1\\n else:\\n if isinstance(modes, Mode):\\n modes = [modes]\\n for mode in modes:\\n if (mode.getEigval() < ZERO) and not zeros:\\n continue\\n elif (mode.getEigval() < ZERO) and zeros:\\n out.write('mode {0} {1:.2f} '.format(\\n mode.getIndex()+1, np.sqrt(1/(0.0001*(mode.getIndex()+1)))))\\n else:\\n out.write('mode {0} {1:.2f} '.format(\\n mode.getIndex()+1, mode.getVariance()**0.5))\\n arr = mode._getArray().tofile(out, ' ', '%.3f')\\n out.write('\\\\n')\\n count += 1\\n if count == 0:\\n LOGGER.warning('No normal mode data was written. '\\n 'Given modes might have 0 eigenvalues.')\\n out.close()\\n return filename\",\n \"def writeChunk(chunk):\",\n \"def writeFFDFile(fileName, nBlocks, nx, ny, nz, points):\\n\\n f = open(fileName, \\\"w\\\")\\n\\n f.write(\\\"%d\\\\n\\\" % nBlocks)\\n for i in range(nBlocks):\\n f.write(\\\"%d %d %d \\\" % (nx[i], ny[i], nz[i]))\\n # end\\n f.write(\\\"\\\\n\\\")\\n for block in range(nBlocks):\\n for k in range(nz[block]):\\n for j in range(ny[block]):\\n for i in range(nx[block]):\\n f.write(\\\"%f \\\" % points[block][i, j, k, 0])\\n # end\\n # end\\n # end\\n f.write(\\\"\\\\n\\\")\\n\\n for k in range(nz[block]):\\n for j in range(ny[block]):\\n for i in range(nx[block]):\\n f.write(\\\"%f \\\" % points[block][i, j, k, 1])\\n # end\\n # end\\n # end\\n f.write(\\\"\\\\n\\\")\\n\\n for k in range(nz[block]):\\n for j in range(ny[block]):\\n for i in range(nx[block]):\\n f.write(\\\"%f \\\" % points[block][i, j, k, 2])\\n # end\\n # end\\n # end\\n # end\\n f.close()\\n return\",\n \"def write_data():\",\n \"def Construct3DMolToFile(fileName,writeFile):\\r\\n # Writing sets of molecules\\r\\n \\r\\n\\r\\n w = Chem.SDWriter(writeFile)\\r\\n suppl = Chem.SDMolSupplier(fileName)\\r\\n mols = [x for x in suppl]\\r\\n for mol in mols:\\r\\n \\t# print(mol.GetProp(\\\"Solvent\\\"))\\r\\n \\t# print(mol.GetPropNames)\\r\\n \\tsignal.signal(signal.SIGALRM, handler)\\r\\n \\tsignal.alarm(100)\\r\\n \\ttry:\\r\\n \\t\\tmol3d = GetMolFromMol(mol,dimension=3)\\r\\n \\t\\tw.write(mol3d)\\r\\n \\texcept Exception:\\r\\n \\t\\tmol3d = mol\\r\\n \\t\\tw.write(mol3d)\\r\\n \\t\\t# print(mol.GetPropsAsDict())\\r\\n\\r\\n\\r\\n w.close()\",\n \"def write(self, filename):\\n f = open(filename, 'w')\\n f.write(str(self.m) + \\\"\\\\n\\\")\\n f.write(str(self.n) + \\\"\\\\n\\\")\\n for i in self.values:\\n for j in i:\\n f.write(str(j)+\\\"\\\\n\\\")\\n f.closed\",\n \"def dumpData(self,out):\\n #--Header\\n out.packSub('MAPH','ii',512,9)\\n #--Data\\n out.pack('4si','MAPD',512*512*3)\\n out.write(''.join(self.mapd))\",\n \"def write(self, file):\\n pos = file.tell()\\n pickle.dump((self.index, self.meta, self.info), file)\\n file.seek(0)\\n\\n # update the header with the position of the content index.\\n file.write(struct.pack('<Q', pos))\",\n \"def compress(in_file, out_file):\\n with open(in_file, \\\"rb\\\") as f1:\\n text = f1.read()\\n freq = make_freq_dict(text)\\n tree = huffman_tree(freq)\\n codes = get_codes(tree)\\n number_nodes(tree)\\n print(\\\"Bits per symbol:\\\", avg_length(tree, freq))\\n result = (num_nodes_to_bytes(tree) + tree_to_bytes(tree) +\\n size_to_bytes(len(text)))\\n result += generate_compressed(text, codes)\\n with open(out_file, \\\"wb\\\") as f2:\\n f2.write(result)\",\n \"def save_decompression():\\n dna_seq, bin_seq, comp_seq, file_comp = binary_to_seq()\\n \\n #create a new file containing the original sequence\\n file_path = os.path.splitext(file_comp)[0]\\n file = open(file_path+ \\\"_decompressed.txt\\\", \\\"w\\\")\\n file.write(dna_seq)\\n file.close()\\n \\n #show a message for saving\\n messagebox.showinfo(\\\"Information\\\", \\\"Your decompression has been saved in \\\"\\n +file_path+\\\"_decompressed.txt.\\\")\\n \\n #print(comp_seq, dna_seq, bin_seq)\\n return comp_seq, dna_seq, bin_seq\",\n \"def _write(self, out_file):\\n out_file.write(' '.encode()) # pad byte\\n out_file.write('{:4d}'.format(self.key).encode())\\n out_file.write(self.code.encode())\\n out_file.write((' '*18).encode()) # pad bytes\\n out_file.write('{:12d}'.format(self.numnod).encode())\\n out_file.write((' '*37).encode()) # pad bytes\\n out_file.write('{:1d}'.format(self.format).encode())\\n out_file.write('\\\\n'.encode())\\n\\n for node in self.nodes:\\n if self.format < 2:\\n out_file.write(' '.encode())\\n out_file.write('-1'.encode())\\n if self.format == 0:\\n out_file.write('{:5d}'.format(node.number).encode())\\n else:\\n out_file.write('{:10d}'.format(node.number).encode())\\n for i in range(3):\\n out_file.write('{:12.5E}'.format(node.pos[i]).encode())\\n out_file.write('\\\\n'.encode())\\n else:\\n out_file.write(struct.pack('i', node.number))\\n if self.format == 2:\\n out_file.write(struct.pack('fff', *node.pos))\\n else:\\n out_file.write(struct.pack('ddd', *node.pos))\\n\\n if self.format < 2:\\n out_file.write(' -3\\\\n'.encode()) # last record for ascii only\",\n \"def write_mat_file(self):\\n mat_dict = {}\\n mat_dict['Lx_p'] = self.Lx_p\\n mat_dict['Ly_p'] = self.Ly_p\\n mat_dict['Lz_p'] = self.Lz_p\\n mat_dict['Lo'] = self.obst.get_Lo()\\n mat_dict['Ny_divs'] = self.N_divs\\n mat_dict['rho_p'] = self.rho_p\\n mat_dict['nu_p'] = self.nu_p\\n mat_dict['snl'] = list(np.union1d(self.obst_list[:],self.solid_list[:]))\\n mat_dict['inl'] = list(self.inlet_list[:])\\n mat_dict['onl'] = list(self.outlet_list[:])\\n\\n scipy.io.savemat('geometry_description',mat_dict)\",\n \"def cam_write(filename, M, N):\\n f = open(filename,'wb')\\n # write the header\\n f.write(TAG_CHAR)\\n M.astype('float64').tofile(f)\\n N.astype('float64').tofile(f)\\n f.close()\",\n \"def write_features_to_file(filename,locs,desc):\\n savetxt(filename, hstack((locs, desc)))\",\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 writeMCToGR3File(filename, mc):\\n nodes = np.vstack((mc.x, mc.y)).T\\n nodalValues = mc.data[:, 0, 0].squeeze()[:, None]\\n connectivity = mc.connectivity\\n openBndNodes = []\\n landBndNodes = []\\n writeGR3File(filename, '', nodes, nodalValues, connectivity, mc.boundaries)\",\n \"def write_megam_file(train_toks, encoding, stream, bernoulli: bool = ..., explicit: bool = ...):\\n ...\",\n \"def writeOutFileUMIs(barcode_dict, outFileName):\\n with gzip.open(outFileName, 'wb') as out_file:\\n \\tfor barcode in barcode_dict:\\n out_file.write(barcode)\\n out_file.write(\\\"\\\\t\\\" + \\\"\\\\t\\\".join(barcode_dict[barcode]))\\n out_file.write(\\\"\\\\n\\\")\",\n \"def to_file(self, file_path, smirnoff_data):\\n pass\",\n \"def save_mb_obj(out_file, metaballs, vertices, vcolors=[], vnormals=[]):\\n if out_file.endswith(\\\".gz\\\"):\\n f_out = gzip.open(out_file, 'wt')\\n else:\\n f_out = open(out_file, 'w')\\n\\n f_out.write(\\\"####\\\\n\\\")\\n f_out.write(\\\"#\\\\n\\\")\\n f_out.write(\\\"# Metaballs: {}\\\\n\\\".format(len(metaballs.mbs)))\\n f_out.write(\\\"#\\\\n\\\")\\n f_out.write(\\\"# mth {}\\\\n\\\".format(str(metaballs.mth)))\\n for mb in metaballs.mbs:\\n mbstr = \\\"# \\\" + str(mb) + \\\"\\\\n\\\"\\n f_out.write(mbstr)\\n f_out.write(\\\"#\\\\n\\\")\\n\\n f_out.write(\\\"####\\\\n\\\")\\n f_out.write(\\\"#\\\\n\\\")\\n f_out.write(\\\"# Vertices: {}\\\\n\\\".format(len(vertices)))\\n f_out.write(\\\"#\\\\n\\\")\\n f_out.write(\\\"####\\\\n\\\")\\n\\n for vi, v in enumerate(vertices):\\n vstr = \\\"v {} {} {}\\\".format(v[0], v[1], v[2])\\n if len(vcolors) > 0:\\n vc = vcolors[vi]\\n vstr += \\\" {} {} {}\\\".format(vc[0], vc[1], vc[2])\\n vstr += \\\"\\\\n\\\"\\n f_out.write(vstr)\\n\\n f_out.write(\\\"# {} vertices\\\\n\\\\n\\\".format(len(vertices)))\\n\\n if len(vnormals) > 0:\\n for vn in vnormals:\\n vnstr = \\\"vn {} {} {}\\\\n\\\".format(vn[0], vn[1], vn[2])\\n f_out.write(vnstr)\\n\\n f_out.write(\\\"# {} normals\\\\n\\\\n\\\".format(len(vnormals)))\\n\\n f_out.write(\\\"# End of File\\\")\\n f_out.close()\\n\\n return True\",\n \"def save(self, filename, compression=True, transpose=False,\\n sparse=False, support=False, compression_opts=1):\\n write_ga_file(filename, self.value, self[0].layout.metric, self[0].layout.basis_names,\\n compression=compression, transpose=transpose,\\n sparse=sparse, support=support, compression_opts=compression_opts)\",\n \"def write_zfile(file_handle, data, compress=1):\\r\\n file_handle.write(_ZFILE_PREFIX)\\r\\n length = hex(len(data))\\r\\n if sys.version_info[0] < 3 and type(length) is long:\\r\\n # We need to remove the trailing 'L' in the hex representation\\r\\n length = length[:-1]\\r\\n # Store the length of the data\\r\\n file_handle.write(asbytes(length.ljust(_MAX_LEN)))\\r\\n file_handle.write(zlib.compress(asbytes(data), compress))\",\n \"def write_density(fname, density):\\n K, M, N = density.shape\\n output = open(fname, \\\"w\\\")\\n output.write(\\\"ARMA_CUB_TXT_FN008\\\\n\\\")\\n output.write(\\\"%d %d %d\\\\n\\\" % (K, M, N))\\n for i in range(N):\\n for k in range(K):\\n for m in range(M):\\n output.write(\\\" %+.6e\\\" % density[k, m, i])\\n output.write(\\\"\\\\n\\\")\\n\\n output.close()\",\n \"def save_geneset_to_file(geneset, output_file):\\n with gzip.open(output_file, \\\"w\\\") as handle:\\n handle.write(\\\"\\\\n\\\".join(geneset).encode(\\\"utf-8\\\"))\",\n \"def write_compressed_skims(skims, output=\\\"emmemat.zarr\\\"):\\n known_exts = (\\\".zarr\\\", \\\".zarr.zip\\\")\\n if not any(output.endswith(k) for k in known_exts):\\n raise NotImplementedError(output)\\n if output.endswith(\\\".zarr\\\"):\\n skims.to_zarr(output, mode='a')\\n elif output.endswith(\\\".zarr.zip\\\"):\\n if os.path.exists(output):\\n raise FileExistsError(output)\\n with zarr.ZipStore(output, mode='w') as store:\\n skims.to_zarr(store)\",\n \"def write_mm(g, fn):\\n f = open(fn, \\\"w\\\")\\n f.write(\\\"%d %d %d\\\\n\\\" % (g.vcount(), g.vcount(), g.ecount()))\\n\\n if g.is_weighted():\\n for e in g.es():\\n f.write(\\\"%d %d %.4f\\\\n\\\" % (e.source, e.target, e[\\\"weight\\\"]))\\n else:\\n for e in g.es():\\n f.write(\\\"%d %d 1\\\\n\\\" % (e.source, e.target))\\n\\n f.close()\",\n \"def compress_file(in_file: str, out_file: str) -> None:\\n with open(in_file, \\\"rb\\\") as f1:\\n text = f1.read()\\n freq = build_frequency_dict(text)\\n tree = build_huffman_tree(freq)\\n codes = get_codes(tree)\\n number_nodes(tree)\\n print(\\\"Bits per symbol:\\\", avg_length(tree, freq))\\n result = (tree.num_nodes_to_bytes() + tree_to_bytes(tree) +\\n int32_to_bytes(len(text)))\\n result += compress_bytes(text, codes)\\n with open(out_file, \\\"wb\\\") as f2:\\n f2.write(result)\",\n \"def write2hdf5(filename, dict2store, compression=\\\"lzf\\\"):\\n\\twith h5py.File(filename,'w') as hf:\\n\\t\\tfor key,value in dict2store.iteritems():\\n\\t\\t\\thf.create_dataset(key, data=value,compression=compression)\",\n \"def dumpData(self,out):\\n #--Get sizes and dump into dataIO\\n self.hedr.getSize()\\n self.hedr.dump(out)\\n for (name,size) in self.masters:\\n out.packSub0('MAST',name)\\n out.packSub('DATA','Q',size)\\n if self.gmdt: \\n self.gmdt.getSize()\\n self.gmdt.dump(out)\\n for other in self.others:\\n other.getSize()\\n other.dump(out)\",\n \"def write_minisat(self):\\n num_variables = len(self.label_encodings)\\n num_clauses = self.num_clauses\\n clauses = self.clauses\\n outfile = MinisatRunner.temp_in\\n out = open(outfile,\\\"w\\\")\\n try:\\n out.write(\\\"p cnf %3d %3d\\\\n\\\" % (num_variables,num_clauses))\\n for clause in clauses:\\n for clause_variable in clause:\\n out.write(\\\" %3d\\\" % self.minisat_encode_label(clause_variable));\\n out.write(\\\" 0\\\\n\\\")\\n finally:\\n out.close()\",\n \"def dump_mat(filename, obj, **kwargs):\\n return sio.savemat(filename, obj, **kwargs)\",\n \"def savemodel(self, fname):\\n if not fname.endswith('.gz'):\\n fname += '.gz'\\n D = {'clf':self.clf, 'vocab':self.vocab,\\n 'idxlabelmap':self.labelmap}\\n with gzip.open(fname, 'w') as fout:\\n dump(D, fout)\\n print 'Save model into file: {}'.format(fname)\",\n \"def writeOutFileBarcodeCounts(barcode_dict_summary, outFileName):\\n with gzip.open(outFileName, 'wb') as out_file:\\n for barcode in barcode_dict_summary:\\n out_file.write(barcode)\\n out_file.write(\\\"\\\\t\\\" + \\\"\\\\t\\\".join(map(str,barcode_dict_summary[barcode])))\\n out_file.write(\\\"\\\\n\\\")\",\n \"def write_embeddings_to_file(self):\\n modes = [self.generator, self.discriminator]\\n for i in range(2):\\n embedding_matrix = modes[i].embedding_matrix\\n embedding_matrix = embedding_matrix.detach().to('cpu').numpy()\\n index = np.array(range(self.n_node)).reshape(-1, 1)\\n embedding_matrix = np.hstack([index, embedding_matrix])\\n embedding_list = embedding_matrix.tolist()\\n embedding_str = [str(int(emb[0])) + \\\"\\\\t\\\" + \\\"\\\\t\\\".join([str(x) for x in emb[1:]]) + \\\"\\\\n\\\" \\n for emb in embedding_list]\\n with open(config.emb_filenames[i], \\\"w+\\\") as f:\\n lines = [str(self.n_node) + \\\"\\\\t\\\" + str(config.n_emb) + \\\"\\\\n\\\"] + embedding_str\\n f.writelines(lines)\",\n \"def save_nelder_mead_data(name, simplex, fvals, iters, evals):\\n N = simplex.shape[0] # Number of points in simplex\\n K = simplex.shape[1] # Total number of parameters\\n\\n with open(name + \\\".txt\\\", \\\"w\\\") as f:\\n my_writer = csv.writer(f, delimiter=\\\",\\\")\\n my_writer.writerow(simplex.shape)\\n my_writer.writerow([iters, evals])\\n for n in range(N):\\n my_writer.writerow(simplex[n, :])\\n my_writer.writerow(fvals)\",\n \"def save_to_xyz(self, filename): \\n with open( filename, 'a' ) as F:\\n F = open( filename, 'a' )\\n F.write( '%d\\\\n'%self.num_atoms )\\n F.write( \\\"XYZ\\\\n\\\" )\\n for num,row in enumerate(self.atoms):\\n try:\\n F.write('%s '%self.species[num])\\n except:\\n F.write('X%d '%num)\\n F.write( mat2str( row, \\\"%16.10f\\\" ) )\\n F.write( \\\"\\\\n\\\" )\",\n \"def dump(self, file):\\n if isinstance(file, basestring):\\n file = open(file, 'w')\\n metadb = self.metadb.dumps()\\n file.write('v%s:%d\\\\n' % (self.VERSION, len(metadb)))\\n file.write(metadb)\\n file.write(self.datadb.dumps())\",\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 compress_image(filename,k):\",\n \"def write_md_file(sip_uuid, filepath):\\n sip = SIP.objects.get(pk=sip_uuid)\\n md_object = load_file_data_from_db(sip, filepath)\\n convert_md_object = json.dumps(\\n md_object, sort_keys=True, ensure_ascii=False, indent=4\\n )\\n filename = os.path.join(filepath, \\\"metadata_output.json\\\")\\n with open(filename, \\\"wb\\\") as f:\\n f.write(six.ensure_binary(convert_md_object))\",\n \"def write_metadata(metadata_buffer, meta_dir, meta_file_name):\\n \\n with open(os.path.join(meta_dir, meta_file_name), 'w+') as meta_file:\\n writer = csv.writer(meta_file, delimiter=',', quotechar='\\\"')\\n writer.writerows(metadata_buffer)\",\n \"def compress(self, file):\\n\\t\\t\\n\\t\\ttext = file.read() \\n\\t\\ttext = text.rstrip() #elimina los espacios en blanco del final\\n\\n\\t\\t\\n\\t\\tfrequency = self.make_frequency_dict(text)#obtenemos la frencuencia de cada numero en el texto\\n\\t\\tself.make_heap(frequency)\\n\\t\\tself.merge_nodes()\\n\\t\\tself.make_codes()\\n\\t\\tencoded_text = self.get_encoded_text(text)\\n\\t\\tpadded_encoded_text = self.pad_encoded_text(encoded_text)\\n\\n\\t\\tb = self.get_byte_array(padded_encoded_text)\\n\\n\\t\\treturn b\",\n \"def WriteDataPack(resources, output_file, encoding):\\n content = WriteDataPackToString(resources, encoding)\\n with open(output_file, \\\"wb\\\") as file:\\n file.write(content)\",\n \"def compress_file(netcdf_file_name):\\n\\n radar_io.compress_file(netcdf_file_name)\",\n \"def write_mir(self, filename):\\n raise NotImplementedError\",\n \"def close(self):\\n # write META-INF\\n self.zip.writestr(\\\"META-INF/container.xml\\\", str(self.xml))\\n # write content.opf\\n self.zip.writestr(\\\"OEBPS/content.opf\\\", str(self.opf))\\n # write toc.ncx\\n self.zip.writestr(\\\"OEBPS/toc.ncx\\\", str(self.ncx))\\n self.zip.close()\",\n \"def WriteDataPack(resources, output_file, encoding):\\n content = WriteDataPackToString(resources, encoding)\\n with open(output_file, 'wb') as file:\\n file.write(content)\",\n \"def write(self, fname):\\n pass\",\n \"def write(self, file):\\n #write header\\n for variable in self.variables:\\n variable.write(file)\\n for subchunk in self.subchunks:\\n subchunk.write(file)\",\n \"def compression(s):\",\n \"def save_progress(filename, derm_counts):\\n\\n with open(filename, 'w') as f:\\n f.write(\\\"zipcode,derms_within_%d_miles\\\\n\\\" % RADIUS)\\n prefix = \\\"\\\"\\n for key, val in derm_counts.iteritems():\\n f.write(prefix)\\n f.write(key)\\n f.write(',')\\n f.write(val)\\n prefix= \\\"\\\\n\\\"\",\n \"def write_xdmf(self, filename: str):\\n\\n mesh = UnstructuredMesh.from_h5(filename)\\n mesh.write_h5(filename)\",\n \"def save_as(self, filename: str) -> None:\\n save_data = lzma.compress(pickle.dumps(self))\\n with open(filename, \\\"wb\\\") as f:\\n f.write(save_data)\",\n \"def write(self, data: bytes, name: str, compress: bool = False):\\n filepath = self.join(name)\\n if compress:\\n self.driver.write(gzip(data), filepath)\\n else:\\n self.driver.write(data, filepath)\",\n \"def save_data(dfin, outfile=\\\"./FPeng_prepped\\\"):\\n dfin.to_csv(outfile+'.csv', sep='\\\\t', index=False)\\n # s3.meta.client.upload_file(outfile+\\\".csv\\\", 'p3-engine', 'ETL/FPeng_prepped.csv')\\n print(\\\"csv...\\\", end=\\\" \\\")\\n\\n dfin.to_pickle(outfile+'.pkl' ,protocol=4)\\n # s3.meta.client.upload_file(outfile+'.pkl', 'p3-engine', 'ETL/FPeng_prepped.pkl')\\n print(\\\"pkl...\\\", end=\\\" \\\")\\n #dfin.to_msgpack(outfile+'.msg')\\n #print(\\\"msg...\\\", end=\\\" \\\")\\n\\n #s3.meta.client.upload_file(outfile+\\\".msg\\\", 'p3-engine', 'ETL/FPeng_prepped.msg')\\n\\n # print(\\\"to s3 complete\\\", end=\\\" \\\")\",\n \"def write_cando_file(self, file_name):\\n cando_writer = CandoWriter(self.dna_structure)\\n cando_writer.write(file_name)\",\n \"def tofile(self, filename:'Union[str, Path]',\\n *args, **kwargs):\\n\\n self._data.tofile(filename, *args, **kwargs)\\n dims_filename = filename + '.ini' # '.meta'\\n self._dims.tofile(dims_filename)\\n\\n with open(dims_filename, mode='a') as file:\\n file.write(f'dtype={self._data.dtype.name}\\\\n')\",\n \"def write_structure_file(self, file_name):\\n self.dna_structure.write(file_name,write_json_format=True)\",\n \"def save(filename, points3, tris, metadata):\\n logging.info(\\\"saving mesh: %s\\\"%filename)\\n cells = {'triangle':tris}\\n vtk_io.write(filename, points3, cells)\\n with open(filename+'.readme','w') as fid:\\n fid.write(metadata)\",\n \"def write_data(data, filename):\\n f = h5py.File(filename, 'w', libver='latest')\\n dset = f.create_dataset('array', shape=(data.shape), data = data, compression='gzip', compression_opts=9)\\n f.close()\",\n \"def save(self, filename):\\n target = open(filename, 'w')\\n target.write(\\\"\\\\\\\\data\\\\\\\\\\\\n\\\")\\n target.write(\\\"ngram 1=\\\" + str(len(self.f1)) + \\\"\\\\n\\\\n\\\")\\n target.write(\\\"\\\\\\\\1-grams:\\\\n\\\")\\n for w,p in sorted(self.f1.items()): \\n target.write(str(p) + \\\" \\\" + w + \\\"\\\\n\\\")\\n target.write(\\\"\\\\\\\\end\\\\\\\\\\\\n\\\")\\n target.close()\",\n \"def save(self, filename):\\n with gzip.open(filename, \\\"w\\\") as f:\\n f.write(pickle.dumps(self))\",\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 exportMmf(self, filename):\\n self.matrix.export_mtx(filename)\",\n \"def write(data):\",\n \"def write_sigmf(data_file, data, buffer=None, append=True):\\n\\n packed = pack_bin(data)\\n\\n write_bin(data_file, packed, buffer, append)\",\n \"def write_uem(uemf, uem, n_digits=3):\\n with open(uemf, 'wb') as f:\\n for file_id in sorted(iterkeys(uem)):\\n for onset, offset in sorted(uem[file_id]):\\n line = ' '.join([file_id,\\n '1',\\n format_float(onset, n_digits),\\n format_float(offset, n_digits)\\n ])\\n f.write(line.encode('utf-8'))\\n f.write(b'\\\\n')\",\n \"def to_dat(self, **kwargs):\\n return self.write(file_format=\\\"dat\\\", **kwargs)\",\n \"def create_dnz_file(args):\\n\\n file = open(args.o, 'w')\\n\\n file.write(\\\"% ----DATA VARIABLES----\\\\n\\\\n\\\")\\n file.write(\\\"t=\\\" + str(args.t) + \\\";\\\" + \\\"%number of attributes\\\\n\\\")\\n file.write(\\\"k=\\\" + str(args.k) + \\\";\\\" + \\\"%max length of the support set\\\\n\\\")\\n file.write(\\\"n=\\\" + str(args.n) + \\\";\\\" + \\\"%number of positive instances\\\\n\\\")\\n file.write(\\\"m=\\\" + str(args.m) + \\\";\\\" + \\\"%number of negative instances\\\\n\\\")\\n file.write(\\\"c=\\\" + str(args.c) + \\\";\\\" + \\\"%number of atMostOne Constraints\\\\n\\\\n\\\")\\n\\n file.write(\\\"% ----OMEGAS----\\\\n\\\\n\\\")\\n\\n omega_p = generate_omega_data(args.t, args.n, args.b)\\n file.write(\\\"omegap= \\\" + omega_to_mz(omega_p) + \\\"\\\\n\\\\n\\\")\\n\\n omega_n = generate_disjoint_omega_data(omega_p, args.m, args.b)\\n file.write(\\\"omegan= \\\" + omega_to_mz(omega_n) + \\\"\\\\n\\\\n\\\")\\n\\n file.write(\\\"% ----CONSTRAINS----\\\\n\\\\n\\\")\\n at_most_one = generate_at_most_one(int(args.t/2), args.c, 1, args.t)\\n file.write(\\\"atMostOne=\\\" + at_most_one_to_mz(at_most_one))\",\n \"def save_compressed_image(self, filename):\\n if filename[-5:] != '.pbz2':\\n filename + '.pbz2'\\n self.compressed_pickle(filename, self)\",\n \"def write_shortfile_table(self):\\n\\n # KMEL actually removes duplicate short filenames from this\\n # table.\\n\\n start_of_shortfiles = self.db_file.tell()\\n\\n shortfiles = {}\\n for miEntry in self.mainIndex:\\n short_filename = miEntry.encodedShortfile\\n if short_filename in shortfiles:\\n miEntry.set_shortfile_offset(\\n shortfiles[short_filename])\\n else:\\n shortfiles[short_filename] = \\\\\\n self.db_file.tell() - start_of_shortfiles\\n\\n miEntry.set_shortfile_offset(\\n shortfiles[short_filename])\\n self.db_file.write(short_filename)\",\n \"def write(self, data, filename):\\n id_ = 1\\n weightlist_el = Element('weight-list')\\n for dataset in data:\\n weight_el = SubElement(weightlist_el, 'weight')\\n id_el = SubElement(weight_el, 'id')\\n id_el.text = str(id_)\\n date_el = SubElement(weight_el, 'date')\\n date_el.text = str(dataset.date) + 'T12:00:00'\\n value_el = SubElement(weight_el, 'value')\\n value_el.text = str(dataset.weight)\\n comment_el = SubElement(weight_el, 'comment')\\n comment_el.text = dataset.note\\n id_ += 1\\n st_tree = ElementTree(weightlist_el)\\n st_tree.write(filename, encoding='UTF-8')\",\n \"def write_out4fp(fname,specorder,nspcs,agr,nr,rmax,pairs,nperline=6):\\n ndat = nr *len(pairs)\\n data = np.zeros(ndat)\\n n = 0\\n for pair in pairs:\\n isid,jsid = pair\\n for i in range(nr):\\n data[n] = agr[isid,jsid,i]\\n n += 1\\n\\n with open(fname,'w') as f:\\n f.write('# RDF for pairs: ')\\n for pair in pairs:\\n si = specorder[pair[0]-1]\\n sj = specorder[pair[1]-1]\\n f.write(' {0:s}-{1:s},'.format(si,sj))\\n f.write('\\\\n')\\n f.write('# rmax, nr = {0:.3f}, {1:d}\\\\n'.format(rmax,nr))\\n f.write('#\\\\n')\\n #...Num of data, weight for the data\\n f.write(' {0:6d} {1:7.3f}\\\\n'.format(ndat, 1.0))\\n j0 = 0\\n while True:\\n f.write(' '.join('{0:12.4e}'.format(data[j]) for j in range(j0,j0+nperline) if j < ndat))\\n f.write('\\\\n')\\n j0 += nperline\\n if j0 >= ndat:\\n break\\n\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66734606","0.6449204","0.61703485","0.6010072","0.5976385","0.5969885","0.59663653","0.59331244","0.5882864","0.5877286","0.5830967","0.5827414","0.5769662","0.574796","0.57416415","0.5724244","0.5712031","0.56908506","0.5682276","0.5674419","0.56734663","0.56734544","0.56269914","0.5602295","0.5590598","0.5577713","0.55673736","0.5564312","0.5549882","0.5542561","0.5529909","0.5528757","0.5525905","0.5522067","0.5517885","0.55012745","0.54895926","0.5484564","0.547589","0.54729193","0.5472285","0.5460378","0.5447356","0.5447068","0.54409903","0.54367256","0.5434682","0.5422218","0.54170007","0.5415363","0.54104394","0.540258","0.53848356","0.53793126","0.5366277","0.5365634","0.53614926","0.53592855","0.535028","0.53487897","0.53334194","0.53329295","0.5332172","0.5328979","0.53226006","0.53221625","0.5321325","0.5316614","0.53161055","0.529638","0.5293982","0.5293666","0.52780735","0.5277023","0.52758366","0.52741796","0.52708393","0.5269947","0.5263435","0.5259244","0.5257802","0.5250943","0.5250753","0.5250086","0.5246645","0.52453583","0.52408266","0.5239187","0.52379507","0.5235555","0.5231602","0.52302814","0.52266896","0.5225999","0.52204233","0.52186865","0.52144444","0.52121115","0.52114296","0.52077013"],"string":"[\n \"0.66734606\",\n \"0.6449204\",\n \"0.61703485\",\n \"0.6010072\",\n \"0.5976385\",\n \"0.5969885\",\n \"0.59663653\",\n \"0.59331244\",\n \"0.5882864\",\n \"0.5877286\",\n \"0.5830967\",\n \"0.5827414\",\n \"0.5769662\",\n \"0.574796\",\n \"0.57416415\",\n \"0.5724244\",\n \"0.5712031\",\n \"0.56908506\",\n \"0.5682276\",\n \"0.5674419\",\n \"0.56734663\",\n \"0.56734544\",\n \"0.56269914\",\n \"0.5602295\",\n \"0.5590598\",\n \"0.5577713\",\n \"0.55673736\",\n \"0.5564312\",\n \"0.5549882\",\n \"0.5542561\",\n \"0.5529909\",\n \"0.5528757\",\n \"0.5525905\",\n \"0.5522067\",\n \"0.5517885\",\n \"0.55012745\",\n \"0.54895926\",\n \"0.5484564\",\n \"0.547589\",\n \"0.54729193\",\n \"0.5472285\",\n \"0.5460378\",\n \"0.5447356\",\n \"0.5447068\",\n \"0.54409903\",\n \"0.54367256\",\n \"0.5434682\",\n \"0.5422218\",\n \"0.54170007\",\n \"0.5415363\",\n \"0.54104394\",\n \"0.540258\",\n \"0.53848356\",\n \"0.53793126\",\n \"0.5366277\",\n \"0.5365634\",\n \"0.53614926\",\n \"0.53592855\",\n \"0.535028\",\n \"0.53487897\",\n \"0.53334194\",\n \"0.53329295\",\n \"0.5332172\",\n \"0.5328979\",\n \"0.53226006\",\n \"0.53221625\",\n \"0.5321325\",\n \"0.5316614\",\n \"0.53161055\",\n \"0.529638\",\n \"0.5293982\",\n \"0.5293666\",\n \"0.52780735\",\n \"0.5277023\",\n \"0.52758366\",\n \"0.52741796\",\n \"0.52708393\",\n \"0.5269947\",\n \"0.5263435\",\n \"0.5259244\",\n \"0.5257802\",\n \"0.5250943\",\n \"0.5250753\",\n \"0.5250086\",\n \"0.5246645\",\n \"0.52453583\",\n \"0.52408266\",\n \"0.5239187\",\n \"0.52379507\",\n \"0.5235555\",\n \"0.5231602\",\n \"0.52302814\",\n \"0.52266896\",\n \"0.5225999\",\n \"0.52204233\",\n \"0.52186865\",\n \"0.52144444\",\n \"0.52121115\",\n \"0.52114296\",\n \"0.52077013\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6046685"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":193,"cells":{"query":{"kind":"string","value":"build the object data, filling in the stub we read note position offsets appear nowhere in this function"},"document":{"kind":"string","value":"def _build_meds_layout(self):\n\n\n nim = self.image_info.size\n nobj = self.obj_data.size\n\n trim_to_coadd = self.get('trim_to_coadd',False)\n if trim_to_coadd:\n print(' trimming to coadd')\n coadd_wcs, coadd_pos, coadd_bnds, coadd_q = \\\n self._get_pos_and_bounds(self.obj_data, 0)\n in_bnds = coadd_bnds.contains_points(coadd_pos['zrow'], coadd_pos['zcol'])\n w_in_bnds, = np.where(in_bnds == True)\n assert w_in_bnds.size > 0,\"none found in coadd\"\n\n w_in_bnds = coadd_q[w_in_bnds]\n self.obj_data = self.obj_data[w_in_bnds]\n\n self._do_psf_setup()\n\n # box sizes are even\n half_box_size = self.obj_data['box_size']//2\n\n for file_id in range(nim):\n\n wcs, pos, bnds, q = self._get_pos_and_bounds(self.obj_data, file_id)\n\n # do the test\n in_bnds = bnds.contains_points(pos['zrow'], pos['zcol'])\n q_rc, = np.where(in_bnds == True)\n print(' second cut: %6d of %6d objects' % (len(q_rc),len(q)))\n\n # now make sure everything is there\n if self['check_in_first_image']:\n if file_id == 0 and len(self.obj_data['ra']) != len(q_rc):\n raise MEDSCreationError('Not all objects were found in first image for '\n 'MEDS making (which is the coadd/detection '\n 'image by convention).')\n # compose them\n q = q[q_rc]\n\n # fill in the object_data structure\n\n # note q_rc since pos was created using obj_data[q]\n qrow = pos['zrow'][q_rc]\n qcol = pos['zcol'][q_rc]\n\n icut = self.obj_data['ncutout'][q]\n self.obj_data['file_id'][q,icut] = file_id\n self.obj_data['orig_row'][q,icut] = qrow\n self.obj_data['orig_col'][q,icut] = qcol\n\n # this results in the object center being close to\n # the natural center (dim-1.)/2.\n ostart_row = qrow.astype('i4') - half_box_size[q] + 1\n ostart_col = qcol.astype('i4') - half_box_size[q] + 1\n crow = qrow - ostart_row\n ccol = qcol - ostart_col\n\n self.obj_data['orig_start_row'][q,icut] = ostart_row\n self.obj_data['orig_start_col'][q,icut] = ostart_col\n self.obj_data['cutout_row'][q,icut] = crow\n self.obj_data['cutout_col'][q,icut] = ccol\n\n # do jacobian, in original, not-offset coords\n # note q_rc since pos was created using self.obj_data[q]\n jacob = wcs.get_jacobian(\n x=pos['wcs_col'][q_rc],\n y=pos['wcs_row'][q_rc])\n\n # jacob is a tuple of arrays\n self.obj_data['dudcol'][q,icut] = jacob[0]\n self.obj_data['dudrow'][q,icut] = jacob[1]\n self.obj_data['dvdcol'][q,icut] = jacob[2]\n self.obj_data['dvdrow'][q,icut] = jacob[3]\n\n # increment\n self.obj_data['ncutout'][q] += 1\n\n w,=np.where(self.obj_data['ncutout'] > 0)\n print('%d/%d had ncut > 0' % (w.size, self.obj_data.size))\n #self.obj_data = self.obj_data[w]\n\n self.obj_data = self._make_resized_data(self.obj_data)\n print('setting number field as sequential')\n self.obj_data['number'] = 1+np.arange(self.obj_data.size)\n\n\n self._set_start_rows_and_pixel_count()\n\n if self['survey']=='cosmos':\n self._set_psf_layout_hst()\n else:\n self._set_psf_layout_psfex()"},"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 prepare_raw_data(self, idx: int):\n info = super().prepare_raw_data(idx)\n if self.cache_reader is not None:\n self.human_data = self.cache_reader.get_item(idx)\n idx = idx % self.cache_reader.slice_size\n\n if 'smplx' in self.human_data:\n smplx_dict = self.human_data['smplx']\n info['has_smplx'] = 1\n else:\n smplx_dict = {}\n info['has_smplx'] = 0\n if 'global_orient' in smplx_dict:\n info['smplx_global_orient'] = smplx_dict['global_orient'][idx]\n info['has_smplx_global_orient'] = 1\n else:\n info['smplx_global_orient'] = np.zeros((3), dtype=np.float32)\n info['has_smplx_global_orient'] = 0\n\n if 'body_pose' in smplx_dict:\n info['smplx_body_pose'] = smplx_dict['body_pose'][idx]\n info['has_smplx_body_pose'] = 1\n else:\n info['smplx_body_pose'] = np.zeros((21, 3), dtype=np.float32)\n info['has_smplx_body_pose'] = 0\n\n if 'right_hand_pose' in smplx_dict:\n info['smplx_right_hand_pose'] = smplx_dict['right_hand_pose'][idx]\n info['has_smplx_right_hand_pose'] = 1\n else:\n info['smplx_right_hand_pose'] = np.zeros((15, 3), dtype=np.float32)\n info['has_smplx_right_hand_pose'] = 0\n\n if 'left_hand_pose' in smplx_dict:\n info['smplx_left_hand_pose'] = smplx_dict['left_hand_pose'][idx]\n info['has_smplx_left_hand_pose'] = 1\n else:\n info['smplx_left_hand_pose'] = np.zeros((15, 3), dtype=np.float32)\n info['has_smplx_left_hand_pose'] = 0\n\n if 'jaw_pose' in smplx_dict:\n info['smplx_jaw_pose'] = smplx_dict['jaw_pose'][idx]\n info['has_smplx_jaw_pose'] = 1\n else:\n info['smplx_jaw_pose'] = np.zeros((3), dtype=np.float32)\n info['has_smplx_jaw_pose'] = 0\n\n if 'betas' in smplx_dict:\n info['smplx_betas'] = smplx_dict['betas'][idx]\n info['has_smplx_betas'] = 1\n else:\n info['smplx_betas'] = np.zeros((self.num_betas), dtype=np.float32)\n info['has_smplx_betas'] = 0\n\n if 'expression' in smplx_dict:\n info['smplx_expression'] = smplx_dict['expression'][idx]\n info['has_smplx_expression'] = 1\n else:\n info['smplx_expression'] = np.zeros((self.num_expression),\n dtype=np.float32)\n info['has_smplx_expression'] = 0\n\n return info","def __init__(self, starting_point=-1):\n self.i_read = starting_point\n self.data = [['fake_chip_id', 'fake_version'],\n [96, 110, 203, 104, 50, 0, 29, 145, 59, 215, 208, 11,\n 232, 38, 42, 255, 249, 255, 172, 38, 10, 216, 189, 16],\n [75],\n [129, 1, 0, 16, 44, 3, 30],\n [76, 60, 128, 129, 49, 128, 94, 120]]","def __init__(self):\n self.x = {}\n self.len = 0\n self.annotations = {}","def _get_observation(self):\n di = super()._get_observation()\n\n # low-level object information\n if self.use_object_obs:\n # Get robot prefix\n if self.env_configuration == \"bimanual\":\n pr0 = self.robots[0].robot_model.naming_prefix + \"left_\"\n pr1 = self.robots[0].robot_model.naming_prefix + \"right_\"\n else:\n pr0 = self.robots[0].robot_model.naming_prefix\n pr1 = self.robots[1].robot_model.naming_prefix\n\n # position and rotation of object\n cube_pos = np.array(self.sim.data.body_xpos[self.cube_body_id])\n cube_quat = T.convert_quat(\n self.sim.data.body_xquat[self.cube_body_id], to=\"xyzw\"\n )\n di[\"cube_pos\"] = cube_pos\n di[\"cube_quat\"] = cube_quat\n\n di[pr0 + \"eef_xpos\"] = self._eef0_xpos\n di[pr1 + \"eef_xpos\"] = self._eef1_xpos\n di[\"handle_0_xpos\"] = np.array(self._handle_0_xpos)\n di[\"handle_1_xpos\"] = np.array(self._handle_1_xpos)\n di[pr0 + \"gripper_to_handle\"] = np.array(self._gripper_0_to_handle)\n di[pr1 + \"gripper_to_handle\"] = np.array(self._gripper_1_to_handle)\n\n di[\"object-state\"] = np.concatenate(\n [\n di[\"cube_pos\"],\n di[\"cube_quat\"],\n di[pr0 + \"eef_xpos\"],\n di[pr1 + \"eef_xpos\"],\n di[\"handle_0_xpos\"],\n di[\"handle_1_xpos\"],\n di[pr0 + \"gripper_to_handle\"],\n di[pr1 + \"gripper_to_handle\"],\n ]\n )\n\n return di","def build(self):\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\n #print('self.IDs', self.data)\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\n assert self.nelements > 0, 'nelements=%s' % self.nelements\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\n self.nelements //= self.ntimes\n\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\n self.node = np.zeros(self.ntotal, dtype=idtype)\n #oxx, oyy, txy, angle, major, minor, ovm\n self.data = np.zeros((self.ntimes, self.ntotal, 8), dtype=fdtype)\n self.location = np.empty(self.ntotal, dtype='U8')\n self._times = np.zeros(self.ntimes, dtype=dtype)","def build(self):\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\n #print('self.IDs', self.data)\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\n assert self.nelements > 0, 'nelements=%s' % self.nelements\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\n #self.names = []\n self.nelements //= self.ntimes\n\n self.node = np.zeros(self.ntotal, dtype='int32')\n #oxx, oyy, ozz, txy, pressure\n self.data = np.zeros((self.ntimes, self.ntotal, 5), dtype='float32')\n self.location = np.empty(self.ntotal, dtype='U8')\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\n\n self._times = np.zeros(self.ntimes, dtype=dtype)","def finish_constructing(self, more_data):\n self.draw_aspect = None\n self.obj_type = None\n self.ex_obj_id = None\n self.sub_type = None\n self.persist_id_ref = None\n if self.size != 0x18:\n raise ValueError('ExOleObjAtom has wrong size {0} != 0x18'\n .format(self.size))\n if self.data:\n self.draw_aspect, self.obj_type, self.ex_obj_id, self.sub_type, \\\n self.persist_id_ref, _ = unpack('<LLLLLL', self.data)\n if self.obj_type not in self.OBJ_TYPES:\n logging.warning('Unknown \"type\" value in ExOleObjAtom: {0}'\n .format(self.obj_type))\n if self.sub_type not in self.SUB_TYPES:\n logging.warning('Unknown sub type value in ExOleObjAtom: {0}'\n .format(self.sub_type))","def getRigBuildData(self):\n\n # Values\n mouthPosition = self.jawCtrl.xfo.tr\n jawEndPosition = self.jawEndCtrl.xfo.tr\n mouthLen = mouthPosition.subtract(jawEndPosition).length()\n\n # Calculate Mouth Xfo\n\n # atVector\n # mouthUpV = Vec3(0.0, 1.0, 0.0)\n\n # rootToEnd = jawEndPosition.subtract(mouthPosition).unit()\n # rootToUpV = mouthUpV.subtract(mouthPosition).unit()\n # bone1ZAxis = rootToUpV.cross(rootToEnd).unit()\n # bone1Normal = bone1ZAxis.cross(rootToEnd).unit()\n\n jawXfo = self.jawEndCtrl.xfo\n # jawXfo.setFromVectors(rootToEnd, bone1Normal, bone1ZAxis, mouthPosition)\n\n\n\n data = super(OSSMouthGuide, self).getRigBuildData()\n\n # should include getCurveData\n data = self.saveAllObjectData(data, \"Control\")\n data = self.saveAllObjectData(data, \"Transform\")\n data['jawXfo'] = self.jawCtrl.xfo\n data['mouthLen'] = mouthLen\n return data","def _build_base_structure(self):\n result = dict(self.contents)\n # clean out optional fields that were missing\n if not self.contents[DataParticleKey.PORT_TIMESTAMP]:\n del result[DataParticleKey.PORT_TIMESTAMP]\n if not self.contents[DataParticleKey.INTERNAL_TIMESTAMP]:\n del result[DataParticleKey.INTERNAL_TIMESTAMP]\n return result","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 build_item(\n self,\n part,\n timestamp=1539023700,\n userdata=0,\n position=[0, 0, 0],\n up_vec=[0, 1, 0],\n at_vec=[0, 0, 1],\n skip_power_controls=False):\n # Get the obj path.\n item = self.retrieve_part(part)\n\n # Lock Everything if it's the BASE_FLAG or U_POWERLINE.\n # BASE_FLAG can break things if user moves it around.\n # As it acts as the \"origin\" of the base.\n locked_parts = [\"BASE_FLAG\", \"U_POWERLINE\", \"U_PIPELINE\", \"U_PORTALLINE\"]\n line_parts = [\"U_POWERLINE\", \"U_PIPELINE\", \"U_PORTALLINE\"]\n if part in locked_parts:\n item.lock_location[0] = True\n item.lock_location[1] = True\n item.lock_location[2] = True\n item.lock_rotation[0] = True\n item.lock_rotation[1] = True\n item.lock_rotation[2] = True\n item.lock_scale[0] = True\n item.lock_scale[1] = True\n item.lock_scale[2] = True\n \n # Add custom attributes.\n item[\"ObjectID\"] = part\n item[\"SnapID\"] = part\n item[\"Timestamp\"] = timestamp\n item[\"belongs_to_preset\"] = False\n # Add an order flag to retain order when generating data..\n item[\"Order\"] = self.part_order\n self.part_order += 1\n # Apply Colour\n is_powerline = part in line_parts\n is_pipeline = part in [\"U_PIPELINE\"]\n material.assign_material(\n item,\n userdata,\n powerline=is_powerline,\n pipeline=is_pipeline\n )\n\n # Move\n utils.move_to(item, position=position, up=up_vec, at=at_vec)\n\n # If the object is a powerline, we should create additional controls\n # for it.\n if is_powerline and not skip_power_controls:\n power.create_power_controls(item)\n # Select the new object.\n item.select_set(True)\n return item","def __init__(self):\n self.dtrs = []\n self.chunkIndex = 0\n self.eventList = [] \n self.position = None\n self.positionCount = 0\n self.parent = None\n self.embeddedTags = []","def fill_data(self, data):\n self._data = data\n\n self._data_length = data[1:3]\n self._frame_id = data[4]\n self._address = XbeeAddress(data[5:9], data[9:13], data[13:15])\n self._at_command = data[15:17]\n self._command_status = data[17]\n try:\n self._command_data = data[18:21]\n self._checksum = data[22]\n except IndexError:\n self._command_data = None\n self._checksum = data[18]","def _read_data(self):","def _dataslicing(self):\n if self._build_properties[\"dataslice0\"] == \"undefined\":\n warnings.warn(\"No _build_properties['dataslice0'] defined. 0 assumed\")\n offset0 = [0,-1]\n else:\n offset0=self._build_properties[\"dataslice0\"]\n if self._build_properties[\"dataslice1\"] == \"undefined\":\n warnings.warn(\"No _build_properties['dataslice1'] defined. 0 assumed\")\n offset1 = [0,-1]\n else:\n offset1=self._build_properties[\"dataslice1\"]\n \n if offset0[1] is None:\n offset0[1] = self.header[\"NAXIS2\"]\n \n if offset0[1] <0:\n offset0[1] = self.height+offset0[1]+1\n \n if offset1[1] is None:\n offset1[1] = self.header[\"NAXIS1\"]\n \n if offset1[1] <0:\n offset1[1] = self.width +offset1[1]+1\n \n return offset0[0],offset1[0],offset0[1]-offset0[0],offset1[1]-offset1[0]","def prepare_data(self):","def build_base(self):\n\n # start- and endpoints of lines are nodes, but they do not need to have a point object associated to them\n # in this case, self.geo is None and the no, prop and name attributes stay as the default values set in the constructor\n if (self.geo):\n\n attr = ri.RhinoInput(rs.ObjectName(self.geo))\n\n self.no = attr.get_no()\n if (self.no != -1):\n self.strict_naming = True\n\n self.name = attr.get_name()\n self.prop = attr.get_prop()","def initialize(self):\n self.muondEdx = []\n self.muondNdx = []\n self.muonmomentum = []\n self.piondEdx = []\n self.piondNdx = []\n self.pionmomentum = []\n self.kaondEdx = []\n self.kaondNdx = []\n self.kaonmomentum = []\n self.protdEdx = []\n self.protdNdx = []\n self.protmomentum = []\n self.elecdEdx = []\n self.elecdNdx = []\n self.elecmomentum = []","def __init__(self):\n self.notes = []","def __init__(self, data=b''):\n self.data = data\n self.offset = 0","def load_data(self):\n super(MudderyObjectCreater, self).load_data()\n \n data = self.get_data_record()\n if not data:\n return\n \n # set common object's info\n self.obj_list = {}\n\n for obj in data.obj_list.split(\",\"):\n obj_key = \"\"\n number = 0\n arg = obj.split(\":\", 1)\n if len(arg) == 1:\n obj_key = arg[0]\n number = 1\n elif len(arg) >= 2:\n obj_key = arg[0]\n number = int(arg[1])\n\n self.obj_list[obj_key] = number","def _read(self):\n # initializng data dictionary\n self.data={}\n\n f = FortranFile(self.filename)\n # Default omnivor binary header\n self.data['MK'] = f.readInts('i')\n self.data['itime'] = f.readInts('i')\n self.data['version'] = f.readString()\n self.data['file_id'] = f.readInts('i')\n self.data['sversion'] = f.readString()\n # Velocity field\n self.data['stype'] = f.readString()\n self.data['is_grid'] = f.readInts('i')\n nCPs = f.readInts('i')\n self.data['nCPs'] = nCPs\n if self.data['MK'] == 8:\n real_char='d'\n else:\n real_char='f'\n if self.data['is_grid']:\n #print('File is a velocity grid file')\n n1 = f.readInts('i')\n n2 = f.readInts('i')\n n3 = f.readInts('i')\n self.data['n1'] = n1\n self.data['n2'] = n2\n self.data['n3'] = n3\n self.data['is_straight'] = f.readInts('i')\n self.data['v1'] = f.readReals(real_char)\n self.data['v2'] = f.readReals(real_char)\n self.data['v3'] = f.readReals(real_char)\n\n CPs_raw = f.readReals(real_char)\n Utot_raw = f.readReals(real_char)\n CPs = np.reshape(CPs_raw,(3,nCPs),order = 'F')\n Utot = np.reshape(Utot_raw,(3,nCPs),order = 'F')\n\n acc=-1\n CPsTab = np.zeros((3, n1,n2,n3))\n UtotTab = np.zeros((3, n1,n2,n3))\n # Reshaping the nasty way (this is natural order). \n for i in range(0,n1):\n for j in range(0,n2):\n for k in range(0,n3):\n acc=acc+1\n CPsTab[0:3,i,j,k] = CPs[0:3,acc]\n UtotTab[0:3,i,j,k] = Utot[0:3,acc]\n\n self.data['CPs'] = CPs\n self.data['CPsTab'] = CPsTab\n self.data['Utot'] = Utot\n self.data['UtotTab'] = UtotTab","def start_data(self, obj_name_parts, game, filename, pos_start, length):\n if len(obj_name_parts) == 0:\n self.filename = filename\n self.pos_start = pos_start\n self.length = length\n self.game = game\n self.has_data = True\n self.data = []\n return self.data\n lower = obj_name_parts[0].lower()\n if lower not in self.children:\n self.children[lower] = Node(obj_name_parts[0])\n return self.children[lower].start_data(\n obj_name_parts[1:],\n game,\n filename,\n pos_start,\n length)","def __init__(self):\r\n self.data = PositionalList()","def build(self):\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\n #print('self.IDs', self.data)\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\n assert self.nelements > 0, 'nelements=%s' % self.nelements\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\n self.nelements //= self.ntimes\n\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\n self.node = np.zeros(self.ntotal, dtype=idtype)\n #lxa, lxb, lxc, lya, lyb, lyc, lza, lzb, lzc, sa, sb, sc, epr, ovm\n self.data = np.zeros((self.ntimes, self.ntotal, 14), dtype=fdtype)\n self.location = np.empty(self.ntotal, dtype='U8')\n\n self._times = np.zeros(self.ntimes, dtype=dtype)","def __init__(self):\n\n\n self.dtype = np.dtype([\n ('fault_flags', np.uint32),\n ('raw_x', np.int16),\n ('raw_y', np.int16),\n ('raw_z', np.int16),\n ('accel_x', np.float32),\n ('accel_y', np.float32),\n ('accel_z', np.float32), \n ('pitch', np.float32),\n ('roll', np.float32), \n ])\n \n self._accel_indices = [0, 4, 5, 6]\n \n self.data = np.array([(0, 0.1, 12, 1234, 0.12345678901234, 0.12345678901234, 0.12345678901234, 0.12345678901234, 0.12345678901234)], dtype=self.dtype)\n self.data['fault_flags'] = 0\n self.data['raw_x'] = 0.1\n self.data['raw_y'] = 12\n self.data['raw_z'] = 31929\n self.data['accel_x'] = 0.12345678901234\n self.data['accel_y'] = 0.23456789012345\n self.data['accel_z'] = 0.34567890123456\n self.data['pitch'] = 0.1000\n self.data['roll'] = 0.2000\n\n\n #print len(self.data.tostring(order=\"C\"))","def ani_init(self):\n self.line.set_data([], [])\n self.galactic_centre.set_data([], [])\n self.impactor.set_data([], [])\n self.time_text.set_text(\"\")\n self.KE_text.set_text(\"\")\n self.GPE_text.set_text(\"\")\n self.energy_text.set_text(\"\")\n return (\n self.line,\n self.galactic_centre,\n self.impactor,\n self.time_text,\n self.KE_text,\n self.GPE_text,\n self.energy_text,\n )\n # One might hope that there was a better way to return objects","def __init__(self, data):\n # loop through data\n for x in data:\n # create pitches list if attribute name is pitches\n if x == 'pitches':\n self.pitches = []\n for y in data[x]:\n self.pitches.append(Pitch(y))\n else:\n # set information as correct data type\n mlbgame.object.setobjattr(self, x, data[x])","def _init_data(self) -> None:\n self.dtype = dict()\n self.shape = dict()\n self.size = dict()\n self.attrs = dict()\n self.data_ptr = dict()\n\n if self.mode == 'r':\n for k in self.fp.keys():\n self.dtype[k] = self.fp[k].dtype\n self.shape[k] = self.fp[k].shape\n self.size[k] = self.fp[k].shape[0]\n self.data_ptr[k] = 0","def prepare(self):\n if self.pin.lower() == \"homo\":\n for i,line in enumerate(self.x):\n self.x[i] = [x - self.Lead_HOMOs_xval[i] for x in line]\n elif self.pin.lower() == \"lumo\":\n for i,line in enumerate(self.x):\n self.x[i] = [x - self.Lead_LUMOs_xval[i] for x in line]\n elif \"vac\" in self.pin.lower():\n for i,line in enumerate(self.x):\n self.x[i] = [x - self.vacuum[i] for x in line]\n elif \"ef\" in self.pin.lower():\n for i,line in enumerate(self.x):\n self.x[i] = [x - self.fermi_levels[i] for x in line]","def __init__(self):\n self.__deviceselected__ = \"SR-DMS4AP{LOCALBUMP}DEV:Sel-SP\"\n self.__source__ = \"SR-DMS4AP{LOCALBUMP}S-SP\"\n self.__plane__ = \"SR-DMS4AP{LOCALBUMP}PLANE-SP\"\n #self.__xshift__ = \"SR-DMS4AP{LOCALBUMP}SHIFT:X-SP\"\n #self.__yshift__ = \"SR-DMS4AP{LOCALBUMP}SHIFT:Y-SP\"\n #self.__xangle__ = \"SR-DMS4AP{LOCALBUMP}ANGLE:X-SP\"\n #self.__yangle__ = \"SR-DMS4AP{LOCALBUMP}ANGLE:Y-SP\"\n self.__shift__ = \"SR-DMS4AP{LOCALBUMP}SHIFT-SP\"\n self.__angle__ = \"SR-DMS4AP{LOCALBUMP}ANGLE-SP\"\n # with all offsets\n self.__anglerb__ = \"SR-DMS4AP{LOCALBUMP}ANGLE-I\"\n self.__positionrb__ = \"SR-DMS4AP{LOCALBUMP}POS-I\"\n # with BBA offset only\n self.__anglerb0__ = \"SR-DMS4AP{LOCALBUMP}ANGLE:BBA-I\"\n self.__positionrb0__ = \"SR-DMS4AP{LOCALBUMP}POS:BBA-I\"\n\n self.__bpmposition__ = \"SR-DMS4AP{LOCALBUMP:BPM}Pos-I\"\n self.__bpmorbitx__ = \"SR-DMS4AP{LOCALBUMP:BPM}ORB:X-I\"\n self.__bpmorbity__ = \"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y-I\"\n self.__bpmorbitx0__ = \"SR-DMS4AP{LOCALBUMP:BPM}ORB:X0-I\"\n self.__bpmorbity0__ = \"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y0-I\"\n\n self.__correctorposition__ = \"SR-DMS4AP{LOCALBUMP:COR}Pos-I\"\n self.__hcorrectorcurrent__ = \"SR-DMS4AP{LOCALBUMP:HCOR}PS-SP\"\n self.__hcorrectordiff__ = \"SR-DMS4AP{LOCALBUMP:HCOR}PS:Delta-SP\"\n self.__vcorrectorcurrent__ = \"SR-DMS4AP{LOCALBUMP:VCOR}PS-SP\"\n self.__vcorrectordiff__ = \"SR-DMS4AP{LOCALBUMP:VCOR}PS:Delta-SP\"\n\n self.__undo__ = \"SR-DMS4AP{LOCALBUMP}Enbl:Undo-Cmd\"\n self.__apply__ = \"SR-DMS4AP{LOCALBUMP}Enbl-Cmd\"\n self.__status__ = \"SR-DMS4AP{LOCALBUMP}TS-I\"\n self.__idposinfo__ = \"SR-DMS4AP{LOCALBUMP}S-I\"\n self.__srcposition__ = \"SR-DMS4AP{LOCALBUMP}SRC-SP\"","def _read(self):\n\t\tself._infoMuscles = []\n\t\tself._infoCommonCellsInMuscles = []\n\t\tself._infoSpecialCells = []\n\t\tself._infoCommonMuscleConnections = []\n\t\tself._infoInterMuscSensorimotorConnections = {}\n\t\tself._infoSpecialConnections = []\n\t\tif rank==0:\n\t\t\tsection = None\n\t\t\tsensorimotorConnections = None\n\t\t\tsensorimotorMatrix = None\n\t\t\tfor line in open(\"../nnStructures/\"+self._inputFile,\"r\"):\n\t\t\t\tif line[0] == \"#\" or line[0] == \"\\n\": continue\n\t\t\t\telif line[0] == \"@\": section = float(line[1])\n\t\t\t\telif section == 1: self._infoMuscles.append(line.strip(\"\\n\").split())\n\t\t\t\telif section == 2: self._infoCommonCellsInMuscles.append(line.strip(\"\\n\").split())\n\t\t\t\telif section == 3: self._infoSpecialCells.append(line.strip(\"\\n\").split())\n\t\t\t\telif section == 4: self._infoCommonMuscleConnections.append(line.strip(\"\\n\").split())\n\t\t\t\telif section == 5:\n\t\t\t\t\tif line[0] == \"+\":\n\t\t\t\t\t\tdictName = line[1:].strip(\"\\n\")\n\t\t\t\t\t\tself._infoInterMuscSensorimotorConnections[dictName] = {}\n\t\t\t\t\t\tsensorimotorConnections = False\n\t\t\t\t\t\tsensorimotorMatrix = False\n\t\t\t\t\telif \"Connections\" in line:\n\t\t\t\t\t\t sensorimotorConnections = True\n\t\t\t\t\t\t self._infoInterMuscSensorimotorConnections[dictName][\"connections\"]=[]\n\t\t\t\t\telif \"WeightsMatrix\" in line:\n\t\t\t\t\t\t sensorimotorConnections = False\n\t\t\t\t\t\t sensorimotorMatrix = True\n\t\t\t\t\t\t self._infoInterMuscSensorimotorConnections[dictName][\"matrix\"]=[]\n\t\t\t\t\telif sensorimotorConnections:\n\t\t\t\t\t\tself._infoInterMuscSensorimotorConnections[dictName][\"connections\"].append(line.strip(\"\\n\").split())\n\t\t\t\t\telif sensorimotorMatrix:\n\t\t\t\t\t\tself._infoInterMuscSensorimotorConnections[dictName][\"matrix\"].append(line.strip(\"\\n\").split())\n\t\t\t\telif section == 6: self._infoSpecialConnections.append(line.strip(\"\\n\").split())\n\n\t\tself._infoMuscles = comm.bcast(self._infoMuscles,root=0)\n\t\tself._infoCommonCellsInMuscles = comm.bcast(self._infoCommonCellsInMuscles,root=0)\n\t\tself._infoSpecialCells = comm.bcast(self._infoSpecialCells,root=0)\n\t\tself._infoCommonMuscleConnections = comm.bcast(self._infoCommonMuscleConnections,root=0)\n\t\tself._infoInterMuscSensorimotorConnections = comm.bcast(self._infoInterMuscSensorimotorConnections,root=0)\n\t\tself._infoSpecialConnections = comm.bcast(self._infoSpecialConnections,root=0)","def __init__(self):\n self.data = []\n self.idx = {}","def build(self):\n if self.is_built:\n return\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\n assert self.nelements > 0, 'nelements=%s' % self.nelements\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\n #self.names = []\n self.nelements //= self.ntimes\n\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\n self.node_element = np.zeros((self.ntotal, 2), dtype=idtype)\n #oxx, oyy, txy, angle, major, minor, ovm\n self.data = np.zeros((self.ntimes, self.nelements, 8), dtype=fdtype)\n self.location = np.empty(self.ntotal, dtype='U8')\n\n self._times = np.zeros(self.ntimes, dtype=dtype)","def __init__(self, inFilename):\n\n self._prmtopVersion=None\n self._flags=[]\n self._raw_format={}\n self._raw_data={}\n self._has_nbfix_terms = False\n\n with open(inFilename, 'r') as fIn:\n for line in fIn:\n if line[0] == '%':\n if line.startswith('%VERSION'):\n tag, self._prmtopVersion = line.rstrip().split(None, 1)\n elif line.startswith('%FLAG'):\n tag, flag = line.rstrip().split(None, 1)\n self._flags.append(flag)\n self._raw_data[flag] = []\n elif line.startswith('%FORMAT'):\n format = line.rstrip()\n index0=format.index('(')\n index1=format.index(')')\n format = format[index0+1:index1]\n try:\n m = FORMAT_RE_PATTERN.search(format)\n self._raw_format[self._flags[-1]] = (format, m.group(1), m.group(2), int(m.group(3)), m.group(4))\n except:\n # We couldn't parse the format, so just treat the whole line as a single string.\n self._raw_format[self._flags[-1]] = (format, 1, 'a', 80, '')\n elif line.startswith('%COMMENT'):\n continue\n elif self._flags \\\n and 'TITLE'==self._flags[-1] \\\n and not self._raw_data['TITLE']:\n self._raw_data['TITLE'] = line.rstrip()\n else:\n flag=self._flags[-1]\n (format, numItems, itemType,\n iLength, itemPrecision) = self._getFormat(flag)\n line = line.rstrip()\n for index in range(0, len(line), iLength):\n item = line[index:index+iLength]\n if item:\n self._raw_data[flag].append(item.strip())\n # See if this is a CHAMBER-style topology file, which is not supported\n # for creating Systems\n self.chamber = 'CTITLE' in self._flags","def __init__(self, data):\n\t\tself.protocol_version, self.le_state, self.playback_state, \\\n\t\t self.source, self.le_flags, self.playback_flags, \\\n\t\t self.source_flags, self.fullness, self.point_rate, \\\n\t\t self.point_count = \\\n\t\t\tstruct.unpack(\"<BBBBHHHHII\", data)","def __init__(self):\n ProcessingUnit.__init__(self)\n print(\" [ START ] init - Metodo Simulator Reader\")\n\n self.isConfig = False\n self.basicHeaderObj = BasicHeader(LOCALTIME)\n self.systemHeaderObj = SystemHeader()\n self.radarControllerHeaderObj = RadarControllerHeader()\n self.processingHeaderObj = ProcessingHeader()\n self.profileIndex = 2**32-1\n self.dataOut = Voltage()\n #code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])\n code0 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,1,-1,1,-1,-1,-1,1,1,1,-1,1])\n #code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])\n code1 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,1,1,-1,-1,-1,1,-1])\n #self.Dyn_snCode = numpy.array([code0,code1])\n self.Dyn_snCode = None","def _build(self):\n xml = ET.parse(self.fn)\n root = xml.getroot()\n\n metadata = None\n trk = None\n self.prefix = root.tag[:-3]\n metadata = root.find(self._get_tag('metadata'))\n # print(metadata.find(self._get_tag('time')))\n trk = root.find(self._get_tag('trk'))\n\n trkseg = trk.find(self._get_tag('trkseg'))\n\n # I just wanted to flatten the track point and get the\n # fields that I am actually interested in.\n def walker(node):\n nonlocal data\n tags = {'lat': float,\n 'lon': float,\n 'ele': float,\n 'time': cvt_time,\n 'temp': float,\n 'hr': float}\n for tag in tags:\n if node.tag.find(tag) >= 0:\n data[tag] = tags[tag](node.text)\n for child in node:\n walker(child)\n\n for trkpt in trkseg.findall(self._get_tag('trkpt')):\n data = {}\n data['lat'] = trkpt.attrib['lat']\n data['lon'] = trkpt.attrib['lon']\n walker(trkpt)\n self.points.append(TrackPoint(**data))","def initDataParms(self):\n self.xpos = self.pltw.curvelist[self.blkno].xvinfo.vidx\n self.data = self.pltw.blklst[self.blkno] # original data block\n self.idata = None # interpolated data\n (self.nvec, self.npt) = self.data.shape\n self.xmin = (self.data[self.xpos]).min()\n self.xmax = (self.data[self.xpos]).max()\n self.xspan = self.xmax - self.xmin\n if self.parent.test:\n self.dx = self.xspan / (self.npt * 5)","def build(self, data: dict):","def process(self):\n dataobj = Data()\n targetmap = {}\n sta_indices = {}\n hdulist = self.hdulist\n # First get all the OI_TARGET, OI_WAVELENGTH and OI_ARRAY tables\n for hdu in hdulist:\n header = hdu.header\n data = hdu.data\n if hdu.name == \"OI_WAVELENGTH\":\n if dataobj.wavelength == None:\n dataobj.wavelength = {}\n insname = header[\"INSNAME\"]\n dataobj.wavelength[insname] = OI_WAVELENGTH(\n data.field(\"EFF_WAVE\"), data.field(\"EFF_BAND\")\n )\n elif hdu.name == \"OI_TARGET\":\n for row in data:\n target_id = row[\"TARGET_ID\"]\n target = OI_TARGET(\n target=row[\"TARGET\"],\n raep0=row[\"RAEP0\"],\n decep0=row[\"DECEP0\"],\n equinox=row[\"EQUINOX\"],\n ra_err=row[\"RA_ERR\"],\n dec_err=row[\"DEC_ERR\"],\n sysvel=row[\"SYSVEL\"],\n veltyp=row[\"VELTYP\"],\n veldef=row[\"VELDEF\"],\n pmra=row[\"PMRA\"],\n pmdec=row[\"PMDEC\"],\n pmra_err=row[\"PMRA_ERR\"],\n pmdec_err=row[\"PMDEC_ERR\"],\n parallax=row[\"PARALLAX\"],\n para_err=row[\"PARA_ERR\"],\n spectyp=row[\"SPECTYP\"],\n )\n dataobj.target = np.append(dataobj.target, target)\n targetmap[target_id] = target\n elif hdu.name == \"OI_ARRAY\":\n if dataobj.array == None:\n dataobj.array = {}\n arrname = header[\"ARRNAME\"]\n frame = header[\"FRAME\"]\n arrxyz = np.array(\n [header[\"ARRAYX\"], header[\"ARRAYY\"], header[\"ARRAYZ\"]]\n )\n dataobj.array[arrname] = OI_ARRAY(frame, arrxyz, stations=data)\n # Save the sta_index for each array, as we will need it\n # later to match measurements to stations\n sta_indices[arrname] = data.field(\"sta_index\")\n\n # Then get any science measurements\n for hdu in hdulist:\n header = hdu.header\n data = hdu.data\n if hdu.name in (\"OI_VIS\", \"OI_VIS2\", \"OI_T3\"):\n if \"ARRNAME\" in header.keys():\n arrname = header[\"ARRNAME\"]\n else:\n arrname = None\n if arrname and dataobj.array:\n array = dataobj.array[arrname]\n else:\n array = None\n wavelength = dataobj.wavelength[header[\"INSNAME\"]]\n if hdu.name == \"OI_VIS\":\n for row in data:\n date = header[\"DATE-OBS\"].split(\"-\")\n timeobs = datetime.datetime(\n int(date[0]), int(date[1]), int(date[2])\n ) + datetime.timedelta(seconds=np.around(row.field(\"TIME\"), 2))\n int_time = row.field(\"INT_TIME\")\n visamp = np.reshape(row.field(\"VISAMP\"), -1)\n visamperr = np.reshape(row.field(\"VISAMPERR\"), -1)\n visphi = np.reshape(row.field(\"VISPHI\"), -1)\n visphierr = np.reshape(row.field(\"VISPHIERR\"), -1)\n if \"CFLUX\" in row.array.names:\n cflux = np.reshape(row.field(\"CFLUX\"), -1)\n else:\n cflux = None\n if \"CFLUXERR\" in row.array.names:\n cfluxerr = np.reshape(row.field(\"CFLUXERR\"), -1)\n else:\n cfluxerr = None\n flag = np.reshape(row.field(\"FLAG\"), -1)\n ucoord = row.field(\"UCOORD\")\n vcoord = row.field(\"VCOORD\")\n target = targetmap[row.field(\"TARGET_ID\")]\n if array:\n sta_index = row.field(\"STA_INDEX\")\n s1 = array.station[sta_indices[arrname] == sta_index[0]][0]\n s2 = array.station[sta_indices[arrname] == sta_index[1]][0]\n station = [s1, s2]\n else:\n station = [None, None]\n dataobj.vis = np.append(\n dataobj.vis,\n OI_VIS(\n timeobs=timeobs,\n int_time=int_time,\n visamp=visamp,\n visamperr=visamperr,\n visphi=visphi,\n visphierr=visphierr,\n flag=flag,\n ucoord=ucoord,\n vcoord=vcoord,\n wavelength=wavelength,\n target=target,\n array=array,\n station=station,\n cflux=cflux,\n cfluxerr=cfluxerr,\n ),\n )\n elif hdu.name == \"OI_VIS2\":\n for row in data:\n date = header[\"DATE-OBS\"].split(\"-\")\n timeobs = datetime.datetime(\n int(date[0]), int(date[1]), int(date[2])\n ) + datetime.timedelta(seconds=np.around(row.field(\"TIME\"), 2))\n int_time = row.field(\"INT_TIME\")\n vis2data = np.reshape(row.field(\"VIS2DATA\"), -1)\n vis2err = np.reshape(row.field(\"VIS2ERR\"), -1)\n flag = np.reshape(row.field(\"FLAG\"), -1)\n ucoord = row.field(\"UCOORD\")\n vcoord = row.field(\"VCOORD\")\n target = targetmap[row.field(\"TARGET_ID\")]\n if array:\n sta_index = row.field(\"STA_INDEX\")\n s1 = array.station[sta_indices[arrname] == sta_index[0]][0]\n s2 = array.station[sta_indices[arrname] == sta_index[1]][0]\n station = [s1, s2]\n else:\n station = [None, None]\n dataobj.vis2 = np.append(\n dataobj.vis2,\n OI_VIS2(\n timeobs=timeobs,\n int_time=int_time,\n vis2data=vis2data,\n vis2err=vis2err,\n flag=flag,\n ucoord=ucoord,\n vcoord=vcoord,\n wavelength=wavelength,\n target=target,\n array=array,\n station=station,\n ),\n )\n elif hdu.name == \"OI_T3\":\n for row in data:\n date = header[\"DATE-OBS\"].split(\"-\")\n timeobs = datetime.datetime(\n int(date[0]), int(date[1]), int(date[2])\n ) + datetime.timedelta(seconds=np.around(row.field(\"TIME\"), 2))\n int_time = row.field(\"INT_TIME\")\n t3amp = np.reshape(row.field(\"T3AMP\"), -1)\n t3amperr = np.reshape(row.field(\"T3AMPERR\"), -1)\n t3phi = np.reshape(row.field(\"T3PHI\"), -1)\n t3phierr = np.reshape(row.field(\"T3PHIERR\"), -1)\n flag = np.reshape(row.field(\"FLAG\"), -1)\n u1coord = row.field(\"U1COORD\")\n v1coord = row.field(\"V1COORD\")\n u2coord = row.field(\"U2COORD\")\n v2coord = row.field(\"V2COORD\")\n target = targetmap[row.field(\"TARGET_ID\")]\n if array:\n sta_index = row.field(\"STA_INDEX\")\n s1 = array.station[sta_indices[arrname] == sta_index[0]][0]\n s2 = array.station[sta_indices[arrname] == sta_index[1]][0]\n s3 = array.station[sta_indices[arrname] == sta_index[2]][0]\n station = [s1, s2, s3]\n else:\n station = [None, None, None]\n dataobj.t3 = np.append(\n dataobj.t3,\n OI_T3(\n timeobs=timeobs,\n int_time=int_time,\n t3amp=t3amp,\n t3amperr=t3amperr,\n t3phi=t3phi,\n t3phierr=t3phierr,\n flag=flag,\n u1coord=u1coord,\n v1coord=v1coord,\n u2coord=u2coord,\n v2coord=v2coord,\n wavelength=wavelength,\n target=target,\n array=array,\n station=station,\n ),\n )\n return dataobj","def __init__(self):\n self._data = PositionalList() # list of _Item instances","def __init__(self):\r\n self.indices = {}\r\n self.data = []\r\n self.len = 0","def build(self):\n if not hasattr(self, 'subtitle'):\n self.subtitle = self.data_code['subtitle']\n #print('ntimes=%s nelements=%s ntotal=%s subtitle=%s' % (\n #self.ntimes, self.nelements, self.ntotal, self.subtitle))\n nnodes = 1\n\n #self.names = []\n #self.nelements //= nnodes\n self.nelements //= self.ntimes\n #self.ntotal\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n #print('ntotal=%s ntimes=%s nelements=%s' % (self.ntotal, self.ntimes, self.nelements))\n\n self.ntotal = self.nelements * nnodes * 2\n if self.is_sort1:\n ntimes = self.ntimes\n ntotal = self.ntotal\n else:\n #print(\"ntimes=%s nelements=%s ntotal=%s nnodes=%s\" % (self.ntimes, self.nelements, self.ntotal, nnodes))\n ntimes = self.ntotal\n ntotal = self.nelements // 2\n #self.ntotal = ntotal\n #print(\"**BEND: ntimes=%s ntotal=%s\" % (ntimes, ntotal))\n #self.ntotal = nelements * nnodes * 2\n\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\n self._times = np.zeros(ntimes, dtype=dtype)\n #self.ntotal = self.nelements * nnodes\n\n self.element_node = np.zeros((ntotal, 2), dtype=idtype)\n\n # the number is messed up because of the offset for the element's properties\n if not self.nelements * nnodes * 2 == self.ntotal:\n msg = 'ntimes=%s nelements=%s nnodes=%s ne*nn=%s ntotal=%s' % (\n self.ntimes, self.nelements, nnodes, self.nelements * nnodes,\n self.ntotal)\n raise RuntimeError(msg)\n\n # [angle, sc, sd, se, sf, omax, omin, mst, msc]\n self.data = np.zeros((ntimes, ntotal, 9), dtype=fdtype)","def __init__(self):\n self.data = []\n self.record = {}","def set_content(self, offset: int, content_dict: dict):\n super().set_content(offset, content_dict)\n\n # Get the list of files from the properties and determine basenames from the path, which\n # will be used as name in the readfs\n for file in content_dict.get('properties').get('files'):\n self.file_paths.append([os.path.basename(file), file])\n\n # First declare the sub-sections so that the right offsets are computed\n\n # Top structure which will gather all sub-sections\n self.top_struct = CStructParent('readfs', parent=self)\n\n # Main header for readfs size and number of files\n self.header = ReadfsHeader('header', parent=self.top_struct)\n\n # One header per file containig file size, name and flash offset\n for i, path in enumerate(self.file_paths):\n filename, filepath = path\n self.file_headers.append(ReadfsFileHeader(f'file{i} header', len(filename)+1,\n parent=self.top_struct))\n\n # File contents\n for i, path in enumerate(self.file_paths):\n filename, filepath = path\n self.files.append(ReadfsFile(f'file{i}', os.path.getsize(filepath),\n parent=self.top_struct))\n\n\n\n # Now that the offsets have been computed, we can fill-in the various fields\n\n # Main header\n header_size = self.header.get_size()\n for file_header in self.file_headers:\n header_size += file_header.get_size()\n\n self.header.set_field('fs_size', header_size)\n self.header.set_field('nb_files', len(self.files))\n\n for i, path in enumerate(self.file_paths):\n filename, filepath = self.file_paths[i]\n file_header = self.file_headers[i]\n file = self.files[i]\n\n # Per-file header\n file_header.set_field('offset', file.get_offset() - self.get_offset())\n file_header.set_field('file_size', os.path.getsize(filepath))\n file_header.set_field('name_len', len(filename)+1)\n file_header.set_field('name', filename.encode('utf-8') + bytes([0]))\n\n # Per-file content\n with open(filepath, 'rb') as file_desc:\n file.set_field('data', file_desc.read())","def prepare_sFlat_data(notes, track_range = None, enc_shape = (1,), ip_memory = 32, depth = 2, spread = 16):\n track_range = track_range if track_range else [0, 1]\n \n data_in, data_out = [], []\n \n for tr in range(track_range[1] - track_range[0]):\n # trk = tr - track_range[0]\n nt = notes[tr]\n data_in.append([])\n data_out.append([])\n lent = len(notes[tr])\n # for j in range(lent):\n le = len(nt)\n \n chunks_count = le // ip_memory + 1\n \n for i in range(le - ip_memory):\n start, end = i, i + ip_memory\n buf_size = ip_memory if end < le else le - start # only reason due to logic below else not needed\n buffer = numpy.zeros((ip_memory, depth,))\n # print(\"buff shape : \", buffer.shape)\n buffer[:buf_size, :] = nt[start : start + buf_size]\n\n data_in[tr].append(buffer)\n \n data_out[tr].append((nt[end] if end < le else notes[0][0]))\n \n # if track_range[1]- track_range[0] == 1: #is scalar, no track\n # data_in, data_out = data_in[0], data_out[0]\n \n\n return numpy.array(data_in), numpy.array(data_out)","def __init__(self):\n\n\t\t# PDB fields\n\t\tself.s_name = \"\"\t\t\t\t# Name of the structure\n\t\tself.l_s_leading_data = []\t\t# PDB information written above the atom properties\n\t\tself.l_s_trailing_data = []\t\t# PDB information written under the atom properties\n\n\t\t# Structural fields\n\t\tself.i_atom_count = 0\t\t\t# Number of atoms in the structure\n\t\tself.a_atoms = None\t\t\t\t# Array of atoms properties\n\t\tself.a_max_coord = None\t\t\t# Maximal coordinates for each axis\n\t\tself.a_min_coord = None\t\t\t# Minimal coordinates for each axis\n\n\t\t# Grid fields\n\t\tself.a_grid = None\t\t\t\t# 3D grid containing the structure\n\t\tself.l_l_elements = None\t\t# Set of atoms contained in the structure\n\n\t\t# Solubilization fields\n\t\tself.o_tree = None\t\t\t\t\t\t# A KDTree object representing the exact placement of atoms, used for distance determination\n\n\t\t# Comparison fields\n\t\tself.b_loaded = False\t\t# Keeps tracks of the state of the structure\n\n\t\t# Ligands fields\n\t\tself.l_o_ligands = []\t\t# A list for the ligands\n\n\t\t# Pocket fields\n\t\tself.l_i_pocket_residues = []\t\t# List of the residues included in the pocket\n\t\tself.a_pocket_atoms = None\t\t\t# Array of the pocket atoms properties\n\t\tself.a_pocket_grid = None\t\t\t# 3D grid containing the pocket\n\n\t\t# Miscellaneous fields\n\t\tself.a_min_coord = None\t\t# Minimum coordinates of the structure\n\t\tself.a_max_coord = None\t\t# Maximum coordinates of the structure\n\t\tself.f_mass = 0.0\t\t\t# Mass of the structure","def setUp(self):\n\n serial_times = {295: '1971-07-31T01:24:11.754',\n 296: '1971-07-31T01:24:36.970',\n 297: '1971-07-31T01:25:02.243',\n 298: '1971-07-31T01:25:27.457',\n 299: '1971-07-31T01:25:52.669',\n 300: '1971-07-31T01:26:17.923'}\n self.serials = ['APOLLO15/METRIC/{}'.format(i) for i in serial_times.values()]\n\n\n x = list(range(5))\n y = list(range(5))\n pid = [0,0,1,1,1]\n idx = pid\n serials = [self.serials[0], self.serials[1], self.serials[2],\n self.serials[2], self.serials[3]]\n\n\n columns = ['x', 'y', 'idx', 'pid', 'nid']\n self.data_length = 5\n\n data = [x,y, idx, pid, serials]\n\n self.creation_time = strftime(\"%Y-%m-%d %H:%M:%S\", gmtime())\n cnet = C(data, index=columns).T\n\n io_controlnetwork.to_isis('test.net', cnet, mode='wb', targetname='Moon')\n\n self.header_message_size = 85\n self.point_start_byte = 65621","def build(self):\n if not hasattr(self, 'subtitle'):\n self.subtitle = self.data_code['subtitle']\n #print('ntimes=%s nelements=%s ntotal=%s subtitle=%s' % (\n #self.ntimes, self.nelements, self.ntotal, self.subtitle))\n if self.is_built:\n return\n nnodes = 1\n\n #self.names = []\n #self.nelements //= nnodes\n self.nelements //= self.ntimes\n self.ntotal = self.nelements * nnodes * 2\n #self.ntotal\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n #print('ntotal=%s ntimes=%s nelements=%s' % (self.ntotal, self.ntimes, self.nelements))\n\n #print(\"ntimes=%s nelements=%s ntotal=%s\" % (self.ntimes, self.nelements, self.ntotal))\n self._times = np.zeros(self.ntimes, 'float32')\n #self.ntotal = self.nelements * nnodes\n\n self.element_node = np.zeros((self.ntotal, 2), 'int32')\n\n # the number is messed up because of the offset for the element's properties\n if not self.nelements * nnodes * 2 == self.ntotal:\n msg = 'ntimes=%s nelements=%s nnodes=%s ne*nn=%s ntotal=%s' % (\n self.ntimes, self.nelements, nnodes, self.nelements * nnodes,\n self.ntotal)\n raise RuntimeError(msg)\n\n # [angle, sc, sd, se, sf]\n self.data = np.zeros((self.ntimes, self.ntotal, 5), 'complex64')","def _populate_shapes(self):\n point = Point(self.position.x, self.position.y)\n point_buffered = point.buffer(self.radius + self.buffer, 3)\n self._point_shape = point.buffer(self.radius, 3)\n \n scale = 10.0\n font = truetype(self.fontfile, int(self.fontsize * scale), encoding='unic')\n\n x, y = self.position.x, self.position.y\n w, h = font.getsize(self.name)\n w, h = w/scale, h/scale\n \n for placement in placements:\n label_shape = point_label_bounds(x, y, w, h, self.radius, placement)\n mask_shape = label_shape.buffer(self.buffer, 2).union(point_buffered)\n \n self._label_shapes[placement] = label_shape\n self._mask_shapes[placement] = mask_shape\n \n unionize = lambda a, b: a.union(b)\n self._label_footprint = reduce(unionize, self._label_shapes.values())\n self._mask_footprint = reduce(unionize, self._mask_shapes.values())\n \n # number of pixels from the top of the label based on the bottom of a \".\"\n self._baseline = font.getmask('.').getbbox()[3] / scale","def read_makerNotes(makerNotes, values=VALUES, i=0, starting_header=val_list[0]):\n nextHeader = starting_header\n while True:\n if makerNotes[i] == nextHeader:\n pos = val_list.index(nextHeader)\n header = key_list[pos]\n print(f'found header {hex(int(makerNotes[i]))} ({header}) at position {i}')\n type = makerNotes[i+2] # read data type\n num = int(struct.unpack(b\"<L\", makerNotes[i+4:i+8])[0]) # read num of occurances\n dataType = b\"<\"\n if type == 0x01: # pad\n dataType = dataType + (b\"x\" * num)\n size = num * 1\n data = struct.unpack(dataType, makerNotes[i+8:i+8+size])\n elif type == 0x02: # char\n dataType = dataType + (b\"c\" * num)\n size = num * 1\n data = struct.unpack(dataType, makerNotes[i+8:i+8+size])\n data = ' '.join([d.decode() for d in data])[:-1]\n elif type == 0x0b: # float\n dataType = dataType + (b\"f\" * num)\n size = num * 4\n data = struct.unpack(dataType, makerNotes[i+8:i+8+size])[num-1]\n else:\n raise ValueError(f'cannot identify type with hexadecimal representation: {type}')\n values[header] = data\n i = i + 8 + size - 1\n nextHeader += 1\n sumNones = sum([1 for key, val in values.items() if val is None])\n if sumNones == 0:\n break\n i+=1\n return values","def __init__(self, data, parent=None):\n self.parent = parent\n self.bootable_flag = struct.unpack(\"<B\", data[0])[0]\n self.start_chs_address = struct.unpack(\"<BH\", data[1:4])[0]\n self.partition_type = struct.unpack(\"<B\", data[4])[0]\n self.end_chs_address = struct.unpack(\"<BH\", data[5:8])[0]\n # FIXME Check to see how the lba address bytes are used\n if self.get_type() == 'Empty':\n self.lba = 0\n else:\n self.lba = struct.unpack(\"<L\", data[8:12])[0]\n\n self.size = struct.unpack(\"<L\", data[12:16])[0]","def __initialize(self):\n\t\tself.matrix = [None] * self.size\n\t\tself.__get_log_values()\n\t\tfor row in range(self.size):\n\t\t\tself.matrix[row] = [None] * self.size\n\t\tmax_len = self.__get_max_length()\n\t\tdata = self.__get_data(self.text,max_len)\n\t\tmpoly = self.__get_mpoly(data)\n\t\tgpoly = self.__get_gploy()\n\t\tself.final_data = self.__get_final_data(mpoly,gpoly)\n\t\tself.__set_FIP(FP_num = 1)\n\t\tself.__set_FIP(FP_num = 2)\n\t\tself.__set_FIP(FP_num = 3)\n\t\tself.__set_AP()\n\t\tself.__fill_format_info_area()\n\t\tself.__set_TP()","def build_data(self):\n\n _header_ = self._header_ + 'build_data(): '\n\n if self.verbose:\n print(_header_ + 'Building data for %s ...' % self.p_data)\n\n self.read_data()\n self.map_data()\n self.partition_data()\n self.composition()\n\n if self.verbose:\n print(_header_ + 'Build complete.')\n\n return self","def processData(self,data):\n #print 'I GOT DATA',data,[0],data[1]\n # Check for valid data (not null or empty string)\n #print '**************NOTIFICATION***************',type(_RobotCommunicator.WALL_HEADER),type(data[0])\n if data:\n #print '**************NOTIFICATION***************',type(_RobotCommunicator.WALL_HEADER),type(data[0]),_RobotCommunicator.WALL_HEADER==data[0]\n\n # Check header and assign data appropriately\n # TODO: Check length of data for validity\n #print 'Header',data[0]\n if data[0] == _RobotCommunicator.POSE_HEADER:\n self.pose = unpack(_RobotCommunicator.POSE_FORMAT,data[1:])\n elif data[0] == _RobotCommunicator.SENSOR_HEADER:\n\n #for i in range(1, len(data)-1, 2):\n index= unpack('B',data[1])\n value = unpack('?',data[2])\n # Update old values or create new sensor-value pair\n self.sensors[index[0]] = value[0]\n #print 'in csharp: ',[index,value]\n\n elif data[0] == _RobotCommunicator.WAYPOINT_HEADER:\n self.waypoints = [] # Clear old waypoints\n for i in range(1, len(data)-16, 16):\n x,y = unpack(_RobotCommunicator.WAYPOINT_FORMAT,\n data[i:i+15])\n self.waypoints.append((x,y))\n elif data[0] == _RobotCommunicator.DIRECTION_HEADER:\n self.direction = unpack(_RobotCommunicator.DIRECTION_FORMAT,\n data[1:])\n elif data[0] == _RobotCommunicator.ACTUATOR_HEADER:\n self.actuators = [] # Clear old actuator commands for i in range(1, len(data)-1):\n self.actuators.append(unpack(\n _RobotCommunicator.ACTUATOR_FORMAT,data[i]))\n elif data[0] == _RobotCommunicator.WALL_HEADER:\n self.walls = {} # Clear old wall entries\n index = unpack('B', data[1])\n x1,y1,x2,y2 = unpack(_RobotCommunicator.WALL_FORMAT,data[2:34])\n self.walls = (x1,y1,x2,y2)\n #print '**************Coordinates***************',(x1,y1,x2,y2)\n print '****self.walls*********',self.walls\n elif data[0] == _RobotCommunicator.OBS_HEADER:\n index = unpack('B', data[1])\n add,x1,y1 = unpack(_RobotCommunicator.OBS_FORMAT,data[2:26])\n #print '***********self.obs*************'+','.join(map(str,[add,x1,y1]))\n self.obs = [add,x1,round(y1,2)]\n if add == 1:\n a = PolyShapes.Rectangle(self.resolX,self.resolY)\n a.shift(x1,y1)\n self.obsPoly += a\n self.receiveObs = True\n #print \"add obstacle:\" + str(x1) + \",\"+ str(y1)\n elif add == 4:\n if x1 == 0:\n self.STOP = True\n else:\n self.STOP = False\n else:\n a = PolyShapes.Rectangle(self.resolX,self.resolY)\n a.shift(x1,y1)\n self.obsPoly -= a\n self.receiveObs = True\n #print \"del obstacle:\"+ str(x1) + \",\"+ str(y1)\n\n\n else:\n print \"Unexpected or corrupted data packet received.\"","def __init__(self, data):\n # check if dataset contains time information\n # (fetched from bootloader storage)\n if len(data) == 61:\n (_, seconds, minutes, hours, days, months, years) = struct.unpack(\n '<55sBBBBBB', data)\n self.date = datetime(2000 + years, months, days, hours, minutes,\n seconds)\n\n # Only parse preceding data\n data = data[:55]\n power = [0, 0]\n kWh = [0, 0]\n MWh = [0, 0]\n (_, digital, speed, active, power[0], kWh[0], MWh[0], power[1], kWh[1],\n MWh[1]) = struct.unpack('<32sH4sBLHHLHH', data)\n\n analog = struct.unpack(\n '<{}{}'.format('H' * 16, 'x' * (len(data) - 32)), data)\n\n self.analog = {}\n for channel in range(0, 16):\n self.analog[channel + 1] = round(\n self._convert_analog(analog[channel]), 3)\n\n self.digital = {}\n for channel in range(0, 16):\n self.digital[channel + 1] = self._convert_digital(digital, channel)\n\n '''\n self.speed = {}\n for channel in range(0, 4):\n self.speed[channel + 1] = round(\n self._convert_speed(speed[channel]), 3)\n \n\n self.energy = {}\n for channel in range(0, 2):\n self.energy[channel + 1] = round(\n self._convert_energy(MWh[channel], kWh[channel], active,\n channel), 3)\n \n\n self.power = {}\n for channel in range(0, 2):\n self.power[channel + 1] = round(\n self._convert_power(power[channel], active, channel), 3)\n '''","def _get_obs(self):\n pos = []\n z = []\n for i in range(params['memory_size']):\n if self._step - i * params['memory_size'] > 1:\n pos.append(self._track_item['joint_pos'][self._step - i * params['memory_size'] - 1].copy())\n z.append(self._track_item['z'][self._step - i * params['memory_size'] - 1].copy())\n else:\n pos.append(self._track_item['joint_pos'][0].copy())\n if len(self._track_item['z']) < 1:\n z.append(self.z.copy())\n else:\n z.append(self._track_item['z'][0].copy())\n out = pos\n if params['observation_version'] == 1:\n out += z\n ob = {\n 'observation' : np.concatenate(out, -1),\n 'desired_goal' : self.desired_goal.copy(),\n 'achieved_goal' : self.achieved_goal.copy(),\n 'z' : self.z.copy()\n }\n return ob","def deserialize(self, str):\n try:\n if self.header is None:\n self.header = std_msgs.msg.Header()\n if self.sensor_pose_on_robot is None:\n self.sensor_pose_on_robot = geometry_msgs.msg.Pose()\n if self.sensed_data is None:\n self.sensed_data = None\n end = 0\n _x = self\n start = end\n end += 12\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 96\n (_x.sensor_pose_on_robot.position.x, _x.sensor_pose_on_robot.position.y, _x.sensor_pose_on_robot.position.z, _x.sensor_pose_on_robot.orientation.x, _x.sensor_pose_on_robot.orientation.y, _x.sensor_pose_on_robot.orientation.z, _x.sensor_pose_on_robot.orientation.w, _x.min_sensor_distance, _x.max_sensor_distance, _x.sensor_std_range, _x.sensor_std_yaw, _x.sensor_std_pitch,) = _get_struct_12d().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.sensed_data = []\n for i in range(0, length):\n val1 = mrpt_msgs.msg.SingleRangeBearingObservation()\n _x = val1\n start = end\n end += 28\n (_x.range, _x.yaw, _x.pitch, _x.id,) = _get_struct_3di().unpack(str[start:end])\n self.sensed_data.append(val1)\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill","def get_map_notes(map_json, **kwargs):\n length = kwargs.get(\"length\", -1)\n divisor = kwargs.get(\"divisor\", 4)\n tick_times = get_map_timing_array(map_json, length=length, divisor=divisor)\n\n objs = map_json[\"obj\"]\n obj_times = list(map(lambda obj: obj[\"time\"], objs))\n\n # 1 for circle, 2 for slider, 3 for spinner\n def get_note_type(obj):\n if not obj:\n return 0\n if obj[\"type\"] & 2:\n return 2\n elif obj[\"type\"] & 8:\n return 3\n return 1\n\n po = 0\n note_max_wait_time = kwargs.get(\"note_max_wait_time\", 1000)\n start_time = obj_times[0] - note_max_wait_time\n last_obj_time = start_time\n sliding = 0\n slider_end_time = 0\n spinning = 0\n spinner_end_time = 0\n data = []\n flow_data = []\n\n # constant multipliers and subtractions\n tlen_mp = 1/500\n tlen_s = 1\n bpm_mp = 1/120\n bpm_s = 1\n slen_mp = 1/150\n slen_s = 1\n\n # tick count from start of uninherited timing section\n uts_i = 0\n\n # tick is timestamp here\n for i, tick in enumerate(tick_times):\n\n if is_uts_begin(map_json, tick):\n uts_i = 0\n else:\n uts_i += 1\n\n # Attach extra vars at the end of each note data row\n tlen = get_tick_len(map_json, tick)\n bpm = 60000 / tlen\n slen = get_slider_len(map_json, tick)\n ex1 = tlen * tlen_mp - tlen_s\n ex2 = bpm * bpm_mp - bpm_s\n ex3 = slen * slen_mp - slen_s\n\n while obj_times[po] < tick - 5 and po < len(obj_times) - 1:\n po += 1\n if obj_times[po] >= tick - 5 and obj_times[po] <= tick + 5: # found note\n last_obj_time = tick\n note_type = get_note_type(objs[po])\n\n # calculate momentum\n if po >= 1:\n momentum = get_momentum(objs[po], objs[po-1], slen/tlen)\n else:\n momentum = 0\n\n # flow data\n if po >= 1:\n input_vector = get_input_vector(objs[po], objs[po-1])\n output_vector = get_output_vector(objs[po], objs[po-1])\n else:\n input_vector = [0, 0]\n output_vector = [0, 0]\n if input_vector is None or input_vector[0] is None or input_vector[1] is None:\n input_vector = [0, 0]\n if output_vector is None or output_vector[0] is None or output_vector[1] is None:\n output_vector = [0, 0]\n\n # end point\n endpoint = get_end_point(objs[po])\n flow_data.append([uts_i, tick, note_type, objs[po][\"x\"], objs[po][\"y\"], input_vector[0],\n input_vector[1], output_vector[0], output_vector[1], endpoint[0], endpoint[1]])\n\n # put data\n if note_type == 1:\n spinning = 0\n sliding = 0\n elif note_type == 2:\n sliding = 1\n slider_end_time = objs[po][\"sliderData\"][\"endTime\"]\n elif note_type == 3:\n spinning = 1\n spinner_end_time = objs[po][\"spinnerEndTime\"]\n # because the spinner sometimes get over 3 secs\n last_obj_time = spinner_end_time\n\n # TICK, TIME, NOTE, NOTE_TYPE, SLIDING, SPINNING, MOMENTUM, Ex1, Ex2, Ex3\n data.append([uts_i, tick, 1, note_type, sliding,\n spinning, momentum, ex1, ex2, ex3])\n elif spinning == 1:\n if tick >= spinner_end_time - 5:\n spinning = 0\n data.append([uts_i, tick, 1, 5, 0, 0, 0, ex1, ex2, ex3])\n else:\n data.append([uts_i, tick, 0, 0, 0, 1, 0, ex1, ex2, ex3])\n elif sliding == 1:\n if tick >= slider_end_time - 5:\n sliding = 0\n data.append([uts_i, tick, 1, 4, 0, 0, 0, ex1, ex2, ex3])\n else:\n data.append([uts_i, tick, 0, 0, 1, 0, 0, ex1, ex2, ex3])\n else: # not found\n if tick - last_obj_time < note_max_wait_time and tick >= start_time:\n data.append([uts_i, tick, 0, 0, 0, 0, 0, ex1, ex2, ex3])\n return data, flow_data","def __init__(self, data):\n # add play_guid as it sometimes doesn't exist\n if 'play_guid' not in data:\n data['play_guid'] = ''\n # loop through data\n for x in data:\n # set information as correct data type\n mlbgame.object.setobjattr(self, x, data[x])","def build(self, file_number, data):\n pass","def deserialize(self, str):\n try:\n if self.header is None:\n self.header = std_msgs.msg.Header()\n if self.obstacleinfo is None:\n self.obstacleinfo = nubot_common.msg.ObstaclesInfo()\n if self.oppinfo is None:\n self.oppinfo = nubot_common.msg.ObstaclesInfo()\n if self.robotinfo is None:\n self.robotinfo = None\n if self.ballinfo is None:\n self.ballinfo = None\n if self.coachinfo is None:\n self.coachinfo = nubot_common.msg.CoachInfo()\n if self.pass_cmd is None:\n self.pass_cmd = nubot_common.msg.PassCommands()\n end = 0\n _x = self\n start = end\n end += 12\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 12\n (_x.obstacleinfo.header.seq, _x.obstacleinfo.header.stamp.secs, _x.obstacleinfo.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.obstacleinfo.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.obstacleinfo.header.frame_id = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.obstacleinfo.pos = []\n for i in range(0, length):\n val1 = nubot_common.msg.Point2d()\n _x = val1\n start = end\n end += 8\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\n self.obstacleinfo.pos.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.obstacleinfo.polar_pos = []\n for i in range(0, length):\n val1 = nubot_common.msg.PPoint()\n _x = val1\n start = end\n end += 8\n (_x.angle, _x.radius,) = _get_struct_2f().unpack(str[start:end])\n self.obstacleinfo.polar_pos.append(val1)\n _x = self\n start = end\n end += 12\n (_x.oppinfo.header.seq, _x.oppinfo.header.stamp.secs, _x.oppinfo.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.oppinfo.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.oppinfo.header.frame_id = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.oppinfo.pos = []\n for i in range(0, length):\n val1 = nubot_common.msg.Point2d()\n _x = val1\n start = end\n end += 8\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\n self.oppinfo.pos.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.oppinfo.polar_pos = []\n for i in range(0, length):\n val1 = nubot_common.msg.PPoint()\n _x = val1\n start = end\n end += 8\n (_x.angle, _x.radius,) = _get_struct_2f().unpack(str[start:end])\n self.oppinfo.polar_pos.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.robotinfo = []\n for i in range(0, length):\n val1 = nubot_common.msg.RobotInfo()\n _v12 = val1.header\n start = end\n end += 4\n (_v12.seq,) = _get_struct_I().unpack(str[start:end])\n _v13 = _v12.stamp\n _x = _v13\n start = end\n end += 8\n (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n _v12.frame_id = str[start:end].decode('utf-8')\n else:\n _v12.frame_id = str[start:end]\n _x = val1\n start = end\n end += 28\n (_x.AgentID, _x.targetNum1, _x.targetNum2, _x.targetNum3, _x.targetNum4, _x.staticpassNum, _x.staticcatchNum,) = _get_struct_7i().unpack(str[start:end])\n _v14 = val1.pos\n _x = _v14\n start = end\n end += 8\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\n _v15 = val1.heading\n start = end\n end += 4\n (_v15.theta,) = _get_struct_f().unpack(str[start:end])\n start = end\n end += 4\n (val1.vrot,) = _get_struct_f().unpack(str[start:end])\n _v16 = val1.vtrans\n _x = _v16\n start = end\n end += 8\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\n _x = val1\n start = end\n end += 9\n (_x.iskick, _x.isvalid, _x.isstuck, _x.isdribble, _x.current_role, _x.role_time,) = _get_struct_5Bf().unpack(str[start:end])\n val1.iskick = bool(val1.iskick)\n val1.isvalid = bool(val1.isvalid)\n val1.isstuck = bool(val1.isstuck)\n val1.isdribble = bool(val1.isdribble)\n _v17 = val1.target\n _x = _v17\n start = end\n end += 8\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\n self.robotinfo.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.ballinfo = []\n for i in range(0, length):\n val1 = nubot_common.msg.BallInfo()\n _v18 = val1.header\n start = end\n end += 4\n (_v18.seq,) = _get_struct_I().unpack(str[start:end])\n _v19 = _v18.stamp\n _x = _v19\n start = end\n end += 8\n (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n _v18.frame_id = str[start:end].decode('utf-8')\n else:\n _v18.frame_id = str[start:end]\n start = end\n end += 4\n (val1.ballinfostate,) = _get_struct_i().unpack(str[start:end])\n _v20 = val1.pos\n _x = _v20\n start = end\n end += 8\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\n _v21 = val1.real_pos\n _x = _v21\n start = end\n end += 8\n (_x.angle, _x.radius,) = _get_struct_2f().unpack(str[start:end])\n _v22 = val1.velocity\n _x = _v22\n start = end\n end += 8\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\n _x = val1\n start = end\n end += 2\n (_x.pos_known, _x.velocity_known,) = _get_struct_2B().unpack(str[start:end])\n val1.pos_known = bool(val1.pos_known)\n val1.velocity_known = bool(val1.velocity_known)\n self.ballinfo.append(val1)\n _x = self\n start = end\n end += 12\n (_x.coachinfo.header.seq, _x.coachinfo.header.stamp.secs, _x.coachinfo.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.coachinfo.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.coachinfo.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 54\n (_x.coachinfo.MatchMode, _x.coachinfo.MatchType, _x.coachinfo.TestMode, _x.coachinfo.pointA.x, _x.coachinfo.pointA.y, _x.coachinfo.pointB.x, _x.coachinfo.pointB.y, _x.coachinfo.angleA, _x.coachinfo.angleB, _x.coachinfo.idA, _x.coachinfo.idB, _x.coachinfo.kickforce, _x.pass_cmd.pass_id, _x.pass_cmd.catch_id, _x.pass_cmd.pass_pt.x, _x.pass_cmd.pass_pt.y, _x.pass_cmd.catch_pt.x, _x.pass_cmd.catch_pt.y, _x.pass_cmd.is_passout, _x.pass_cmd.is_dynamic_pass, _x.pass_cmd.is_static_pass, _x.pass_cmd.is_valid,) = _get_struct_3B4f2h3B2I4f4B().unpack(str[start:end])\n self.pass_cmd.is_passout = bool(self.pass_cmd.is_passout)\n self.pass_cmd.is_dynamic_pass = bool(self.pass_cmd.is_dynamic_pass)\n self.pass_cmd.is_static_pass = bool(self.pass_cmd.is_static_pass)\n self.pass_cmd.is_valid = bool(self.pass_cmd.is_valid)\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill","def refresh(self):\n self.info = str(self.ser.readline())[2:-5].split(',')\n self.x, self.y, self.z, self.xa, self.ya, self.za, self.o = self.info","def _make_observation(self) -> Dict[str, np.ndarray]:\n return {\n \"cur_pos\": np.array([self.cur_pos], dtype=int),\n }","def __init__(self):\n self._data = PositionalList() # list of Item instances","def deserialize(self, str):\n try:\n if self.base is None:\n self.base = rwrc12_msgs.msg.CellBase()\n end = 0\n _x = self\n start = end\n end += 12\n (_x.base.header.seq, _x.base.header.stamp.secs, _x.base.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.base.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.base.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 20\n (_x.base.cell_width, _x.base.cell_height, _x.base.position.x, _x.base.position.y, _x.base.position.z,) = _struct_5f.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.base.points = []\n for i in range(0, length):\n val1 = geometry_msgs.msg.Point32()\n _x = val1\n start = end\n end += 12\n (_x.x, _x.y, _x.z,) = _struct_3f.unpack(str[start:end])\n self.base.points.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sf'%length\n start = end\n end += struct.calcsize(pattern)\n self.base.intensity = struct.unpack(pattern, str[start:end])\n start = end\n end += 1\n (self.base.cost,) = _struct_b.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.base.label = str[start:end].decode('utf-8')\n else:\n self.base.label = str[start:end]\n _x = self\n start = end\n end += 8\n (_x.mean_height, _x.mean_intensity,) = _struct_2f.unpack(str[start:end])\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill","def __init__(self):\n self.metadata = {}\n self.geometry = {'array': None, \n 'geom': None, \n 'wkt': None}","def __init__(self, data, startLat, startLon, delta, numX, numY):\n self.data = data\n self.startLat = startLat\n self.startLon = startLon\n self.delta = delta\n self.xCells = numX\n self.yCells = numY","def _initialize_data(self):\n self.reset_count = 0\n self._idn_no_firmware = \"KEPCO,BOP 50-20,E1234,\"\n self._firmware = 2.6\n self._init_data()","def _get_data(\n self,\n vis_hdu,\n antenna_nums,\n antenna_names,\n ant_str,\n bls,\n frequencies,\n freq_chans,\n times,\n time_range,\n lsts,\n lst_range,\n polarizations,\n blt_inds,\n phase_center_ids,\n catalog_names,\n keep_all_metadata,\n fix_old_proj,\n fix_use_ant_pos,\n ):\n # figure out what data to read in\n blt_inds, freq_inds, pol_inds, history_update_string = self._select_preprocess(\n antenna_nums,\n antenna_names,\n ant_str,\n bls,\n frequencies,\n freq_chans,\n times,\n time_range,\n lsts,\n lst_range,\n polarizations,\n blt_inds,\n phase_center_ids,\n catalog_names,\n )\n\n if blt_inds is not None:\n blt_frac = len(blt_inds) / float(self.Nblts)\n else:\n blt_frac = 1\n\n if freq_inds is not None:\n freq_frac = len(freq_inds) * float(self.Nspws) / float(self.Nfreqs)\n else:\n freq_frac = 1\n\n if pol_inds is not None:\n pol_frac = len(pol_inds) / float(self.Npols)\n else:\n pol_frac = 1\n\n min_frac = np.min([blt_frac, freq_frac, pol_frac])\n\n if min_frac == 1:\n # no select, read in all the data\n if vis_hdu.header[\"NAXIS\"] == 7:\n raw_data_array = vis_hdu.data.data[:, 0, 0, :, :, :, :]\n assert self.Nspws == raw_data_array.shape[1]\n\n else:\n # in many uvfits files the spw axis is left out,\n # here we put it back in so the dimensionality stays the same\n raw_data_array = vis_hdu.data.data[:, 0, 0, :, :, :]\n raw_data_array = raw_data_array[:, np.newaxis, :, :]\n else:\n # do select operations on everything except data_array, flag_array\n # and nsample_array\n self._select_by_index(\n blt_inds, freq_inds, pol_inds, history_update_string, keep_all_metadata\n )\n\n # just read in the right portions of the data and flag arrays\n if blt_frac == min_frac:\n if vis_hdu.header[\"NAXIS\"] == 7:\n raw_data_array = vis_hdu.data.data[blt_inds, :, :, :, :, :, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\n assert self.Nspws == raw_data_array.shape[1]\n else:\n # in many uvfits files the spw axis is left out,\n # here we put it back in so the dimensionality stays the same\n raw_data_array = vis_hdu.data.data[blt_inds, :, :, :, :, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\n if freq_frac < 1:\n raw_data_array = raw_data_array[:, :, freq_inds, :, :]\n if pol_frac < 1:\n raw_data_array = raw_data_array[:, :, :, pol_inds, :]\n elif freq_frac == min_frac:\n if vis_hdu.header[\"NAXIS\"] == 7:\n raw_data_array = vis_hdu.data.data[:, :, :, :, freq_inds, :, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\n assert self.Nspws == raw_data_array.shape[1]\n else:\n # in many uvfits files the spw axis is left out,\n # here we put it back in so the dimensionality stays the same\n raw_data_array = vis_hdu.data.data[:, :, :, freq_inds, :, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\n\n if blt_frac < 1:\n raw_data_array = raw_data_array[blt_inds, :, :, :, :]\n if pol_frac < 1:\n raw_data_array = raw_data_array[:, :, :, pol_inds, :]\n else:\n if vis_hdu.header[\"NAXIS\"] == 7:\n raw_data_array = vis_hdu.data.data[:, :, :, :, :, pol_inds, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\n assert self.Nspws == raw_data_array.shape[1]\n else:\n # in many uvfits files the spw axis is left out,\n # here we put it back in so the dimensionality stays the same\n raw_data_array = vis_hdu.data.data[:, :, :, :, pol_inds, :]\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\n\n if blt_frac < 1:\n raw_data_array = raw_data_array[blt_inds, :, :, :, :]\n if freq_frac < 1:\n raw_data_array = raw_data_array[:, :, freq_inds, :, :]\n\n assert len(raw_data_array.shape) == 5\n\n # Reshape the data array to be the right size if we are working w/ multiple\n # spectral windows to be 'flex_spw' compliant\n if self.Nspws > 1:\n raw_data_array = np.reshape(\n raw_data_array,\n (self.Nblts, 1, self.Nfreqs, self.Npols, raw_data_array.shape[4]),\n )\n\n # FITS uvw direction convention is opposite ours and Miriad's.\n # So conjugate the visibilities and flip the uvws:\n self.data_array = (\n raw_data_array[:, :, :, :, 0] - 1j * raw_data_array[:, :, :, :, 1]\n )\n self.flag_array = raw_data_array[:, :, :, :, 2] <= 0\n self.nsample_array = np.abs(raw_data_array[:, :, :, :, 2])\n\n if fix_old_proj:\n self.fix_phase(use_ant_pos=fix_use_ant_pos)","def _prepare(self):\n # Time list\n self.time_list = []\n # Distance array\n if self._fxn[0] is True:\n self.res_dists, self.res_keys = build_reslist_dict(self._rpl)\n\n # Distance between alpha carbons\n if self._fxn[1] is True:\n self.ca_dists, self.ca_keys = build_reslist_dict(self._rpl)\n\n # Distance between resid center of mass\n if self._fxn[2] is True:\n self.cm_dists, self.cm_keys = build_reslist_dict(self._rpl)\n\n # Distance between resid center of geometry\n if self._fxn[3] is True:\n self.cg_dists, self.cg_keys = build_reslist_dict(self._rpl)","def func_init(self):\n self.points.set_data([], [])\n for line in self.lines:\n line.set_data([],[])\n self.annotation.set_text('')\n\n return tuple(self.lines) + (self.points, self.annotation)","def __init__(self, data_id, course_fields, speed_fields, heading_fields,\n wind_dir_fields, wind_speed_fields,\n update_on_fields=None,\n zero_line_reference=0,\n convert_wind_factor=1,\n convert_speed_factor=1,\n output_nmea=False):\n super().__init__(input_format=formats.Python_Record,\n output_format=formats.Text)\n self.data_id = data_id\n self.course_fields = course_fields.split(',')\n self.speed_fields = speed_fields.split(',')\n self.heading_fields = heading_fields.split(',')\n self.wind_dir_fields = wind_dir_fields.split(',')\n self.wind_speed_fields = wind_speed_fields.split(',')\n\n if update_on_fields:\n self.update_on_fields = update_on_fields.split(',')\n else:\n self.update_on_fields = self.wind_dir_fields\n self.zero_line_reference = zero_line_reference\n\n self.convert_wind_factor = convert_wind_factor\n self.convert_speed_factor = convert_speed_factor\n self.output_nmea = output_nmea\n \n self.course_val = None\n self.speed_val = None\n self.heading_val = None\n self.wind_dir_val = None\n self.wind_speed_val = None\n\n self.last_timestamp = 0","def _build_parsed_values(self):\n\n # \n # Generate a velocity data particle.\n # Note that raw_data already contains the individual fields\n # extracted and unpacked from the velocity data record.\n #\n global flags\n particle = []\n field = 0\n for flag in range(0, FLAG_RECORD_SIZE):\n #\n # If the flags indicated that this field is to be expected,\n # store the next unpacked value into the data particle.\n #\n key = VEL3D_PARAMETERS[flag][INDEX_KEY]\n if flags[flag]:\n if flag == INDEX_FLAG_Time:\n #\n # This returns a tuple, but particle wants a list.\n #\n time_array = self.raw_data[field:field + OUTPUT_TIME_SIZE]\n\n particle.append({DataParticleKey.VALUE_ID: key,\n DataParticleKey.VALUE: list(time_array)})\n field += OUTPUT_TIME_SIZE\n else:\n particle.append({DataParticleKey.VALUE_ID: key,\n DataParticleKey.VALUE: self.raw_data[field]})\n field += 1\n\n #\n # If flags indicate that this field is not present,\n # output a value of None.\n #\n else:\n particle.append({DataParticleKey.VALUE_ID: key,\n DataParticleKey.VALUE: None})\n\n return particle","def __init__(self):\n self._distance_data = []\n self._location_data = []\n self._package_data = []","def prepare_data(self, context_size, model_name):\n self.context_size = context_size\n data_x = []\n data_y = []\n oob = self.word2idx['OOB']\n\n for item in self.docs:\n data = [oob] * context_size + self.doc2token(item) + [oob] * context_size #padding\n for i in range(context_size, len(data) - context_size):\n data_x.append(data[i - context_size: i] + data[i + 1: i + context_size + 1])\n data_y.append(data[i])\n \n if model_name.lower() == 'skipgram':\n data_x, data_y = data_y, data_x\n self.data_x = Variable(torch.LongTensor(data_x))\n self.data_y = Variable(torch.LongTensor(data_y))\n logging.info(f'data preprocessed, data shape: {self.data_x.shape}, {self.data_y.shape}')","def _build_accessor(bufferview, ele_type, comptype_id, count, max_vals, min_vals, byte_offset, normalized):\n normalized = None if not normalized else normalized\n\n new_accessor = {\n \"bufferView\": bufferview,\n \"componentType\": comptype_id,\n \"type\": ele_type,\n \"count\": count,\n }\n\n properties_keys = [\"byteOffset\", \"normalized\", \"max\", \"min\"]\n properties_values = [byte_offset, normalized, max_vals, min_vals]\n\n for key, val in zip(properties_keys, properties_values):\n if val is not None:\n new_accessor[key] = val\n\n return new_accessor","def init(self):\n logger.info(mm_cnofs.ackn_str)\n self.acknowledgements = mm_cnofs.ackn_str\n self.references = '\\n'.join((mm_cnofs.refs['mission'],\n mm_cnofs.refs['vefi']))\n\n return","def _read_info(self):\n my_filelines = self.file_lines\n info = dict()\n\n for i, line in enumerate(my_filelines):\n if line.startswith(\"VEHICLE\"):\n vehicle_pro_start = i + 2\n elif line.startswith(\"CUSTOMER\"):\n customer_pro_start = i + 3\n\n elif line.startswith(\"NUMBER\"):\n splited = line.split(' ')\n info[splited[0]] = 0\n info[splited[-1]] = 0\n return info, (vehicle_pro_start, customer_pro_start)","def _init():\n line.set_data([], [])\n return line,","def build_data(self):\n from desiutil.io import combine_dicts\n # Loop on exposures\n odict = {}\n for qanight in self.qa_nights:\n for qaexp in qanight.qa_exps:\n # Get the exposure dict\n idict = write_qa_exposure('foo', qaexp, ret_dict=True)\n odict = combine_dicts(odict, idict)\n # Finish\n self.data = odict","def init_data_array(self, mess = None): \n if self.verbose > 1:\n print(\"MultiLinearSpectra.init_data_array()\") \n \n if mess is None:\n if self.mess is None:\n warnings.warn(\"MultiLinearSpectra.init_data_array(): no data to initialize\")\n return None\n else:\n self.mess = mess\n \n\n \n \n for m in range(len(self.mess)):\n \n self.mess[m][\"index\"] = m\n \n kwargs = {}\n for k, v in self.mess[m].items():\n kwargs[k] = v\n \n if self.mess[m][\"class\"] == \"PASGas\" and flag_ST:\n self.mess[m][\"object\"] = PASG.PASGas(verbose = self.verbose, **kwargs)\n\n elif self.mess[m][\"class\"] == \"PASLiquid\" and flag_ST:\n self.mess[m][\"object\"] = PASL.PASLiquid(verbose = self.verbose, **kwargs)\n\n\n # x_unit = self.mess[0].x_unit\n # y_unit = self.mess[0].y_unit\n\n # for m in range(1, len(self.mess)):\n # if x_unit != self.mess[m].x_unit:\n # self.mess.x_unit","def _setup_metadata(self):\n # loom_metadata is what we use to pass all the information about\n # the loom (max_depth, which typeshapes are supported, and the signatures of\n # the LoomOps) to scheduler.cc\n loom_metadata = loom_pb2.LoomMetadata()\n loom_metadata.max_depth = self._max_depth\n for ts, tensor_names in zip(\n self._type_shapes, self._ts_idx_to_tensor_names):\n type_shape_metadata = loom_metadata.type_shape_metadata.add()\n type_shape_metadata.dtype = ts.dtype_enum\n type_shape_metadata.shape.extend(ts.shape)\n type_shape_metadata.tag = ts.tag\n type_shape_metadata.name = str(ts) # Debug string.\n type_shape_metadata.tensor_names.extend(tensor_names)\n type_shape_metadata.is_batch_input = (\n (ts in self._batch_inputs) or self._direct_feed_dict)\n\n for op_name, op in zip(self._loom_op_names, self._loom_ops):\n op_metadata = loom_metadata.op_metadata.add()\n op_metadata.name = op_name\n op_metadata.input_ts_idx.extend(\n self._type_shape_to_idx[ts] for ts in op.input_type_shapes)\n op_metadata.output_ts_idx.extend(\n self._type_shape_to_idx[ts] for ts in op.output_type_shapes)\n\n self._loom_metadata_str = (\n loom_metadata.SerializeToString())","def _read_header(self):\n f = self._open(self.filename, 'rb')\n idx = 0\n header = b''\n # reading the header \n while idx < 13: \n header += f.readline().rstrip() # removes the \"\\n\\r\" at the end\n idx += 1\n # \"magically\" compute the data offset\n try:\n self._offset_auto = ord(header[2]) + 1856\n except:\n self._offset_auto = header[2] + 1856\n\n\n\n header = header[:self._offset_auto+300] # add an extra random header for offset\n header = re.sub(r'(?P<section>\\[[^\\]]+\\])', '\\n\\g<section>', header.decode('latin1'))\n header = header.splitlines()[1:]\n self.header = dict([self._header_sect2dict(line) for line in header])\n self.shape = np.array(self.header['Acquisition']['areGRBScan'].split(',')[-2:]).astype(np.int)\n f.close()\n\n offset_list = {'auto': self._offset_auto,\n 'from_end': -np.prod(self.shape)*self._nbytes,\n 'from_end_4k': - np.prod(self.shape)*self._nbytes - 4092}\n\n if self._offset_input in offset_list:\n\n self._offset_data = offset_list[self._offset_input]\n if self._offset_input.startswith('from_end'):\n # set the flag to seek from the end of the file.\n self._offset_whence = 2\n elif type(self._offset_input) is int:\n self._offset_data = self._offset_input\n else:\n raise ValueError\n\n \n\n return self.header","def __init__(self, keep_last_n_lines=5) :\r\n self.contextLines_ = keep_last_n_lines\r\n self.data_ = CircularBuffer(1024)\r\n self.lineNumber_ = 1\r\n self.charNumber_ = 0","def calculate_module_offsets(self):\n \n # These aren't for instantiating, but we use them to get the dimensions\n self.poly_contact_offset = vector(0.5*contact.poly.width,0.5*contact.poly.height)\n\n # M1/M2 routing pitch is based on contacted pitch\n self.m1_pitch = max(contact.m1m2.width,contact.m1m2.height) + max(self.m1_space,self.m2_space)\n self.m2_pitch = max(contact.m2m3.width,contact.m2m3.height) + max(self.m2_space,self.m3_space)\n \n # This corrects the offset pitch difference between M2 and M1\n self.offset_fix = vector(0.5*(self.m2_width-self.m1_width),0)\n\n # delay chain will be rotated 90, so move it over a width\n # we move it up a inv height just for some routing room\n self.rbl_inv_offset = vector(self.delay_chain.height, self.inv.width)\n # access TX goes right on top of inverter, leave space for an inverter which is\n # about the same as a TX. We'll need to add rails though.\n self.access_tx_offset = vector(1.25*self.inv.height,self.rbl_inv_offset.y) + vector(0,2.5*self.inv.width)\n self.delay_chain_offset = self.rbl_inv_offset + vector(0,4*self.inv.width)\n\n # Replica bitline and such are not rotated, but they must be placed far enough\n # away from the delay chain/inverter with space for three M2 tracks\n self.bitcell_offset = self.rbl_inv_offset + vector(2*self.m2_pitch, 0) + vector(0, self.bitcell.height + self.inv.width)\n\n self.rbl_offset = self.bitcell_offset\n\n \n self.height = self.rbl_offset.y + self.rbl.height + self.m2_pitch\n self.width = self.rbl_offset.x + self.bitcell.width","def __init__(self, extra_fields=None):\n if extra_fields:\n self.fields.extend(extra_fields)\n self.data = {k: [] for k in self.fields}\n self.last_r = 0.0","def _nanosims_header(self, hdr):\n # Called MaskNano in OpenMIMS; BFieldTab separated out; create extra sub-dict PeakCenter\n d = {}\n d['PeakCenter'] = {}\n d['nanosimsheader version'], d['regulation mode'], d['mode'], \\\n d['grain mode'], d['semigraphic mode'], d['stage delta x'], \\\n d['stage delta y'], d['working frame width'], \\\n d['working frame height'], d['scanning frame x'], \\\n d['scanning frame width'], d['scanning frame y'], \\\n d['scanning frame height'], d['counting frame x start'], \\\n d['counting frame x end'], d['counting frame y start'], \\\n d['counting frame y end'], d['detector type'], d['electron scan'], \\\n d['scanning mode'], d['beam blanking'], \\\n d['PeakCenter']['peakcenter enabled'], d['PeakCenter']['start'], \\\n d['PeakCenter']['frequency'], d['b fields'] = \\\n unpack(self._bo + '25i', hdr.read(100))\n\n d['PeakCenter']['peakcenter enabled'] = bool(d['PeakCenter']['peakcenter enabled'])\n d['regulation mode'] = bool(d['regulation mode'])\n d['grain mode'] = bool(d['grain mode'])\n d['semigraphic mode'] = bool(d['semigraphic mode'])\n d['scanning mode'] = bool(d['scanning mode'])\n\n # Set a few extra variables.\n d['counting frame width'] = d['counting frame x end'] - d['counting frame x start'] + 1\n d['counting frame height'] = d['counting frame y end'] - d['counting frame y start'] + 1\n\n # Found in at least one version (file v11, nsHeader v8) a repeat of\n # Poly_list and this first part of nanoSIMSHeader. Total of repeat\n # adds up to 288. After last Poly_list, 288 byte padding zone, not all\n # null-bytes.\n hdr.seek(288, 1)\n\n # Is this the nPrintRed from OpenMIMS?\n d['print results'] = bool(unpack(self._bo + 'i', hdr.read(4))[0])\n\n d['SibCenterHor'] = self._sib_center(hdr)\n d['SibCenterVert'] = self._sib_center(hdr)\n\n # Duplicate and store these two in sub dicts\n b_field_index, has_sib_center = \\\n unpack(self._bo + '2i', hdr.read(8))\n if b_field_index < 0:\n b_field_index = None\n has_sib_center = bool(has_sib_center)\n\n d['SibCenterHor']['b field index'] = b_field_index\n d['SibCenterVert']['b field index'] = b_field_index\n d['SibCenterHor']['sib center enabled'] = has_sib_center\n d['SibCenterVert']['sib center enabled'] = has_sib_center\n\n d['EnergyCenter'] = self._energy_center(hdr)\n d['E0SCenter'] = self._e0s_center(hdr)\n\n d['EnergyCenter']['wait time'], d['presputtering raster'], \\\n d['PeakCenter']['E0P offset'], d['E0SCenter']['steps'], \\\n d['baseline measurement'], d['baseline offset'], \\\n d['baseline frequency'] = \\\n unpack(self._bo + '5i d i', hdr.read(32))\n return d","def _create_dnp3_object_map(self):\n\n feeders = self.file_dict.get(\"feeders\", [])\n measurements = list()\n capacitors = list()\n regulators = list()\n switches = list()\n solarpanels = list()\n batteries = list()\n fuses = list()\n breakers = list()\n reclosers = list()\n energyconsumers = list()\n for x in feeders:\n measurements = x.get(\"measurements\", [])\n capacitors = x.get(\"capacitors\", [])\n regulators = x.get(\"regulators\", [])\n switches = x.get(\"switches\", [])\n solarpanels = x.get(\"solarpanels\", [])\n batteries = x.get(\"batteries\", [])\n fuses = x.get(\"fuses\", [])\n breakers = x.get(\"breakers\", [])\n reclosers = x.get(\"reclosers\", [])\n energyconsumers = x.get(\"energyconsumers\", [])\n\n # Unique grouping of measurements - GroupBy Name, Type and Connectivity node\n groupByNameTypeConNode = defaultdict(list) \n for m in measurements:\n groupByNameTypeConNode[m['name']+m.get(\"measurementType\")+m.get(\"ConnectivityNode\")].append(m)\n\n # Create Net Phase DNP3 Points\n for grpM in groupByNameTypeConNode.values():\n\n if grpM[0]['MeasurementClass'] == \"Analog\" and grpM[0].get(\"measurementType\") == \"VA\":\n measurement_type = grpM[0].get(\"measurementType\")\n measurement_id = m.get(\"mRID\")\n \n\n name1 = grpM[0]['name'] + '-' + \"Phases:ABC\" + '-net-VAR-value'\n name2 = grpM[0]['name'] + '-' + \"Phases:ABC\" + '-net-Watts-value'\n name3 = grpM[0]['name'] + '-' + \"Phases:ABC\" + '-net-VA-value'\n\n description1 = \"Name:\" + grpM[0]['name'] + \",MeasurementType:\" + \"net-VAR\" + \",ConnectivityNode:\" + grpM[0].get(\"ConnectivityNode\") +\",SimObject:\" + grpM[0].get(\"SimObject\")\n description2 = \"Name:\" + grpM[0]['name'] + \",MeasurementType:\" + \"net-Watts\" + \",ConnectivityNode:\" + grpM[0].get(\"ConnectivityNode\") +\",SimObject:\" + grpM[0].get(\"SimObject\")\n description3 = \"Name:\" + grpM[0]['name'] + \",MeasurementType:\" + \"net-VA\" + \",ConnectivityNode:\" + grpM[0].get(\"ConnectivityNode\") +\",SimObject:\" + grpM[0].get(\"SimObject\")\n\n self.assign_val_a(\"AI\", 30, 1, self.c_ai, name1, description1, measurement_type, measurement_id)\n self.c_ai += 1\n self.assign_val_a(\"AI\", 30, 1, self.c_ai, name2, description2, measurement_type, measurement_id)\n self.c_ai += 1\n self.assign_val_a(\"AI\", 30, 1, self.c_ai, name3, description3, measurement_type, measurement_id)\n self.c_ai += 1\n\n # Create Each Phase DNP3 Points\n for m in measurements:\n attribute = attribute_map['regulators']['attribute']\n measurement_type = m.get(\"measurementType\")\n measurement_id = m.get(\"mRID\")\n name= m['name'] + '-' + m['phases']\n description = \"Name:\" + m['name'] + \",Phase:\" + m['phases'] + \",MeasurementType:\" + measurement_type + \",ConnectivityNode:\" + m.get(\"ConnectivityNode\") +\",SimObject:\" + m.get(\"SimObject\")\n if m['MeasurementClass'] == \"Analog\":\n self.assign_val_a(\"AI\", 30, 1, self.c_ai, name, description, measurement_type, measurement_id)\n self.c_ai += 1\n\n if m.get(\"measurementType\") == \"VA\":\n measurement_id = m.get(\"mRID\")\n name1 = m['name'] + '-' + m['phases'] + '-VAR-value'\n name2 = m['name'] + '-' + m['phases'] + '-Watts-value'\n name3 = m['name'] + '-' + m['phases'] + '-angle'\n\n description1 = \"Name:\" + m['name'] + \",Phase:\" + m['phases'] + \",MeasurementType:\" + \"VAR\" + \",ConnectivityNode:\" + m.get(\"ConnectivityNode\") +\",SimObject:\" + m.get(\"SimObject\")\n description2 = \"Name:\" + m['name'] + \",Phase:\" + m['phases'] + \",MeasurementType:\" + \"Watt\" + \",ConnectivityNode:\" + m.get(\"ConnectivityNode\") +\",SimObject:\" + m.get(\"SimObject\")\n description3 = \"Name:\" + m['name'] + \",Phase:\" + m['phases'] + \",MeasurementType:\" + \"angle\" + \",ConnectivityNode:\" + m.get(\"ConnectivityNode\") + \",SimObject:\" + m.get(\"SimObject\")\n if m['MeasurementClass'] == \"Analog\":\n self.assign_val_a(\"AI\", 30, 1, self.c_ai, name1, description1, measurement_type, measurement_id)\n self.c_ai += 1\n self.assign_val_a(\"AI\", 30, 1, self.c_ai, name2, description2, measurement_type, measurement_id)\n self.c_ai += 1\n self.assign_val_a(\"AI\", 30, 1, self.c_ai, name3, description3, measurement_type, measurement_id)\n self.c_ai += 1\n\n\n elif m['MeasurementClass'] == \"Discrete\" and measurement_type == \"Pos\":\n if \"RatioTapChanger\" in m['name'] or \"reg\" in m[\"SimObject\"]:\n # TODO: Do we need step?\n for r in range(5, 7): # [r==4]: Step, [r==5]: LineDropR, [r==6]:LineDropX \n self.assign_val_d(\"AO\", 42, 3, self.c_ao, name, description, measurement_id, attribute[r])\n self.c_ao += 1\n else:\n self.assign_val_a(\"DI\", 1, 2, self.c_di, name, description, measurement_type, measurement_id)\n self.c_di += 1\n\n for m in capacitors:\n measurement_id = m.get(\"mRID\")\n cap_attribute = attribute_map['capacitors']['attribute'] # type: List[str]\n\n for l in range(0, 4):\n # publishing attribute value for capacitors as Bianry/Analog Input points based on phase attribute\n name = m['name']\n description = \"Name:\" + m['name'] + \"ConductingEquipment_type:LinearShuntCompensator\" + \",Attribute:\" + cap_attribute[l] + \",Phase:\" + m['phases']\n self.assign_val_d(\"AO\", 42, 3, self.c_ao, name, description, measurement_id, cap_attribute[l])\n self.c_ao += 1\n for p in range(0, len(m['phases'])):\n name = m['name'] + m['phases'][p]\n description = \"Name:\" + m['name'] + \",ConductingEquipment_type:LinearShuntCompensator\" + \",controlAttribute:\" + cap_attribute[p] + \",Phase:\" + m['phases'][p]\n # description = \"Capacitor, \" + m['name'] + \",\" + \"phase -\" + m['phases'][p] + \", and attribute is - \" + cap_attribute[4]\n self.assign_val_d(\"DO\", 12, 1, self.c_do, name, description, measurement_id, cap_attribute[4])\n self.c_do += 1\n\n for m in regulators:\n reg_attribute = attribute_map['regulators']['attribute']\n # bank_phase = list(m['bankPhases'])\n for n in range(0, 4):\n measurement_id = m.get(\"mRID\")\n name = m['bankName'] + '-' + m['bankPhases']\n description = \"Name:\" + m['bankName'] + \",ConductingEquipment_type:RatioTapChanger_Reg\" +\",Phase:\" + m['bankPhases'] + \",Attribute:\" + reg_attribute[n]\n self.assign_val_d(\"AO\", 42, 3, self.c_ao, name, description, measurement_id[0], reg_attribute[n])\n self.c_ao += 1\n self.assign_val_d(\"AI\", 30, 1, self.c_ai, name, description, measurement_id[0], reg_attribute[n])\n self.c_ai += 1\n for i in range(5, 7):\n for j in range(0, len(m['bankPhases'])):\n measurement_id = m.get(\"mRID\")[j]\n name = m['tankName'][j] + '-' + m['bankPhases'][j]\n description = \"Name:\" + m['tankName'][j] + \",ConductingEquipment_type:RatioTapChanger_Reg\"+ \",Phase:\" + m['bankPhases'][j] + \",controlAttribute:\" + reg_attribute[i]\n self.assign_val_d(\"AO\", 42, 3, self.c_ao, name, description, measurement_id,reg_attribute[i])\n self.c_ao += 1\n self.assign_val_d(\"AI\", 30, 1, self.c_ai, name, description, measurement_id,reg_attribute[i])\n self.c_ai += 1\n \n for m in solarpanels:\n for k in range(0, len(m['phases'])):\n measurement_id = m.get(\"mRID\")\n name = \"Solar\" + m['name'] + '-' + m['phases'][k] + '-Watts-value'\n description = \"Solarpanel:\" + m['name'] + \",Phase:\" + m['phases'] + \",measurementID:\" + measurement_id\n self.assign_val_d(\"AO\", 42, 3, self.c_ao, name, description, measurement_id, \"PowerElectronicsConnection.p\")\n self.c_ao += 1\n \n name1 = \"Solar\" + m['name'] + '-' + m['phases'][k] + '-VAR-value'\n self.assign_val_d(\"AO\", 42, 3, self.c_ao, name1, description, measurement_id, \"PowerElectronicsConnection.q\")\n self.c_ao += 1\n \n name2 = \"Solar\" + m['name'] + '-' + m['phases'][k] + '-VAR-Net-value'\n self.assign_val_d(\"AO\", 42, 3, self.c_ao, name2, description, measurement_id, \"PowerElectronicsConnection.q\")\n self.c_ao += 1\n \n name3 = \"Solar\"+ m['name'] + '-' + m['phases'][k] + '-Watts-Net-value'\n self.assign_val_d(\"AO\", 42, 3, self.c_ao, name3, description, measurement_id, \"PowerElectronicsConnection.p\")\n self.c_ao += 1\n\t\t\t\n for m in batteries:\n for l in range(0, len(m['phases'])):\n measurement_id = m.get(\"mRID\")\n name = m['name'] + '-' + m['phases'][l] + '-Watts-value'\n description = \"Battery, \" + m['name'][l] + \",Phase: \" + m['phases'] + \",ConductingEquipment_type:PowerElectronicConnections\"\n self.assign_val_d(\"AO\", 42, 3, self.c_ao, name, description,measurement_id, \"PowerElectronicsConnection.p\")\n self.c_ao += 1\n name1 = m['name'] + '-' + m['phases'][l] + '-VAR-value'\n self.assign_val_d(\"AO\", 42, 3, self.c_ao, name1, description,measurement_id, \"PowerElectronicsConnection.q\")\n self.c_ao += 1\n \n for m in switches:\n measurement_id = m.get(\"mRID\")\n switch_attribute = attribute_map['switches']['attribute']\n for k in range(0, len(m['phases'])):\n phase_value = list(m['phases'])\n name = m['name'] + \"Phase:\" + m['phases'][k]\n description = \"Name:\" + m[\"name\"] + \",ConductingEquipment_type:LoadBreakSwitch\" + \"Phase:\" + phase_value[k] +\",controlAttribute:\"+switch_attribute\n self.assign_val_d(\"DO\", 12, 1, self.c_do, name, description, measurement_id, switch_attribute)\n self.c_do += 1\n\n for m in fuses:\n measurement_id = m.get(\"mRID\")\n switch_attribute = attribute_map['switches']['attribute']\n for l in range(0, len(m['phases'])):\n phase_value = list(m['phases'])\n name = m['name'] + \"Phase:\" + m['phases'][l]\n description = \"Name:\" + m[\"name\"] + \",Phase:\" + phase_value[l] + \",Attribute:\" + switch_attribute + \",mRID\" + measurement_id\n self.assign_val_d(\"DO\", 12, 1, self.c_do, name, description, measurement_id, switch_attribute)\n self.c_do += 1\n\n for m in breakers:\n measurement_id = m.get(\"mRID\")\n switch_attribute = attribute_map['switches']['attribute']\n for n in range(0, len(m['phases'])):\n phase_value = list(m['phases'])\n name = m['name'] + \"Phase:\" + m['phases'][n]\n description = \"Name: \" + m[\"name\"] + \",Phase:\" + phase_value[n] + \",ConductingEquipment_type:Breaker\" + \",controlAttribute:\" + switch_attribute\n self.assign_val_d(\"DO\", 12, 1, self.c_do, name, description, measurement_id, switch_attribute)\n self.c_do += 1\n \n for m in reclosers:\n measurement_id = m.get(\"mRID\")\n switch_attribute = attribute_map['switches']['attribute']\n for i in range(0, len(m['phases'])):\n phase_value = list(m['phases'])\n name = m['name'] + \"Phase:\" + m['phases'][i]\n description = \"Recloser, \" + m[\"name\"] + \"Phase: - \" + phase_value[i] + \",ConductingEquipment_type:Recloser\"+\"controlAttribute:\" + switch_attribute\n self.assign_val_d(\"DO\", 12, 1, self.c_do, name, description, measurement_id, switch_attribute)\n self.c_do += 1\n\n for m in energyconsumers:\n measurement_id = m.get(\"mRID\")\n for k in range(0, len(m['phases'])):\n phase_value = list(m['phases'])\n name = m['name']+\"phase:\" + m['phases'][k]\n description = \"EnergyConsumer, \" + m[\"name\"] + \"Phase: \" + phase_value[k] \n self.assign_val_d(\"AO\", 42, 3, self.c_ao, name, description, measurement_id, \"EnergyConsumer.p\")\n self.c_ao += 1\n \n name1 = m['name']+\"phase:\" + m['phases'][k] + \"control\"\n self.assign_val_d(\"DO\", 12, 1, self.c_do, name1, description, measurement_id, \"EnergyConsumer.p\")\n self.c_do += 1\n\n return self.out_json","def _populate(self):\n if not hasattr(self, 'multiline'):\n start = self.start\n end = self.end\n txt = self.filetext\n self.start_line = txt.count('\\n', 0, start) + 1\n self.start_column = start - txt.rfind('\\n', 0, start) - 1\n self.end_line = txt.count('\\n', start, end) + self.start_line\n self.end_column = end - txt.rfind('\\n', 0, end) - 1\n self.multiline = self.start_line != self.end_line","def build_parts_from_dict(self, data, skip_power_controls=False):\n \n # Validate Objects information.\n if \"Objects\" not in data:\n return\n\n # Start creating parts.\n parts = []\n for part_data in data[\"Objects\"]:\n part = part_data[\"ObjectID\"].replace(\"^\", \"\")\n timestamp = part_data[\"Timestamp\"]\n user_data = part_data[\"UserData\"]\n part_position = part_data[\"Position\"]\n up_vec = part_data[\"Up\"]\n at_vec = part_data[\"At\"]\n # Build the item.\n item = self.build_item(\n part,\n timestamp,\n user_data,\n part_position,\n up_vec,\n at_vec,\n skip_power_controls\n )\n parts.append(item)\n\n return parts","def __build__(self,data_index=0):\n \n super(Image,self).__build__()\n # -- How to read the image\n self._build_properties = dict(\n data_index = data_index,\n header_exptime = \"EXPTIME\",\n dataslice0=\"undefined\",\n dataslice1=\"undefined\",\n bkgdbox={\"bh\":100,\"bw\":100,\"fh\":3,\"fw\":3},\n )","def _build_parsed_values(self):\n\n SERIAL_NUMBER = \"SerialNumber\"\n CALIBRATION = \"Calibration\"\n ID = \"id\"\n TEMPERATURE_SENSOR_ID = \"Main Temperature\"\n CONDUCTIVITY_SENSOR_ID = \"Main Conductivity\"\n PRESSURE_SENSOR_ID = \"Main Pressure\"\n VOLT0 = \"Volt 0\"\n VOLT1 = \"Volt 1\"\n VOLT2 = \"Volt 2\"\n VOLT3 = \"Volt 3\"\n VOLT4 = \"Volt 4\"\n VOLT5 = \"Volt 5\"\n EXTERNAL_FREQUENCY_CHANNEL = \"external frequency channel\"\n\n # check to make sure there is a correct match before continuing\n match = SBE19CalibrationParticle.regex_compiled().match(self.raw_data)\n if not match:\n raise SampleException(\"No regex match of parsed calibration data: [%s]\" %\n self.raw_data)\n\n dom = parseString(self.raw_data)\n root = dom.documentElement\n log.debug(\"root.tagName = %s\", root.tagName)\n serial_number = root.getAttribute(SERIAL_NUMBER)\n result = [{DataParticleKey.VALUE_ID: SBE19CalibrationParticleKey.SERIAL_NUMBER,\n DataParticleKey.VALUE: serial_number}]\n\n calibration_elements = self._extract_xml_elements(root, CALIBRATION)\n for calibration in calibration_elements:\n id_attr = calibration.getAttribute(ID)\n if id_attr == TEMPERATURE_SENSOR_ID:\n result.append(\n self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TEMP_SENSOR_SERIAL_NUMBER, str))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TEMP_CAL_DATE, str))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TA0))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TA1))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TA2))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TA3))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TOFFSET))\n elif id_attr == CONDUCTIVITY_SENSOR_ID:\n result.append(\n self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.COND_SENSOR_SERIAL_NUMBER, str))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.COND_CAL_DATE, str))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CONDG))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CONDH))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CONDI))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CONDJ))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CPCOR))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CTCOR))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CSLOPE))\n elif id_attr == PRESSURE_SENSOR_ID:\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PRES_SERIAL_NUMBER, str))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PRES_CAL_DATE, str))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PA0))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PA1))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PA2))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCA0))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCA1))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCA2))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCB0))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCB1))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCB2))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTEMPA0))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTEMPA1))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTEMPA2))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.POFFSET))\n result.append(\n self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PRES_RANGE, self.float_to_int))\n elif id_attr == VOLT0:\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT0_OFFSET))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT0_SLOPE))\n elif id_attr == VOLT1:\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT1_OFFSET))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT1_SLOPE))\n elif id_attr == VOLT2:\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT2_OFFSET))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT2_SLOPE))\n elif id_attr == VOLT3:\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT3_OFFSET))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT3_SLOPE))\n elif id_attr == VOLT4:\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT4_OFFSET))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT4_SLOPE))\n elif id_attr == VOLT5:\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT5_OFFSET))\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT5_SLOPE))\n elif id_attr == EXTERNAL_FREQUENCY_CHANNEL:\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_FREQ))\n\n return result","def _build_parsed_values(self):\n\n # \n # Generate a time data particle.\n # Note that raw_data already contains the individual fields\n # extracted and unpacked from the time data record.\n #\n particle = [\n {\n DataParticleKey.VALUE_ID: \n Vel3dKWfpStcTimeDataParticleKey.TIME_ON, \n DataParticleKey.VALUE: self.raw_data[INDEX_TIME_ON]\n },\n {\n DataParticleKey.VALUE_ID: \n Vel3dKWfpStcTimeDataParticleKey.TIME_OFF,\n DataParticleKey.VALUE: self.raw_data[INDEX_TIME_OFF]\n },\n {\n DataParticleKey.VALUE_ID: \n Vel3dKWfpStcTimeDataParticleKey.NUMBER_OF_RECORDS, \n DataParticleKey.VALUE: self.raw_data[INDEX_RECORDS]\n }\n ]\n\n return particle","def __init__(self):\n self._data = PositionalList()","def __init__(self):\n self._data = PositionalList()","def init_meta(self):\n meta = {}\n # Required (core)\n meta['ra'] = dict(ext=0, card='OBJRA')\n meta['dec'] = dict(ext=0, card='OBJDEC')\n meta['target'] = dict(ext=0, card='OBJECT')\n meta['decker'] = dict(ext=0, card='ALAPRTNM')\n meta['binning'] = dict(card=None, compound=True)\n\n meta['mjd'] = dict(ext=0, card=None, compound=True)\n meta['exptime'] = dict(ext=0, card='EXPTIME')\n meta['airmass'] = dict(ext=0, card='AIRMASS')\n # Extras for config and frametyping\n meta['dispname'] = dict(ext=0, card='ALGRNM')\n meta['idname'] = dict(ext=0, card='IMAGETYP')\n # Lamps\n # Use Keck/LRIS approach\n\n # Ingest\n self.meta = meta","def _build_parsed_values(self):\r\n # match the data inside the wrapper\r\n if len(self.raw_data) < ACCEL_BYTES or self.raw_data[0] != ACCEL_ID:\r\n raise SampleException(\"MopakODclAccelParserDataParticle: Not enough bytes provided in [%s]\",\r\n self.raw_data)\r\n fields = struct.unpack('>fffffffffI', self.raw_data[1:ACCEL_BYTES - 2])\r\n\r\n result = [self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ACCELX, fields[0], float),\r\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ACCELY, fields[1], float),\r\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ACCELZ, fields[2], float),\r\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ANG_RATEX, fields[3], float),\r\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ANG_RATEY, fields[4], float),\r\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ANG_RATEZ, fields[5], float),\r\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_MAGX, fields[6], float),\r\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_MAGY, fields[7], float),\r\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_MAGZ, fields[8], float),\r\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_TIMER, fields[9], int)]\r\n\r\n return result","def create_observation(self):","def create_observation(self):"],"string":"[\n \"def prepare_raw_data(self, idx: int):\\n info = super().prepare_raw_data(idx)\\n if self.cache_reader is not None:\\n self.human_data = self.cache_reader.get_item(idx)\\n idx = idx % self.cache_reader.slice_size\\n\\n if 'smplx' in self.human_data:\\n smplx_dict = self.human_data['smplx']\\n info['has_smplx'] = 1\\n else:\\n smplx_dict = {}\\n info['has_smplx'] = 0\\n if 'global_orient' in smplx_dict:\\n info['smplx_global_orient'] = smplx_dict['global_orient'][idx]\\n info['has_smplx_global_orient'] = 1\\n else:\\n info['smplx_global_orient'] = np.zeros((3), dtype=np.float32)\\n info['has_smplx_global_orient'] = 0\\n\\n if 'body_pose' in smplx_dict:\\n info['smplx_body_pose'] = smplx_dict['body_pose'][idx]\\n info['has_smplx_body_pose'] = 1\\n else:\\n info['smplx_body_pose'] = np.zeros((21, 3), dtype=np.float32)\\n info['has_smplx_body_pose'] = 0\\n\\n if 'right_hand_pose' in smplx_dict:\\n info['smplx_right_hand_pose'] = smplx_dict['right_hand_pose'][idx]\\n info['has_smplx_right_hand_pose'] = 1\\n else:\\n info['smplx_right_hand_pose'] = np.zeros((15, 3), dtype=np.float32)\\n info['has_smplx_right_hand_pose'] = 0\\n\\n if 'left_hand_pose' in smplx_dict:\\n info['smplx_left_hand_pose'] = smplx_dict['left_hand_pose'][idx]\\n info['has_smplx_left_hand_pose'] = 1\\n else:\\n info['smplx_left_hand_pose'] = np.zeros((15, 3), dtype=np.float32)\\n info['has_smplx_left_hand_pose'] = 0\\n\\n if 'jaw_pose' in smplx_dict:\\n info['smplx_jaw_pose'] = smplx_dict['jaw_pose'][idx]\\n info['has_smplx_jaw_pose'] = 1\\n else:\\n info['smplx_jaw_pose'] = np.zeros((3), dtype=np.float32)\\n info['has_smplx_jaw_pose'] = 0\\n\\n if 'betas' in smplx_dict:\\n info['smplx_betas'] = smplx_dict['betas'][idx]\\n info['has_smplx_betas'] = 1\\n else:\\n info['smplx_betas'] = np.zeros((self.num_betas), dtype=np.float32)\\n info['has_smplx_betas'] = 0\\n\\n if 'expression' in smplx_dict:\\n info['smplx_expression'] = smplx_dict['expression'][idx]\\n info['has_smplx_expression'] = 1\\n else:\\n info['smplx_expression'] = np.zeros((self.num_expression),\\n dtype=np.float32)\\n info['has_smplx_expression'] = 0\\n\\n return info\",\n \"def __init__(self, starting_point=-1):\\n self.i_read = starting_point\\n self.data = [['fake_chip_id', 'fake_version'],\\n [96, 110, 203, 104, 50, 0, 29, 145, 59, 215, 208, 11,\\n 232, 38, 42, 255, 249, 255, 172, 38, 10, 216, 189, 16],\\n [75],\\n [129, 1, 0, 16, 44, 3, 30],\\n [76, 60, 128, 129, 49, 128, 94, 120]]\",\n \"def __init__(self):\\n self.x = {}\\n self.len = 0\\n self.annotations = {}\",\n \"def _get_observation(self):\\n di = super()._get_observation()\\n\\n # low-level object information\\n if self.use_object_obs:\\n # Get robot prefix\\n if self.env_configuration == \\\"bimanual\\\":\\n pr0 = self.robots[0].robot_model.naming_prefix + \\\"left_\\\"\\n pr1 = self.robots[0].robot_model.naming_prefix + \\\"right_\\\"\\n else:\\n pr0 = self.robots[0].robot_model.naming_prefix\\n pr1 = self.robots[1].robot_model.naming_prefix\\n\\n # position and rotation of object\\n cube_pos = np.array(self.sim.data.body_xpos[self.cube_body_id])\\n cube_quat = T.convert_quat(\\n self.sim.data.body_xquat[self.cube_body_id], to=\\\"xyzw\\\"\\n )\\n di[\\\"cube_pos\\\"] = cube_pos\\n di[\\\"cube_quat\\\"] = cube_quat\\n\\n di[pr0 + \\\"eef_xpos\\\"] = self._eef0_xpos\\n di[pr1 + \\\"eef_xpos\\\"] = self._eef1_xpos\\n di[\\\"handle_0_xpos\\\"] = np.array(self._handle_0_xpos)\\n di[\\\"handle_1_xpos\\\"] = np.array(self._handle_1_xpos)\\n di[pr0 + \\\"gripper_to_handle\\\"] = np.array(self._gripper_0_to_handle)\\n di[pr1 + \\\"gripper_to_handle\\\"] = np.array(self._gripper_1_to_handle)\\n\\n di[\\\"object-state\\\"] = np.concatenate(\\n [\\n di[\\\"cube_pos\\\"],\\n di[\\\"cube_quat\\\"],\\n di[pr0 + \\\"eef_xpos\\\"],\\n di[pr1 + \\\"eef_xpos\\\"],\\n di[\\\"handle_0_xpos\\\"],\\n di[\\\"handle_1_xpos\\\"],\\n di[pr0 + \\\"gripper_to_handle\\\"],\\n di[pr1 + \\\"gripper_to_handle\\\"],\\n ]\\n )\\n\\n return di\",\n \"def build(self):\\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\\n #print('self.IDs', self.data)\\n self.itime = 0\\n self.ielement = 0\\n self.itotal = 0\\n\\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\\n assert self.nelements > 0, 'nelements=%s' % self.nelements\\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\\n self.nelements //= self.ntimes\\n\\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\\n self.node = np.zeros(self.ntotal, dtype=idtype)\\n #oxx, oyy, txy, angle, major, minor, ovm\\n self.data = np.zeros((self.ntimes, self.ntotal, 8), dtype=fdtype)\\n self.location = np.empty(self.ntotal, dtype='U8')\\n self._times = np.zeros(self.ntimes, dtype=dtype)\",\n \"def build(self):\\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\\n #print('self.IDs', self.data)\\n self.itime = 0\\n self.ielement = 0\\n self.itotal = 0\\n\\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\\n assert self.nelements > 0, 'nelements=%s' % self.nelements\\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\\n #self.names = []\\n self.nelements //= self.ntimes\\n\\n self.node = np.zeros(self.ntotal, dtype='int32')\\n #oxx, oyy, ozz, txy, pressure\\n self.data = np.zeros((self.ntimes, self.ntotal, 5), dtype='float32')\\n self.location = np.empty(self.ntotal, dtype='U8')\\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\\n\\n self._times = np.zeros(self.ntimes, dtype=dtype)\",\n \"def finish_constructing(self, more_data):\\n self.draw_aspect = None\\n self.obj_type = None\\n self.ex_obj_id = None\\n self.sub_type = None\\n self.persist_id_ref = None\\n if self.size != 0x18:\\n raise ValueError('ExOleObjAtom has wrong size {0} != 0x18'\\n .format(self.size))\\n if self.data:\\n self.draw_aspect, self.obj_type, self.ex_obj_id, self.sub_type, \\\\\\n self.persist_id_ref, _ = unpack('<LLLLLL', self.data)\\n if self.obj_type not in self.OBJ_TYPES:\\n logging.warning('Unknown \\\"type\\\" value in ExOleObjAtom: {0}'\\n .format(self.obj_type))\\n if self.sub_type not in self.SUB_TYPES:\\n logging.warning('Unknown sub type value in ExOleObjAtom: {0}'\\n .format(self.sub_type))\",\n \"def getRigBuildData(self):\\n\\n # Values\\n mouthPosition = self.jawCtrl.xfo.tr\\n jawEndPosition = self.jawEndCtrl.xfo.tr\\n mouthLen = mouthPosition.subtract(jawEndPosition).length()\\n\\n # Calculate Mouth Xfo\\n\\n # atVector\\n # mouthUpV = Vec3(0.0, 1.0, 0.0)\\n\\n # rootToEnd = jawEndPosition.subtract(mouthPosition).unit()\\n # rootToUpV = mouthUpV.subtract(mouthPosition).unit()\\n # bone1ZAxis = rootToUpV.cross(rootToEnd).unit()\\n # bone1Normal = bone1ZAxis.cross(rootToEnd).unit()\\n\\n jawXfo = self.jawEndCtrl.xfo\\n # jawXfo.setFromVectors(rootToEnd, bone1Normal, bone1ZAxis, mouthPosition)\\n\\n\\n\\n data = super(OSSMouthGuide, self).getRigBuildData()\\n\\n # should include getCurveData\\n data = self.saveAllObjectData(data, \\\"Control\\\")\\n data = self.saveAllObjectData(data, \\\"Transform\\\")\\n data['jawXfo'] = self.jawCtrl.xfo\\n data['mouthLen'] = mouthLen\\n return data\",\n \"def _build_base_structure(self):\\n result = dict(self.contents)\\n # clean out optional fields that were missing\\n if not self.contents[DataParticleKey.PORT_TIMESTAMP]:\\n del result[DataParticleKey.PORT_TIMESTAMP]\\n if not self.contents[DataParticleKey.INTERNAL_TIMESTAMP]:\\n del result[DataParticleKey.INTERNAL_TIMESTAMP]\\n return result\",\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 build_item(\\n self,\\n part,\\n timestamp=1539023700,\\n userdata=0,\\n position=[0, 0, 0],\\n up_vec=[0, 1, 0],\\n at_vec=[0, 0, 1],\\n skip_power_controls=False):\\n # Get the obj path.\\n item = self.retrieve_part(part)\\n\\n # Lock Everything if it's the BASE_FLAG or U_POWERLINE.\\n # BASE_FLAG can break things if user moves it around.\\n # As it acts as the \\\"origin\\\" of the base.\\n locked_parts = [\\\"BASE_FLAG\\\", \\\"U_POWERLINE\\\", \\\"U_PIPELINE\\\", \\\"U_PORTALLINE\\\"]\\n line_parts = [\\\"U_POWERLINE\\\", \\\"U_PIPELINE\\\", \\\"U_PORTALLINE\\\"]\\n if part in locked_parts:\\n item.lock_location[0] = True\\n item.lock_location[1] = True\\n item.lock_location[2] = True\\n item.lock_rotation[0] = True\\n item.lock_rotation[1] = True\\n item.lock_rotation[2] = True\\n item.lock_scale[0] = True\\n item.lock_scale[1] = True\\n item.lock_scale[2] = True\\n \\n # Add custom attributes.\\n item[\\\"ObjectID\\\"] = part\\n item[\\\"SnapID\\\"] = part\\n item[\\\"Timestamp\\\"] = timestamp\\n item[\\\"belongs_to_preset\\\"] = False\\n # Add an order flag to retain order when generating data..\\n item[\\\"Order\\\"] = self.part_order\\n self.part_order += 1\\n # Apply Colour\\n is_powerline = part in line_parts\\n is_pipeline = part in [\\\"U_PIPELINE\\\"]\\n material.assign_material(\\n item,\\n userdata,\\n powerline=is_powerline,\\n pipeline=is_pipeline\\n )\\n\\n # Move\\n utils.move_to(item, position=position, up=up_vec, at=at_vec)\\n\\n # If the object is a powerline, we should create additional controls\\n # for it.\\n if is_powerline and not skip_power_controls:\\n power.create_power_controls(item)\\n # Select the new object.\\n item.select_set(True)\\n return item\",\n \"def __init__(self):\\n self.dtrs = []\\n self.chunkIndex = 0\\n self.eventList = [] \\n self.position = None\\n self.positionCount = 0\\n self.parent = None\\n self.embeddedTags = []\",\n \"def fill_data(self, data):\\n self._data = data\\n\\n self._data_length = data[1:3]\\n self._frame_id = data[4]\\n self._address = XbeeAddress(data[5:9], data[9:13], data[13:15])\\n self._at_command = data[15:17]\\n self._command_status = data[17]\\n try:\\n self._command_data = data[18:21]\\n self._checksum = data[22]\\n except IndexError:\\n self._command_data = None\\n self._checksum = data[18]\",\n \"def _read_data(self):\",\n \"def _dataslicing(self):\\n if self._build_properties[\\\"dataslice0\\\"] == \\\"undefined\\\":\\n warnings.warn(\\\"No _build_properties['dataslice0'] defined. 0 assumed\\\")\\n offset0 = [0,-1]\\n else:\\n offset0=self._build_properties[\\\"dataslice0\\\"]\\n if self._build_properties[\\\"dataslice1\\\"] == \\\"undefined\\\":\\n warnings.warn(\\\"No _build_properties['dataslice1'] defined. 0 assumed\\\")\\n offset1 = [0,-1]\\n else:\\n offset1=self._build_properties[\\\"dataslice1\\\"]\\n \\n if offset0[1] is None:\\n offset0[1] = self.header[\\\"NAXIS2\\\"]\\n \\n if offset0[1] <0:\\n offset0[1] = self.height+offset0[1]+1\\n \\n if offset1[1] is None:\\n offset1[1] = self.header[\\\"NAXIS1\\\"]\\n \\n if offset1[1] <0:\\n offset1[1] = self.width +offset1[1]+1\\n \\n return offset0[0],offset1[0],offset0[1]-offset0[0],offset1[1]-offset1[0]\",\n \"def prepare_data(self):\",\n \"def build_base(self):\\n\\n # start- and endpoints of lines are nodes, but they do not need to have a point object associated to them\\n # in this case, self.geo is None and the no, prop and name attributes stay as the default values set in the constructor\\n if (self.geo):\\n\\n attr = ri.RhinoInput(rs.ObjectName(self.geo))\\n\\n self.no = attr.get_no()\\n if (self.no != -1):\\n self.strict_naming = True\\n\\n self.name = attr.get_name()\\n self.prop = attr.get_prop()\",\n \"def initialize(self):\\n self.muondEdx = []\\n self.muondNdx = []\\n self.muonmomentum = []\\n self.piondEdx = []\\n self.piondNdx = []\\n self.pionmomentum = []\\n self.kaondEdx = []\\n self.kaondNdx = []\\n self.kaonmomentum = []\\n self.protdEdx = []\\n self.protdNdx = []\\n self.protmomentum = []\\n self.elecdEdx = []\\n self.elecdNdx = []\\n self.elecmomentum = []\",\n \"def __init__(self):\\n self.notes = []\",\n \"def __init__(self, data=b''):\\n self.data = data\\n self.offset = 0\",\n \"def load_data(self):\\n super(MudderyObjectCreater, self).load_data()\\n \\n data = self.get_data_record()\\n if not data:\\n return\\n \\n # set common object's info\\n self.obj_list = {}\\n\\n for obj in data.obj_list.split(\\\",\\\"):\\n obj_key = \\\"\\\"\\n number = 0\\n arg = obj.split(\\\":\\\", 1)\\n if len(arg) == 1:\\n obj_key = arg[0]\\n number = 1\\n elif len(arg) >= 2:\\n obj_key = arg[0]\\n number = int(arg[1])\\n\\n self.obj_list[obj_key] = number\",\n \"def _read(self):\\n # initializng data dictionary\\n self.data={}\\n\\n f = FortranFile(self.filename)\\n # Default omnivor binary header\\n self.data['MK'] = f.readInts('i')\\n self.data['itime'] = f.readInts('i')\\n self.data['version'] = f.readString()\\n self.data['file_id'] = f.readInts('i')\\n self.data['sversion'] = f.readString()\\n # Velocity field\\n self.data['stype'] = f.readString()\\n self.data['is_grid'] = f.readInts('i')\\n nCPs = f.readInts('i')\\n self.data['nCPs'] = nCPs\\n if self.data['MK'] == 8:\\n real_char='d'\\n else:\\n real_char='f'\\n if self.data['is_grid']:\\n #print('File is a velocity grid file')\\n n1 = f.readInts('i')\\n n2 = f.readInts('i')\\n n3 = f.readInts('i')\\n self.data['n1'] = n1\\n self.data['n2'] = n2\\n self.data['n3'] = n3\\n self.data['is_straight'] = f.readInts('i')\\n self.data['v1'] = f.readReals(real_char)\\n self.data['v2'] = f.readReals(real_char)\\n self.data['v3'] = f.readReals(real_char)\\n\\n CPs_raw = f.readReals(real_char)\\n Utot_raw = f.readReals(real_char)\\n CPs = np.reshape(CPs_raw,(3,nCPs),order = 'F')\\n Utot = np.reshape(Utot_raw,(3,nCPs),order = 'F')\\n\\n acc=-1\\n CPsTab = np.zeros((3, n1,n2,n3))\\n UtotTab = np.zeros((3, n1,n2,n3))\\n # Reshaping the nasty way (this is natural order). \\n for i in range(0,n1):\\n for j in range(0,n2):\\n for k in range(0,n3):\\n acc=acc+1\\n CPsTab[0:3,i,j,k] = CPs[0:3,acc]\\n UtotTab[0:3,i,j,k] = Utot[0:3,acc]\\n\\n self.data['CPs'] = CPs\\n self.data['CPsTab'] = CPsTab\\n self.data['Utot'] = Utot\\n self.data['UtotTab'] = UtotTab\",\n \"def start_data(self, obj_name_parts, game, filename, pos_start, length):\\n if len(obj_name_parts) == 0:\\n self.filename = filename\\n self.pos_start = pos_start\\n self.length = length\\n self.game = game\\n self.has_data = True\\n self.data = []\\n return self.data\\n lower = obj_name_parts[0].lower()\\n if lower not in self.children:\\n self.children[lower] = Node(obj_name_parts[0])\\n return self.children[lower].start_data(\\n obj_name_parts[1:],\\n game,\\n filename,\\n pos_start,\\n length)\",\n \"def __init__(self):\\r\\n self.data = PositionalList()\",\n \"def build(self):\\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\\n #print('self.IDs', self.data)\\n self.itime = 0\\n self.ielement = 0\\n self.itotal = 0\\n\\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\\n assert self.nelements > 0, 'nelements=%s' % self.nelements\\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\\n self.nelements //= self.ntimes\\n\\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\\n self.node = np.zeros(self.ntotal, dtype=idtype)\\n #lxa, lxb, lxc, lya, lyb, lyc, lza, lzb, lzc, sa, sb, sc, epr, ovm\\n self.data = np.zeros((self.ntimes, self.ntotal, 14), dtype=fdtype)\\n self.location = np.empty(self.ntotal, dtype='U8')\\n\\n self._times = np.zeros(self.ntimes, dtype=dtype)\",\n \"def __init__(self):\\n\\n\\n self.dtype = np.dtype([\\n ('fault_flags', np.uint32),\\n ('raw_x', np.int16),\\n ('raw_y', np.int16),\\n ('raw_z', np.int16),\\n ('accel_x', np.float32),\\n ('accel_y', np.float32),\\n ('accel_z', np.float32), \\n ('pitch', np.float32),\\n ('roll', np.float32), \\n ])\\n \\n self._accel_indices = [0, 4, 5, 6]\\n \\n self.data = np.array([(0, 0.1, 12, 1234, 0.12345678901234, 0.12345678901234, 0.12345678901234, 0.12345678901234, 0.12345678901234)], dtype=self.dtype)\\n self.data['fault_flags'] = 0\\n self.data['raw_x'] = 0.1\\n self.data['raw_y'] = 12\\n self.data['raw_z'] = 31929\\n self.data['accel_x'] = 0.12345678901234\\n self.data['accel_y'] = 0.23456789012345\\n self.data['accel_z'] = 0.34567890123456\\n self.data['pitch'] = 0.1000\\n self.data['roll'] = 0.2000\\n\\n\\n #print len(self.data.tostring(order=\\\"C\\\"))\",\n \"def ani_init(self):\\n self.line.set_data([], [])\\n self.galactic_centre.set_data([], [])\\n self.impactor.set_data([], [])\\n self.time_text.set_text(\\\"\\\")\\n self.KE_text.set_text(\\\"\\\")\\n self.GPE_text.set_text(\\\"\\\")\\n self.energy_text.set_text(\\\"\\\")\\n return (\\n self.line,\\n self.galactic_centre,\\n self.impactor,\\n self.time_text,\\n self.KE_text,\\n self.GPE_text,\\n self.energy_text,\\n )\\n # One might hope that there was a better way to return objects\",\n \"def __init__(self, data):\\n # loop through data\\n for x in data:\\n # create pitches list if attribute name is pitches\\n if x == 'pitches':\\n self.pitches = []\\n for y in data[x]:\\n self.pitches.append(Pitch(y))\\n else:\\n # set information as correct data type\\n mlbgame.object.setobjattr(self, x, data[x])\",\n \"def _init_data(self) -> None:\\n self.dtype = dict()\\n self.shape = dict()\\n self.size = dict()\\n self.attrs = dict()\\n self.data_ptr = dict()\\n\\n if self.mode == 'r':\\n for k in self.fp.keys():\\n self.dtype[k] = self.fp[k].dtype\\n self.shape[k] = self.fp[k].shape\\n self.size[k] = self.fp[k].shape[0]\\n self.data_ptr[k] = 0\",\n \"def prepare(self):\\n if self.pin.lower() == \\\"homo\\\":\\n for i,line in enumerate(self.x):\\n self.x[i] = [x - self.Lead_HOMOs_xval[i] for x in line]\\n elif self.pin.lower() == \\\"lumo\\\":\\n for i,line in enumerate(self.x):\\n self.x[i] = [x - self.Lead_LUMOs_xval[i] for x in line]\\n elif \\\"vac\\\" in self.pin.lower():\\n for i,line in enumerate(self.x):\\n self.x[i] = [x - self.vacuum[i] for x in line]\\n elif \\\"ef\\\" in self.pin.lower():\\n for i,line in enumerate(self.x):\\n self.x[i] = [x - self.fermi_levels[i] for x in line]\",\n \"def __init__(self):\\n self.__deviceselected__ = \\\"SR-DMS4AP{LOCALBUMP}DEV:Sel-SP\\\"\\n self.__source__ = \\\"SR-DMS4AP{LOCALBUMP}S-SP\\\"\\n self.__plane__ = \\\"SR-DMS4AP{LOCALBUMP}PLANE-SP\\\"\\n #self.__xshift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT:X-SP\\\"\\n #self.__yshift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT:Y-SP\\\"\\n #self.__xangle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:X-SP\\\"\\n #self.__yangle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:Y-SP\\\"\\n self.__shift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT-SP\\\"\\n self.__angle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE-SP\\\"\\n # with all offsets\\n self.__anglerb__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE-I\\\"\\n self.__positionrb__ = \\\"SR-DMS4AP{LOCALBUMP}POS-I\\\"\\n # with BBA offset only\\n self.__anglerb0__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:BBA-I\\\"\\n self.__positionrb0__ = \\\"SR-DMS4AP{LOCALBUMP}POS:BBA-I\\\"\\n\\n self.__bpmposition__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}Pos-I\\\"\\n self.__bpmorbitx__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:X-I\\\"\\n self.__bpmorbity__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y-I\\\"\\n self.__bpmorbitx0__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:X0-I\\\"\\n self.__bpmorbity0__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y0-I\\\"\\n\\n self.__correctorposition__ = \\\"SR-DMS4AP{LOCALBUMP:COR}Pos-I\\\"\\n self.__hcorrectorcurrent__ = \\\"SR-DMS4AP{LOCALBUMP:HCOR}PS-SP\\\"\\n self.__hcorrectordiff__ = \\\"SR-DMS4AP{LOCALBUMP:HCOR}PS:Delta-SP\\\"\\n self.__vcorrectorcurrent__ = \\\"SR-DMS4AP{LOCALBUMP:VCOR}PS-SP\\\"\\n self.__vcorrectordiff__ = \\\"SR-DMS4AP{LOCALBUMP:VCOR}PS:Delta-SP\\\"\\n\\n self.__undo__ = \\\"SR-DMS4AP{LOCALBUMP}Enbl:Undo-Cmd\\\"\\n self.__apply__ = \\\"SR-DMS4AP{LOCALBUMP}Enbl-Cmd\\\"\\n self.__status__ = \\\"SR-DMS4AP{LOCALBUMP}TS-I\\\"\\n self.__idposinfo__ = \\\"SR-DMS4AP{LOCALBUMP}S-I\\\"\\n self.__srcposition__ = \\\"SR-DMS4AP{LOCALBUMP}SRC-SP\\\"\",\n \"def _read(self):\\n\\t\\tself._infoMuscles = []\\n\\t\\tself._infoCommonCellsInMuscles = []\\n\\t\\tself._infoSpecialCells = []\\n\\t\\tself._infoCommonMuscleConnections = []\\n\\t\\tself._infoInterMuscSensorimotorConnections = {}\\n\\t\\tself._infoSpecialConnections = []\\n\\t\\tif rank==0:\\n\\t\\t\\tsection = None\\n\\t\\t\\tsensorimotorConnections = None\\n\\t\\t\\tsensorimotorMatrix = None\\n\\t\\t\\tfor line in open(\\\"../nnStructures/\\\"+self._inputFile,\\\"r\\\"):\\n\\t\\t\\t\\tif line[0] == \\\"#\\\" or line[0] == \\\"\\\\n\\\": continue\\n\\t\\t\\t\\telif line[0] == \\\"@\\\": section = float(line[1])\\n\\t\\t\\t\\telif section == 1: self._infoMuscles.append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\telif section == 2: self._infoCommonCellsInMuscles.append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\telif section == 3: self._infoSpecialCells.append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\telif section == 4: self._infoCommonMuscleConnections.append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\telif section == 5:\\n\\t\\t\\t\\t\\tif line[0] == \\\"+\\\":\\n\\t\\t\\t\\t\\t\\tdictName = line[1:].strip(\\\"\\\\n\\\")\\n\\t\\t\\t\\t\\t\\tself._infoInterMuscSensorimotorConnections[dictName] = {}\\n\\t\\t\\t\\t\\t\\tsensorimotorConnections = False\\n\\t\\t\\t\\t\\t\\tsensorimotorMatrix = False\\n\\t\\t\\t\\t\\telif \\\"Connections\\\" in line:\\n\\t\\t\\t\\t\\t\\t sensorimotorConnections = True\\n\\t\\t\\t\\t\\t\\t self._infoInterMuscSensorimotorConnections[dictName][\\\"connections\\\"]=[]\\n\\t\\t\\t\\t\\telif \\\"WeightsMatrix\\\" in line:\\n\\t\\t\\t\\t\\t\\t sensorimotorConnections = False\\n\\t\\t\\t\\t\\t\\t sensorimotorMatrix = True\\n\\t\\t\\t\\t\\t\\t self._infoInterMuscSensorimotorConnections[dictName][\\\"matrix\\\"]=[]\\n\\t\\t\\t\\t\\telif sensorimotorConnections:\\n\\t\\t\\t\\t\\t\\tself._infoInterMuscSensorimotorConnections[dictName][\\\"connections\\\"].append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\t\\telif sensorimotorMatrix:\\n\\t\\t\\t\\t\\t\\tself._infoInterMuscSensorimotorConnections[dictName][\\\"matrix\\\"].append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\telif section == 6: self._infoSpecialConnections.append(line.strip(\\\"\\\\n\\\").split())\\n\\n\\t\\tself._infoMuscles = comm.bcast(self._infoMuscles,root=0)\\n\\t\\tself._infoCommonCellsInMuscles = comm.bcast(self._infoCommonCellsInMuscles,root=0)\\n\\t\\tself._infoSpecialCells = comm.bcast(self._infoSpecialCells,root=0)\\n\\t\\tself._infoCommonMuscleConnections = comm.bcast(self._infoCommonMuscleConnections,root=0)\\n\\t\\tself._infoInterMuscSensorimotorConnections = comm.bcast(self._infoInterMuscSensorimotorConnections,root=0)\\n\\t\\tself._infoSpecialConnections = comm.bcast(self._infoSpecialConnections,root=0)\",\n \"def __init__(self):\\n self.data = []\\n self.idx = {}\",\n \"def build(self):\\n if self.is_built:\\n return\\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\\n self.itime = 0\\n self.ielement = 0\\n self.itotal = 0\\n\\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\\n assert self.nelements > 0, 'nelements=%s' % self.nelements\\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\\n #self.names = []\\n self.nelements //= self.ntimes\\n\\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\\n self.node_element = np.zeros((self.ntotal, 2), dtype=idtype)\\n #oxx, oyy, txy, angle, major, minor, ovm\\n self.data = np.zeros((self.ntimes, self.nelements, 8), dtype=fdtype)\\n self.location = np.empty(self.ntotal, dtype='U8')\\n\\n self._times = np.zeros(self.ntimes, dtype=dtype)\",\n \"def __init__(self, inFilename):\\n\\n self._prmtopVersion=None\\n self._flags=[]\\n self._raw_format={}\\n self._raw_data={}\\n self._has_nbfix_terms = False\\n\\n with open(inFilename, 'r') as fIn:\\n for line in fIn:\\n if line[0] == '%':\\n if line.startswith('%VERSION'):\\n tag, self._prmtopVersion = line.rstrip().split(None, 1)\\n elif line.startswith('%FLAG'):\\n tag, flag = line.rstrip().split(None, 1)\\n self._flags.append(flag)\\n self._raw_data[flag] = []\\n elif line.startswith('%FORMAT'):\\n format = line.rstrip()\\n index0=format.index('(')\\n index1=format.index(')')\\n format = format[index0+1:index1]\\n try:\\n m = FORMAT_RE_PATTERN.search(format)\\n self._raw_format[self._flags[-1]] = (format, m.group(1), m.group(2), int(m.group(3)), m.group(4))\\n except:\\n # We couldn't parse the format, so just treat the whole line as a single string.\\n self._raw_format[self._flags[-1]] = (format, 1, 'a', 80, '')\\n elif line.startswith('%COMMENT'):\\n continue\\n elif self._flags \\\\\\n and 'TITLE'==self._flags[-1] \\\\\\n and not self._raw_data['TITLE']:\\n self._raw_data['TITLE'] = line.rstrip()\\n else:\\n flag=self._flags[-1]\\n (format, numItems, itemType,\\n iLength, itemPrecision) = self._getFormat(flag)\\n line = line.rstrip()\\n for index in range(0, len(line), iLength):\\n item = line[index:index+iLength]\\n if item:\\n self._raw_data[flag].append(item.strip())\\n # See if this is a CHAMBER-style topology file, which is not supported\\n # for creating Systems\\n self.chamber = 'CTITLE' in self._flags\",\n \"def __init__(self, data):\\n\\t\\tself.protocol_version, self.le_state, self.playback_state, \\\\\\n\\t\\t self.source, self.le_flags, self.playback_flags, \\\\\\n\\t\\t self.source_flags, self.fullness, self.point_rate, \\\\\\n\\t\\t self.point_count = \\\\\\n\\t\\t\\tstruct.unpack(\\\"<BBBBHHHHII\\\", data)\",\n \"def __init__(self):\\n ProcessingUnit.__init__(self)\\n print(\\\" [ START ] init - Metodo Simulator Reader\\\")\\n\\n self.isConfig = False\\n self.basicHeaderObj = BasicHeader(LOCALTIME)\\n self.systemHeaderObj = SystemHeader()\\n self.radarControllerHeaderObj = RadarControllerHeader()\\n self.processingHeaderObj = ProcessingHeader()\\n self.profileIndex = 2**32-1\\n self.dataOut = Voltage()\\n #code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])\\n code0 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,1,-1,1,-1,-1,-1,1,1,1,-1,1])\\n #code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])\\n code1 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,1,1,-1,-1,-1,1,-1])\\n #self.Dyn_snCode = numpy.array([code0,code1])\\n self.Dyn_snCode = None\",\n \"def _build(self):\\n xml = ET.parse(self.fn)\\n root = xml.getroot()\\n\\n metadata = None\\n trk = None\\n self.prefix = root.tag[:-3]\\n metadata = root.find(self._get_tag('metadata'))\\n # print(metadata.find(self._get_tag('time')))\\n trk = root.find(self._get_tag('trk'))\\n\\n trkseg = trk.find(self._get_tag('trkseg'))\\n\\n # I just wanted to flatten the track point and get the\\n # fields that I am actually interested in.\\n def walker(node):\\n nonlocal data\\n tags = {'lat': float,\\n 'lon': float,\\n 'ele': float,\\n 'time': cvt_time,\\n 'temp': float,\\n 'hr': float}\\n for tag in tags:\\n if node.tag.find(tag) >= 0:\\n data[tag] = tags[tag](node.text)\\n for child in node:\\n walker(child)\\n\\n for trkpt in trkseg.findall(self._get_tag('trkpt')):\\n data = {}\\n data['lat'] = trkpt.attrib['lat']\\n data['lon'] = trkpt.attrib['lon']\\n walker(trkpt)\\n self.points.append(TrackPoint(**data))\",\n \"def initDataParms(self):\\n self.xpos = self.pltw.curvelist[self.blkno].xvinfo.vidx\\n self.data = self.pltw.blklst[self.blkno] # original data block\\n self.idata = None # interpolated data\\n (self.nvec, self.npt) = self.data.shape\\n self.xmin = (self.data[self.xpos]).min()\\n self.xmax = (self.data[self.xpos]).max()\\n self.xspan = self.xmax - self.xmin\\n if self.parent.test:\\n self.dx = self.xspan / (self.npt * 5)\",\n \"def build(self, data: dict):\",\n \"def process(self):\\n dataobj = Data()\\n targetmap = {}\\n sta_indices = {}\\n hdulist = self.hdulist\\n # First get all the OI_TARGET, OI_WAVELENGTH and OI_ARRAY tables\\n for hdu in hdulist:\\n header = hdu.header\\n data = hdu.data\\n if hdu.name == \\\"OI_WAVELENGTH\\\":\\n if dataobj.wavelength == None:\\n dataobj.wavelength = {}\\n insname = header[\\\"INSNAME\\\"]\\n dataobj.wavelength[insname] = OI_WAVELENGTH(\\n data.field(\\\"EFF_WAVE\\\"), data.field(\\\"EFF_BAND\\\")\\n )\\n elif hdu.name == \\\"OI_TARGET\\\":\\n for row in data:\\n target_id = row[\\\"TARGET_ID\\\"]\\n target = OI_TARGET(\\n target=row[\\\"TARGET\\\"],\\n raep0=row[\\\"RAEP0\\\"],\\n decep0=row[\\\"DECEP0\\\"],\\n equinox=row[\\\"EQUINOX\\\"],\\n ra_err=row[\\\"RA_ERR\\\"],\\n dec_err=row[\\\"DEC_ERR\\\"],\\n sysvel=row[\\\"SYSVEL\\\"],\\n veltyp=row[\\\"VELTYP\\\"],\\n veldef=row[\\\"VELDEF\\\"],\\n pmra=row[\\\"PMRA\\\"],\\n pmdec=row[\\\"PMDEC\\\"],\\n pmra_err=row[\\\"PMRA_ERR\\\"],\\n pmdec_err=row[\\\"PMDEC_ERR\\\"],\\n parallax=row[\\\"PARALLAX\\\"],\\n para_err=row[\\\"PARA_ERR\\\"],\\n spectyp=row[\\\"SPECTYP\\\"],\\n )\\n dataobj.target = np.append(dataobj.target, target)\\n targetmap[target_id] = target\\n elif hdu.name == \\\"OI_ARRAY\\\":\\n if dataobj.array == None:\\n dataobj.array = {}\\n arrname = header[\\\"ARRNAME\\\"]\\n frame = header[\\\"FRAME\\\"]\\n arrxyz = np.array(\\n [header[\\\"ARRAYX\\\"], header[\\\"ARRAYY\\\"], header[\\\"ARRAYZ\\\"]]\\n )\\n dataobj.array[arrname] = OI_ARRAY(frame, arrxyz, stations=data)\\n # Save the sta_index for each array, as we will need it\\n # later to match measurements to stations\\n sta_indices[arrname] = data.field(\\\"sta_index\\\")\\n\\n # Then get any science measurements\\n for hdu in hdulist:\\n header = hdu.header\\n data = hdu.data\\n if hdu.name in (\\\"OI_VIS\\\", \\\"OI_VIS2\\\", \\\"OI_T3\\\"):\\n if \\\"ARRNAME\\\" in header.keys():\\n arrname = header[\\\"ARRNAME\\\"]\\n else:\\n arrname = None\\n if arrname and dataobj.array:\\n array = dataobj.array[arrname]\\n else:\\n array = None\\n wavelength = dataobj.wavelength[header[\\\"INSNAME\\\"]]\\n if hdu.name == \\\"OI_VIS\\\":\\n for row in data:\\n date = header[\\\"DATE-OBS\\\"].split(\\\"-\\\")\\n timeobs = datetime.datetime(\\n int(date[0]), int(date[1]), int(date[2])\\n ) + datetime.timedelta(seconds=np.around(row.field(\\\"TIME\\\"), 2))\\n int_time = row.field(\\\"INT_TIME\\\")\\n visamp = np.reshape(row.field(\\\"VISAMP\\\"), -1)\\n visamperr = np.reshape(row.field(\\\"VISAMPERR\\\"), -1)\\n visphi = np.reshape(row.field(\\\"VISPHI\\\"), -1)\\n visphierr = np.reshape(row.field(\\\"VISPHIERR\\\"), -1)\\n if \\\"CFLUX\\\" in row.array.names:\\n cflux = np.reshape(row.field(\\\"CFLUX\\\"), -1)\\n else:\\n cflux = None\\n if \\\"CFLUXERR\\\" in row.array.names:\\n cfluxerr = np.reshape(row.field(\\\"CFLUXERR\\\"), -1)\\n else:\\n cfluxerr = None\\n flag = np.reshape(row.field(\\\"FLAG\\\"), -1)\\n ucoord = row.field(\\\"UCOORD\\\")\\n vcoord = row.field(\\\"VCOORD\\\")\\n target = targetmap[row.field(\\\"TARGET_ID\\\")]\\n if array:\\n sta_index = row.field(\\\"STA_INDEX\\\")\\n s1 = array.station[sta_indices[arrname] == sta_index[0]][0]\\n s2 = array.station[sta_indices[arrname] == sta_index[1]][0]\\n station = [s1, s2]\\n else:\\n station = [None, None]\\n dataobj.vis = np.append(\\n dataobj.vis,\\n OI_VIS(\\n timeobs=timeobs,\\n int_time=int_time,\\n visamp=visamp,\\n visamperr=visamperr,\\n visphi=visphi,\\n visphierr=visphierr,\\n flag=flag,\\n ucoord=ucoord,\\n vcoord=vcoord,\\n wavelength=wavelength,\\n target=target,\\n array=array,\\n station=station,\\n cflux=cflux,\\n cfluxerr=cfluxerr,\\n ),\\n )\\n elif hdu.name == \\\"OI_VIS2\\\":\\n for row in data:\\n date = header[\\\"DATE-OBS\\\"].split(\\\"-\\\")\\n timeobs = datetime.datetime(\\n int(date[0]), int(date[1]), int(date[2])\\n ) + datetime.timedelta(seconds=np.around(row.field(\\\"TIME\\\"), 2))\\n int_time = row.field(\\\"INT_TIME\\\")\\n vis2data = np.reshape(row.field(\\\"VIS2DATA\\\"), -1)\\n vis2err = np.reshape(row.field(\\\"VIS2ERR\\\"), -1)\\n flag = np.reshape(row.field(\\\"FLAG\\\"), -1)\\n ucoord = row.field(\\\"UCOORD\\\")\\n vcoord = row.field(\\\"VCOORD\\\")\\n target = targetmap[row.field(\\\"TARGET_ID\\\")]\\n if array:\\n sta_index = row.field(\\\"STA_INDEX\\\")\\n s1 = array.station[sta_indices[arrname] == sta_index[0]][0]\\n s2 = array.station[sta_indices[arrname] == sta_index[1]][0]\\n station = [s1, s2]\\n else:\\n station = [None, None]\\n dataobj.vis2 = np.append(\\n dataobj.vis2,\\n OI_VIS2(\\n timeobs=timeobs,\\n int_time=int_time,\\n vis2data=vis2data,\\n vis2err=vis2err,\\n flag=flag,\\n ucoord=ucoord,\\n vcoord=vcoord,\\n wavelength=wavelength,\\n target=target,\\n array=array,\\n station=station,\\n ),\\n )\\n elif hdu.name == \\\"OI_T3\\\":\\n for row in data:\\n date = header[\\\"DATE-OBS\\\"].split(\\\"-\\\")\\n timeobs = datetime.datetime(\\n int(date[0]), int(date[1]), int(date[2])\\n ) + datetime.timedelta(seconds=np.around(row.field(\\\"TIME\\\"), 2))\\n int_time = row.field(\\\"INT_TIME\\\")\\n t3amp = np.reshape(row.field(\\\"T3AMP\\\"), -1)\\n t3amperr = np.reshape(row.field(\\\"T3AMPERR\\\"), -1)\\n t3phi = np.reshape(row.field(\\\"T3PHI\\\"), -1)\\n t3phierr = np.reshape(row.field(\\\"T3PHIERR\\\"), -1)\\n flag = np.reshape(row.field(\\\"FLAG\\\"), -1)\\n u1coord = row.field(\\\"U1COORD\\\")\\n v1coord = row.field(\\\"V1COORD\\\")\\n u2coord = row.field(\\\"U2COORD\\\")\\n v2coord = row.field(\\\"V2COORD\\\")\\n target = targetmap[row.field(\\\"TARGET_ID\\\")]\\n if array:\\n sta_index = row.field(\\\"STA_INDEX\\\")\\n s1 = array.station[sta_indices[arrname] == sta_index[0]][0]\\n s2 = array.station[sta_indices[arrname] == sta_index[1]][0]\\n s3 = array.station[sta_indices[arrname] == sta_index[2]][0]\\n station = [s1, s2, s3]\\n else:\\n station = [None, None, None]\\n dataobj.t3 = np.append(\\n dataobj.t3,\\n OI_T3(\\n timeobs=timeobs,\\n int_time=int_time,\\n t3amp=t3amp,\\n t3amperr=t3amperr,\\n t3phi=t3phi,\\n t3phierr=t3phierr,\\n flag=flag,\\n u1coord=u1coord,\\n v1coord=v1coord,\\n u2coord=u2coord,\\n v2coord=v2coord,\\n wavelength=wavelength,\\n target=target,\\n array=array,\\n station=station,\\n ),\\n )\\n return dataobj\",\n \"def __init__(self):\\n self._data = PositionalList() # list of _Item instances\",\n \"def __init__(self):\\r\\n self.indices = {}\\r\\n self.data = []\\r\\n self.len = 0\",\n \"def build(self):\\n if not hasattr(self, 'subtitle'):\\n self.subtitle = self.data_code['subtitle']\\n #print('ntimes=%s nelements=%s ntotal=%s subtitle=%s' % (\\n #self.ntimes, self.nelements, self.ntotal, self.subtitle))\\n nnodes = 1\\n\\n #self.names = []\\n #self.nelements //= nnodes\\n self.nelements //= self.ntimes\\n #self.ntotal\\n self.itime = 0\\n self.ielement = 0\\n self.itotal = 0\\n #print('ntotal=%s ntimes=%s nelements=%s' % (self.ntotal, self.ntimes, self.nelements))\\n\\n self.ntotal = self.nelements * nnodes * 2\\n if self.is_sort1:\\n ntimes = self.ntimes\\n ntotal = self.ntotal\\n else:\\n #print(\\\"ntimes=%s nelements=%s ntotal=%s nnodes=%s\\\" % (self.ntimes, self.nelements, self.ntotal, nnodes))\\n ntimes = self.ntotal\\n ntotal = self.nelements // 2\\n #self.ntotal = ntotal\\n #print(\\\"**BEND: ntimes=%s ntotal=%s\\\" % (ntimes, ntotal))\\n #self.ntotal = nelements * nnodes * 2\\n\\n dtype, idtype, fdtype = get_times_dtype(self.nonlinear_factor, self.size, self.analysis_fmt)\\n self._times = np.zeros(ntimes, dtype=dtype)\\n #self.ntotal = self.nelements * nnodes\\n\\n self.element_node = np.zeros((ntotal, 2), dtype=idtype)\\n\\n # the number is messed up because of the offset for the element's properties\\n if not self.nelements * nnodes * 2 == self.ntotal:\\n msg = 'ntimes=%s nelements=%s nnodes=%s ne*nn=%s ntotal=%s' % (\\n self.ntimes, self.nelements, nnodes, self.nelements * nnodes,\\n self.ntotal)\\n raise RuntimeError(msg)\\n\\n # [angle, sc, sd, se, sf, omax, omin, mst, msc]\\n self.data = np.zeros((ntimes, ntotal, 9), dtype=fdtype)\",\n \"def __init__(self):\\n self.data = []\\n self.record = {}\",\n \"def set_content(self, offset: int, content_dict: dict):\\n super().set_content(offset, content_dict)\\n\\n # Get the list of files from the properties and determine basenames from the path, which\\n # will be used as name in the readfs\\n for file in content_dict.get('properties').get('files'):\\n self.file_paths.append([os.path.basename(file), file])\\n\\n # First declare the sub-sections so that the right offsets are computed\\n\\n # Top structure which will gather all sub-sections\\n self.top_struct = CStructParent('readfs', parent=self)\\n\\n # Main header for readfs size and number of files\\n self.header = ReadfsHeader('header', parent=self.top_struct)\\n\\n # One header per file containig file size, name and flash offset\\n for i, path in enumerate(self.file_paths):\\n filename, filepath = path\\n self.file_headers.append(ReadfsFileHeader(f'file{i} header', len(filename)+1,\\n parent=self.top_struct))\\n\\n # File contents\\n for i, path in enumerate(self.file_paths):\\n filename, filepath = path\\n self.files.append(ReadfsFile(f'file{i}', os.path.getsize(filepath),\\n parent=self.top_struct))\\n\\n\\n\\n # Now that the offsets have been computed, we can fill-in the various fields\\n\\n # Main header\\n header_size = self.header.get_size()\\n for file_header in self.file_headers:\\n header_size += file_header.get_size()\\n\\n self.header.set_field('fs_size', header_size)\\n self.header.set_field('nb_files', len(self.files))\\n\\n for i, path in enumerate(self.file_paths):\\n filename, filepath = self.file_paths[i]\\n file_header = self.file_headers[i]\\n file = self.files[i]\\n\\n # Per-file header\\n file_header.set_field('offset', file.get_offset() - self.get_offset())\\n file_header.set_field('file_size', os.path.getsize(filepath))\\n file_header.set_field('name_len', len(filename)+1)\\n file_header.set_field('name', filename.encode('utf-8') + bytes([0]))\\n\\n # Per-file content\\n with open(filepath, 'rb') as file_desc:\\n file.set_field('data', file_desc.read())\",\n \"def prepare_sFlat_data(notes, track_range = None, enc_shape = (1,), ip_memory = 32, depth = 2, spread = 16):\\n track_range = track_range if track_range else [0, 1]\\n \\n data_in, data_out = [], []\\n \\n for tr in range(track_range[1] - track_range[0]):\\n # trk = tr - track_range[0]\\n nt = notes[tr]\\n data_in.append([])\\n data_out.append([])\\n lent = len(notes[tr])\\n # for j in range(lent):\\n le = len(nt)\\n \\n chunks_count = le // ip_memory + 1\\n \\n for i in range(le - ip_memory):\\n start, end = i, i + ip_memory\\n buf_size = ip_memory if end < le else le - start # only reason due to logic below else not needed\\n buffer = numpy.zeros((ip_memory, depth,))\\n # print(\\\"buff shape : \\\", buffer.shape)\\n buffer[:buf_size, :] = nt[start : start + buf_size]\\n\\n data_in[tr].append(buffer)\\n \\n data_out[tr].append((nt[end] if end < le else notes[0][0]))\\n \\n # if track_range[1]- track_range[0] == 1: #is scalar, no track\\n # data_in, data_out = data_in[0], data_out[0]\\n \\n\\n return numpy.array(data_in), numpy.array(data_out)\",\n \"def __init__(self):\\n\\n\\t\\t# PDB fields\\n\\t\\tself.s_name = \\\"\\\"\\t\\t\\t\\t# Name of the structure\\n\\t\\tself.l_s_leading_data = []\\t\\t# PDB information written above the atom properties\\n\\t\\tself.l_s_trailing_data = []\\t\\t# PDB information written under the atom properties\\n\\n\\t\\t# Structural fields\\n\\t\\tself.i_atom_count = 0\\t\\t\\t# Number of atoms in the structure\\n\\t\\tself.a_atoms = None\\t\\t\\t\\t# Array of atoms properties\\n\\t\\tself.a_max_coord = None\\t\\t\\t# Maximal coordinates for each axis\\n\\t\\tself.a_min_coord = None\\t\\t\\t# Minimal coordinates for each axis\\n\\n\\t\\t# Grid fields\\n\\t\\tself.a_grid = None\\t\\t\\t\\t# 3D grid containing the structure\\n\\t\\tself.l_l_elements = None\\t\\t# Set of atoms contained in the structure\\n\\n\\t\\t# Solubilization fields\\n\\t\\tself.o_tree = None\\t\\t\\t\\t\\t\\t# A KDTree object representing the exact placement of atoms, used for distance determination\\n\\n\\t\\t# Comparison fields\\n\\t\\tself.b_loaded = False\\t\\t# Keeps tracks of the state of the structure\\n\\n\\t\\t# Ligands fields\\n\\t\\tself.l_o_ligands = []\\t\\t# A list for the ligands\\n\\n\\t\\t# Pocket fields\\n\\t\\tself.l_i_pocket_residues = []\\t\\t# List of the residues included in the pocket\\n\\t\\tself.a_pocket_atoms = None\\t\\t\\t# Array of the pocket atoms properties\\n\\t\\tself.a_pocket_grid = None\\t\\t\\t# 3D grid containing the pocket\\n\\n\\t\\t# Miscellaneous fields\\n\\t\\tself.a_min_coord = None\\t\\t# Minimum coordinates of the structure\\n\\t\\tself.a_max_coord = None\\t\\t# Maximum coordinates of the structure\\n\\t\\tself.f_mass = 0.0\\t\\t\\t# Mass of the structure\",\n \"def setUp(self):\\n\\n serial_times = {295: '1971-07-31T01:24:11.754',\\n 296: '1971-07-31T01:24:36.970',\\n 297: '1971-07-31T01:25:02.243',\\n 298: '1971-07-31T01:25:27.457',\\n 299: '1971-07-31T01:25:52.669',\\n 300: '1971-07-31T01:26:17.923'}\\n self.serials = ['APOLLO15/METRIC/{}'.format(i) for i in serial_times.values()]\\n\\n\\n x = list(range(5))\\n y = list(range(5))\\n pid = [0,0,1,1,1]\\n idx = pid\\n serials = [self.serials[0], self.serials[1], self.serials[2],\\n self.serials[2], self.serials[3]]\\n\\n\\n columns = ['x', 'y', 'idx', 'pid', 'nid']\\n self.data_length = 5\\n\\n data = [x,y, idx, pid, serials]\\n\\n self.creation_time = strftime(\\\"%Y-%m-%d %H:%M:%S\\\", gmtime())\\n cnet = C(data, index=columns).T\\n\\n io_controlnetwork.to_isis('test.net', cnet, mode='wb', targetname='Moon')\\n\\n self.header_message_size = 85\\n self.point_start_byte = 65621\",\n \"def build(self):\\n if not hasattr(self, 'subtitle'):\\n self.subtitle = self.data_code['subtitle']\\n #print('ntimes=%s nelements=%s ntotal=%s subtitle=%s' % (\\n #self.ntimes, self.nelements, self.ntotal, self.subtitle))\\n if self.is_built:\\n return\\n nnodes = 1\\n\\n #self.names = []\\n #self.nelements //= nnodes\\n self.nelements //= self.ntimes\\n self.ntotal = self.nelements * nnodes * 2\\n #self.ntotal\\n self.itime = 0\\n self.ielement = 0\\n self.itotal = 0\\n #print('ntotal=%s ntimes=%s nelements=%s' % (self.ntotal, self.ntimes, self.nelements))\\n\\n #print(\\\"ntimes=%s nelements=%s ntotal=%s\\\" % (self.ntimes, self.nelements, self.ntotal))\\n self._times = np.zeros(self.ntimes, 'float32')\\n #self.ntotal = self.nelements * nnodes\\n\\n self.element_node = np.zeros((self.ntotal, 2), 'int32')\\n\\n # the number is messed up because of the offset for the element's properties\\n if not self.nelements * nnodes * 2 == self.ntotal:\\n msg = 'ntimes=%s nelements=%s nnodes=%s ne*nn=%s ntotal=%s' % (\\n self.ntimes, self.nelements, nnodes, self.nelements * nnodes,\\n self.ntotal)\\n raise RuntimeError(msg)\\n\\n # [angle, sc, sd, se, sf]\\n self.data = np.zeros((self.ntimes, self.ntotal, 5), 'complex64')\",\n \"def _populate_shapes(self):\\n point = Point(self.position.x, self.position.y)\\n point_buffered = point.buffer(self.radius + self.buffer, 3)\\n self._point_shape = point.buffer(self.radius, 3)\\n \\n scale = 10.0\\n font = truetype(self.fontfile, int(self.fontsize * scale), encoding='unic')\\n\\n x, y = self.position.x, self.position.y\\n w, h = font.getsize(self.name)\\n w, h = w/scale, h/scale\\n \\n for placement in placements:\\n label_shape = point_label_bounds(x, y, w, h, self.radius, placement)\\n mask_shape = label_shape.buffer(self.buffer, 2).union(point_buffered)\\n \\n self._label_shapes[placement] = label_shape\\n self._mask_shapes[placement] = mask_shape\\n \\n unionize = lambda a, b: a.union(b)\\n self._label_footprint = reduce(unionize, self._label_shapes.values())\\n self._mask_footprint = reduce(unionize, self._mask_shapes.values())\\n \\n # number of pixels from the top of the label based on the bottom of a \\\".\\\"\\n self._baseline = font.getmask('.').getbbox()[3] / scale\",\n \"def read_makerNotes(makerNotes, values=VALUES, i=0, starting_header=val_list[0]):\\n nextHeader = starting_header\\n while True:\\n if makerNotes[i] == nextHeader:\\n pos = val_list.index(nextHeader)\\n header = key_list[pos]\\n print(f'found header {hex(int(makerNotes[i]))} ({header}) at position {i}')\\n type = makerNotes[i+2] # read data type\\n num = int(struct.unpack(b\\\"<L\\\", makerNotes[i+4:i+8])[0]) # read num of occurances\\n dataType = b\\\"<\\\"\\n if type == 0x01: # pad\\n dataType = dataType + (b\\\"x\\\" * num)\\n size = num * 1\\n data = struct.unpack(dataType, makerNotes[i+8:i+8+size])\\n elif type == 0x02: # char\\n dataType = dataType + (b\\\"c\\\" * num)\\n size = num * 1\\n data = struct.unpack(dataType, makerNotes[i+8:i+8+size])\\n data = ' '.join([d.decode() for d in data])[:-1]\\n elif type == 0x0b: # float\\n dataType = dataType + (b\\\"f\\\" * num)\\n size = num * 4\\n data = struct.unpack(dataType, makerNotes[i+8:i+8+size])[num-1]\\n else:\\n raise ValueError(f'cannot identify type with hexadecimal representation: {type}')\\n values[header] = data\\n i = i + 8 + size - 1\\n nextHeader += 1\\n sumNones = sum([1 for key, val in values.items() if val is None])\\n if sumNones == 0:\\n break\\n i+=1\\n return values\",\n \"def __init__(self, data, parent=None):\\n self.parent = parent\\n self.bootable_flag = struct.unpack(\\\"<B\\\", data[0])[0]\\n self.start_chs_address = struct.unpack(\\\"<BH\\\", data[1:4])[0]\\n self.partition_type = struct.unpack(\\\"<B\\\", data[4])[0]\\n self.end_chs_address = struct.unpack(\\\"<BH\\\", data[5:8])[0]\\n # FIXME Check to see how the lba address bytes are used\\n if self.get_type() == 'Empty':\\n self.lba = 0\\n else:\\n self.lba = struct.unpack(\\\"<L\\\", data[8:12])[0]\\n\\n self.size = struct.unpack(\\\"<L\\\", data[12:16])[0]\",\n \"def __initialize(self):\\n\\t\\tself.matrix = [None] * self.size\\n\\t\\tself.__get_log_values()\\n\\t\\tfor row in range(self.size):\\n\\t\\t\\tself.matrix[row] = [None] * self.size\\n\\t\\tmax_len = self.__get_max_length()\\n\\t\\tdata = self.__get_data(self.text,max_len)\\n\\t\\tmpoly = self.__get_mpoly(data)\\n\\t\\tgpoly = self.__get_gploy()\\n\\t\\tself.final_data = self.__get_final_data(mpoly,gpoly)\\n\\t\\tself.__set_FIP(FP_num = 1)\\n\\t\\tself.__set_FIP(FP_num = 2)\\n\\t\\tself.__set_FIP(FP_num = 3)\\n\\t\\tself.__set_AP()\\n\\t\\tself.__fill_format_info_area()\\n\\t\\tself.__set_TP()\",\n \"def build_data(self):\\n\\n _header_ = self._header_ + 'build_data(): '\\n\\n if self.verbose:\\n print(_header_ + 'Building data for %s ...' % self.p_data)\\n\\n self.read_data()\\n self.map_data()\\n self.partition_data()\\n self.composition()\\n\\n if self.verbose:\\n print(_header_ + 'Build complete.')\\n\\n return self\",\n \"def processData(self,data):\\n #print 'I GOT DATA',data,[0],data[1]\\n # Check for valid data (not null or empty string)\\n #print '**************NOTIFICATION***************',type(_RobotCommunicator.WALL_HEADER),type(data[0])\\n if data:\\n #print '**************NOTIFICATION***************',type(_RobotCommunicator.WALL_HEADER),type(data[0]),_RobotCommunicator.WALL_HEADER==data[0]\\n\\n # Check header and assign data appropriately\\n # TODO: Check length of data for validity\\n #print 'Header',data[0]\\n if data[0] == _RobotCommunicator.POSE_HEADER:\\n self.pose = unpack(_RobotCommunicator.POSE_FORMAT,data[1:])\\n elif data[0] == _RobotCommunicator.SENSOR_HEADER:\\n\\n #for i in range(1, len(data)-1, 2):\\n index= unpack('B',data[1])\\n value = unpack('?',data[2])\\n # Update old values or create new sensor-value pair\\n self.sensors[index[0]] = value[0]\\n #print 'in csharp: ',[index,value]\\n\\n elif data[0] == _RobotCommunicator.WAYPOINT_HEADER:\\n self.waypoints = [] # Clear old waypoints\\n for i in range(1, len(data)-16, 16):\\n x,y = unpack(_RobotCommunicator.WAYPOINT_FORMAT,\\n data[i:i+15])\\n self.waypoints.append((x,y))\\n elif data[0] == _RobotCommunicator.DIRECTION_HEADER:\\n self.direction = unpack(_RobotCommunicator.DIRECTION_FORMAT,\\n data[1:])\\n elif data[0] == _RobotCommunicator.ACTUATOR_HEADER:\\n self.actuators = [] # Clear old actuator commands for i in range(1, len(data)-1):\\n self.actuators.append(unpack(\\n _RobotCommunicator.ACTUATOR_FORMAT,data[i]))\\n elif data[0] == _RobotCommunicator.WALL_HEADER:\\n self.walls = {} # Clear old wall entries\\n index = unpack('B', data[1])\\n x1,y1,x2,y2 = unpack(_RobotCommunicator.WALL_FORMAT,data[2:34])\\n self.walls = (x1,y1,x2,y2)\\n #print '**************Coordinates***************',(x1,y1,x2,y2)\\n print '****self.walls*********',self.walls\\n elif data[0] == _RobotCommunicator.OBS_HEADER:\\n index = unpack('B', data[1])\\n add,x1,y1 = unpack(_RobotCommunicator.OBS_FORMAT,data[2:26])\\n #print '***********self.obs*************'+','.join(map(str,[add,x1,y1]))\\n self.obs = [add,x1,round(y1,2)]\\n if add == 1:\\n a = PolyShapes.Rectangle(self.resolX,self.resolY)\\n a.shift(x1,y1)\\n self.obsPoly += a\\n self.receiveObs = True\\n #print \\\"add obstacle:\\\" + str(x1) + \\\",\\\"+ str(y1)\\n elif add == 4:\\n if x1 == 0:\\n self.STOP = True\\n else:\\n self.STOP = False\\n else:\\n a = PolyShapes.Rectangle(self.resolX,self.resolY)\\n a.shift(x1,y1)\\n self.obsPoly -= a\\n self.receiveObs = True\\n #print \\\"del obstacle:\\\"+ str(x1) + \\\",\\\"+ str(y1)\\n\\n\\n else:\\n print \\\"Unexpected or corrupted data packet received.\\\"\",\n \"def __init__(self, data):\\n # check if dataset contains time information\\n # (fetched from bootloader storage)\\n if len(data) == 61:\\n (_, seconds, minutes, hours, days, months, years) = struct.unpack(\\n '<55sBBBBBB', data)\\n self.date = datetime(2000 + years, months, days, hours, minutes,\\n seconds)\\n\\n # Only parse preceding data\\n data = data[:55]\\n power = [0, 0]\\n kWh = [0, 0]\\n MWh = [0, 0]\\n (_, digital, speed, active, power[0], kWh[0], MWh[0], power[1], kWh[1],\\n MWh[1]) = struct.unpack('<32sH4sBLHHLHH', data)\\n\\n analog = struct.unpack(\\n '<{}{}'.format('H' * 16, 'x' * (len(data) - 32)), data)\\n\\n self.analog = {}\\n for channel in range(0, 16):\\n self.analog[channel + 1] = round(\\n self._convert_analog(analog[channel]), 3)\\n\\n self.digital = {}\\n for channel in range(0, 16):\\n self.digital[channel + 1] = self._convert_digital(digital, channel)\\n\\n '''\\n self.speed = {}\\n for channel in range(0, 4):\\n self.speed[channel + 1] = round(\\n self._convert_speed(speed[channel]), 3)\\n \\n\\n self.energy = {}\\n for channel in range(0, 2):\\n self.energy[channel + 1] = round(\\n self._convert_energy(MWh[channel], kWh[channel], active,\\n channel), 3)\\n \\n\\n self.power = {}\\n for channel in range(0, 2):\\n self.power[channel + 1] = round(\\n self._convert_power(power[channel], active, channel), 3)\\n '''\",\n \"def _get_obs(self):\\n pos = []\\n z = []\\n for i in range(params['memory_size']):\\n if self._step - i * params['memory_size'] > 1:\\n pos.append(self._track_item['joint_pos'][self._step - i * params['memory_size'] - 1].copy())\\n z.append(self._track_item['z'][self._step - i * params['memory_size'] - 1].copy())\\n else:\\n pos.append(self._track_item['joint_pos'][0].copy())\\n if len(self._track_item['z']) < 1:\\n z.append(self.z.copy())\\n else:\\n z.append(self._track_item['z'][0].copy())\\n out = pos\\n if params['observation_version'] == 1:\\n out += z\\n ob = {\\n 'observation' : np.concatenate(out, -1),\\n 'desired_goal' : self.desired_goal.copy(),\\n 'achieved_goal' : self.achieved_goal.copy(),\\n 'z' : self.z.copy()\\n }\\n return ob\",\n \"def deserialize(self, str):\\n try:\\n if self.header is None:\\n self.header = std_msgs.msg.Header()\\n if self.sensor_pose_on_robot is None:\\n self.sensor_pose_on_robot = geometry_msgs.msg.Pose()\\n if self.sensed_data is None:\\n self.sensed_data = None\\n end = 0\\n _x = self\\n start = end\\n end += 12\\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.header.frame_id = str[start:end]\\n _x = self\\n start = end\\n end += 96\\n (_x.sensor_pose_on_robot.position.x, _x.sensor_pose_on_robot.position.y, _x.sensor_pose_on_robot.position.z, _x.sensor_pose_on_robot.orientation.x, _x.sensor_pose_on_robot.orientation.y, _x.sensor_pose_on_robot.orientation.z, _x.sensor_pose_on_robot.orientation.w, _x.min_sensor_distance, _x.max_sensor_distance, _x.sensor_std_range, _x.sensor_std_yaw, _x.sensor_std_pitch,) = _get_struct_12d().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.sensed_data = []\\n for i in range(0, length):\\n val1 = mrpt_msgs.msg.SingleRangeBearingObservation()\\n _x = val1\\n start = end\\n end += 28\\n (_x.range, _x.yaw, _x.pitch, _x.id,) = _get_struct_3di().unpack(str[start:end])\\n self.sensed_data.append(val1)\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) #most likely buffer underfill\",\n \"def get_map_notes(map_json, **kwargs):\\n length = kwargs.get(\\\"length\\\", -1)\\n divisor = kwargs.get(\\\"divisor\\\", 4)\\n tick_times = get_map_timing_array(map_json, length=length, divisor=divisor)\\n\\n objs = map_json[\\\"obj\\\"]\\n obj_times = list(map(lambda obj: obj[\\\"time\\\"], objs))\\n\\n # 1 for circle, 2 for slider, 3 for spinner\\n def get_note_type(obj):\\n if not obj:\\n return 0\\n if obj[\\\"type\\\"] & 2:\\n return 2\\n elif obj[\\\"type\\\"] & 8:\\n return 3\\n return 1\\n\\n po = 0\\n note_max_wait_time = kwargs.get(\\\"note_max_wait_time\\\", 1000)\\n start_time = obj_times[0] - note_max_wait_time\\n last_obj_time = start_time\\n sliding = 0\\n slider_end_time = 0\\n spinning = 0\\n spinner_end_time = 0\\n data = []\\n flow_data = []\\n\\n # constant multipliers and subtractions\\n tlen_mp = 1/500\\n tlen_s = 1\\n bpm_mp = 1/120\\n bpm_s = 1\\n slen_mp = 1/150\\n slen_s = 1\\n\\n # tick count from start of uninherited timing section\\n uts_i = 0\\n\\n # tick is timestamp here\\n for i, tick in enumerate(tick_times):\\n\\n if is_uts_begin(map_json, tick):\\n uts_i = 0\\n else:\\n uts_i += 1\\n\\n # Attach extra vars at the end of each note data row\\n tlen = get_tick_len(map_json, tick)\\n bpm = 60000 / tlen\\n slen = get_slider_len(map_json, tick)\\n ex1 = tlen * tlen_mp - tlen_s\\n ex2 = bpm * bpm_mp - bpm_s\\n ex3 = slen * slen_mp - slen_s\\n\\n while obj_times[po] < tick - 5 and po < len(obj_times) - 1:\\n po += 1\\n if obj_times[po] >= tick - 5 and obj_times[po] <= tick + 5: # found note\\n last_obj_time = tick\\n note_type = get_note_type(objs[po])\\n\\n # calculate momentum\\n if po >= 1:\\n momentum = get_momentum(objs[po], objs[po-1], slen/tlen)\\n else:\\n momentum = 0\\n\\n # flow data\\n if po >= 1:\\n input_vector = get_input_vector(objs[po], objs[po-1])\\n output_vector = get_output_vector(objs[po], objs[po-1])\\n else:\\n input_vector = [0, 0]\\n output_vector = [0, 0]\\n if input_vector is None or input_vector[0] is None or input_vector[1] is None:\\n input_vector = [0, 0]\\n if output_vector is None or output_vector[0] is None or output_vector[1] is None:\\n output_vector = [0, 0]\\n\\n # end point\\n endpoint = get_end_point(objs[po])\\n flow_data.append([uts_i, tick, note_type, objs[po][\\\"x\\\"], objs[po][\\\"y\\\"], input_vector[0],\\n input_vector[1], output_vector[0], output_vector[1], endpoint[0], endpoint[1]])\\n\\n # put data\\n if note_type == 1:\\n spinning = 0\\n sliding = 0\\n elif note_type == 2:\\n sliding = 1\\n slider_end_time = objs[po][\\\"sliderData\\\"][\\\"endTime\\\"]\\n elif note_type == 3:\\n spinning = 1\\n spinner_end_time = objs[po][\\\"spinnerEndTime\\\"]\\n # because the spinner sometimes get over 3 secs\\n last_obj_time = spinner_end_time\\n\\n # TICK, TIME, NOTE, NOTE_TYPE, SLIDING, SPINNING, MOMENTUM, Ex1, Ex2, Ex3\\n data.append([uts_i, tick, 1, note_type, sliding,\\n spinning, momentum, ex1, ex2, ex3])\\n elif spinning == 1:\\n if tick >= spinner_end_time - 5:\\n spinning = 0\\n data.append([uts_i, tick, 1, 5, 0, 0, 0, ex1, ex2, ex3])\\n else:\\n data.append([uts_i, tick, 0, 0, 0, 1, 0, ex1, ex2, ex3])\\n elif sliding == 1:\\n if tick >= slider_end_time - 5:\\n sliding = 0\\n data.append([uts_i, tick, 1, 4, 0, 0, 0, ex1, ex2, ex3])\\n else:\\n data.append([uts_i, tick, 0, 0, 1, 0, 0, ex1, ex2, ex3])\\n else: # not found\\n if tick - last_obj_time < note_max_wait_time and tick >= start_time:\\n data.append([uts_i, tick, 0, 0, 0, 0, 0, ex1, ex2, ex3])\\n return data, flow_data\",\n \"def __init__(self, data):\\n # add play_guid as it sometimes doesn't exist\\n if 'play_guid' not in data:\\n data['play_guid'] = ''\\n # loop through data\\n for x in data:\\n # set information as correct data type\\n mlbgame.object.setobjattr(self, x, data[x])\",\n \"def build(self, file_number, data):\\n pass\",\n \"def deserialize(self, str):\\n try:\\n if self.header is None:\\n self.header = std_msgs.msg.Header()\\n if self.obstacleinfo is None:\\n self.obstacleinfo = nubot_common.msg.ObstaclesInfo()\\n if self.oppinfo is None:\\n self.oppinfo = nubot_common.msg.ObstaclesInfo()\\n if self.robotinfo is None:\\n self.robotinfo = None\\n if self.ballinfo is None:\\n self.ballinfo = None\\n if self.coachinfo is None:\\n self.coachinfo = nubot_common.msg.CoachInfo()\\n if self.pass_cmd is None:\\n self.pass_cmd = nubot_common.msg.PassCommands()\\n end = 0\\n _x = self\\n start = end\\n end += 12\\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.header.frame_id = str[start:end]\\n _x = self\\n start = end\\n end += 12\\n (_x.obstacleinfo.header.seq, _x.obstacleinfo.header.stamp.secs, _x.obstacleinfo.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.obstacleinfo.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.obstacleinfo.header.frame_id = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.obstacleinfo.pos = []\\n for i in range(0, length):\\n val1 = nubot_common.msg.Point2d()\\n _x = val1\\n start = end\\n end += 8\\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\\n self.obstacleinfo.pos.append(val1)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.obstacleinfo.polar_pos = []\\n for i in range(0, length):\\n val1 = nubot_common.msg.PPoint()\\n _x = val1\\n start = end\\n end += 8\\n (_x.angle, _x.radius,) = _get_struct_2f().unpack(str[start:end])\\n self.obstacleinfo.polar_pos.append(val1)\\n _x = self\\n start = end\\n end += 12\\n (_x.oppinfo.header.seq, _x.oppinfo.header.stamp.secs, _x.oppinfo.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.oppinfo.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.oppinfo.header.frame_id = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.oppinfo.pos = []\\n for i in range(0, length):\\n val1 = nubot_common.msg.Point2d()\\n _x = val1\\n start = end\\n end += 8\\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\\n self.oppinfo.pos.append(val1)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.oppinfo.polar_pos = []\\n for i in range(0, length):\\n val1 = nubot_common.msg.PPoint()\\n _x = val1\\n start = end\\n end += 8\\n (_x.angle, _x.radius,) = _get_struct_2f().unpack(str[start:end])\\n self.oppinfo.polar_pos.append(val1)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.robotinfo = []\\n for i in range(0, length):\\n val1 = nubot_common.msg.RobotInfo()\\n _v12 = val1.header\\n start = end\\n end += 4\\n (_v12.seq,) = _get_struct_I().unpack(str[start:end])\\n _v13 = _v12.stamp\\n _x = _v13\\n start = end\\n end += 8\\n (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n _v12.frame_id = str[start:end].decode('utf-8')\\n else:\\n _v12.frame_id = str[start:end]\\n _x = val1\\n start = end\\n end += 28\\n (_x.AgentID, _x.targetNum1, _x.targetNum2, _x.targetNum3, _x.targetNum4, _x.staticpassNum, _x.staticcatchNum,) = _get_struct_7i().unpack(str[start:end])\\n _v14 = val1.pos\\n _x = _v14\\n start = end\\n end += 8\\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\\n _v15 = val1.heading\\n start = end\\n end += 4\\n (_v15.theta,) = _get_struct_f().unpack(str[start:end])\\n start = end\\n end += 4\\n (val1.vrot,) = _get_struct_f().unpack(str[start:end])\\n _v16 = val1.vtrans\\n _x = _v16\\n start = end\\n end += 8\\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\\n _x = val1\\n start = end\\n end += 9\\n (_x.iskick, _x.isvalid, _x.isstuck, _x.isdribble, _x.current_role, _x.role_time,) = _get_struct_5Bf().unpack(str[start:end])\\n val1.iskick = bool(val1.iskick)\\n val1.isvalid = bool(val1.isvalid)\\n val1.isstuck = bool(val1.isstuck)\\n val1.isdribble = bool(val1.isdribble)\\n _v17 = val1.target\\n _x = _v17\\n start = end\\n end += 8\\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\\n self.robotinfo.append(val1)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.ballinfo = []\\n for i in range(0, length):\\n val1 = nubot_common.msg.BallInfo()\\n _v18 = val1.header\\n start = end\\n end += 4\\n (_v18.seq,) = _get_struct_I().unpack(str[start:end])\\n _v19 = _v18.stamp\\n _x = _v19\\n start = end\\n end += 8\\n (_x.secs, _x.nsecs,) = _get_struct_2I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n _v18.frame_id = str[start:end].decode('utf-8')\\n else:\\n _v18.frame_id = str[start:end]\\n start = end\\n end += 4\\n (val1.ballinfostate,) = _get_struct_i().unpack(str[start:end])\\n _v20 = val1.pos\\n _x = _v20\\n start = end\\n end += 8\\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\\n _v21 = val1.real_pos\\n _x = _v21\\n start = end\\n end += 8\\n (_x.angle, _x.radius,) = _get_struct_2f().unpack(str[start:end])\\n _v22 = val1.velocity\\n _x = _v22\\n start = end\\n end += 8\\n (_x.x, _x.y,) = _get_struct_2f().unpack(str[start:end])\\n _x = val1\\n start = end\\n end += 2\\n (_x.pos_known, _x.velocity_known,) = _get_struct_2B().unpack(str[start:end])\\n val1.pos_known = bool(val1.pos_known)\\n val1.velocity_known = bool(val1.velocity_known)\\n self.ballinfo.append(val1)\\n _x = self\\n start = end\\n end += 12\\n (_x.coachinfo.header.seq, _x.coachinfo.header.stamp.secs, _x.coachinfo.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.coachinfo.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.coachinfo.header.frame_id = str[start:end]\\n _x = self\\n start = end\\n end += 54\\n (_x.coachinfo.MatchMode, _x.coachinfo.MatchType, _x.coachinfo.TestMode, _x.coachinfo.pointA.x, _x.coachinfo.pointA.y, _x.coachinfo.pointB.x, _x.coachinfo.pointB.y, _x.coachinfo.angleA, _x.coachinfo.angleB, _x.coachinfo.idA, _x.coachinfo.idB, _x.coachinfo.kickforce, _x.pass_cmd.pass_id, _x.pass_cmd.catch_id, _x.pass_cmd.pass_pt.x, _x.pass_cmd.pass_pt.y, _x.pass_cmd.catch_pt.x, _x.pass_cmd.catch_pt.y, _x.pass_cmd.is_passout, _x.pass_cmd.is_dynamic_pass, _x.pass_cmd.is_static_pass, _x.pass_cmd.is_valid,) = _get_struct_3B4f2h3B2I4f4B().unpack(str[start:end])\\n self.pass_cmd.is_passout = bool(self.pass_cmd.is_passout)\\n self.pass_cmd.is_dynamic_pass = bool(self.pass_cmd.is_dynamic_pass)\\n self.pass_cmd.is_static_pass = bool(self.pass_cmd.is_static_pass)\\n self.pass_cmd.is_valid = bool(self.pass_cmd.is_valid)\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) #most likely buffer underfill\",\n \"def refresh(self):\\n self.info = str(self.ser.readline())[2:-5].split(',')\\n self.x, self.y, self.z, self.xa, self.ya, self.za, self.o = self.info\",\n \"def _make_observation(self) -> Dict[str, np.ndarray]:\\n return {\\n \\\"cur_pos\\\": np.array([self.cur_pos], dtype=int),\\n }\",\n \"def __init__(self):\\n self._data = PositionalList() # list of Item instances\",\n \"def deserialize(self, str):\\n try:\\n if self.base is None:\\n self.base = rwrc12_msgs.msg.CellBase()\\n end = 0\\n _x = self\\n start = end\\n end += 12\\n (_x.base.header.seq, _x.base.header.stamp.secs, _x.base.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.base.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.base.header.frame_id = str[start:end]\\n _x = self\\n start = end\\n end += 20\\n (_x.base.cell_width, _x.base.cell_height, _x.base.position.x, _x.base.position.y, _x.base.position.z,) = _struct_5f.unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.base.points = []\\n for i in range(0, length):\\n val1 = geometry_msgs.msg.Point32()\\n _x = val1\\n start = end\\n end += 12\\n (_x.x, _x.y, _x.z,) = _struct_3f.unpack(str[start:end])\\n self.base.points.append(val1)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sf'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.base.intensity = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 1\\n (self.base.cost,) = _struct_b.unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.base.label = str[start:end].decode('utf-8')\\n else:\\n self.base.label = str[start:end]\\n _x = self\\n start = end\\n end += 8\\n (_x.mean_height, _x.mean_intensity,) = _struct_2f.unpack(str[start:end])\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) #most likely buffer underfill\",\n \"def __init__(self):\\n self.metadata = {}\\n self.geometry = {'array': None, \\n 'geom': None, \\n 'wkt': None}\",\n \"def __init__(self, data, startLat, startLon, delta, numX, numY):\\n self.data = data\\n self.startLat = startLat\\n self.startLon = startLon\\n self.delta = delta\\n self.xCells = numX\\n self.yCells = numY\",\n \"def _initialize_data(self):\\n self.reset_count = 0\\n self._idn_no_firmware = \\\"KEPCO,BOP 50-20,E1234,\\\"\\n self._firmware = 2.6\\n self._init_data()\",\n \"def _get_data(\\n self,\\n vis_hdu,\\n antenna_nums,\\n antenna_names,\\n ant_str,\\n bls,\\n frequencies,\\n freq_chans,\\n times,\\n time_range,\\n lsts,\\n lst_range,\\n polarizations,\\n blt_inds,\\n phase_center_ids,\\n catalog_names,\\n keep_all_metadata,\\n fix_old_proj,\\n fix_use_ant_pos,\\n ):\\n # figure out what data to read in\\n blt_inds, freq_inds, pol_inds, history_update_string = self._select_preprocess(\\n antenna_nums,\\n antenna_names,\\n ant_str,\\n bls,\\n frequencies,\\n freq_chans,\\n times,\\n time_range,\\n lsts,\\n lst_range,\\n polarizations,\\n blt_inds,\\n phase_center_ids,\\n catalog_names,\\n )\\n\\n if blt_inds is not None:\\n blt_frac = len(blt_inds) / float(self.Nblts)\\n else:\\n blt_frac = 1\\n\\n if freq_inds is not None:\\n freq_frac = len(freq_inds) * float(self.Nspws) / float(self.Nfreqs)\\n else:\\n freq_frac = 1\\n\\n if pol_inds is not None:\\n pol_frac = len(pol_inds) / float(self.Npols)\\n else:\\n pol_frac = 1\\n\\n min_frac = np.min([blt_frac, freq_frac, pol_frac])\\n\\n if min_frac == 1:\\n # no select, read in all the data\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :]\\n else:\\n # do select operations on everything except data_array, flag_array\\n # and nsample_array\\n self._select_by_index(\\n blt_inds, freq_inds, pol_inds, history_update_string, keep_all_metadata\\n )\\n\\n # just read in the right portions of the data and flag arrays\\n if blt_frac == min_frac:\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[blt_inds, :, :, :, :, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[blt_inds, :, :, :, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\\n if freq_frac < 1:\\n raw_data_array = raw_data_array[:, :, freq_inds, :, :]\\n if pol_frac < 1:\\n raw_data_array = raw_data_array[:, :, :, pol_inds, :]\\n elif freq_frac == min_frac:\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[:, :, :, :, freq_inds, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[:, :, :, freq_inds, :, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\\n\\n if blt_frac < 1:\\n raw_data_array = raw_data_array[blt_inds, :, :, :, :]\\n if pol_frac < 1:\\n raw_data_array = raw_data_array[:, :, :, pol_inds, :]\\n else:\\n if vis_hdu.header[\\\"NAXIS\\\"] == 7:\\n raw_data_array = vis_hdu.data.data[:, :, :, :, :, pol_inds, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :, :]\\n assert self.Nspws == raw_data_array.shape[1]\\n else:\\n # in many uvfits files the spw axis is left out,\\n # here we put it back in so the dimensionality stays the same\\n raw_data_array = vis_hdu.data.data[:, :, :, :, pol_inds, :]\\n raw_data_array = raw_data_array[:, 0, 0, :, :, :]\\n raw_data_array = raw_data_array[:, np.newaxis, :, :, :]\\n\\n if blt_frac < 1:\\n raw_data_array = raw_data_array[blt_inds, :, :, :, :]\\n if freq_frac < 1:\\n raw_data_array = raw_data_array[:, :, freq_inds, :, :]\\n\\n assert len(raw_data_array.shape) == 5\\n\\n # Reshape the data array to be the right size if we are working w/ multiple\\n # spectral windows to be 'flex_spw' compliant\\n if self.Nspws > 1:\\n raw_data_array = np.reshape(\\n raw_data_array,\\n (self.Nblts, 1, self.Nfreqs, self.Npols, raw_data_array.shape[4]),\\n )\\n\\n # FITS uvw direction convention is opposite ours and Miriad's.\\n # So conjugate the visibilities and flip the uvws:\\n self.data_array = (\\n raw_data_array[:, :, :, :, 0] - 1j * raw_data_array[:, :, :, :, 1]\\n )\\n self.flag_array = raw_data_array[:, :, :, :, 2] <= 0\\n self.nsample_array = np.abs(raw_data_array[:, :, :, :, 2])\\n\\n if fix_old_proj:\\n self.fix_phase(use_ant_pos=fix_use_ant_pos)\",\n \"def _prepare(self):\\n # Time list\\n self.time_list = []\\n # Distance array\\n if self._fxn[0] is True:\\n self.res_dists, self.res_keys = build_reslist_dict(self._rpl)\\n\\n # Distance between alpha carbons\\n if self._fxn[1] is True:\\n self.ca_dists, self.ca_keys = build_reslist_dict(self._rpl)\\n\\n # Distance between resid center of mass\\n if self._fxn[2] is True:\\n self.cm_dists, self.cm_keys = build_reslist_dict(self._rpl)\\n\\n # Distance between resid center of geometry\\n if self._fxn[3] is True:\\n self.cg_dists, self.cg_keys = build_reslist_dict(self._rpl)\",\n \"def func_init(self):\\n self.points.set_data([], [])\\n for line in self.lines:\\n line.set_data([],[])\\n self.annotation.set_text('')\\n\\n return tuple(self.lines) + (self.points, self.annotation)\",\n \"def __init__(self, data_id, course_fields, speed_fields, heading_fields,\\n wind_dir_fields, wind_speed_fields,\\n update_on_fields=None,\\n zero_line_reference=0,\\n convert_wind_factor=1,\\n convert_speed_factor=1,\\n output_nmea=False):\\n super().__init__(input_format=formats.Python_Record,\\n output_format=formats.Text)\\n self.data_id = data_id\\n self.course_fields = course_fields.split(',')\\n self.speed_fields = speed_fields.split(',')\\n self.heading_fields = heading_fields.split(',')\\n self.wind_dir_fields = wind_dir_fields.split(',')\\n self.wind_speed_fields = wind_speed_fields.split(',')\\n\\n if update_on_fields:\\n self.update_on_fields = update_on_fields.split(',')\\n else:\\n self.update_on_fields = self.wind_dir_fields\\n self.zero_line_reference = zero_line_reference\\n\\n self.convert_wind_factor = convert_wind_factor\\n self.convert_speed_factor = convert_speed_factor\\n self.output_nmea = output_nmea\\n \\n self.course_val = None\\n self.speed_val = None\\n self.heading_val = None\\n self.wind_dir_val = None\\n self.wind_speed_val = None\\n\\n self.last_timestamp = 0\",\n \"def _build_parsed_values(self):\\n\\n # \\n # Generate a velocity data particle.\\n # Note that raw_data already contains the individual fields\\n # extracted and unpacked from the velocity data record.\\n #\\n global flags\\n particle = []\\n field = 0\\n for flag in range(0, FLAG_RECORD_SIZE):\\n #\\n # If the flags indicated that this field is to be expected,\\n # store the next unpacked value into the data particle.\\n #\\n key = VEL3D_PARAMETERS[flag][INDEX_KEY]\\n if flags[flag]:\\n if flag == INDEX_FLAG_Time:\\n #\\n # This returns a tuple, but particle wants a list.\\n #\\n time_array = self.raw_data[field:field + OUTPUT_TIME_SIZE]\\n\\n particle.append({DataParticleKey.VALUE_ID: key,\\n DataParticleKey.VALUE: list(time_array)})\\n field += OUTPUT_TIME_SIZE\\n else:\\n particle.append({DataParticleKey.VALUE_ID: key,\\n DataParticleKey.VALUE: self.raw_data[field]})\\n field += 1\\n\\n #\\n # If flags indicate that this field is not present,\\n # output a value of None.\\n #\\n else:\\n particle.append({DataParticleKey.VALUE_ID: key,\\n DataParticleKey.VALUE: None})\\n\\n return particle\",\n \"def __init__(self):\\n self._distance_data = []\\n self._location_data = []\\n self._package_data = []\",\n \"def prepare_data(self, context_size, model_name):\\n self.context_size = context_size\\n data_x = []\\n data_y = []\\n oob = self.word2idx['OOB']\\n\\n for item in self.docs:\\n data = [oob] * context_size + self.doc2token(item) + [oob] * context_size #padding\\n for i in range(context_size, len(data) - context_size):\\n data_x.append(data[i - context_size: i] + data[i + 1: i + context_size + 1])\\n data_y.append(data[i])\\n \\n if model_name.lower() == 'skipgram':\\n data_x, data_y = data_y, data_x\\n self.data_x = Variable(torch.LongTensor(data_x))\\n self.data_y = Variable(torch.LongTensor(data_y))\\n logging.info(f'data preprocessed, data shape: {self.data_x.shape}, {self.data_y.shape}')\",\n \"def _build_accessor(bufferview, ele_type, comptype_id, count, max_vals, min_vals, byte_offset, normalized):\\n normalized = None if not normalized else normalized\\n\\n new_accessor = {\\n \\\"bufferView\\\": bufferview,\\n \\\"componentType\\\": comptype_id,\\n \\\"type\\\": ele_type,\\n \\\"count\\\": count,\\n }\\n\\n properties_keys = [\\\"byteOffset\\\", \\\"normalized\\\", \\\"max\\\", \\\"min\\\"]\\n properties_values = [byte_offset, normalized, max_vals, min_vals]\\n\\n for key, val in zip(properties_keys, properties_values):\\n if val is not None:\\n new_accessor[key] = val\\n\\n return new_accessor\",\n \"def init(self):\\n logger.info(mm_cnofs.ackn_str)\\n self.acknowledgements = mm_cnofs.ackn_str\\n self.references = '\\\\n'.join((mm_cnofs.refs['mission'],\\n mm_cnofs.refs['vefi']))\\n\\n return\",\n \"def _read_info(self):\\n my_filelines = self.file_lines\\n info = dict()\\n\\n for i, line in enumerate(my_filelines):\\n if line.startswith(\\\"VEHICLE\\\"):\\n vehicle_pro_start = i + 2\\n elif line.startswith(\\\"CUSTOMER\\\"):\\n customer_pro_start = i + 3\\n\\n elif line.startswith(\\\"NUMBER\\\"):\\n splited = line.split(' ')\\n info[splited[0]] = 0\\n info[splited[-1]] = 0\\n return info, (vehicle_pro_start, customer_pro_start)\",\n \"def _init():\\n line.set_data([], [])\\n return line,\",\n \"def build_data(self):\\n from desiutil.io import combine_dicts\\n # Loop on exposures\\n odict = {}\\n for qanight in self.qa_nights:\\n for qaexp in qanight.qa_exps:\\n # Get the exposure dict\\n idict = write_qa_exposure('foo', qaexp, ret_dict=True)\\n odict = combine_dicts(odict, idict)\\n # Finish\\n self.data = odict\",\n \"def init_data_array(self, mess = None): \\n if self.verbose > 1:\\n print(\\\"MultiLinearSpectra.init_data_array()\\\") \\n \\n if mess is None:\\n if self.mess is None:\\n warnings.warn(\\\"MultiLinearSpectra.init_data_array(): no data to initialize\\\")\\n return None\\n else:\\n self.mess = mess\\n \\n\\n \\n \\n for m in range(len(self.mess)):\\n \\n self.mess[m][\\\"index\\\"] = m\\n \\n kwargs = {}\\n for k, v in self.mess[m].items():\\n kwargs[k] = v\\n \\n if self.mess[m][\\\"class\\\"] == \\\"PASGas\\\" and flag_ST:\\n self.mess[m][\\\"object\\\"] = PASG.PASGas(verbose = self.verbose, **kwargs)\\n\\n elif self.mess[m][\\\"class\\\"] == \\\"PASLiquid\\\" and flag_ST:\\n self.mess[m][\\\"object\\\"] = PASL.PASLiquid(verbose = self.verbose, **kwargs)\\n\\n\\n # x_unit = self.mess[0].x_unit\\n # y_unit = self.mess[0].y_unit\\n\\n # for m in range(1, len(self.mess)):\\n # if x_unit != self.mess[m].x_unit:\\n # self.mess.x_unit\",\n \"def _setup_metadata(self):\\n # loom_metadata is what we use to pass all the information about\\n # the loom (max_depth, which typeshapes are supported, and the signatures of\\n # the LoomOps) to scheduler.cc\\n loom_metadata = loom_pb2.LoomMetadata()\\n loom_metadata.max_depth = self._max_depth\\n for ts, tensor_names in zip(\\n self._type_shapes, self._ts_idx_to_tensor_names):\\n type_shape_metadata = loom_metadata.type_shape_metadata.add()\\n type_shape_metadata.dtype = ts.dtype_enum\\n type_shape_metadata.shape.extend(ts.shape)\\n type_shape_metadata.tag = ts.tag\\n type_shape_metadata.name = str(ts) # Debug string.\\n type_shape_metadata.tensor_names.extend(tensor_names)\\n type_shape_metadata.is_batch_input = (\\n (ts in self._batch_inputs) or self._direct_feed_dict)\\n\\n for op_name, op in zip(self._loom_op_names, self._loom_ops):\\n op_metadata = loom_metadata.op_metadata.add()\\n op_metadata.name = op_name\\n op_metadata.input_ts_idx.extend(\\n self._type_shape_to_idx[ts] for ts in op.input_type_shapes)\\n op_metadata.output_ts_idx.extend(\\n self._type_shape_to_idx[ts] for ts in op.output_type_shapes)\\n\\n self._loom_metadata_str = (\\n loom_metadata.SerializeToString())\",\n \"def _read_header(self):\\n f = self._open(self.filename, 'rb')\\n idx = 0\\n header = b''\\n # reading the header \\n while idx < 13: \\n header += f.readline().rstrip() # removes the \\\"\\\\n\\\\r\\\" at the end\\n idx += 1\\n # \\\"magically\\\" compute the data offset\\n try:\\n self._offset_auto = ord(header[2]) + 1856\\n except:\\n self._offset_auto = header[2] + 1856\\n\\n\\n\\n header = header[:self._offset_auto+300] # add an extra random header for offset\\n header = re.sub(r'(?P<section>\\\\[[^\\\\]]+\\\\])', '\\\\n\\\\g<section>', header.decode('latin1'))\\n header = header.splitlines()[1:]\\n self.header = dict([self._header_sect2dict(line) for line in header])\\n self.shape = np.array(self.header['Acquisition']['areGRBScan'].split(',')[-2:]).astype(np.int)\\n f.close()\\n\\n offset_list = {'auto': self._offset_auto,\\n 'from_end': -np.prod(self.shape)*self._nbytes,\\n 'from_end_4k': - np.prod(self.shape)*self._nbytes - 4092}\\n\\n if self._offset_input in offset_list:\\n\\n self._offset_data = offset_list[self._offset_input]\\n if self._offset_input.startswith('from_end'):\\n # set the flag to seek from the end of the file.\\n self._offset_whence = 2\\n elif type(self._offset_input) is int:\\n self._offset_data = self._offset_input\\n else:\\n raise ValueError\\n\\n \\n\\n return self.header\",\n \"def __init__(self, keep_last_n_lines=5) :\\r\\n self.contextLines_ = keep_last_n_lines\\r\\n self.data_ = CircularBuffer(1024)\\r\\n self.lineNumber_ = 1\\r\\n self.charNumber_ = 0\",\n \"def calculate_module_offsets(self):\\n \\n # These aren't for instantiating, but we use them to get the dimensions\\n self.poly_contact_offset = vector(0.5*contact.poly.width,0.5*contact.poly.height)\\n\\n # M1/M2 routing pitch is based on contacted pitch\\n self.m1_pitch = max(contact.m1m2.width,contact.m1m2.height) + max(self.m1_space,self.m2_space)\\n self.m2_pitch = max(contact.m2m3.width,contact.m2m3.height) + max(self.m2_space,self.m3_space)\\n \\n # This corrects the offset pitch difference between M2 and M1\\n self.offset_fix = vector(0.5*(self.m2_width-self.m1_width),0)\\n\\n # delay chain will be rotated 90, so move it over a width\\n # we move it up a inv height just for some routing room\\n self.rbl_inv_offset = vector(self.delay_chain.height, self.inv.width)\\n # access TX goes right on top of inverter, leave space for an inverter which is\\n # about the same as a TX. We'll need to add rails though.\\n self.access_tx_offset = vector(1.25*self.inv.height,self.rbl_inv_offset.y) + vector(0,2.5*self.inv.width)\\n self.delay_chain_offset = self.rbl_inv_offset + vector(0,4*self.inv.width)\\n\\n # Replica bitline and such are not rotated, but they must be placed far enough\\n # away from the delay chain/inverter with space for three M2 tracks\\n self.bitcell_offset = self.rbl_inv_offset + vector(2*self.m2_pitch, 0) + vector(0, self.bitcell.height + self.inv.width)\\n\\n self.rbl_offset = self.bitcell_offset\\n\\n \\n self.height = self.rbl_offset.y + self.rbl.height + self.m2_pitch\\n self.width = self.rbl_offset.x + self.bitcell.width\",\n \"def __init__(self, extra_fields=None):\\n if extra_fields:\\n self.fields.extend(extra_fields)\\n self.data = {k: [] for k in self.fields}\\n self.last_r = 0.0\",\n \"def _nanosims_header(self, hdr):\\n # Called MaskNano in OpenMIMS; BFieldTab separated out; create extra sub-dict PeakCenter\\n d = {}\\n d['PeakCenter'] = {}\\n d['nanosimsheader version'], d['regulation mode'], d['mode'], \\\\\\n d['grain mode'], d['semigraphic mode'], d['stage delta x'], \\\\\\n d['stage delta y'], d['working frame width'], \\\\\\n d['working frame height'], d['scanning frame x'], \\\\\\n d['scanning frame width'], d['scanning frame y'], \\\\\\n d['scanning frame height'], d['counting frame x start'], \\\\\\n d['counting frame x end'], d['counting frame y start'], \\\\\\n d['counting frame y end'], d['detector type'], d['electron scan'], \\\\\\n d['scanning mode'], d['beam blanking'], \\\\\\n d['PeakCenter']['peakcenter enabled'], d['PeakCenter']['start'], \\\\\\n d['PeakCenter']['frequency'], d['b fields'] = \\\\\\n unpack(self._bo + '25i', hdr.read(100))\\n\\n d['PeakCenter']['peakcenter enabled'] = bool(d['PeakCenter']['peakcenter enabled'])\\n d['regulation mode'] = bool(d['regulation mode'])\\n d['grain mode'] = bool(d['grain mode'])\\n d['semigraphic mode'] = bool(d['semigraphic mode'])\\n d['scanning mode'] = bool(d['scanning mode'])\\n\\n # Set a few extra variables.\\n d['counting frame width'] = d['counting frame x end'] - d['counting frame x start'] + 1\\n d['counting frame height'] = d['counting frame y end'] - d['counting frame y start'] + 1\\n\\n # Found in at least one version (file v11, nsHeader v8) a repeat of\\n # Poly_list and this first part of nanoSIMSHeader. Total of repeat\\n # adds up to 288. After last Poly_list, 288 byte padding zone, not all\\n # null-bytes.\\n hdr.seek(288, 1)\\n\\n # Is this the nPrintRed from OpenMIMS?\\n d['print results'] = bool(unpack(self._bo + 'i', hdr.read(4))[0])\\n\\n d['SibCenterHor'] = self._sib_center(hdr)\\n d['SibCenterVert'] = self._sib_center(hdr)\\n\\n # Duplicate and store these two in sub dicts\\n b_field_index, has_sib_center = \\\\\\n unpack(self._bo + '2i', hdr.read(8))\\n if b_field_index < 0:\\n b_field_index = None\\n has_sib_center = bool(has_sib_center)\\n\\n d['SibCenterHor']['b field index'] = b_field_index\\n d['SibCenterVert']['b field index'] = b_field_index\\n d['SibCenterHor']['sib center enabled'] = has_sib_center\\n d['SibCenterVert']['sib center enabled'] = has_sib_center\\n\\n d['EnergyCenter'] = self._energy_center(hdr)\\n d['E0SCenter'] = self._e0s_center(hdr)\\n\\n d['EnergyCenter']['wait time'], d['presputtering raster'], \\\\\\n d['PeakCenter']['E0P offset'], d['E0SCenter']['steps'], \\\\\\n d['baseline measurement'], d['baseline offset'], \\\\\\n d['baseline frequency'] = \\\\\\n unpack(self._bo + '5i d i', hdr.read(32))\\n return d\",\n \"def _create_dnp3_object_map(self):\\n\\n feeders = self.file_dict.get(\\\"feeders\\\", [])\\n measurements = list()\\n capacitors = list()\\n regulators = list()\\n switches = list()\\n solarpanels = list()\\n batteries = list()\\n fuses = list()\\n breakers = list()\\n reclosers = list()\\n energyconsumers = list()\\n for x in feeders:\\n measurements = x.get(\\\"measurements\\\", [])\\n capacitors = x.get(\\\"capacitors\\\", [])\\n regulators = x.get(\\\"regulators\\\", [])\\n switches = x.get(\\\"switches\\\", [])\\n solarpanels = x.get(\\\"solarpanels\\\", [])\\n batteries = x.get(\\\"batteries\\\", [])\\n fuses = x.get(\\\"fuses\\\", [])\\n breakers = x.get(\\\"breakers\\\", [])\\n reclosers = x.get(\\\"reclosers\\\", [])\\n energyconsumers = x.get(\\\"energyconsumers\\\", [])\\n\\n # Unique grouping of measurements - GroupBy Name, Type and Connectivity node\\n groupByNameTypeConNode = defaultdict(list) \\n for m in measurements:\\n groupByNameTypeConNode[m['name']+m.get(\\\"measurementType\\\")+m.get(\\\"ConnectivityNode\\\")].append(m)\\n\\n # Create Net Phase DNP3 Points\\n for grpM in groupByNameTypeConNode.values():\\n\\n if grpM[0]['MeasurementClass'] == \\\"Analog\\\" and grpM[0].get(\\\"measurementType\\\") == \\\"VA\\\":\\n measurement_type = grpM[0].get(\\\"measurementType\\\")\\n measurement_id = m.get(\\\"mRID\\\")\\n \\n\\n name1 = grpM[0]['name'] + '-' + \\\"Phases:ABC\\\" + '-net-VAR-value'\\n name2 = grpM[0]['name'] + '-' + \\\"Phases:ABC\\\" + '-net-Watts-value'\\n name3 = grpM[0]['name'] + '-' + \\\"Phases:ABC\\\" + '-net-VA-value'\\n\\n description1 = \\\"Name:\\\" + grpM[0]['name'] + \\\",MeasurementType:\\\" + \\\"net-VAR\\\" + \\\",ConnectivityNode:\\\" + grpM[0].get(\\\"ConnectivityNode\\\") +\\\",SimObject:\\\" + grpM[0].get(\\\"SimObject\\\")\\n description2 = \\\"Name:\\\" + grpM[0]['name'] + \\\",MeasurementType:\\\" + \\\"net-Watts\\\" + \\\",ConnectivityNode:\\\" + grpM[0].get(\\\"ConnectivityNode\\\") +\\\",SimObject:\\\" + grpM[0].get(\\\"SimObject\\\")\\n description3 = \\\"Name:\\\" + grpM[0]['name'] + \\\",MeasurementType:\\\" + \\\"net-VA\\\" + \\\",ConnectivityNode:\\\" + grpM[0].get(\\\"ConnectivityNode\\\") +\\\",SimObject:\\\" + grpM[0].get(\\\"SimObject\\\")\\n\\n self.assign_val_a(\\\"AI\\\", 30, 1, self.c_ai, name1, description1, measurement_type, measurement_id)\\n self.c_ai += 1\\n self.assign_val_a(\\\"AI\\\", 30, 1, self.c_ai, name2, description2, measurement_type, measurement_id)\\n self.c_ai += 1\\n self.assign_val_a(\\\"AI\\\", 30, 1, self.c_ai, name3, description3, measurement_type, measurement_id)\\n self.c_ai += 1\\n\\n # Create Each Phase DNP3 Points\\n for m in measurements:\\n attribute = attribute_map['regulators']['attribute']\\n measurement_type = m.get(\\\"measurementType\\\")\\n measurement_id = m.get(\\\"mRID\\\")\\n name= m['name'] + '-' + m['phases']\\n description = \\\"Name:\\\" + m['name'] + \\\",Phase:\\\" + m['phases'] + \\\",MeasurementType:\\\" + measurement_type + \\\",ConnectivityNode:\\\" + m.get(\\\"ConnectivityNode\\\") +\\\",SimObject:\\\" + m.get(\\\"SimObject\\\")\\n if m['MeasurementClass'] == \\\"Analog\\\":\\n self.assign_val_a(\\\"AI\\\", 30, 1, self.c_ai, name, description, measurement_type, measurement_id)\\n self.c_ai += 1\\n\\n if m.get(\\\"measurementType\\\") == \\\"VA\\\":\\n measurement_id = m.get(\\\"mRID\\\")\\n name1 = m['name'] + '-' + m['phases'] + '-VAR-value'\\n name2 = m['name'] + '-' + m['phases'] + '-Watts-value'\\n name3 = m['name'] + '-' + m['phases'] + '-angle'\\n\\n description1 = \\\"Name:\\\" + m['name'] + \\\",Phase:\\\" + m['phases'] + \\\",MeasurementType:\\\" + \\\"VAR\\\" + \\\",ConnectivityNode:\\\" + m.get(\\\"ConnectivityNode\\\") +\\\",SimObject:\\\" + m.get(\\\"SimObject\\\")\\n description2 = \\\"Name:\\\" + m['name'] + \\\",Phase:\\\" + m['phases'] + \\\",MeasurementType:\\\" + \\\"Watt\\\" + \\\",ConnectivityNode:\\\" + m.get(\\\"ConnectivityNode\\\") +\\\",SimObject:\\\" + m.get(\\\"SimObject\\\")\\n description3 = \\\"Name:\\\" + m['name'] + \\\",Phase:\\\" + m['phases'] + \\\",MeasurementType:\\\" + \\\"angle\\\" + \\\",ConnectivityNode:\\\" + m.get(\\\"ConnectivityNode\\\") + \\\",SimObject:\\\" + m.get(\\\"SimObject\\\")\\n if m['MeasurementClass'] == \\\"Analog\\\":\\n self.assign_val_a(\\\"AI\\\", 30, 1, self.c_ai, name1, description1, measurement_type, measurement_id)\\n self.c_ai += 1\\n self.assign_val_a(\\\"AI\\\", 30, 1, self.c_ai, name2, description2, measurement_type, measurement_id)\\n self.c_ai += 1\\n self.assign_val_a(\\\"AI\\\", 30, 1, self.c_ai, name3, description3, measurement_type, measurement_id)\\n self.c_ai += 1\\n\\n\\n elif m['MeasurementClass'] == \\\"Discrete\\\" and measurement_type == \\\"Pos\\\":\\n if \\\"RatioTapChanger\\\" in m['name'] or \\\"reg\\\" in m[\\\"SimObject\\\"]:\\n # TODO: Do we need step?\\n for r in range(5, 7): # [r==4]: Step, [r==5]: LineDropR, [r==6]:LineDropX \\n self.assign_val_d(\\\"AO\\\", 42, 3, self.c_ao, name, description, measurement_id, attribute[r])\\n self.c_ao += 1\\n else:\\n self.assign_val_a(\\\"DI\\\", 1, 2, self.c_di, name, description, measurement_type, measurement_id)\\n self.c_di += 1\\n\\n for m in capacitors:\\n measurement_id = m.get(\\\"mRID\\\")\\n cap_attribute = attribute_map['capacitors']['attribute'] # type: List[str]\\n\\n for l in range(0, 4):\\n # publishing attribute value for capacitors as Bianry/Analog Input points based on phase attribute\\n name = m['name']\\n description = \\\"Name:\\\" + m['name'] + \\\"ConductingEquipment_type:LinearShuntCompensator\\\" + \\\",Attribute:\\\" + cap_attribute[l] + \\\",Phase:\\\" + m['phases']\\n self.assign_val_d(\\\"AO\\\", 42, 3, self.c_ao, name, description, measurement_id, cap_attribute[l])\\n self.c_ao += 1\\n for p in range(0, len(m['phases'])):\\n name = m['name'] + m['phases'][p]\\n description = \\\"Name:\\\" + m['name'] + \\\",ConductingEquipment_type:LinearShuntCompensator\\\" + \\\",controlAttribute:\\\" + cap_attribute[p] + \\\",Phase:\\\" + m['phases'][p]\\n # description = \\\"Capacitor, \\\" + m['name'] + \\\",\\\" + \\\"phase -\\\" + m['phases'][p] + \\\", and attribute is - \\\" + cap_attribute[4]\\n self.assign_val_d(\\\"DO\\\", 12, 1, self.c_do, name, description, measurement_id, cap_attribute[4])\\n self.c_do += 1\\n\\n for m in regulators:\\n reg_attribute = attribute_map['regulators']['attribute']\\n # bank_phase = list(m['bankPhases'])\\n for n in range(0, 4):\\n measurement_id = m.get(\\\"mRID\\\")\\n name = m['bankName'] + '-' + m['bankPhases']\\n description = \\\"Name:\\\" + m['bankName'] + \\\",ConductingEquipment_type:RatioTapChanger_Reg\\\" +\\\",Phase:\\\" + m['bankPhases'] + \\\",Attribute:\\\" + reg_attribute[n]\\n self.assign_val_d(\\\"AO\\\", 42, 3, self.c_ao, name, description, measurement_id[0], reg_attribute[n])\\n self.c_ao += 1\\n self.assign_val_d(\\\"AI\\\", 30, 1, self.c_ai, name, description, measurement_id[0], reg_attribute[n])\\n self.c_ai += 1\\n for i in range(5, 7):\\n for j in range(0, len(m['bankPhases'])):\\n measurement_id = m.get(\\\"mRID\\\")[j]\\n name = m['tankName'][j] + '-' + m['bankPhases'][j]\\n description = \\\"Name:\\\" + m['tankName'][j] + \\\",ConductingEquipment_type:RatioTapChanger_Reg\\\"+ \\\",Phase:\\\" + m['bankPhases'][j] + \\\",controlAttribute:\\\" + reg_attribute[i]\\n self.assign_val_d(\\\"AO\\\", 42, 3, self.c_ao, name, description, measurement_id,reg_attribute[i])\\n self.c_ao += 1\\n self.assign_val_d(\\\"AI\\\", 30, 1, self.c_ai, name, description, measurement_id,reg_attribute[i])\\n self.c_ai += 1\\n \\n for m in solarpanels:\\n for k in range(0, len(m['phases'])):\\n measurement_id = m.get(\\\"mRID\\\")\\n name = \\\"Solar\\\" + m['name'] + '-' + m['phases'][k] + '-Watts-value'\\n description = \\\"Solarpanel:\\\" + m['name'] + \\\",Phase:\\\" + m['phases'] + \\\",measurementID:\\\" + measurement_id\\n self.assign_val_d(\\\"AO\\\", 42, 3, self.c_ao, name, description, measurement_id, \\\"PowerElectronicsConnection.p\\\")\\n self.c_ao += 1\\n \\n name1 = \\\"Solar\\\" + m['name'] + '-' + m['phases'][k] + '-VAR-value'\\n self.assign_val_d(\\\"AO\\\", 42, 3, self.c_ao, name1, description, measurement_id, \\\"PowerElectronicsConnection.q\\\")\\n self.c_ao += 1\\n \\n name2 = \\\"Solar\\\" + m['name'] + '-' + m['phases'][k] + '-VAR-Net-value'\\n self.assign_val_d(\\\"AO\\\", 42, 3, self.c_ao, name2, description, measurement_id, \\\"PowerElectronicsConnection.q\\\")\\n self.c_ao += 1\\n \\n name3 = \\\"Solar\\\"+ m['name'] + '-' + m['phases'][k] + '-Watts-Net-value'\\n self.assign_val_d(\\\"AO\\\", 42, 3, self.c_ao, name3, description, measurement_id, \\\"PowerElectronicsConnection.p\\\")\\n self.c_ao += 1\\n\\t\\t\\t\\n for m in batteries:\\n for l in range(0, len(m['phases'])):\\n measurement_id = m.get(\\\"mRID\\\")\\n name = m['name'] + '-' + m['phases'][l] + '-Watts-value'\\n description = \\\"Battery, \\\" + m['name'][l] + \\\",Phase: \\\" + m['phases'] + \\\",ConductingEquipment_type:PowerElectronicConnections\\\"\\n self.assign_val_d(\\\"AO\\\", 42, 3, self.c_ao, name, description,measurement_id, \\\"PowerElectronicsConnection.p\\\")\\n self.c_ao += 1\\n name1 = m['name'] + '-' + m['phases'][l] + '-VAR-value'\\n self.assign_val_d(\\\"AO\\\", 42, 3, self.c_ao, name1, description,measurement_id, \\\"PowerElectronicsConnection.q\\\")\\n self.c_ao += 1\\n \\n for m in switches:\\n measurement_id = m.get(\\\"mRID\\\")\\n switch_attribute = attribute_map['switches']['attribute']\\n for k in range(0, len(m['phases'])):\\n phase_value = list(m['phases'])\\n name = m['name'] + \\\"Phase:\\\" + m['phases'][k]\\n description = \\\"Name:\\\" + m[\\\"name\\\"] + \\\",ConductingEquipment_type:LoadBreakSwitch\\\" + \\\"Phase:\\\" + phase_value[k] +\\\",controlAttribute:\\\"+switch_attribute\\n self.assign_val_d(\\\"DO\\\", 12, 1, self.c_do, name, description, measurement_id, switch_attribute)\\n self.c_do += 1\\n\\n for m in fuses:\\n measurement_id = m.get(\\\"mRID\\\")\\n switch_attribute = attribute_map['switches']['attribute']\\n for l in range(0, len(m['phases'])):\\n phase_value = list(m['phases'])\\n name = m['name'] + \\\"Phase:\\\" + m['phases'][l]\\n description = \\\"Name:\\\" + m[\\\"name\\\"] + \\\",Phase:\\\" + phase_value[l] + \\\",Attribute:\\\" + switch_attribute + \\\",mRID\\\" + measurement_id\\n self.assign_val_d(\\\"DO\\\", 12, 1, self.c_do, name, description, measurement_id, switch_attribute)\\n self.c_do += 1\\n\\n for m in breakers:\\n measurement_id = m.get(\\\"mRID\\\")\\n switch_attribute = attribute_map['switches']['attribute']\\n for n in range(0, len(m['phases'])):\\n phase_value = list(m['phases'])\\n name = m['name'] + \\\"Phase:\\\" + m['phases'][n]\\n description = \\\"Name: \\\" + m[\\\"name\\\"] + \\\",Phase:\\\" + phase_value[n] + \\\",ConductingEquipment_type:Breaker\\\" + \\\",controlAttribute:\\\" + switch_attribute\\n self.assign_val_d(\\\"DO\\\", 12, 1, self.c_do, name, description, measurement_id, switch_attribute)\\n self.c_do += 1\\n \\n for m in reclosers:\\n measurement_id = m.get(\\\"mRID\\\")\\n switch_attribute = attribute_map['switches']['attribute']\\n for i in range(0, len(m['phases'])):\\n phase_value = list(m['phases'])\\n name = m['name'] + \\\"Phase:\\\" + m['phases'][i]\\n description = \\\"Recloser, \\\" + m[\\\"name\\\"] + \\\"Phase: - \\\" + phase_value[i] + \\\",ConductingEquipment_type:Recloser\\\"+\\\"controlAttribute:\\\" + switch_attribute\\n self.assign_val_d(\\\"DO\\\", 12, 1, self.c_do, name, description, measurement_id, switch_attribute)\\n self.c_do += 1\\n\\n for m in energyconsumers:\\n measurement_id = m.get(\\\"mRID\\\")\\n for k in range(0, len(m['phases'])):\\n phase_value = list(m['phases'])\\n name = m['name']+\\\"phase:\\\" + m['phases'][k]\\n description = \\\"EnergyConsumer, \\\" + m[\\\"name\\\"] + \\\"Phase: \\\" + phase_value[k] \\n self.assign_val_d(\\\"AO\\\", 42, 3, self.c_ao, name, description, measurement_id, \\\"EnergyConsumer.p\\\")\\n self.c_ao += 1\\n \\n name1 = m['name']+\\\"phase:\\\" + m['phases'][k] + \\\"control\\\"\\n self.assign_val_d(\\\"DO\\\", 12, 1, self.c_do, name1, description, measurement_id, \\\"EnergyConsumer.p\\\")\\n self.c_do += 1\\n\\n return self.out_json\",\n \"def _populate(self):\\n if not hasattr(self, 'multiline'):\\n start = self.start\\n end = self.end\\n txt = self.filetext\\n self.start_line = txt.count('\\\\n', 0, start) + 1\\n self.start_column = start - txt.rfind('\\\\n', 0, start) - 1\\n self.end_line = txt.count('\\\\n', start, end) + self.start_line\\n self.end_column = end - txt.rfind('\\\\n', 0, end) - 1\\n self.multiline = self.start_line != self.end_line\",\n \"def build_parts_from_dict(self, data, skip_power_controls=False):\\n \\n # Validate Objects information.\\n if \\\"Objects\\\" not in data:\\n return\\n\\n # Start creating parts.\\n parts = []\\n for part_data in data[\\\"Objects\\\"]:\\n part = part_data[\\\"ObjectID\\\"].replace(\\\"^\\\", \\\"\\\")\\n timestamp = part_data[\\\"Timestamp\\\"]\\n user_data = part_data[\\\"UserData\\\"]\\n part_position = part_data[\\\"Position\\\"]\\n up_vec = part_data[\\\"Up\\\"]\\n at_vec = part_data[\\\"At\\\"]\\n # Build the item.\\n item = self.build_item(\\n part,\\n timestamp,\\n user_data,\\n part_position,\\n up_vec,\\n at_vec,\\n skip_power_controls\\n )\\n parts.append(item)\\n\\n return parts\",\n \"def __build__(self,data_index=0):\\n \\n super(Image,self).__build__()\\n # -- How to read the image\\n self._build_properties = dict(\\n data_index = data_index,\\n header_exptime = \\\"EXPTIME\\\",\\n dataslice0=\\\"undefined\\\",\\n dataslice1=\\\"undefined\\\",\\n bkgdbox={\\\"bh\\\":100,\\\"bw\\\":100,\\\"fh\\\":3,\\\"fw\\\":3},\\n )\",\n \"def _build_parsed_values(self):\\n\\n SERIAL_NUMBER = \\\"SerialNumber\\\"\\n CALIBRATION = \\\"Calibration\\\"\\n ID = \\\"id\\\"\\n TEMPERATURE_SENSOR_ID = \\\"Main Temperature\\\"\\n CONDUCTIVITY_SENSOR_ID = \\\"Main Conductivity\\\"\\n PRESSURE_SENSOR_ID = \\\"Main Pressure\\\"\\n VOLT0 = \\\"Volt 0\\\"\\n VOLT1 = \\\"Volt 1\\\"\\n VOLT2 = \\\"Volt 2\\\"\\n VOLT3 = \\\"Volt 3\\\"\\n VOLT4 = \\\"Volt 4\\\"\\n VOLT5 = \\\"Volt 5\\\"\\n EXTERNAL_FREQUENCY_CHANNEL = \\\"external frequency channel\\\"\\n\\n # check to make sure there is a correct match before continuing\\n match = SBE19CalibrationParticle.regex_compiled().match(self.raw_data)\\n if not match:\\n raise SampleException(\\\"No regex match of parsed calibration data: [%s]\\\" %\\n self.raw_data)\\n\\n dom = parseString(self.raw_data)\\n root = dom.documentElement\\n log.debug(\\\"root.tagName = %s\\\", root.tagName)\\n serial_number = root.getAttribute(SERIAL_NUMBER)\\n result = [{DataParticleKey.VALUE_ID: SBE19CalibrationParticleKey.SERIAL_NUMBER,\\n DataParticleKey.VALUE: serial_number}]\\n\\n calibration_elements = self._extract_xml_elements(root, CALIBRATION)\\n for calibration in calibration_elements:\\n id_attr = calibration.getAttribute(ID)\\n if id_attr == TEMPERATURE_SENSOR_ID:\\n result.append(\\n self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TEMP_SENSOR_SERIAL_NUMBER, str))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TEMP_CAL_DATE, str))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TA0))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TA1))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TA2))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TA3))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.TOFFSET))\\n elif id_attr == CONDUCTIVITY_SENSOR_ID:\\n result.append(\\n self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.COND_SENSOR_SERIAL_NUMBER, str))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.COND_CAL_DATE, str))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CONDG))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CONDH))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CONDI))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CONDJ))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CPCOR))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CTCOR))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.CSLOPE))\\n elif id_attr == PRESSURE_SENSOR_ID:\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PRES_SERIAL_NUMBER, str))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PRES_CAL_DATE, str))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PA0))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PA1))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PA2))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCA0))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCA1))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCA2))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCB0))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCB1))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTCB2))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTEMPA0))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTEMPA1))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PTEMPA2))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.POFFSET))\\n result.append(\\n self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.PRES_RANGE, self.float_to_int))\\n elif id_attr == VOLT0:\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT0_OFFSET))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT0_SLOPE))\\n elif id_attr == VOLT1:\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT1_OFFSET))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT1_SLOPE))\\n elif id_attr == VOLT2:\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT2_OFFSET))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT2_SLOPE))\\n elif id_attr == VOLT3:\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT3_OFFSET))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT3_SLOPE))\\n elif id_attr == VOLT4:\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT4_OFFSET))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT4_SLOPE))\\n elif id_attr == VOLT5:\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT5_OFFSET))\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_VOLT5_SLOPE))\\n elif id_attr == EXTERNAL_FREQUENCY_CHANNEL:\\n result.append(self._get_xml_parameter(calibration, SBE19CalibrationParticleKey.EXT_FREQ))\\n\\n return result\",\n \"def _build_parsed_values(self):\\n\\n # \\n # Generate a time data particle.\\n # Note that raw_data already contains the individual fields\\n # extracted and unpacked from the time data record.\\n #\\n particle = [\\n {\\n DataParticleKey.VALUE_ID: \\n Vel3dKWfpStcTimeDataParticleKey.TIME_ON, \\n DataParticleKey.VALUE: self.raw_data[INDEX_TIME_ON]\\n },\\n {\\n DataParticleKey.VALUE_ID: \\n Vel3dKWfpStcTimeDataParticleKey.TIME_OFF,\\n DataParticleKey.VALUE: self.raw_data[INDEX_TIME_OFF]\\n },\\n {\\n DataParticleKey.VALUE_ID: \\n Vel3dKWfpStcTimeDataParticleKey.NUMBER_OF_RECORDS, \\n DataParticleKey.VALUE: self.raw_data[INDEX_RECORDS]\\n }\\n ]\\n\\n return particle\",\n \"def __init__(self):\\n self._data = PositionalList()\",\n \"def __init__(self):\\n self._data = PositionalList()\",\n \"def init_meta(self):\\n meta = {}\\n # Required (core)\\n meta['ra'] = dict(ext=0, card='OBJRA')\\n meta['dec'] = dict(ext=0, card='OBJDEC')\\n meta['target'] = dict(ext=0, card='OBJECT')\\n meta['decker'] = dict(ext=0, card='ALAPRTNM')\\n meta['binning'] = dict(card=None, compound=True)\\n\\n meta['mjd'] = dict(ext=0, card=None, compound=True)\\n meta['exptime'] = dict(ext=0, card='EXPTIME')\\n meta['airmass'] = dict(ext=0, card='AIRMASS')\\n # Extras for config and frametyping\\n meta['dispname'] = dict(ext=0, card='ALGRNM')\\n meta['idname'] = dict(ext=0, card='IMAGETYP')\\n # Lamps\\n # Use Keck/LRIS approach\\n\\n # Ingest\\n self.meta = meta\",\n \"def _build_parsed_values(self):\\r\\n # match the data inside the wrapper\\r\\n if len(self.raw_data) < ACCEL_BYTES or self.raw_data[0] != ACCEL_ID:\\r\\n raise SampleException(\\\"MopakODclAccelParserDataParticle: Not enough bytes provided in [%s]\\\",\\r\\n self.raw_data)\\r\\n fields = struct.unpack('>fffffffffI', self.raw_data[1:ACCEL_BYTES - 2])\\r\\n\\r\\n result = [self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ACCELX, fields[0], float),\\r\\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ACCELY, fields[1], float),\\r\\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ACCELZ, fields[2], float),\\r\\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ANG_RATEX, fields[3], float),\\r\\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ANG_RATEY, fields[4], float),\\r\\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_ANG_RATEZ, fields[5], float),\\r\\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_MAGX, fields[6], float),\\r\\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_MAGY, fields[7], float),\\r\\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_MAGZ, fields[8], float),\\r\\n self._encode_value(MopakODclAccelParserDataParticleKey.MOPAK_TIMER, fields[9], int)]\\r\\n\\r\\n return result\",\n \"def create_observation(self):\",\n \"def create_observation(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6157046","0.6072608","0.58471173","0.58050644","0.57371134","0.5713524","0.5703575","0.5679709","0.56751573","0.5645145","0.5609161","0.5597858","0.5583448","0.556738","0.55536085","0.5551123","0.5549294","0.5537869","0.5534043","0.55129117","0.55097","0.54995054","0.54811347","0.54799044","0.54686415","0.5433186","0.5424546","0.5421587","0.54006356","0.539491","0.5390095","0.5385168","0.53821373","0.5378212","0.5368411","0.53660816","0.5365773","0.5364958","0.5364525","0.53469825","0.5344724","0.5340566","0.53395283","0.533932","0.53388256","0.5336162","0.53319293","0.5330364","0.5319766","0.53186613","0.53157556","0.5311225","0.5307367","0.53037626","0.5297951","0.5290392","0.5287088","0.5282958","0.52800566","0.52773386","0.5276146","0.5270409","0.5268794","0.52658683","0.5262592","0.5259623","0.52594256","0.525852","0.52580935","0.5252423","0.5251241","0.52380085","0.5229968","0.52269745","0.5217946","0.5204737","0.5204122","0.5201803","0.51947206","0.5192479","0.51877606","0.51836234","0.5183403","0.51825905","0.5179669","0.5172083","0.51702887","0.516931","0.5166824","0.5165168","0.51647574","0.516351","0.51628596","0.51578915","0.5155275","0.51543987","0.51543987","0.5145753","0.5145331","0.51435316","0.51435316"],"string":"[\n \"0.6157046\",\n \"0.6072608\",\n \"0.58471173\",\n \"0.58050644\",\n \"0.57371134\",\n \"0.5713524\",\n \"0.5703575\",\n \"0.5679709\",\n \"0.56751573\",\n \"0.5645145\",\n \"0.5609161\",\n \"0.5597858\",\n \"0.5583448\",\n \"0.556738\",\n \"0.55536085\",\n \"0.5551123\",\n \"0.5549294\",\n \"0.5537869\",\n \"0.5534043\",\n \"0.55129117\",\n \"0.55097\",\n \"0.54995054\",\n \"0.54811347\",\n \"0.54799044\",\n \"0.54686415\",\n \"0.5433186\",\n \"0.5424546\",\n \"0.5421587\",\n \"0.54006356\",\n \"0.539491\",\n \"0.5390095\",\n \"0.5385168\",\n \"0.53821373\",\n \"0.5378212\",\n \"0.5368411\",\n \"0.53660816\",\n \"0.5365773\",\n \"0.5364958\",\n \"0.5364525\",\n \"0.53469825\",\n \"0.5344724\",\n \"0.5340566\",\n \"0.53395283\",\n \"0.533932\",\n \"0.53388256\",\n \"0.5336162\",\n \"0.53319293\",\n \"0.5330364\",\n \"0.5319766\",\n \"0.53186613\",\n \"0.53157556\",\n \"0.5311225\",\n \"0.5307367\",\n \"0.53037626\",\n \"0.5297951\",\n \"0.5290392\",\n \"0.5287088\",\n \"0.5282958\",\n \"0.52800566\",\n \"0.52773386\",\n \"0.5276146\",\n \"0.5270409\",\n \"0.5268794\",\n \"0.52658683\",\n \"0.5262592\",\n \"0.5259623\",\n \"0.52594256\",\n \"0.525852\",\n \"0.52580935\",\n \"0.5252423\",\n \"0.5251241\",\n \"0.52380085\",\n \"0.5229968\",\n \"0.52269745\",\n \"0.5217946\",\n \"0.5204737\",\n \"0.5204122\",\n \"0.5201803\",\n \"0.51947206\",\n \"0.5192479\",\n \"0.51877606\",\n \"0.51836234\",\n \"0.5183403\",\n \"0.51825905\",\n \"0.5179669\",\n \"0.5172083\",\n \"0.51702887\",\n \"0.516931\",\n \"0.5166824\",\n \"0.5165168\",\n \"0.51647574\",\n \"0.516351\",\n \"0.51628596\",\n \"0.51578915\",\n \"0.5155275\",\n \"0.51543987\",\n \"0.51543987\",\n \"0.5145753\",\n \"0.5145331\",\n \"0.51435316\",\n \"0.51435316\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":194,"cells":{"query":{"kind":"string","value":"write the cutouts for the specified type"},"document":{"kind":"string","value":"def _write_psf_cutouts_hst(self):\n\n print('writing psf cutouts')\n\n obj_data=self.obj_data\n psf_data=self.psf_data\n\n nfile=self.image_info.size\n nobj=obj_data.size\n\n cutout_hdu = self.fits['psf']\n\n for iobj in range(nobj):\n if (iobj+1) % 100 == 0:\n print(' %d/%d' % (iobj+1,obj_data.size))\n\n # HST psf is same for every cutout, in fact ncut should always\n # be 1\n try:\n psf_im = self.psf_data.get_psf(iobj)\n except AttributeError:\n psf_im = None\n\n ncut=obj_data['ncutout'][iobj]\n\n for icut in range(ncut):\n\n if psf_im is None:\n row = obj_data['orig_row'][iobj, icut]\n col = obj_data['orig_col'][iobj, icut]\n file_id = obj_data['file_id'][iobj,icut]\n\n p = self.psf_data[file_id]\n\n psf_im = p.get_rec(row,col)\n\n expected_psf_shape = (\n obj_data['psf_row_size'][iobj,icut],\n obj_data['psf_col_size'][iobj,icut],\n )\n\n file_id = obj_data['file_id'][iobj, icut]\n\n row = obj_data['orig_row'][iobj, icut]\n col = obj_data['orig_col'][iobj, icut]\n start_row = obj_data['psf_start_row'][iobj, icut]\n\n if psf_im.shape != expected_psf_shape:\n raise ValueError(\"psf size mismatch, expected %s \"\n \"got %s\" % (expected_psf_shape, psf_im.shape))\n\n cutout_hdu.write(psf_im, start=start_row)"},"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_moleculetype(top_file: IO, mol_name: str, nrexcl: int = 3):\n top_file.write(\"[ moleculetype ]\\n\")\n top_file.write(\"; Name\\tnrexcl\\n\")\n top_file.write(f\"{mol_name}\\t{nrexcl}\\n\\n\")","def write(self, out):","def write_output(self):","def write(self):","def write(self):","def writeOutput(self, output):","def write_readouts(path, dataset_dict, image_list, datasettype, mask_part,\n do_wt1_signal, do_dach1_signal, do_stereology_pred, do_stereology_gt):\n\n titles = []\n for i in range(len(image_list)):\n image_name = os.path.split(image_list[i])[1]\n titles.append(image_name[:-4])\n\n # Segmentation of only 1 class was applied (e.g. glomerulus or podocytes)\n if len(mask_part) == 1:\n mask_el = mask_part.pop()\n\n if mask_el == \"glomerulus\":\n network_area = \"glomerulus_area\"\n # Add a column if GET_WT1_SIGNAL_FOR_GLOMERULUS = True\n if do_wt1_signal:\n df = pd.DataFrame(\n {'image_name': pd.Series(titles),\n network_area: pd.Series(dataset_dict['area_preds_%s' % mask_el]),\n 'mean_WT1_signal_in_glom': pd.Series(dataset_dict['mean_WT1_glom_preds']),\n 'var_WT1_signal_in_glom': pd.Series(dataset_dict['var_WT1_glom_preds']),\n 'median_WT1_signal_in_glom': pd.Series(dataset_dict['median_WT1_glom_preds']),\n 'min_WT1_signal_in_glom': pd.Series(dataset_dict['min_WT1_glom_preds']),\n 'max_WT1_signal_in_glom': pd.Series(dataset_dict['max_WT1_glom_preds']),\n 'perc25_WT1_signal_in_glom': pd.Series(dataset_dict['perc25_WT1_glom_preds']),\n 'perc75_WT1_signal_in_glom': pd.Series(dataset_dict['perc75_WT1_glom_preds'])})\n else:\n df = pd.DataFrame({'image_name': pd.Series(titles),\n network_area: pd.Series(dataset_dict['area_preds_%s' % mask_el])})\n\n elif mask_el == \"podocytes\":\n network_count = \"podocyte_count\"\n network_area = \"podocyte_nuclear_area\"\n # Add a column if GET_DACH1_SIGNAL_FOR_PODOCYTES = True\n if do_dach1_signal:\n df = pd.DataFrame({'image_name': pd.Series(titles),\n network_count: pd.Series(dataset_dict['count_preds_%s' % mask_el]),\n network_area: pd.Series(dataset_dict['area_preds_%s' % mask_el]),\n 'mean_DACH1_signal_in_podo': pd.Series(dataset_dict['mean_DACH1_podo_preds']),\n 'var_DACH1_signal_in_podo': pd.Series(dataset_dict['var_DACH1_podo_preds']),\n 'median_DACH1_signal_in_podo': pd.Series(dataset_dict['median_DACH1_podo_preds']),\n 'min_DACH1_signal_in_podo': pd.Series(dataset_dict['min_DACH1_podo_preds']),\n 'max_DACH1_signal_in_podo': pd.Series(dataset_dict['max_DACH1_podo_preds']),\n 'perc25_DACH1_signal_in_podo': pd.Series(dataset_dict['perc25_DACH1_podo_preds']),\n 'perc75_DACH1_signal_in_podo': pd.Series(dataset_dict['perc75_DACH1_podo_preds'])\n })\n else:\n df = pd.DataFrame({'image_name': pd.Series(titles),\n network_count: pd.Series(dataset_dict['count_preds_%s' % mask_el]),\n network_area: pd.Series(dataset_dict['area_preds_%s' % mask_el])})\n\n else:\n raise ValueError('The name of the segmentation is not known:', mask_el)\n\n savepath = str(os.path.join(path, datasettype + '_Dataframe_' + mask_el))\n df.to_csv(savepath + '.csv')\n df.to_excel(savepath + '.xlsx')\n\n # Segmentation of 2 classes were applied (e.g. glomerulus and podocytes)\n elif len(mask_part) == 2:\n df = pd.DataFrame(\n {'image_name': pd.Series(titles),\n \"glomerulus_area\": pd.Series(dataset_dict['area_preds_%s' % mask_part[0]]),\n \"podocyte_count\": pd.Series(dataset_dict['count_preds_%s' % mask_part[1]]),\n \"podocyte_nuclear_area\": pd.Series(dataset_dict['area_preds_%s' % mask_part[1]])})\n\n # Add a column if GET_WT1_SIGNAL_FOR_GLOMERULUS = True\n if do_wt1_signal:\n df['mean_WT1_signal_in_glom'] = dataset_dict['mean_WT1_glom_preds']\n df['var_WT1_signal_in_glom'] = dataset_dict['var_WT1_glom_preds']\n df['median_WT1_signal_in_glom'] = dataset_dict['median_WT1_glom_preds']\n df['min_WT1_signal_in_glom'] = dataset_dict['min_WT1_glom_preds']\n df['max_WT1_signal_in_glom'] = dataset_dict['max_WT1_glom_preds']\n df['perc25_WT1_signal_in_glom'] = dataset_dict['perc25_WT1_glom_preds']\n df['perc75_WT1_signal_in_glom'] = dataset_dict['perc75_WT1_glom_preds']\n\n # Add a column if GET_DACH1_SIGNAL_FOR_PODOCYTES = True\n if do_dach1_signal:\n df['mean_DACH1_signal_in_podo'] = dataset_dict['mean_DACH1_podo_preds']\n df['var_DACH1_signal_in_podo'] = dataset_dict['var_DACH1_podo_preds']\n df['median_DACH1_signal_in_podo'] = dataset_dict['median_DACH1_podo_preds']\n df['min_DACH1_signal_in_podo'] = dataset_dict['min_DACH1_podo_preds']\n df['max_DACH1_signal_in_podo'] = dataset_dict['max_DACH1_podo_preds']\n df['perc25_DACH1_signal_in_podo'] = dataset_dict['perc25_DACH1_podo_preds']\n df['perc75_DACH1_signal_in_podo'] = dataset_dict['perc75_DACH1_podo_preds']\n\n if do_stereology_pred:\n stereo_dict = get_stereology_readouts(dataset_dict, mask_part, titles, mode='pred')\n # Add it to df\n df['stereology_on_prediction-glomerular_volume_per_million'] = stereo_dict[\"glomerular_volume_per_million\"]\n df['stereology_on_prediction-podocyte_count'] = stereo_dict[\"podocyte_count\"]\n df['stereology_on_prediction-podocyte_density'] = stereo_dict[\"podocyte_density\"]\n\n if do_stereology_gt:\n stereo_dict = get_stereology_readouts(dataset_dict, mask_part, titles, mode='gt')\n # Add it to df\n df['stereology_on_groundtruth-glomerular_volume_per_million'] = stereo_dict[\"glomerular_volume_per_million\"]\n df['stereology_on_groundtruth-podocyte_count'] = stereo_dict[\"podocyte_count\"]\n df['stereology_on_groundtruth-podocyte_density'] = stereo_dict[\"podocyte_density\"]\n\n savepath = str(os.path.join(path, datasettype + '_Dataframe_' + mask_part[0] + mask_part[1]))\n df.to_csv(savepath + '.csv')\n df.to_excel(savepath + '.xlsx')\n return","def writetif(self,outputname,):\n pass","def write(self, out):\r\n out.write('# {0:<11} {1:<6} {2:<6} {3:<6} {4}\\n'\r\n .format('Time(s)', 'X(mm)', 'Y(mm)', 'Z(um)', 'Tile'))\r\n for i in self: out.write(self.format_pt(i))","def write_report(report, ftype):\n if ftype == 'text':\n msg = '{} disks have been removed\\n'.format(len(report))\n msg += 'To replace them, run:\\n'\n for device, action_args in report.items():\n args = json.dumps(action_args, separators=(' ', '='))\n args = args.replace('{', '').replace('}', '').replace('\"', '')\n msg += 'juju run-action {} add-disk {} {}'.format(\n hookenv.local_unit(), 'osd-devices=' + device, args)\n else:\n msg = json.dumps(report)\n\n hookenv.action_set({'message': msg})","def do_write(self, args):\n\t\tasplit = args.split(\" \")\n\t\tfname = asplit[0]\n\t\twhat = asplit[1]\n\n\t\tif what == \"summary\" or what == \"oldsummary\":\n\t\t\twith open(fname, 'w') as f:\n\t\t\t\tform = DresherInterface.summary_format if what == \"summary\" else DresherInterface.oldsummary_format\n\t\t\t\tfor i, x in enumerate(form):\n\t\t\t\t\tf.write(x)\n\t\t\t\t\tif i == len(form)-1:\n\t\t\t\t\t\tf.write(\"\\n\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t#for lang in sorted(self.languages, key = lambda l: len(l._phones.keys())):\n\t\t\t\t#\tdw.writerow(dict(zip(form, [self.get_language_info(lang, x) for x in form])))\n\t\t\t\tfor lang in sorted(self.languages, key = lambda l: len(l._phones.keys())):\n\t\t\t\t\tfor i, x in enumerate(form):\n\t\t\t\t\t\tf.write(str(self.get_language_info(lang, x)))\n\t\t\t\t\t\tif i == len(form)-1:\n\t\t\t\t\t\t\tf.write(\"\\n\")\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tf.write(\"\\t\")\n\t\tif what == \"hierarchies\":\n\t\t\t# format: #vowels, langname, hierarchy, len(hier), #of marks, lfeats, inv, freq, \n\t\t\t# how many times each feat marked, the actual marks, vowel:feature set, unused features\n\t\t\t# take fname to be name of directory to write outfiles to\n\t\t\tif not os.path.exists(fname):\n\t\t\t\tos.mkdir(fname)\n\t\t\tfor lang in self.languages:\n\t\t\t\tnum_vowels = self.get_language_info(lang, \"linv\")\n\t\t\t\tname = lang.name\n\t\t\t\tnum_feats = self.get_language_info(lang, \"lfeats\")\n\t\t\t\tinv = self.get_language_info(lang, \"inv\")\n\t\t\t\tfreq = self.get_language_info(lang, \"freq\")\n\t\t\t\tinv_feats = lang.phone_feat_dict\n\t\t\t\twith open(os.path.join(fname,name.replace(\" \",\"\")+\".txt\"), 'w') as f:\n\t\t\t\t\tf.write(\"num_vowels\\tname\\thierarchy\\tlen_hier\\tnum_marks\\tnumfeats\\tinv\\tfreq\\tfeat_marks\\tinv_marks\\tinv_feats\\tunused_feats\\n\")\n\t\t\t\t\tfor h in lang.hierarchies:\n\t\t\t\t\t\tf.write(str(num_vowels))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(name)\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(h))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(len(h)))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tspec = SDA(lang._phones, lang._features, h)\n\t\t\t\t\t\tmarkedness = sum([x for phone in spec.keys() for x in spec[phone] if x == 1])\n\t\t\t\t\t\tf.write(str(markedness))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(num_feats))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(inv))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(freq))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tfeat_counts = {f:sum([spec[phone][i] for phone in spec.keys() if spec[phone][i] == 1]) for i, f in enumerate(h)}\n\t\t\t\t\t\tf.write(str(feat_counts))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(spec))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(inv_feats))\n\t\t\t\t\t\tf.write(\"\\t\")\n\t\t\t\t\t\tf.write(str(list(set(lang._features)-set(h))))\n\t\t\t\t\t\tf.write(\"\\n\")\n\t\t# make sure all the threads that need to be finished have finished\n\t\t# using .join() on the appropriate groups of threads","def to_logchunk(self):\n\t\tdemo_name = os.path.splitext(self.demo_name)[0]\n\t\tto_write = [(\"Killstreak\", value, tick, date) for value, tick, date in self.killstreaks]\n\t\tto_write.extend((\"Bookmark\", value, tick, date) for value, tick, date in self.bookmarks)\n\n\t\tto_write.sort(key = lambda t: t[2])\n\n\t\treturn \"\\n\".join(\n\t\t\tf'[{date}] {type_} {value} (\"{demo_name}\" at {tick})'\n\t\t\tfor type_, value, tick, date in to_write\n\t\t)","def write_output(self,content):\n text=\"\"\"# typ eta phi pt jmass ntrk btag had/em dummy dummy\\n\"\"\"\n self.output.writelines(text)\n text=\"0 \"+str(self.nb_data)+\" \"+str(len(content))+\"\\n\"\n self.output.writelines(text)\n\n i=1\n for particle in content:\n text=str(i)+' '+particle.lhco_line()+'\\n'\n self.output.writelines(text)\n i+=1","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 dump_cuts_list(self, file_name):\n assert(file_name is not None)\n with open(file_name, 'w') as fd:\n uids = self._cuts.keys()\n uids.sort()\n for cut_uid in uids:\n cut = self._cuts[cut_uid]\n fd.write(cut.get_cost_var() + \" \" + str(cut.get_cost()) + \"\\n\")\n return","def write_out(c2ptmk, ofn):\n print \"Writing out to [{}]\".format(ofn)\n with codecs.open(ofn, \"w\", \"utf8\") as ofd:\n for co, infos in sorted(c2ptmk.items()):\n ofd.write(u\"{}\\t{}\\t{}\\n\".format(\n co, infos[\"uri\"], \",\".join(\n [unicode(x) for x in infos[\"ptmks\"]])))","def write_run(run):\n r=Run(run)\n r.write_all()","def write_analysis(path, dataset_dict, datasettype, mask_part, start_time, supervised=True):\n for mask_el in mask_part:\n if mask_el == 'podocytes':\n filename = datasettype + '_podos.txt'\n filestr = 'podos images'\n elif mask_el == 'glomerulus':\n filename = datasettype + '_gloms.txt'\n filestr = 'gloms images'\n else:\n filename = datasettype + 'unknown.txt'\n filestr = 'unknown type'\n\n write_txt = open(str(os.path.join(path, filename)), \"w\")\n\n if supervised:\n dc_mean = np.sum(np.array(dataset_dict['dice_coeffs_%s' % mask_el])) / len(dataset_dict['dice_coeffs_%s'\n % mask_el])\n dc_min = np.min(np.array(dataset_dict['dice_coeffs_%s' % mask_el]))\n dc_max = np.max(np.array(dataset_dict['dice_coeffs_%s' % mask_el]))\n object_dc_mean = np.sum(np.array(dataset_dict['object_dc_%s' % mask_el])) / len(dataset_dict['object_dc_%s'\n % mask_el])\n object_dc_min = np.min(np.array(dataset_dict['object_dc_%s' % mask_el]))\n object_dc_max = np.max(np.array(dataset_dict['object_dc_%s' % mask_el]))\n pearson = calculate_pearson(dataset_dict['count_masks_%s' % mask_el], dataset_dict['count_preds_%s'\n % mask_el])\n\n write_txt.write(str(\"Mean dice coefficient on pixels of \" + filestr + \" compared to groundtruth: \") +\n str(dc_mean) + '\\n')\n write_txt.write(str(\"Min dice coefficient on pixels of \" + filestr + \" compared to groundtruth: \") +\n str(dc_min) + '\\n')\n write_txt.write(str(\"Max dice coefficient on pixels of \" + filestr + \" compared to groundtruth: \") +\n str(dc_max) + '\\n')\n write_txt.write(str(\"Pearson correlation coefficient on objects of \" + filestr +\n \" compared to groundtruth: \") + str(pearson) + '\\n')\n write_txt.write(str(\"Mean dice coeff on objects of \" + filestr + \" compared to groundtruth: \") +\n str(object_dc_mean) + '\\n')\n write_txt.write(str(\"Min dice coeff on objects of \" + filestr + \" compared to groundtruth: \") +\n str(object_dc_min) + '\\n')\n write_txt.write(str(\"Max dice coeff on objects of \" + filestr + \" compared to groundtruth: \") +\n str(object_dc_max) + '\\n')\n write_txt.write('\\n')\n\n duration = time.time() - start_time\n duration_std = int(duration / 3600)\n duration_min = int((duration % 3600) / 60)\n duration_sec = int(duration % 60)\n\n write_txt.write(str(\"Test time: \") + str(duration_std) + \"h \" + str(duration_min)\n + \"min \" + str(duration_sec) + 'sec \\n')\n write_txt.close()\n return","def writeClumptoDump(self,ID):\n clumpxyz = self.clumpcat[ID][:3]\n r2 = (self.disc.xyzh[0]-clumpxyz[0])**2 + (self.disc.xyzh[1]-clumpxyz[1])**2\n members = np.sqrt(r2) < self.annulus #members are all particles within radial annulus\n\n gas = self.disc.itype == 1\n dust = self.disc.itype == 2\n\n dustfrac = self.disc.dustfrac*1e8 #as I originally set dust-to-gas=1e-10\n\n #Calculate temperatures from thermal energies\n k = 1.38064852e-16 #ergs\n mH = 1.6735575e-24 #grams\n gmw = 2.381 #mean mass taken from Phantom\n N = sum(gas*self.disc.massofgas)*self.umass/mH/gmw #number of atoms\n temp = 2.*self.disc.utherm*self.uenerg/3./k/N\n\n\t\tutime = self.utime/(60*60*24*365.25)\n\n\t\t#create arrays of particle masses\n\t\tmass = np.zeros(len(self.disc.xyzh[0,:]))\n\t\tmass[self.disc.itype == 1] = self.disc.massofgas\n\t\tmass[self.disc.itype == 2] = self.disc.massofdust\n\n\t\tclumpdata = zip(self.disc.xyzh[0,members], self.disc.xyzh[1,members], self.disc.xyzh[2,members], \n self.disc.xyzh[3,members], self.disc.density[members], mass[members], \n temp[members], dustfrac[members], self.disc.itype[members])\n\t\tclumpdata = np.asarray(clumpdata)\n\t\theader = (\"time: %s utime (yrs^-1): %s \\n x, y, z, h, density, mass, temp, \" %(str(self.disc.time), str(utime)) +\n\t\t\t \"dustfrac, itype \\n %s, %s, %s, %s, %s, %s, 0.0, 0.0, 0.0 \\n \\n\" %(str(self.udist), str(self.udist),\n\t\t\t \t\t\t\t\t\t\t\t str(self.udist), str(self.udist),\n\t\t\t\t\t\t\t\t\t\t\t str(self.udens), str(self.umass)))\n\t\tnp.savetxt('%s/clumpfiles/clumpdata_%.0f.txt' %(self.wd,self.disc.time), clumpdata, header=header)","def write_pc_cards(bc_file, bc_class):\n bc_file.write('! Output Control\\n')\n oc = bc_class.output_control\n objects = list(oc.param.output_control_option.get_range())\n if oc.output_control_option == objects[0]:\n bc_file.write('OC {}\\n'.format(oc.oc_time_series_id))\n ofs = oc.output_flow_strings\n if not ofs.empty:\n bc_file.write(ofs.to_csv(sep=' ', na_rep='', index=False, header=False,).replace('\\r\\n', '\\n'))\n\n if oc.print_adaptive_mesh:\n bc_file.write('PC ADP\\n')\n if oc.print_numerical_fish_surrogate:\n bc_file.write('PC ELM\\n')\n if oc.screen_output_residual:\n bc_file.write('SOUT RESID\\n')\n if oc.screen_output_all:\n bc_file.write('SOUT ALL\\n')\n if oc.screen_output_mass_error:\n bc_file.write('SOUT MERROR\\n')\n if oc.screen_output_worst_nonlinear_node:\n bc_file.write('SOUT NLNODE\\n')\n if oc.screen_output_worst_linear_node:\n bc_file.write('SOUT LNODE\\n')\n if oc.file_output_wind:\n bc_file.write('FOUT WIND\\n')\n if oc.file_output_wave:\n bc_file.write('FOUT WAVE\\n')\n if oc.file_output_adapted_grid:\n bc_file.write('FOUT ADAPT GRID\\n')\n if oc.file_output_adapted_solution:\n bc_file.write('FOUT ADAPT SW\\n')\n if oc.file_output_adapted_transport:\n bc_file.write('FOUT ADAPT CON\\n')\n if oc.file_output_sediment:\n bc_file.write('FOUT SED\\n')\n\n bc_file.write('\\n') # blank line after Output Control","def write_tcv(self):\n suffix = '_'+str(self.shot)+'_'+str(int(self.t*1e3))\n self.write_input(suffix=suffix)","def write(self, file_name, *, file_type=None, precision=None, write_patch_results=False):\n self.logger.info('Writing KG correlations to %s',file_name)\n precision = self.config.get('precision', 4) if precision is None else precision\n name = 'main' if write_patch_results else None\n with make_writer(file_name, precision, file_type, self.logger) as writer:\n self._write(writer, name, write_patch_results)","def sitofp(self, typ):","def write_fits(self, name=None, output_path=None):\n pass","def write_to(self, stream: StreamWrapper):\n stream.write_int(len(self.moves))\n for element in self.moves:\n element.write_to(stream)\n stream.write_int(len(self.buildings))\n for element in self.buildings:\n element.write_to(stream)\n if self.choose_specialty is None:\n stream.write_bool(False)\n else:\n stream.write_bool(True)\n stream.write_int(self.choose_specialty)","def write(self, outfile):\n outfile.write(\n '\\t'.join(\n [\n str(i) for i in [\n self.chrom, self.start, self.end, self.name,\n self.count, self.fold_change, self.log10p\n ]\n ]\n )\n )\n outfile.write('\\n')","def write_output_files(self, file_type, output, expected):\n actual_filename = self.output_filename(self.FILENAME_SUFFIX_ACTUAL + file_type)\n expected_filename = self.output_filename(self.FILENAME_SUFFIX_EXPECTED + file_type)\n\n self._write_file(actual_filename, output)\n self._write_file(expected_filename, expected)","def export_summary(\n self,\n output_dir=None,\n solution_name=None,\n type=\"Object\",\n geometryType=\"Volume\",\n quantity=\"Temperature\",\n variation=\"\",\n variationlist=[],\n ):\n all_objs = list(self.modeler.oeditor.GetObjectsInGroup(\"Solids\"))\n all_objs_NonModeled = list(self.modeler.oeditor.GetObjectsInGroup(\"Non Model\"))\n all_objs_model = [item for item in all_objs if item not in all_objs_NonModeled]\n arg = []\n self.logger.glb.info(\"Objects lists \" + str(all_objs_model))\n for el in all_objs_model:\n try:\n self.osolution.EditFieldsSummarySetting(\n [\"Calculation:=\", [type, geometryType, el, quantity, \"\", \"Default\"]]\n )\n arg.append(\"Calculation:=\")\n arg.append([type, geometryType, el, quantity, \"\", \"Default\"])\n except Exception as e:\n self.logger.glb.error(\"Object \" + el + \" not added.\")\n self.logger.glb.error(str(e))\n if not output_dir:\n output_dir = self.project_path\n self.osolution.EditFieldsSummarySetting(arg)\n if not os.path.exists(output_dir):\n os.mkdir(output_dir)\n if not solution_name:\n solution_name = self.nominal_sweep\n if variation:\n for l in variationlist:\n self.osolution.ExportFieldsSummary(\n [\n \"SolutionName:=\",\n solution_name,\n \"DesignVariationKey:=\",\n variation + \"='\" + str(l) + \"'\",\n \"ExportFileName:=\",\n os.path.join(output_dir, \"IPKsummaryReport\" + quantity + \"_\" + str(l) + \".csv\"),\n ]\n )\n else:\n self.osolution.ExportFieldsSummary(\n [\n \"SolutionName:=\",\n solution_name,\n \"DesignVariationKey:=\",\n \"\",\n \"ExportFileName:=\",\n os.path.join(output_dir, \"IPKsummaryReport\" + quantity + \".csv\"),\n ]\n )\n return True","def write(self):\n pass","def write(self):\n pass","def cutPaper(self, cut='partial', feed=True):\n if cut not in ['partial', 'full']:\n raise ValueError('cut must be \\'partial\\' or \\'full\\'')\n elif type(feed) is not bool:\n raise ValueError('feed must be True or False')\n else:\n value = 0 if cut == 'full' else 1\n value += 65 if feed else 0\n self._write(self.__class__.__GS + 'V' + chr(value))","def cut_to_summary(file_name, directory, leave_out=[]):\n i = 0\n if not os.path.exists(directory):\n os.makedirs(directory)\n with open(file_name) as to_cut:\n line = to_cut.readline()\n while line != \"\" and line is not None:\n if i in leave_out:\n i += 1\n print(line)\n f = open(\"{}/summary_{}.txt\".format(directory, i), \"w\")\n f.write(line)\n f.close()\n i += 1\n line = to_cut.readline()\n print(file_name, i)","def export(self, file: TextIO) -> None:\n file.write(f'\"{self.name}\"\\n\\t{{\\n')\n file.write(f'\\tchannel {self.channel}\\n')\n file.write(f'\\tsoundlevel {join_float(self.level)}\\n')\n\n if self.volume != (1, 1):\n file.write(f'\\tvolume {join_float(self.volume)}\\n')\n if self.pitch != (100, 100):\n file.write(f'\\tpitch {join_float(self.pitch)}\\n')\n\n if len(self.sounds) != 1:\n file.write('\\trndwave\\n\\t\\t{\\n')\n for wav in self.sounds:\n file.write(f'\\t\\twave \"{wav}\"\\n')\n file.write('\\t\\t}\\n')\n else:\n file.write(f'\\twave \"{self.sounds[0]}\"\\n')\n\n if self.force_v2 or self.stack_start or self.stack_stop or self.stack_update:\n file.write(\n '\\t' 'soundentry_version 2\\n'\n '\\t' 'operator_stacks\\n'\n '\\t\\t' '{\\n'\n )\n if self.stack_start:\n file.write(\n '\\t\\t' 'start_stack\\n'\n '\\t\\t\\t' '{\\n'\n )\n for prop in self.stack_start:\n for line in prop.export():\n file.write('\\t\\t\\t' + line)\n file.write('\\t\\t\\t}\\n')\n if self.stack_update:\n file.write(\n '\\t\\t' 'update_stack\\n'\n '\\t\\t\\t' '{\\n'\n )\n for prop in self.stack_update:\n for line in prop.export():\n file.write('\\t\\t\\t' + line)\n file.write('\\t\\t\\t}\\n')\n if self.stack_stop:\n file.write(\n '\\t\\t' 'stop_stack\\n'\n '\\t\\t\\t' '{\\n'\n )\n for prop in self.stack_stop:\n for line in prop.export():\n file.write('\\t\\t\\t' + line)\n file.write('\\t\\t\\t}\\n')\n file.write('\\t\\t}\\n')\n file.write('\\t}\\n')","def write(self):\n raise NotImplementedError","def save(self):\n \n fileName=self.characterName+\"_\"+self.race+\"_\"+self.classType+\"_lvl_\"+str(self.level)\n new_file = open(str(fileName)+\".txt\",\"w\")\n new_file.write(\"~~~~~~~~~~~ \"+self.characterName+\" the \"+self.race+\" \"+self.classType+\" ~~~~~~~~~~~\\n\\n\")\n new_file.write(\"Level: \"+str(self.level)+\" HP: \"+str(self.hp)+\" XP: \"+str(self.xp)+\" Hit Dice: \"+str(self.level)+str(self.hit_dice[self.classType])+\"\\n\")\n new_file.write(str(self.abilityScores()))\n new_file.write(\"\\n\\n~~~~~~~~~ Skills ~~~~~~~~~\\n\")\n for i in self.skills:\n new_file.write(\"\\n\"+i+\" \"+\"(\"+skills[i.lower()].upper()+\")\")\n new_file.write(\"\\n\\n~~~~~~~~~ Traits ~~~~~~~~~\\n\")\n for i in self.traits:\n new_file.write(\"\\n ~~\"+i+\"~~\\n \"+str(self.traits[i])+\"\\n\")\n new_file.write(\"\\n\\n~~~~~~~~~ Specialty: \"+self.specialty+\" ~~~~~~~~\\n\")\n new_file.write(\"\\n \"+self.specialtyStory+\"\\n\")\n new_file.write(\"\\n ~~~~ Feats ~~~~\\n\")\n for i in range(1,self.level+1):\n if i == 1 or i%3 == 0:\n new_file.write(\"\\n Level \"+str(i)+\": \"+self.feats[i]['name']+' '\\\n \"(\"+self.feats[i]['type']+\")\\n\"\\\n ' \"'+self.feats[i]['description']+'\"\\n\\n')\n if 'prereq' in self.feats[i]:\n new_file.write(\" Prerequisite: \"+self.feats[i]['prereq']+\"\\n\")\n if 'benefit' in self.feats[i]:\n new_file.write(\" Benefit: \"+self.feats[i]['benefit']+\"\\n\")\n if 'effect' in self.feats[i]:\n new_file(\" Effect: \"+self.feats[i]['effect']+\"\\n\")\n \n new_file.write(\"\\n\\n~~~~~~~~~ Background: \"+self.background+\" ~~~~~~~~\\n\")\n if self.backgroundProfession == '':\n pass\n else:\n new_file.write(\"Profession: \"+self.backgroundProfession)\n new_file.write(\"\\n \"+self.backgroundStory)\n \n new_file.close()\n print \"File \"+str(fileName)+\".txt saved.\"","def write_output(self) -> None:\n self.home.round(2).to_csv(var.indicators_base_cumsum + \"home_\" + str(self.year) + \".csv\")\n self.away.round(2).to_csv(var.indicators_base_cumsum + \"away_\" + str(self.year) + \".csv\")","def writeDataCards(opt,sigExp,bkgExp,shapesURL):\n\n #create a card per category\n dcList=[]\n for icat in range(len(opt.categs)):\n cat='%s_a%d_%d'%(opt.chTag,opt.xangle,icat)\n dcTxt='%s/shapes-parametric.datacard_%s.dat'%(opt.output,cat)\n dcList.append(dcTxt)\n with open(dcTxt,'w') as dc:\n dc.write('#\\n')\n dc.write('# datacard was automatically generated with generateWorkspace.py\\n')\n dc.write('# the options passed are printed below\\n')\n dc.write('# %s\\n'%opt)\n dc.write('#\\n')\n dc.write('imax *\\n')\n dc.write('jmax *\\n')\n dc.write('kmax *\\n')\n dc.write('-'*50+'\\n')\n dc.write('shapes * * {0} $PROCESS_{1} $PROCESS_$SYSTEMATIC\\n'.format(shapesURL,cat))\n dc.write('shapes data_obs * {0} $PROCESS_{1}\\n'.format(shapesURL,cat))\n dc.write('-'*50+'\\n')\n dc.write('bin %s\\n'%cat)\n dc.write('observation -1\\n')\n dc.write('-'*50+'\\n')\n dc.write('%15s %15s %15s\\n'%('bin',cat,cat))\n dc.write('%15s %15s %15s\\n'%('process','sig','bkg'))\n dc.write('%15s %15s %15s\\n'%('process','0', '1'))\n dc.write('%15s %15s %15s\\n'%('rate','%3.2f'%sigExp[icat], '%3.2f'%bkgExp[icat]))\n dc.write('-'*50+'\\n')\n \n #float the background normalization as well as the signal\n dc.write('mu_bkg{0} rateParam {0} bkg 1\\n'.format(cat))\n\n #uncertainties\n dc.write('lumi %8s %15s %15s\\n'%('lnN','1.027','-'))\n dc.write('%s_sigShape %8s %15s %15s\\n'%(cat,'shape','1','-'))\n dc.write('%s_bkgShape %8s %15s %15s\\n'%(cat,'shape','-','1'))\n dc.write('{0} autoMCStats 0.0 1\\n'.format(cat))\n \n print '\\tshapes available @',shapesURL\n print '\\tgenerated the following datacards',dcList","def _write_sets(self, size, card_writer):\n msg = []\n if (self.sets or self.setsSuper or self.asets or self.bsets or\n self.csets or self.qsets):\n msg.append('$SETS\\n')\n for (unused_id, set_obj) in sorted(self.sets.iteritems()): # dict\n msg.append(set_obj.write_bdf(size, card_writer))\n for set_obj in self.asets: # list\n msg.append(set_obj.write_bdf(size, card_writer))\n for set_obj in self.bsets: # list\n msg.append(set_obj.write_bdf(size, card_writer))\n for set_obj in self.csets: # list\n msg.append(set_obj.write_bdf(size, card_writer))\n for set_obj in self.qsets: # list\n msg.append(set_obj.write_bdf(size, card_writer))\n for (set_id, set_obj) in sorted(self.setsSuper.iteritems()): # dict\n msg.append(set_obj.write_bdf(size, card_writer))\n return ''.join(msg)","def write_collected(self, names_file, kb_file, cat_file):\n with open(names_file, 'w') as fp:\n for kb_id, name in self.collected_names.items():\n fp.write('\\t'.join(['name', kb_id, name]) + '\\n')\n with open(kb_file, 'w') as fp:\n for kb_id, tail_set in self.collected_edges.items():\n for (rel, tail_id) in tail_set:\n fp.write('\\t'.join([rel, kb_id, tail_id]) + '\\n')\n with open(cat_file, 'w') as fp:\n for c, ms in self.collected_cat_mems.items():\n fp.write(c + '\\t' + self.kb[c].name + '\\t')\n fp.write('|'.join(ms) + '\\n')","def write():\n pass","def writeKittiSubmission(data, prefix, index, type='stereo'):\r\n if type=='stereo':\r\n data = data*256.0\r\n data[data<1.0] = 1.0\r\n data = data.astype(np.uint16)\r\n cv2.imwrite(prefix+'/%06d_10.png' % index, data)\r\n elif type=='flow':\r\n # TODO: I didn't check this part\r\n # please refer to io_flow.h in KITTI 2015 development KIT, if you have any questions\r\n # in BGR order\r\n flow = np.zeros(data.shape[:2]+(3,))\r\n flow[:, :, 1] = data[:, :, 1]\r\n flow[:, :, 2] = data[:, :, 0]\r\n flow[:, :, 1:] = flow[:, :, 1:] * 64.0 + 32768.0\r\n flow[flow<0.0] = 0.0\r\n flow[flow>65535] = 65535\r\n flow[:, :, 0] = 1\r\n flow = flow.astype(np.uint16)\r\n cv2.imwrite(prefix + '/%06d_10.png' % index, flow)","def write(self):\n self.output_directory.mkdir(parents=True, exist_ok=True)\n parameter_set_files = [pathlib.Path(set_name) for set_name in\n self.parameter_study.coords[_set_coordinate_key].values]\n if self.write_meta and self.provided_output_file_template:\n self._write_meta(parameter_set_files)\n if self.output_file_type == 'h5':\n self._write_dataset()\n elif self.output_file_type == 'yaml':\n self._write_yaml(parameter_set_files)\n else:\n raise ValueError(f\"Unsupported output file type '{self.output_file_type}'\")","def write(self, unknown_category):\n\n self.unknown_category = unknown_category\n rules, lexicon = self.generate_rules_and_lexicon()\n self.rules_generated = u' '.join(map(u''.join, rules))\n cPickle.dump(lexicon, open(self.get_file_path('lexicon'), 'wb'))\n if not self.rich_upper:\n dictionary = self.generate_dictionary(lexicon)\n cPickle.dump(dictionary, open(self.get_file_path('dictionary'), 'wb'))\n script_path = self.get_file_path('script')\n binary_path = self.get_file_path('binary')\n compiler_path = self.get_file_path('compiler')\n with open(compiler_path, 'w') as f:\n if self.script_type == 'lexc':\n f.write('#!/bin/sh\\nfoma -e \"read lexc %s\" -e \"save stack %s\" -e \"quit\"' % (\n script_path, binary_path))\n else:\n f.write('#!/bin/sh\\nfoma -e \"source %s\" -e \"regex morphology;\" '\n '-e \"save stack %s\" -e \"quit\"' % (script_path, binary_path))\n os.chmod(compiler_path, 0744)\n morphology_generator = self.get_morphology_generator(rules, lexicon)\n with codecs.open(script_path, 'w', 'utf8') as f:\n for line in morphology_generator:\n f.write(line)","def write_type_scores(path, lines):\n\n print \"Opening %s for score output\" % base_name(path)\n headers = [\"Type\", \"Total\", \"Detection\", \"Detection (%)\",\n \"Recognition\", \"Recognition (%)\",\n \"Correction\", \"Correction (%)\"]\n\n write_csv(path, lines, headers)","def _write_executive_control_deck(self):\n msg = ''\n if self.executive_control_lines:\n msg = '$EXECUTIVE CONTROL DECK\\n'\n if self.sol == 600:\n newSol = 'SOL 600,%s' % self.solMethod\n else:\n newSol = 'SOL %s' % self.sol\n\n if self.iSolLine is not None:\n self.executive_control_lines[self.iSolLine] = newSol\n\n for line in self.executive_control_lines:\n msg += line + '\\n'\n return msg","def write(self, mode):\n if mode == \"pretrain\":\n out_tmp = self.log_buffer.output\n log_string = (\"Pre-Tr ep [{}/{}] it [{}/{}] BT {:.3f} DT {:.3f} acc {:.3f}\\n\"\n \"loss_total {:.3f}\").format(\n self.epoch+1, self.max_epochs, self.iter, self.max_iters,\n out_tmp[\"batch_time\"], out_tmp[\"data_time\"],\n self.acc, out_tmp[\"train/loss/total\"])\n self.logger.info(log_string)\n\n elif mode == \"train\":\n out_tmp = self.log_buffer.output\n log_string = (\"Tr loop {} ep [{}/{}] it [{}/{}] BT {:.3f} DT {:.3f} acc {:.3f}\\n\"\n \"loss_total {:.3f} loss_C {:.3f} loss_GD {:.3f}\\n\"\n \"score: max {:.2f} min {:.2f} mean {:.2f} select {} samples in latest iteration\").format(\n self.loop+1, self.epoch+1, self.max_epochs+self.cfg.warmup_epochs, self.iter, self.actual_max_iters,\n out_tmp[\"batch_time\"], out_tmp[\"data_time\"], self.acc,\n out_tmp[\"train/loss/total\"], out_tmp[\"train/loss/loss_C\"],\n out_tmp[\"train/loss/loss_GD\"],\n *self.meta[\"score_statistic\"],\n self.meta[\"n_select\"])\n\n self.logger.info(log_string)\n type(self).__base__.__base__.__base__.write(self)\n\n elif mode == \"eval\":\n print_string = (\"Te it [{}/{}] Time {:.3f} \"\n \"Target acc {:.3f} Best acc so far {:.3f} in epoch {}\").format(\n self.iter, self.actual_max_iters,\n self.timer.since_last(),\n self.acc, self.best_acc, self.best_epoch)\n self.logger.info(print_string + \"\\n\")\n self.tb_writer.add_scalars(\n \"acc\", {\n \"test\": self.acc,\n \"best_acc\": self.best_acc\n }, self.iter)\n\n elif mode == \"loop\":\n print_string = \" Test acc after loop {}: {:.2f}, the best is {:.2f} in loop {}\".format(\n self.loop + 1, self.acc,\n self.best_acc_loop, self.best_loop + 1)\n self.logger.info(print_string + \"\\n\")\n else:\n raise NotImplementedError(\"mode: {} for Solver.write()\".format(mode))","def write_data_card(spec, data_card, channels, path):\n with open(path, \"w\") as f:\n f.write(f\"imax {str(size(data_card.bins))}\" + \"\\n\")\n f.write(\n \"jmax \"\n + str(size(data_card.processes) - size(data_card.isSignal.keys()))\n + \"\\n\"\n )\n f.write(f\"kmax {str(size(data_card.systs, 0))}\" + \"\\n\")\n\n if data_card.hasShapes:\n for channel in data_card.shapeMap.keys():\n for sample in data_card.shapeMap[channel].keys():\n f.write(\n f\"shapes {sample} {channel} {data_card.shapeMap[channel][sample][0]} {data_card.shapeMap[channel][sample][1]}\"\n )\n if size(data_card.shapeMap[channel][sample]) > 2:\n f.write(f\" {data_card.shapeMap[channel][sample][2]}\" + \"\\n\")\n else:\n f.write(\"\\n\")\n\n f.write(\"\\n---------------------------------\\n\")\n f.write(\"bin \")\n for bin in data_card.obs.keys():\n f.write(f\"{bin} \")\n f.write(\"\\n\")\n f.write(\"observation \")\n for channel in data_card.obs.keys():\n f.write(f\"{str(data_card.obs[channel])} \")\n f.write(\"\\n---------------------------------\\n\")\n f.write(\"bin \")\n for channel in data_card.obs.keys():\n for sample in data_card.exp[channel].keys():\n f.write(f\"{channel} \")\n f.write(\"\\n\")\n f.write(\"process \")\n for channel in data_card.bins:\n for sample in data_card.exp[channel].keys():\n f.write(f\"{sample} \")\n f.write(\"\\n\")\n f.write(\"process \")\n for channel in data_card.bins:\n for sample in data_card.exp[channel].keys():\n if sample in data_card.signals:\n f.write(f\"{str(-1 * data_card.processes.index(sample))} \")\n else:\n f.write(f\"{str(data_card.processes.index(sample) + 1)} \")\n f.write(\"\\n\")\n f.write(\"rate \")\n for channel in data_card.bins:\n for sample in data_card.exp[channel].keys():\n\n f.write(f\"{str(data_card.exp[channel][sample])} \")\n f.write(\"\\n---------------------------------\\n\")\n for syst in data_card.systs:\n f.write(f\"{syst[0]} {syst[2]} \")\n for bin in syst[4].keys():\n for sample in data_card.exp[bin].keys():\n if syst[4][bin][sample] != 0:\n f.write(f\"{str(syst[4][bin][sample])} \")\n else:\n f.write(\"- \")\n\n f.write(\"\\n\")\n f.write(\"\\n---------------------------------\\n\")\n for cAp in data_card.rateParams.keys():\n _dir = cAp.split(\"AND\")\n for i in range(size(data_card.rateParams[cAp], 0)):\n if size(data_card.rateParams[cAp][i][0]) > 3:\n f.write(\n f\"{str(data_card.rateParams[cAp][i][0][0])} rateParam {_dir[0]} {_dir[1]} {str(data_card.rateParams[cAp][i][0][1])} {data_card.rateParams[cAp][i][0][3]}\"\n )\n else:\n f.write(\n f\"{str(data_card.rateParams[cAp][i][0][0])} rateParam {_dir[0]} {_dir[1]} {str(data_card.rateParams[cAp][i][0][1])}\"\n )\n f.write(\"\\n\")\n f.write(\"\\n---------------------------------\\n\")\n for idxc, channel in enumerate(channels):\n if (\n channel in data_card.binParFlags.keys()\n and data_card.binParFlags[channel] == True\n ):\n # double check to be safe\n shapesys = False\n staterror = False\n for sample in spec[\"channels\"][idxc][\"samples\"]:\n mod_types = [mod[\"type\"] for mod in sample[\"modifiers\"]]\n if \"shapesys\" in mod_types:\n shapesys = True\n elif \"staterror\" in mod_types:\n staterror = True\n\n if shapesys:\n f.write(f\"{channel} autoMCStats 100000 0 2\" + \"\\n\")\n if staterror:\n f.write(f\"{channel} autoMCStats 0 0 2\" + \"\\n\")","def _write_nover():\n return []","def writeHoc(self):\n print('Writing output file %s ...' % self.outFile)\n with open(self.outFile, 'w') as fOut:\n \n def createSection(secNum):\n fOut.write('create section_%i\\n' %secNum)\n fOut.write('section_%i {\\n' %secNum)\n fOut.write('pt3dclear()\\n')\n for node in xrange(len(self.sections[secNum])):\n fOut.write('pt3dadd(%.6f, %.6f, %.6f, %.6f)\\n' \\\n % (self.sections[secNum][node][0],\n self.sections[secNum][node][1],\n self.sections[secNum][node][2],\n self.secRads[secNum][node]))\n fOut.write('}\\n')\n \n def createConnection():\n for c in xrange(len(self.connections)):\n fOut.write('connect section_%i(1), section_%i(0)\\n' \\\n % (self.connections[c][0],self.connections[c][1]))\n \n \n for sec in self.sections.keys():\n createSection(sec)\n createConnection()\n \n \n return","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))","def writeOutput(self):\n\n self.collect.writeOutput()","def uitofp(self, typ):","def output_file(cls, pki_type_enum, pki_id, raw_data, output_path):\n pki_type = None\n\n for pki_type in cls.TYPE:\n if cls.TYPE[pki_type] == pki_type_enum:\n break\n else:\n raise StandardError(\"pki type not supported: 0x%02x\" % pki_type_enum)\n\n folder_path = os.path.join(output_path, pki_type)\n if os.path.exists(folder_path) is False:\n os.makedirs(folder_path)\n\n file_name = \"%s_%d.%s\" % (pki_type, pki_id, \"key\" if \"key\" in pki_type else \"cer\")\n\n with open(os.path.join(folder_path, file_name), \"wb+\") as _file:\n _file.write(raw_data)","def write(self, file):\n\n # Initialize output buffer\n out = ''\n\n # Print specification\n for key, value in self.specification.items():\n out += f'{key} : {value}\\n'\n\n # Print the tour\n if self.tour:\n out += 'TOUR_SECTION\\n'\n for s in self.tour:\n out += str(s) + '\\n'\n out += '-1\\n'\n\n # Append EOF\n out += 'EOF\\n'\n\n # Write to file\n with open(file, 'w') as f:\n f.write(out)","def _write_endcy():\n return []","def Writedata(self, tstep):\n \n nc = Dataset(self.outfile, 'a')\n \n nc.variables['time'][tstep] = self.time\n nc.variables['salt'][tstep] = self.salt\n nc.variables['temp'][tstep] = self.temp\n nc.variables['uc'][tstep] = self.uc\n nc.variables['vc'][tstep] = self.vc\n nc.variables['nu_v'][tstep] = self.nu_v\n nc.variables['rho'][tstep] = self.rho\n nc.variables['tau_x'][tstep] = self.tau_x\n nc.variables['tau_y'][tstep] = self.tau_y\n nc.variables['eta'][tstep] = self.eta\n \n nc.close()","def write_data():","def write(self, entry):\n if entry is \"all\":\n for k, item in self.nodes.items():\n if type(item) is list:\n for node in item:\n node.write()\n else:\n item.write()\n else:\n # other option is 'rooms'\n for node in self.nodes[entry]:\n node.write()","def write_output_shifts_to_file(self, shift_output):\n pass","def save_to_poscar(self, filename,direct=False,species_line=False): \n with open( filename, 'w' ) as F:\n F.write( self.name )\n F.write( \" 1.0\\n\" )\n F.write( mat2str( self.unit_cell, \"%16.10f\" ) )\n if species_line:\n pos = 0\n for n in self.num_per_type: \n F.write('%s '%self.species[pos])\n pos += n\n F.write('\\n')\n F.write(' '.join([str(n) for n in self.num_per_type]) )\n F.write('\\n')\n if not direct:\n F.write(\"Cart\\n\")\n F.write( mat2str( self.atoms, \"%16.10f\" ) )\n else:\n F.write(\"Direct\\n\")\n F.write( mat2str( dot(self.atoms,self.recip_cell), \"%16.10f\" ) )","def write_minisat(self):\n num_variables = len(self.label_encodings)\n num_clauses = self.num_clauses\n clauses = self.clauses\n outfile = MinisatRunner.temp_in\n out = open(outfile,\"w\")\n try:\n out.write(\"p cnf %3d %3d\\n\" % (num_variables,num_clauses))\n for clause in clauses:\n for clause_variable in clause:\n out.write(\" %3d\" % self.minisat_encode_label(clause_variable));\n out.write(\" 0\\n\")\n finally:\n out.close()","def write(data):","def write(self):\n #\n if self.what == 'ecutwfc':\n for i in range(self.Ndata):\n self.pwinput.filename = self.inpFiles[i]\n self.pwinput.SYSTEM.set_ecutwfc(self.values[i])\n self.pwinput.write()\n #\n elif self.what == 'ecutrho':\n for i in range(self.Ndata):\n self.pwinput.filename = self.inpFiles[i]\n self.pwinput.SYSTEM.ecutrho = self.values[i]\n self.pwinput.write()\n elif self.what == 'kpoints':\n for i in range(self.Ndata):\n self.pwinput.filename = self.inpFiles[i]\n self.pwinput.Nk = self.values[i]\n self.pwinput.write()\n #\n else:\n raise RuntimeError('what = %s is not implemented yet' % (self.what))\n #\n self.inputs_have_been_written = True","def _write(self, preset_type, data):\n logger.debug('write presets for %s', self._device.name)\n with self._file_open_rlock(preset_type) as f:\n f.seek(0)\n yaml.dump(data, f, default_flow_style=False)\n f.truncate()","def write(self, filename=None):\n if filename == None:\n filename = self.ofilename\n\n ofile = open(filename, 'w')\n\n ofile.write('# Susceptibility: %E d(susc): %E Coercivity: %E d(coer): %E\\n' % (self.susceptibility_mean, self.susceptibility_std, self.coercivity_mean, self.coercivity_std) )\n ofile.write('# H[] M[] Mfit[]\\n')\n\n #for i in range(len(self.h)):\n # ofile.write(\" %12.10f %12.10f %12.10f\\n\" % ( self.h[i], self.m[i], self.m_fit[i] ) )\n\n ofile.close()","def _prepare_for_write(self):\r\n self._writer = tf.summary.FileWriter(self._model.output_path,\r\n self._tensorflow_session.graph)\r\n for mode in ('train', 'test', 'full_test'):\r\n self._expensive_ops[mode].update(self._cheap_ops[mode])\r\n self._ready_to_write = True","def _writeOutput(self):\n head = \"Station\\tX\\tY\\tZ\\tUEast\\tUNorth\\tUUp\\tSigEast\\tSigNorth\\tSigUp\\n\"\n outFmt = \"%s\" + 9 * \"\\t%g\" + \"\\n\"\n\n f = open(self.outputFile, 'w')\n f.write(head)\n\n for stationNum in range(self.numStations):\n outLine = outFmt % (self.stations[stationNum],\n self.coords[stationNum, 0], self.coords[stationNum, 1],\n self.coords[stationNum, 2],\n self.dispNoise[stationNum, 0],\n self.dispNoise[stationNum, 1],\n self.dispNoise[stationNum, 2],\n self.sigmaEast, self.sigmaNorth, self.sigmaUp)\n f.write(outLine)\n\n f.close()\n\n return","def write_all(self):\r\n pass","def _write_table(self, var_type, var_data, hierarchical, print_arrays, out_stream):\n if out_stream is None:\n return\n\n # Make a dict of variables. Makes it easier to work with in this method\n var_dict = OrderedDict()\n for name, vals in var_data:\n var_dict[name] = vals\n\n # determine pathname of the system\n if self.source in ('root', 'driver', 'problem', 'root.nonlinear_solver'):\n pathname = ''\n elif '|' in self.source:\n pathname = get_source_system(self.source)\n else:\n pathname = self.source.replace('root.', '')\n if pathname.endswith('.nonlinear_solver'):\n pathname = pathname[:-17] # len('.nonlinear_solver') == 17\n\n # vars should be in execution order\n if 'execution_order' in self._var_info:\n var_order = self._var_info['execution_order']\n var_list = [var_name for var_name in var_order if var_name in var_dict]\n else:\n # don't have execution order, just sort for determinism\n var_list = sorted(var_dict.keys())\n\n top_name = pathname if pathname else 'model'\n write_var_table(pathname, var_list, var_type, var_dict,\n hierarchical=hierarchical, top_name=top_name,\n print_arrays=print_arrays, out_stream=out_stream)","def create_export_files(n,input_choice,timing,min_hull_per):\n\n\n\texists = os.path.isdir('analysis')\n\tif exists:\n\t\tf = open('analysis/results.csv','a',newline='')\n\t\tresults = csv.writer(f)\n\telse:\n\t\tos.mkdir('analysis')\n\t\tf = open('analysis/results.csv','w',newline='')\n\t\tresults = csv.writer(f)\n\t\tresults.writerow(['Algo','Size of Input','Min. Hull Pts Per','Type of Input','Timing'])\n\n\n\tresults.writerow(['Graham Scan',n,min_hull_per,input_choice,timing])","def write_location(self, param_type, path, pool=None, cont=None):\n self.run_ior_with_params(param_type, path, pool, cont,\n self.test_file, self.ior_flags[0])","def _save_chromosome_at_index(self, index, file_name):\n how_to_open = 'w' if index == 0 else 'a'\n with open(file_name, how_to_open) as out_file:\n for category in self.population[index].get_genes():\n out_file.write(''.join(category) + '\\t')\n out_file.write(\n '\\n{}\\n'.format(self.population[index].get_fitness())\n )","def _write_transact_types(self, file):\n for tp in self._transact_types:\n tp.write(file)\n file.write('\\n')","def write_compact(self, fout):\n for ignored in self.ignored_rules:\n fout.write(ignored)\n self.sort_decls()\n for (pos, (ss, pp)) in enumerate(self.cliques):\n fout.write(','.join(sorted(ss)))\n fout.write('{')\n fout.write(';'.join(pp))\n fout.write('}')","def write(self, outfile, rebasings=None):\r\n raise NotImplementedError()","def write_pypeit(self, output_path=None, cfg_lines=None,\n write_bkg_pairs=False, write_manual=False,\n configs=None, config_subdir=True,\n version_override=None, date_override=None):\n # Set output path\n if output_path is None:\n output_path = os.getcwd()\n\n # Find unique configurations, always ignoring any 'None'\n # configurations...\n cfg = self.unique_configurations(copy=True, rm_none=True)\n\n # Get the setups to write\n if configs is None or configs == 'all' or configs == ['all']:\n cfg_keys = list(cfg.keys())\n else:\n _configs = configs if isinstance(configs, list) else [configs]\n cfg_keys = [key for key in cfg.keys() if key in _configs]\n\n if len(cfg_keys) == 0:\n msgs.error('No setups to write!')\n\n # Grab output columns\n output_cols = self.set_pypeit_cols(write_bkg_pairs=write_bkg_pairs,\n write_manual=write_manual)\n\n # Write the pypeit files\n ofiles = [None]*len(cfg_keys)\n for j,setup in enumerate(cfg_keys):\n # Create the output directory\n root = '{0}_{1}'.format(self.spectrograph.name, setup)\n if config_subdir:\n odir = os.path.join(output_path, root)\n if not os.path.isdir(odir):\n os.makedirs(odir)\n else:\n odir = output_path\n # Create the output file name\n ofiles[j] = os.path.join(odir, '{0}.pypeit'.format(root))\n\n # Setup dict\n setup_dict = {}\n setup_dict[f'Setup {setup}'] = {}\n for key in cfg[setup]:\n setup_dict[f'Setup {setup}'][key] = cfg[setup][key]\n \n # Get the paths\n in_cfg = np.array([setup in _set for _set in self.table['setup']])\n if not np.any(in_cfg):\n continue\n paths = np.unique(self['directory'][in_cfg]).tolist()\n\n # Get the data lines\n subtbl = self.table[output_cols][in_cfg]\n if 'calib' in output_cols:\n # calib can be a str with a list of values because in some cases (e.g. MOSFIRE) the same\n # calibration files are used for different setups. Here we update calib to have only the\n # value relevant for this setup.\n # find the calib value in this setup that is not a list (which is probably a science/standard)\n no_list = np.array([',' not in str(cc) for cc in subtbl['calib']])\n if np.any(no_list):\n # assign the calib value in this setup that is not a list to frames that have calib as a list\n subtbl['calib'][np.logical_not(no_list)] = subtbl['calib'][no_list][0]\n subtbl.sort(['frametype','filename'])\n #with io.StringIO() as ff:\n # subtbl.write(ff, format='ascii.fixed_width')\n # data_lines = ff.getvalue().split('\\n')[:-1]\n\n # Config lines\n if cfg_lines is None:\n cfg_lines = ['[rdx]']\n cfg_lines += [' spectrograph = {0}'.format(self.spectrograph.name)]\n\n # Instantiate a PypeItFile\n pypeItFile = inputfiles.PypeItFile(cfg_lines, paths, subtbl, setup_dict)\n # Write\n pypeItFile.write(ofiles[j], version_override=version_override,\n date_override=date_override) \n\n # Return\n return ofiles","def _write_dataset(self):\n if self.output_file:\n if self.dryrun:\n sys.stdout.write(f\"{self.output_file.resolve()}\\n{self.parameter_study}\\n\")\n else:\n self.output_file.parent.mkdir(parents=True, exist_ok=True)\n self._conditionally_write_dataset(self.output_file, self.parameter_study)\n else:\n for parameter_set_file, parameter_set in self.parameter_study.groupby(_set_coordinate_key):\n parameter_set_file = pathlib.Path(parameter_set_file)\n # If no output file template is provided, print to stdout\n if not self.provided_output_file_template:\n sys.stdout.write(f\"{parameter_set_file.name}\\n{parameter_set}\")\n sys.stdout.write(\"\\n\")\n # If overwrite is specified or if file doesn't exist\n elif self.overwrite or not parameter_set_file.is_file():\n # If dry run is specified, print the files that would have been written to stdout\n if self.dryrun:\n sys.stdout.write(f\"{parameter_set_file.resolve()}:\\n{parameter_set}\")\n sys.stdout.write(\"\\n\")\n else:\n self._conditionally_write_dataset(parameter_set_file, parameter_set)","def export_manual_pipetting(args):\n if args.type == 'purify':\n clarity_epp.export.manual_pipetting.samplesheet_purify(lims, args.process_id, args.output_file)\n elif args.type == 'dilute_library_pool':\n clarity_epp.export.manual_pipetting.samplesheet_dilute_library_pool(lims, args.process_id, args.output_file)\n elif args.type == 'multiplex_library_pool':\n clarity_epp.export.manual_pipetting.samplesheet_multiplex_library_pool(lims, args.process_id, args.output_file)\n elif args.type == 'multiplex_sequence_pool':\n clarity_epp.export.manual_pipetting.samplesheet_multiplex_sequence_pool(lims, args.process_id, args.output_file)\n elif args.type == 'normalization':\n clarity_epp.export.manual_pipetting.samplesheet_normalization(lims, args.process_id, args.output_file)\n elif args.type == 'capture':\n clarity_epp.export.manual_pipetting.samplesheet_capture(lims, args.process_id, args.output_file)\n elif args.type == 'exonuclease':\n clarity_epp.export.manual_pipetting.sammplesheet_exonuclease(lims, args.process_id, args.output_file)\n elif args.type == 'pcr_exonuclease':\n clarity_epp.export.manual_pipetting.sammplesheet_pcr_exonuclease(lims, args.process_id, args.output_file)\n elif args.type == 'mip_multiplex_pool':\n clarity_epp.export.manual_pipetting.samplesheet_mip_multiplex_pool(lims, args.process_id, args.output_file)\n elif args.type == 'mip_dilute_pool':\n clarity_epp.export.manual_pipetting.samplesheet_mip_pool_dilution(lims, args.process_id, args.output_file)\n elif args.type == 'pool_samples':\n clarity_epp.export.manual_pipetting.samplesheet_pool_samples(lims, args.process_id, args.output_file)\n elif args.type == 'pool_magnis_pools':\n clarity_epp.export.manual_pipetting.samplesheet_pool_magnis_pools(lims, args.process_id, args.output_file)","def write_species(mcmc_set_name, model):\n species_filename = '%s_species.txt' % mcmc_set_name\n try:\n with open(species_filename, 'w') as f:\n #f.write('\\n'.join([str(s) for s in model.rules]))\n #f.write('\\n')\n f.write('\\n'.join([str(s) for s in model.species]))\n except IOError as e:\n pass\n return species_filename","def dump_parts(self, io):\n\n # XXX refactor with Tempita\n title = \"Parts created by the docutils writer '%s'\" % self.strategy.name\n io.say(title + os.linesep)\n io.say(len(title) * '-')\n io.say(2 * os.linesep)\n io.say('Part keys: ' + 2 * os.linesep)\n\n parts = self.publish_parts(io)\n io.say(os.linesep.join(sorted(parts.keys())))\n io.say(2 * os.linesep)\n for part in parts:\n io.say(\"Value of part '%s':%s\" % (part, os.linesep))\n io.say(parts[part].encode('utf-8') + os.linesep)\n io.say(80*'-'+os.linesep)\n io.say(os.linesep)","def Writefile(self, outfile, verbose=True):\n \n self.outfile = outfile\n \n # Write SUNTANS grid to file\n nc = Dataset(outfile, 'w', format='NETCDF3_CLASSIC')\n nc.Description = 'SUNTANS subsetted history file'\n nc.Author = ''\n nc.Created = datetime.now().isoformat()\n nc.type = 'SUNTANS HIS file'\n #pdb.set_trace()\n nc.createDimension('Nc', self.Nc)\n nc.createDimension('Np', self.Np)\n nc.createDimension('Ne', self.Ne)\n nc.createDimension('Nk', self.Nk)\n nc.createDimension('numsides', self.numsides)\n \n nc.createDimension('time', None)\n \n def write_nc_var(var, name, dimensions, units=None):\n nc.createVariable(name, 'f8', dimensions)\n if units is not None:\n nc.variables[name].units = units\n nc.variables[name][:] = var\n if verbose:\n print ' ... wrote ', name\n \n def create_nc_var(name, dimensions, units=None):\n nc.createVariable(name, 'f8', dimensions)\n if units is not None:\n nc.variables[name].units = units\n if verbose:\n print ' ... wrote ', name\n \n # Grid variables\n write_nc_var(self.xv, 'xv', ('Nc'))\n write_nc_var(self.yv, 'yv', ('Nc'))\n write_nc_var(self.xp, 'xp', ('Np'))\n write_nc_var(self.yp, 'yp', ('Np'))\n write_nc_var(self.xe, 'xe', ('Ne'))\n write_nc_var(self.ye, 'ye', ('Ne'))\n write_nc_var(self.dz, 'dz', ('Nk'))\n write_nc_var(self.dv, 'dv', ('Nc'))\n write_nc_var(self.Ac, 'Ac', ('Nc'))\n write_nc_var(self.Nk, 'Nk', ('Nc'))\n write_nc_var(self.face, 'face', ('Nc','numsides'))\n write_nc_var(self.mark, 'mark', ('Ne'))\n write_nc_var(self.cells, 'cells', ('Nc','numsides'))\n \n \n # Create the data variables\n create_nc_var('time',('time'),'seconds since 1990-01-01 00:00:00')\n create_nc_var('salt',('time','Nk','Nc'),'psu')\n create_nc_var('temp',('time','Nk','Nc'),'degrees C')\n create_nc_var('uc',('time','Nk','Nc'),'meter second-1')\n create_nc_var('vc',('time','Nk','Nc'),'meter second-1')\n create_nc_var('nu_v',('time','Nk','Nc'),'m2 s-1')\n create_nc_var('rho',('time','Nk','Nc'),'kg m-3')\n create_nc_var('tau_x',('time','Nc'),'N m-2')\n create_nc_var('tau_y',('time','Nc'),'N m-2')\n create_nc_var('eta',('time','Nc'),'m')\n \n nc.close()","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 write(self, out, ignored, displayOptions=None):\n # \"ignored\" argument for bw compat with rmake\n if displayOptions is None:\n displayOptions = {}\n\n if displayOptions.get('showLineOrigins', False):\n lineStrs = []\n curPath = None\n for path, lineNum in self.origins:\n if path == curPath:\n continue\n else:\n lineStrs.append('%s' % (path,))\n curPath = path\n if lineStrs:\n out.write('# %s: %s\\n' % (self.name, ' '.join(lineStrs)))\n for line in self.valueType.toStrings(self.value, displayOptions):\n out.write('%-25s %s\\n' % (self.name, line))","def write_out(self, content_content: str):\n print(\"[write_out] Computation name: \", self.comp_name)\n # meta_title_content object creation to return as a first part\n if self.write_out_part_counter < 0:\n metatitle_content = Content(self.comp_name, \"sdo:\\n\" + str(self.comp_name) + \"/streaming/p*\")\n self.queue_to_lower.put((self.packetid, metatitle_content))\n # self.cs.add_content_object(metatitle_content) TODO not needed? \n\n # actual content_object for streaming\n self.write_out_part_counter += 1\n content_name = self.comp_name\n content_name += \"/streaming/p\" + str(self.write_out_part_counter)\n content_object = Content(content_name, content_content)\n self.cs.add_content_object(content_object)\n print(\"[write_out] Last entry in content store:\", self.cs.get_container()[-1].content.name,\n self.cs.get_container()[-1].content.content)","def save_csv(self, filename: str, type='n', **args):\n if type == 'n':\n df = self.export_nodes()\n else:\n df = self.export_edges()\n df.to_csv(filename, index=False)","def write_out_v(vc2ptmk, ofn):\n print \"Writing out verbose to [{}]\".format(ofn)\n with codecs.open(ofn, \"w\", \"utf8\") as ofd:\n for (co, uri), infos in sorted(vc2ptmk.items()):\n for di in infos:\n ol = u\"{}\\t{}\\t{}\\t{}\\t{}\\n\".format(\n co, uri, di[\"ptmk\"], di[\"spk\"], di[\"sco\"])\n ofd.write(ol)","def _write_stats(self, stat_type, user=None, summ_type=None):\n if stat_type == \"full collection\":\n self.summary_file.write(\"\\n\\nDataset: {c}\\n\".format(c=self.dataset_name))\n self.summary_file.write(\"Number of unique urls: {u}\\nNumber of unique sites: {s}\\n\".format(u=len(set(self.stat_dict['urls'])), s=len(set(self.stat_dict['sites'])))\n )\n site_cnts = Counter(self.stat_dict['sites']).most_common()\n for site in site_cnts:\n self.summary_file.write(\"{s}: {n}\\n\".format(s=site[0], n=site[1]))\n\n if stat_type == \"token_counts\":\n self.summary_file.write(\"\\n\\nDataset: {c}\\n\".format(c=self.dataset_name))\n for doc_type in self.stat_dict:\n if user is not None:\n self.summary_file.write(\"\\n{0}, {1}\\n\".format(user, summ_type))\n\n self.summary_file.write(\n \"\\nNumber of {d}s: {p}\\nAverage tokens/{d}: {t}\\nAverage sentences/{d}: {s}\\n\".format(\n d=doc_type, p=len(self.stat_dict[doc_type][0]), t=sum(self.stat_dict[doc_type][1])/len(self.stat_dict[doc_type][1]), s=sum(self.stat_dict[doc_type][0])/len(self.stat_dict[doc_type][0])\n )\n )\n\n self.summary_file.write(\n \"Median tokens/{d}: {p}\\nStandard deviation tokens/{d}: {t}\\n\".format(\n d=doc_type, p=np.median(self.stat_dict[doc_type][1]), t=np.std(self.stat_dict[doc_type][1])\n )\n )\n\n self.summary_file.write(\n \"Median sentences/{d}: {p}\\nStandard deviation sentences/{d}: {t}\\n\".format(\n d=doc_type, p=np.median(self.stat_dict[doc_type][0]), t=np.std(self.stat_dict[doc_type][0])\n )\n )","def write_output(label1, label2, label3, submission_file):\n with open(submission_file, 'w') as f:\n f.write('Id,Bound'+ '\\n')\n for index, lab in enumerate(label1):\n f.write(str(index) + ',' + str(int(lab)) + '\\n')\n for index, lab in enumerate(label2):\n f.write(str(len(label1) + index) + ',' + str(int(lab)) + '\\n')\n for index, lab in enumerate(label3):\n f.write(str(len(label1) + len(label2) + index) + ',' + str(int(lab)))\n if index < len(label3) - 1:\n f.write('\\n')","def write(self,vname,kmz='out.kmz'):\n\n imgs=[] # to store a list of all images created\n content=[] # the content of the main kml\n vstr='files/%s_%05i.png' # format specification for images (all stored in `files/' subdirectory)\n\n # create empty files subdirectory for output images\n try:\n shutil.rmtree('files')\n except:\n pass\n os.makedirs('files')\n\n # loop through all time slices and create the image data\n # appending to the kml content string for each image\n for i in xrange(0,self.nstep,1):\n kml=ncNWRC(self.filename,istep=i)\n img=vstr % (vname,i)\n imgs.append(img)\n content.append(kml.image2kml(vname,img))\n\n # create the main kml file\n kml=ncNWRC.kmlstr % \\\n {'content':'\\n'.join(content),\\\n 'prog':ncNWRC.progname}\n\n # create a zipfile to store all images + kml into a single compressed file\n z=zipfile.ZipFile(kmz,'w',compression=zipfile.ZIP_DEFLATED)\n z.writestr(kmz[:-3]+'kml',kml)\n for img in imgs:\n z.write(img)\n z.close()","def write(self, cull=False):\n if cull:\n cull_prefixes(self).write()\n else:\n ser = self.g.serialize(format='nifttl', encoding='utf-8')\n with open(self.filename, 'wb') as f:\n f.write(ser)\n #print('yes we wrote the first version...', self.name)","def write(self, text):\n text = open(text, 'w')\n text.write('File type = \"ooTextFile\"\\n')\n text.write('Object class = \"TextGrid\"\\n\\n')\n text.write('xmin = %f\\n' % self.__xmin)\n text.write('xmax = %f\\n' % self.__xmax)\n text.write('tiers? <exists>\\n')\n text.write('size = %d\\n' % self.__n)\n text.write('item []:\\n')\n for (tier, n) in zip(self.__tiers, range(1, self.__n + 1)):\n text.write('\\titem [%d]:\\n' % n)\n if tier.__class__ == IntervalTier: \n text.write('\\t\\tclass = \"IntervalTier\"\\n')\n text.write('\\t\\tname = \"%s\"\\n' % tier.name())\n text.write('\\t\\txmin = %f\\n' % tier.xmin())\n text.write('\\t\\txmax = %f\\n' % tier.xmax())\n text.write('\\t\\tintervals: size = %d\\n' % len(tier))\n for (interval, o) in zip(tier, range(1, len(tier) + 1)): \n text.write('\\t\\t\\tintervals [%d]:\\n' % o)\n text.write('\\t\\t\\t\\txmin = %f\\n' % interval.xmin())\n text.write('\\t\\t\\t\\txmax = %f\\n' % interval.xmax())\n text.write('\\t\\t\\t\\ttext = \"%s\"\\n' % interval.mark())\n else: # PointTier\n text.write('\\t\\tclass = \"TextTier\"\\n')\n text.write('\\t\\tname = \"%s\"\\n' % tier.name())\n text.write('\\t\\txmin = %f\\n' % tier.xmin())\n text.write('\\t\\txmax = %f\\n' % tier.xmax())\n text.write('\\t\\tpoints: size = %d\\n' % len(tier))\n for (point, o) in zip(tier, range(1, len(tier) + 1)):\n text.write('\\t\\t\\tpoints [%d]:\\n' % o)\n text.write('\\t\\t\\t\\ttime = %f\\n' % point.time())\n text.write('\\t\\t\\t\\tmark = \"%s\"\\n' % point.mark())\n text.close()","def _write_data_out(solutions, unable_to_resolve, unresolvables):\n print('')\n print('------------------------')\n print('--- Progress So Far: ---')\n print('Solved: ' + str(len(solutions)))\n print('Error while resolving: ' + str(len(unable_to_resolve)))\n print('Unresolvable conflicts: ' + str(len(unresolvables)))\n print('Saving progress to json.')\n print('------------------------')\n print('')\n json.dump(solutions, open(fname_solutions, 'w'))\n json.dump(unable_to_resolve, open(fname_errors, 'w'))\n json.dump(unresolvables, open(fname_unresolvables, 'w'))","def ior_write_dataset(self):\n for oclass in self.obj_class:\n for sizes in self.ior_chu_trs_blk_size:\n # Skip the object type if server count does not meet the minimum\n # EC object server count\n if oclass[1] > self.server_count:\n continue\n self.ior_param_update(oclass, sizes)\n\n # Create the new container with correct redundancy factor\n # for EC object type\n self.ec_contaier_create(oclass[0])\n self.update_ior_cmd_with_pool(oclass=oclass[0],\n create_cont=False)\n # Start IOR Write\n self.container.uuid = self.ec_container.uuid\n self.start_ior_load(operation=\"WriteRead\", percent=1,\n create_cont=False)\n self.cont_uuid.append(self.ior_cmd.dfs_cont.value)","def _write_rocks(parameters):\n # Reorder rocks\n if parameters[\"rocks_order\"] is not None:\n order = parameters[\"rocks_order\"]\n for rock in parameters[\"rocks\"].keys():\n if rock not in order:\n order.append(rock)\n else:\n order = parameters[\"rocks\"].keys()\n\n # Formats\n fmt = block_to_format[\"ROCKS\"]\n fmt1 = str2format(fmt[1])\n fmt2 = str2format(fmt[2])\n\n fmt = block_to_format[\"RPCAP\"]\n fmt3 = str2format(fmt)\n\n out = []\n for k in order:\n # Load data\n data = parameters[\"rocks\"][k]\n\n # Number of additional lines to write per rock\n cond = any(\n data[k] is not None\n for k in [\n \"compressibility\",\n \"expansivity\",\n \"conductivity_dry\",\n \"tortuosity\",\n \"klinkenberg_parameter\",\n \"distribution_coefficient_3\",\n \"distribution_coefficient_4\",\n ]\n )\n nad = (\n 2\n if \"relative_permeability\" in data.keys() or \"capillarity\" in data.keys()\n else int(cond)\n )\n\n # Permeability\n per = data[\"permeability\"]\n per = [per] * 3 if not numpy.ndim(per) else per\n if not (isinstance(per, (list, tuple, numpy.ndarray)) and len(per) == 3):\n raise TypeError()\n\n # Record 1\n values = [\n k,\n nad if nad else \"\",\n data[\"density\"],\n data[\"porosity\"],\n per[0],\n per[1],\n per[2],\n data[\"conductivity\"],\n data[\"specific_heat\"],\n ]\n out += write_record(values, fmt1)\n\n # Record 2\n if cond:\n values = [\n data[\"compressibility\"],\n data[\"expansivity\"],\n data[\"conductivity_dry\"],\n data[\"tortuosity\"],\n data[\"klinkenberg_parameter\"],\n data[\"distribution_coefficient_3\"],\n data[\"distribution_coefficient_4\"],\n ]\n out += write_record(values, fmt2)\n else:\n out += write_record([], []) if nad == 2 else []\n\n # Relative permeability / Capillary pressure\n if nad == 2:\n for key in [\"relative_permeability\", \"capillarity\"]:\n if key in data.keys():\n values = [data[key][\"id\"], None]\n values += list(data[key][\"parameters\"])\n out += write_record(values, fmt3)\n else:\n out += write_record([], [])\n\n return out","def write(self, outputFile):\n \n try: \n f = open(outputFile + '.py', 'w')\n for trail in self.trails: \n f.write(\"[\")\n for index in trail:\n f.write(\"({0}, {1}), \".format(*index)) \n f.write(\"]\\n\")\n \n except IOError, e:\n msg = \"Exception encountered when attempting \" + \\\n \"to write data to file: {0}.\" + \\\n \"\\n\\t -- Exception was: {1}\" + \\\n \"\\n\\t For help use --help\".format(outputFile, e)\n raise Usage(e)","def print_cat(self):\n for ion in self.cations:\n data_str = (\"HETATM\", int(self.nmb) + ion, self.cations[ion][0], \"\",\n self.cations[ion][0],\"\", ion, \"\",\n Vector.x(self.cations[ion][1]), Vector.y(self.cations[ion][1]),\n Vector.z(self.cations[ion][1]), 1.00, 0.00,\n self.cations[ion][0], \"\",\"\\n\")\n out_str = self.pdb_format % data_str\n self.output.write(out_str)\n self.output.close()\n return 1","def write( data ):","def write_file(self):\n rl_df, lift_df = self.create_df()\n\n number = re.findall('\\d+', self.url)[0]\n\n if self.write is True:\n with open('house_{}.csv'.format(number), 'w',\n encoding='utf-8-sig') as file:\n rl_df.to_csv(file, sep=';')\n with open('house_lifts_{}.csv'.format(number), 'w',\n encoding='utf-8-sig') as file2:\n lift_df.to_csv(file2, sep=';')","def write(name, keyword, domain, citation, author, description, species, version, contact, license, values, output):\n write_namespace(\n name, keyword, domain, author, citation, values,\n namespace_description=description,\n namespace_species=species,\n namespace_version=version,\n author_contact=contact,\n author_copyright=license,\n file=output,\n )","def write(self):\n\t\traise NotImplementedError('%s: No write function implemented!' % self.name)"],"string":"[\n \"def _write_moleculetype(top_file: IO, mol_name: str, nrexcl: int = 3):\\n top_file.write(\\\"[ moleculetype ]\\\\n\\\")\\n top_file.write(\\\"; Name\\\\tnrexcl\\\\n\\\")\\n top_file.write(f\\\"{mol_name}\\\\t{nrexcl}\\\\n\\\\n\\\")\",\n \"def write(self, out):\",\n \"def write_output(self):\",\n \"def write(self):\",\n \"def write(self):\",\n \"def writeOutput(self, output):\",\n \"def write_readouts(path, dataset_dict, image_list, datasettype, mask_part,\\n do_wt1_signal, do_dach1_signal, do_stereology_pred, do_stereology_gt):\\n\\n titles = []\\n for i in range(len(image_list)):\\n image_name = os.path.split(image_list[i])[1]\\n titles.append(image_name[:-4])\\n\\n # Segmentation of only 1 class was applied (e.g. glomerulus or podocytes)\\n if len(mask_part) == 1:\\n mask_el = mask_part.pop()\\n\\n if mask_el == \\\"glomerulus\\\":\\n network_area = \\\"glomerulus_area\\\"\\n # Add a column if GET_WT1_SIGNAL_FOR_GLOMERULUS = True\\n if do_wt1_signal:\\n df = pd.DataFrame(\\n {'image_name': pd.Series(titles),\\n network_area: pd.Series(dataset_dict['area_preds_%s' % mask_el]),\\n 'mean_WT1_signal_in_glom': pd.Series(dataset_dict['mean_WT1_glom_preds']),\\n 'var_WT1_signal_in_glom': pd.Series(dataset_dict['var_WT1_glom_preds']),\\n 'median_WT1_signal_in_glom': pd.Series(dataset_dict['median_WT1_glom_preds']),\\n 'min_WT1_signal_in_glom': pd.Series(dataset_dict['min_WT1_glom_preds']),\\n 'max_WT1_signal_in_glom': pd.Series(dataset_dict['max_WT1_glom_preds']),\\n 'perc25_WT1_signal_in_glom': pd.Series(dataset_dict['perc25_WT1_glom_preds']),\\n 'perc75_WT1_signal_in_glom': pd.Series(dataset_dict['perc75_WT1_glom_preds'])})\\n else:\\n df = pd.DataFrame({'image_name': pd.Series(titles),\\n network_area: pd.Series(dataset_dict['area_preds_%s' % mask_el])})\\n\\n elif mask_el == \\\"podocytes\\\":\\n network_count = \\\"podocyte_count\\\"\\n network_area = \\\"podocyte_nuclear_area\\\"\\n # Add a column if GET_DACH1_SIGNAL_FOR_PODOCYTES = True\\n if do_dach1_signal:\\n df = pd.DataFrame({'image_name': pd.Series(titles),\\n network_count: pd.Series(dataset_dict['count_preds_%s' % mask_el]),\\n network_area: pd.Series(dataset_dict['area_preds_%s' % mask_el]),\\n 'mean_DACH1_signal_in_podo': pd.Series(dataset_dict['mean_DACH1_podo_preds']),\\n 'var_DACH1_signal_in_podo': pd.Series(dataset_dict['var_DACH1_podo_preds']),\\n 'median_DACH1_signal_in_podo': pd.Series(dataset_dict['median_DACH1_podo_preds']),\\n 'min_DACH1_signal_in_podo': pd.Series(dataset_dict['min_DACH1_podo_preds']),\\n 'max_DACH1_signal_in_podo': pd.Series(dataset_dict['max_DACH1_podo_preds']),\\n 'perc25_DACH1_signal_in_podo': pd.Series(dataset_dict['perc25_DACH1_podo_preds']),\\n 'perc75_DACH1_signal_in_podo': pd.Series(dataset_dict['perc75_DACH1_podo_preds'])\\n })\\n else:\\n df = pd.DataFrame({'image_name': pd.Series(titles),\\n network_count: pd.Series(dataset_dict['count_preds_%s' % mask_el]),\\n network_area: pd.Series(dataset_dict['area_preds_%s' % mask_el])})\\n\\n else:\\n raise ValueError('The name of the segmentation is not known:', mask_el)\\n\\n savepath = str(os.path.join(path, datasettype + '_Dataframe_' + mask_el))\\n df.to_csv(savepath + '.csv')\\n df.to_excel(savepath + '.xlsx')\\n\\n # Segmentation of 2 classes were applied (e.g. glomerulus and podocytes)\\n elif len(mask_part) == 2:\\n df = pd.DataFrame(\\n {'image_name': pd.Series(titles),\\n \\\"glomerulus_area\\\": pd.Series(dataset_dict['area_preds_%s' % mask_part[0]]),\\n \\\"podocyte_count\\\": pd.Series(dataset_dict['count_preds_%s' % mask_part[1]]),\\n \\\"podocyte_nuclear_area\\\": pd.Series(dataset_dict['area_preds_%s' % mask_part[1]])})\\n\\n # Add a column if GET_WT1_SIGNAL_FOR_GLOMERULUS = True\\n if do_wt1_signal:\\n df['mean_WT1_signal_in_glom'] = dataset_dict['mean_WT1_glom_preds']\\n df['var_WT1_signal_in_glom'] = dataset_dict['var_WT1_glom_preds']\\n df['median_WT1_signal_in_glom'] = dataset_dict['median_WT1_glom_preds']\\n df['min_WT1_signal_in_glom'] = dataset_dict['min_WT1_glom_preds']\\n df['max_WT1_signal_in_glom'] = dataset_dict['max_WT1_glom_preds']\\n df['perc25_WT1_signal_in_glom'] = dataset_dict['perc25_WT1_glom_preds']\\n df['perc75_WT1_signal_in_glom'] = dataset_dict['perc75_WT1_glom_preds']\\n\\n # Add a column if GET_DACH1_SIGNAL_FOR_PODOCYTES = True\\n if do_dach1_signal:\\n df['mean_DACH1_signal_in_podo'] = dataset_dict['mean_DACH1_podo_preds']\\n df['var_DACH1_signal_in_podo'] = dataset_dict['var_DACH1_podo_preds']\\n df['median_DACH1_signal_in_podo'] = dataset_dict['median_DACH1_podo_preds']\\n df['min_DACH1_signal_in_podo'] = dataset_dict['min_DACH1_podo_preds']\\n df['max_DACH1_signal_in_podo'] = dataset_dict['max_DACH1_podo_preds']\\n df['perc25_DACH1_signal_in_podo'] = dataset_dict['perc25_DACH1_podo_preds']\\n df['perc75_DACH1_signal_in_podo'] = dataset_dict['perc75_DACH1_podo_preds']\\n\\n if do_stereology_pred:\\n stereo_dict = get_stereology_readouts(dataset_dict, mask_part, titles, mode='pred')\\n # Add it to df\\n df['stereology_on_prediction-glomerular_volume_per_million'] = stereo_dict[\\\"glomerular_volume_per_million\\\"]\\n df['stereology_on_prediction-podocyte_count'] = stereo_dict[\\\"podocyte_count\\\"]\\n df['stereology_on_prediction-podocyte_density'] = stereo_dict[\\\"podocyte_density\\\"]\\n\\n if do_stereology_gt:\\n stereo_dict = get_stereology_readouts(dataset_dict, mask_part, titles, mode='gt')\\n # Add it to df\\n df['stereology_on_groundtruth-glomerular_volume_per_million'] = stereo_dict[\\\"glomerular_volume_per_million\\\"]\\n df['stereology_on_groundtruth-podocyte_count'] = stereo_dict[\\\"podocyte_count\\\"]\\n df['stereology_on_groundtruth-podocyte_density'] = stereo_dict[\\\"podocyte_density\\\"]\\n\\n savepath = str(os.path.join(path, datasettype + '_Dataframe_' + mask_part[0] + mask_part[1]))\\n df.to_csv(savepath + '.csv')\\n df.to_excel(savepath + '.xlsx')\\n return\",\n \"def writetif(self,outputname,):\\n pass\",\n \"def write(self, out):\\r\\n out.write('# {0:<11} {1:<6} {2:<6} {3:<6} {4}\\\\n'\\r\\n .format('Time(s)', 'X(mm)', 'Y(mm)', 'Z(um)', 'Tile'))\\r\\n for i in self: out.write(self.format_pt(i))\",\n \"def write_report(report, ftype):\\n if ftype == 'text':\\n msg = '{} disks have been removed\\\\n'.format(len(report))\\n msg += 'To replace them, run:\\\\n'\\n for device, action_args in report.items():\\n args = json.dumps(action_args, separators=(' ', '='))\\n args = args.replace('{', '').replace('}', '').replace('\\\"', '')\\n msg += 'juju run-action {} add-disk {} {}'.format(\\n hookenv.local_unit(), 'osd-devices=' + device, args)\\n else:\\n msg = json.dumps(report)\\n\\n hookenv.action_set({'message': msg})\",\n \"def do_write(self, args):\\n\\t\\tasplit = args.split(\\\" \\\")\\n\\t\\tfname = asplit[0]\\n\\t\\twhat = asplit[1]\\n\\n\\t\\tif what == \\\"summary\\\" or what == \\\"oldsummary\\\":\\n\\t\\t\\twith open(fname, 'w') as f:\\n\\t\\t\\t\\tform = DresherInterface.summary_format if what == \\\"summary\\\" else DresherInterface.oldsummary_format\\n\\t\\t\\t\\tfor i, x in enumerate(form):\\n\\t\\t\\t\\t\\tf.write(x)\\n\\t\\t\\t\\t\\tif i == len(form)-1:\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\n\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t#for lang in sorted(self.languages, key = lambda l: len(l._phones.keys())):\\n\\t\\t\\t\\t#\\tdw.writerow(dict(zip(form, [self.get_language_info(lang, x) for x in form])))\\n\\t\\t\\t\\tfor lang in sorted(self.languages, key = lambda l: len(l._phones.keys())):\\n\\t\\t\\t\\t\\tfor i, x in enumerate(form):\\n\\t\\t\\t\\t\\t\\tf.write(str(self.get_language_info(lang, x)))\\n\\t\\t\\t\\t\\t\\tif i == len(form)-1:\\n\\t\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\n\\\")\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\tif what == \\\"hierarchies\\\":\\n\\t\\t\\t# format: #vowels, langname, hierarchy, len(hier), #of marks, lfeats, inv, freq, \\n\\t\\t\\t# how many times each feat marked, the actual marks, vowel:feature set, unused features\\n\\t\\t\\t# take fname to be name of directory to write outfiles to\\n\\t\\t\\tif not os.path.exists(fname):\\n\\t\\t\\t\\tos.mkdir(fname)\\n\\t\\t\\tfor lang in self.languages:\\n\\t\\t\\t\\tnum_vowels = self.get_language_info(lang, \\\"linv\\\")\\n\\t\\t\\t\\tname = lang.name\\n\\t\\t\\t\\tnum_feats = self.get_language_info(lang, \\\"lfeats\\\")\\n\\t\\t\\t\\tinv = self.get_language_info(lang, \\\"inv\\\")\\n\\t\\t\\t\\tfreq = self.get_language_info(lang, \\\"freq\\\")\\n\\t\\t\\t\\tinv_feats = lang.phone_feat_dict\\n\\t\\t\\t\\twith open(os.path.join(fname,name.replace(\\\" \\\",\\\"\\\")+\\\".txt\\\"), 'w') as f:\\n\\t\\t\\t\\t\\tf.write(\\\"num_vowels\\\\tname\\\\thierarchy\\\\tlen_hier\\\\tnum_marks\\\\tnumfeats\\\\tinv\\\\tfreq\\\\tfeat_marks\\\\tinv_marks\\\\tinv_feats\\\\tunused_feats\\\\n\\\")\\n\\t\\t\\t\\t\\tfor h in lang.hierarchies:\\n\\t\\t\\t\\t\\t\\tf.write(str(num_vowels))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(name)\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(h))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(len(h)))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tspec = SDA(lang._phones, lang._features, h)\\n\\t\\t\\t\\t\\t\\tmarkedness = sum([x for phone in spec.keys() for x in spec[phone] if x == 1])\\n\\t\\t\\t\\t\\t\\tf.write(str(markedness))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(num_feats))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(inv))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(freq))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tfeat_counts = {f:sum([spec[phone][i] for phone in spec.keys() if spec[phone][i] == 1]) for i, f in enumerate(h)}\\n\\t\\t\\t\\t\\t\\tf.write(str(feat_counts))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(spec))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(inv_feats))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\t\\\")\\n\\t\\t\\t\\t\\t\\tf.write(str(list(set(lang._features)-set(h))))\\n\\t\\t\\t\\t\\t\\tf.write(\\\"\\\\n\\\")\\n\\t\\t# make sure all the threads that need to be finished have finished\\n\\t\\t# using .join() on the appropriate groups of threads\",\n \"def to_logchunk(self):\\n\\t\\tdemo_name = os.path.splitext(self.demo_name)[0]\\n\\t\\tto_write = [(\\\"Killstreak\\\", value, tick, date) for value, tick, date in self.killstreaks]\\n\\t\\tto_write.extend((\\\"Bookmark\\\", value, tick, date) for value, tick, date in self.bookmarks)\\n\\n\\t\\tto_write.sort(key = lambda t: t[2])\\n\\n\\t\\treturn \\\"\\\\n\\\".join(\\n\\t\\t\\tf'[{date}] {type_} {value} (\\\"{demo_name}\\\" at {tick})'\\n\\t\\t\\tfor type_, value, tick, date in to_write\\n\\t\\t)\",\n \"def write_output(self,content):\\n text=\\\"\\\"\\\"# typ eta phi pt jmass ntrk btag had/em dummy dummy\\\\n\\\"\\\"\\\"\\n self.output.writelines(text)\\n text=\\\"0 \\\"+str(self.nb_data)+\\\" \\\"+str(len(content))+\\\"\\\\n\\\"\\n self.output.writelines(text)\\n\\n i=1\\n for particle in content:\\n text=str(i)+' '+particle.lhco_line()+'\\\\n'\\n self.output.writelines(text)\\n i+=1\",\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 dump_cuts_list(self, file_name):\\n assert(file_name is not None)\\n with open(file_name, 'w') as fd:\\n uids = self._cuts.keys()\\n uids.sort()\\n for cut_uid in uids:\\n cut = self._cuts[cut_uid]\\n fd.write(cut.get_cost_var() + \\\" \\\" + str(cut.get_cost()) + \\\"\\\\n\\\")\\n return\",\n \"def write_out(c2ptmk, ofn):\\n print \\\"Writing out to [{}]\\\".format(ofn)\\n with codecs.open(ofn, \\\"w\\\", \\\"utf8\\\") as ofd:\\n for co, infos in sorted(c2ptmk.items()):\\n ofd.write(u\\\"{}\\\\t{}\\\\t{}\\\\n\\\".format(\\n co, infos[\\\"uri\\\"], \\\",\\\".join(\\n [unicode(x) for x in infos[\\\"ptmks\\\"]])))\",\n \"def write_run(run):\\n r=Run(run)\\n r.write_all()\",\n \"def write_analysis(path, dataset_dict, datasettype, mask_part, start_time, supervised=True):\\n for mask_el in mask_part:\\n if mask_el == 'podocytes':\\n filename = datasettype + '_podos.txt'\\n filestr = 'podos images'\\n elif mask_el == 'glomerulus':\\n filename = datasettype + '_gloms.txt'\\n filestr = 'gloms images'\\n else:\\n filename = datasettype + 'unknown.txt'\\n filestr = 'unknown type'\\n\\n write_txt = open(str(os.path.join(path, filename)), \\\"w\\\")\\n\\n if supervised:\\n dc_mean = np.sum(np.array(dataset_dict['dice_coeffs_%s' % mask_el])) / len(dataset_dict['dice_coeffs_%s'\\n % mask_el])\\n dc_min = np.min(np.array(dataset_dict['dice_coeffs_%s' % mask_el]))\\n dc_max = np.max(np.array(dataset_dict['dice_coeffs_%s' % mask_el]))\\n object_dc_mean = np.sum(np.array(dataset_dict['object_dc_%s' % mask_el])) / len(dataset_dict['object_dc_%s'\\n % mask_el])\\n object_dc_min = np.min(np.array(dataset_dict['object_dc_%s' % mask_el]))\\n object_dc_max = np.max(np.array(dataset_dict['object_dc_%s' % mask_el]))\\n pearson = calculate_pearson(dataset_dict['count_masks_%s' % mask_el], dataset_dict['count_preds_%s'\\n % mask_el])\\n\\n write_txt.write(str(\\\"Mean dice coefficient on pixels of \\\" + filestr + \\\" compared to groundtruth: \\\") +\\n str(dc_mean) + '\\\\n')\\n write_txt.write(str(\\\"Min dice coefficient on pixels of \\\" + filestr + \\\" compared to groundtruth: \\\") +\\n str(dc_min) + '\\\\n')\\n write_txt.write(str(\\\"Max dice coefficient on pixels of \\\" + filestr + \\\" compared to groundtruth: \\\") +\\n str(dc_max) + '\\\\n')\\n write_txt.write(str(\\\"Pearson correlation coefficient on objects of \\\" + filestr +\\n \\\" compared to groundtruth: \\\") + str(pearson) + '\\\\n')\\n write_txt.write(str(\\\"Mean dice coeff on objects of \\\" + filestr + \\\" compared to groundtruth: \\\") +\\n str(object_dc_mean) + '\\\\n')\\n write_txt.write(str(\\\"Min dice coeff on objects of \\\" + filestr + \\\" compared to groundtruth: \\\") +\\n str(object_dc_min) + '\\\\n')\\n write_txt.write(str(\\\"Max dice coeff on objects of \\\" + filestr + \\\" compared to groundtruth: \\\") +\\n str(object_dc_max) + '\\\\n')\\n write_txt.write('\\\\n')\\n\\n duration = time.time() - start_time\\n duration_std = int(duration / 3600)\\n duration_min = int((duration % 3600) / 60)\\n duration_sec = int(duration % 60)\\n\\n write_txt.write(str(\\\"Test time: \\\") + str(duration_std) + \\\"h \\\" + str(duration_min)\\n + \\\"min \\\" + str(duration_sec) + 'sec \\\\n')\\n write_txt.close()\\n return\",\n \"def writeClumptoDump(self,ID):\\n clumpxyz = self.clumpcat[ID][:3]\\n r2 = (self.disc.xyzh[0]-clumpxyz[0])**2 + (self.disc.xyzh[1]-clumpxyz[1])**2\\n members = np.sqrt(r2) < self.annulus #members are all particles within radial annulus\\n\\n gas = self.disc.itype == 1\\n dust = self.disc.itype == 2\\n\\n dustfrac = self.disc.dustfrac*1e8 #as I originally set dust-to-gas=1e-10\\n\\n #Calculate temperatures from thermal energies\\n k = 1.38064852e-16 #ergs\\n mH = 1.6735575e-24 #grams\\n gmw = 2.381 #mean mass taken from Phantom\\n N = sum(gas*self.disc.massofgas)*self.umass/mH/gmw #number of atoms\\n temp = 2.*self.disc.utherm*self.uenerg/3./k/N\\n\\n\\t\\tutime = self.utime/(60*60*24*365.25)\\n\\n\\t\\t#create arrays of particle masses\\n\\t\\tmass = np.zeros(len(self.disc.xyzh[0,:]))\\n\\t\\tmass[self.disc.itype == 1] = self.disc.massofgas\\n\\t\\tmass[self.disc.itype == 2] = self.disc.massofdust\\n\\n\\t\\tclumpdata = zip(self.disc.xyzh[0,members], self.disc.xyzh[1,members], self.disc.xyzh[2,members], \\n self.disc.xyzh[3,members], self.disc.density[members], mass[members], \\n temp[members], dustfrac[members], self.disc.itype[members])\\n\\t\\tclumpdata = np.asarray(clumpdata)\\n\\t\\theader = (\\\"time: %s utime (yrs^-1): %s \\\\n x, y, z, h, density, mass, temp, \\\" %(str(self.disc.time), str(utime)) +\\n\\t\\t\\t \\\"dustfrac, itype \\\\n %s, %s, %s, %s, %s, %s, 0.0, 0.0, 0.0 \\\\n \\\\n\\\" %(str(self.udist), str(self.udist),\\n\\t\\t\\t \\t\\t\\t\\t\\t\\t\\t\\t str(self.udist), str(self.udist),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t str(self.udens), str(self.umass)))\\n\\t\\tnp.savetxt('%s/clumpfiles/clumpdata_%.0f.txt' %(self.wd,self.disc.time), clumpdata, header=header)\",\n \"def write_pc_cards(bc_file, bc_class):\\n bc_file.write('! Output Control\\\\n')\\n oc = bc_class.output_control\\n objects = list(oc.param.output_control_option.get_range())\\n if oc.output_control_option == objects[0]:\\n bc_file.write('OC {}\\\\n'.format(oc.oc_time_series_id))\\n ofs = oc.output_flow_strings\\n if not ofs.empty:\\n bc_file.write(ofs.to_csv(sep=' ', na_rep='', index=False, header=False,).replace('\\\\r\\\\n', '\\\\n'))\\n\\n if oc.print_adaptive_mesh:\\n bc_file.write('PC ADP\\\\n')\\n if oc.print_numerical_fish_surrogate:\\n bc_file.write('PC ELM\\\\n')\\n if oc.screen_output_residual:\\n bc_file.write('SOUT RESID\\\\n')\\n if oc.screen_output_all:\\n bc_file.write('SOUT ALL\\\\n')\\n if oc.screen_output_mass_error:\\n bc_file.write('SOUT MERROR\\\\n')\\n if oc.screen_output_worst_nonlinear_node:\\n bc_file.write('SOUT NLNODE\\\\n')\\n if oc.screen_output_worst_linear_node:\\n bc_file.write('SOUT LNODE\\\\n')\\n if oc.file_output_wind:\\n bc_file.write('FOUT WIND\\\\n')\\n if oc.file_output_wave:\\n bc_file.write('FOUT WAVE\\\\n')\\n if oc.file_output_adapted_grid:\\n bc_file.write('FOUT ADAPT GRID\\\\n')\\n if oc.file_output_adapted_solution:\\n bc_file.write('FOUT ADAPT SW\\\\n')\\n if oc.file_output_adapted_transport:\\n bc_file.write('FOUT ADAPT CON\\\\n')\\n if oc.file_output_sediment:\\n bc_file.write('FOUT SED\\\\n')\\n\\n bc_file.write('\\\\n') # blank line after Output Control\",\n \"def write_tcv(self):\\n suffix = '_'+str(self.shot)+'_'+str(int(self.t*1e3))\\n self.write_input(suffix=suffix)\",\n \"def write(self, file_name, *, file_type=None, precision=None, write_patch_results=False):\\n self.logger.info('Writing KG correlations to %s',file_name)\\n precision = self.config.get('precision', 4) if precision is None else precision\\n name = 'main' if write_patch_results else None\\n with make_writer(file_name, precision, file_type, self.logger) as writer:\\n self._write(writer, name, write_patch_results)\",\n \"def sitofp(self, typ):\",\n \"def write_fits(self, name=None, output_path=None):\\n pass\",\n \"def write_to(self, stream: StreamWrapper):\\n stream.write_int(len(self.moves))\\n for element in self.moves:\\n element.write_to(stream)\\n stream.write_int(len(self.buildings))\\n for element in self.buildings:\\n element.write_to(stream)\\n if self.choose_specialty is None:\\n stream.write_bool(False)\\n else:\\n stream.write_bool(True)\\n stream.write_int(self.choose_specialty)\",\n \"def write(self, outfile):\\n outfile.write(\\n '\\\\t'.join(\\n [\\n str(i) for i in [\\n self.chrom, self.start, self.end, self.name,\\n self.count, self.fold_change, self.log10p\\n ]\\n ]\\n )\\n )\\n outfile.write('\\\\n')\",\n \"def write_output_files(self, file_type, output, expected):\\n actual_filename = self.output_filename(self.FILENAME_SUFFIX_ACTUAL + file_type)\\n expected_filename = self.output_filename(self.FILENAME_SUFFIX_EXPECTED + file_type)\\n\\n self._write_file(actual_filename, output)\\n self._write_file(expected_filename, expected)\",\n \"def export_summary(\\n self,\\n output_dir=None,\\n solution_name=None,\\n type=\\\"Object\\\",\\n geometryType=\\\"Volume\\\",\\n quantity=\\\"Temperature\\\",\\n variation=\\\"\\\",\\n variationlist=[],\\n ):\\n all_objs = list(self.modeler.oeditor.GetObjectsInGroup(\\\"Solids\\\"))\\n all_objs_NonModeled = list(self.modeler.oeditor.GetObjectsInGroup(\\\"Non Model\\\"))\\n all_objs_model = [item for item in all_objs if item not in all_objs_NonModeled]\\n arg = []\\n self.logger.glb.info(\\\"Objects lists \\\" + str(all_objs_model))\\n for el in all_objs_model:\\n try:\\n self.osolution.EditFieldsSummarySetting(\\n [\\\"Calculation:=\\\", [type, geometryType, el, quantity, \\\"\\\", \\\"Default\\\"]]\\n )\\n arg.append(\\\"Calculation:=\\\")\\n arg.append([type, geometryType, el, quantity, \\\"\\\", \\\"Default\\\"])\\n except Exception as e:\\n self.logger.glb.error(\\\"Object \\\" + el + \\\" not added.\\\")\\n self.logger.glb.error(str(e))\\n if not output_dir:\\n output_dir = self.project_path\\n self.osolution.EditFieldsSummarySetting(arg)\\n if not os.path.exists(output_dir):\\n os.mkdir(output_dir)\\n if not solution_name:\\n solution_name = self.nominal_sweep\\n if variation:\\n for l in variationlist:\\n self.osolution.ExportFieldsSummary(\\n [\\n \\\"SolutionName:=\\\",\\n solution_name,\\n \\\"DesignVariationKey:=\\\",\\n variation + \\\"='\\\" + str(l) + \\\"'\\\",\\n \\\"ExportFileName:=\\\",\\n os.path.join(output_dir, \\\"IPKsummaryReport\\\" + quantity + \\\"_\\\" + str(l) + \\\".csv\\\"),\\n ]\\n )\\n else:\\n self.osolution.ExportFieldsSummary(\\n [\\n \\\"SolutionName:=\\\",\\n solution_name,\\n \\\"DesignVariationKey:=\\\",\\n \\\"\\\",\\n \\\"ExportFileName:=\\\",\\n os.path.join(output_dir, \\\"IPKsummaryReport\\\" + quantity + \\\".csv\\\"),\\n ]\\n )\\n return True\",\n \"def write(self):\\n pass\",\n \"def write(self):\\n pass\",\n \"def cutPaper(self, cut='partial', feed=True):\\n if cut not in ['partial', 'full']:\\n raise ValueError('cut must be \\\\'partial\\\\' or \\\\'full\\\\'')\\n elif type(feed) is not bool:\\n raise ValueError('feed must be True or False')\\n else:\\n value = 0 if cut == 'full' else 1\\n value += 65 if feed else 0\\n self._write(self.__class__.__GS + 'V' + chr(value))\",\n \"def cut_to_summary(file_name, directory, leave_out=[]):\\n i = 0\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n with open(file_name) as to_cut:\\n line = to_cut.readline()\\n while line != \\\"\\\" and line is not None:\\n if i in leave_out:\\n i += 1\\n print(line)\\n f = open(\\\"{}/summary_{}.txt\\\".format(directory, i), \\\"w\\\")\\n f.write(line)\\n f.close()\\n i += 1\\n line = to_cut.readline()\\n print(file_name, i)\",\n \"def export(self, file: TextIO) -> None:\\n file.write(f'\\\"{self.name}\\\"\\\\n\\\\t{{\\\\n')\\n file.write(f'\\\\tchannel {self.channel}\\\\n')\\n file.write(f'\\\\tsoundlevel {join_float(self.level)}\\\\n')\\n\\n if self.volume != (1, 1):\\n file.write(f'\\\\tvolume {join_float(self.volume)}\\\\n')\\n if self.pitch != (100, 100):\\n file.write(f'\\\\tpitch {join_float(self.pitch)}\\\\n')\\n\\n if len(self.sounds) != 1:\\n file.write('\\\\trndwave\\\\n\\\\t\\\\t{\\\\n')\\n for wav in self.sounds:\\n file.write(f'\\\\t\\\\twave \\\"{wav}\\\"\\\\n')\\n file.write('\\\\t\\\\t}\\\\n')\\n else:\\n file.write(f'\\\\twave \\\"{self.sounds[0]}\\\"\\\\n')\\n\\n if self.force_v2 or self.stack_start or self.stack_stop or self.stack_update:\\n file.write(\\n '\\\\t' 'soundentry_version 2\\\\n'\\n '\\\\t' 'operator_stacks\\\\n'\\n '\\\\t\\\\t' '{\\\\n'\\n )\\n if self.stack_start:\\n file.write(\\n '\\\\t\\\\t' 'start_stack\\\\n'\\n '\\\\t\\\\t\\\\t' '{\\\\n'\\n )\\n for prop in self.stack_start:\\n for line in prop.export():\\n file.write('\\\\t\\\\t\\\\t' + line)\\n file.write('\\\\t\\\\t\\\\t}\\\\n')\\n if self.stack_update:\\n file.write(\\n '\\\\t\\\\t' 'update_stack\\\\n'\\n '\\\\t\\\\t\\\\t' '{\\\\n'\\n )\\n for prop in self.stack_update:\\n for line in prop.export():\\n file.write('\\\\t\\\\t\\\\t' + line)\\n file.write('\\\\t\\\\t\\\\t}\\\\n')\\n if self.stack_stop:\\n file.write(\\n '\\\\t\\\\t' 'stop_stack\\\\n'\\n '\\\\t\\\\t\\\\t' '{\\\\n'\\n )\\n for prop in self.stack_stop:\\n for line in prop.export():\\n file.write('\\\\t\\\\t\\\\t' + line)\\n file.write('\\\\t\\\\t\\\\t}\\\\n')\\n file.write('\\\\t\\\\t}\\\\n')\\n file.write('\\\\t}\\\\n')\",\n \"def write(self):\\n raise NotImplementedError\",\n \"def save(self):\\n \\n fileName=self.characterName+\\\"_\\\"+self.race+\\\"_\\\"+self.classType+\\\"_lvl_\\\"+str(self.level)\\n new_file = open(str(fileName)+\\\".txt\\\",\\\"w\\\")\\n new_file.write(\\\"~~~~~~~~~~~ \\\"+self.characterName+\\\" the \\\"+self.race+\\\" \\\"+self.classType+\\\" ~~~~~~~~~~~\\\\n\\\\n\\\")\\n new_file.write(\\\"Level: \\\"+str(self.level)+\\\" HP: \\\"+str(self.hp)+\\\" XP: \\\"+str(self.xp)+\\\" Hit Dice: \\\"+str(self.level)+str(self.hit_dice[self.classType])+\\\"\\\\n\\\")\\n new_file.write(str(self.abilityScores()))\\n new_file.write(\\\"\\\\n\\\\n~~~~~~~~~ Skills ~~~~~~~~~\\\\n\\\")\\n for i in self.skills:\\n new_file.write(\\\"\\\\n\\\"+i+\\\" \\\"+\\\"(\\\"+skills[i.lower()].upper()+\\\")\\\")\\n new_file.write(\\\"\\\\n\\\\n~~~~~~~~~ Traits ~~~~~~~~~\\\\n\\\")\\n for i in self.traits:\\n new_file.write(\\\"\\\\n ~~\\\"+i+\\\"~~\\\\n \\\"+str(self.traits[i])+\\\"\\\\n\\\")\\n new_file.write(\\\"\\\\n\\\\n~~~~~~~~~ Specialty: \\\"+self.specialty+\\\" ~~~~~~~~\\\\n\\\")\\n new_file.write(\\\"\\\\n \\\"+self.specialtyStory+\\\"\\\\n\\\")\\n new_file.write(\\\"\\\\n ~~~~ Feats ~~~~\\\\n\\\")\\n for i in range(1,self.level+1):\\n if i == 1 or i%3 == 0:\\n new_file.write(\\\"\\\\n Level \\\"+str(i)+\\\": \\\"+self.feats[i]['name']+' '\\\\\\n \\\"(\\\"+self.feats[i]['type']+\\\")\\\\n\\\"\\\\\\n ' \\\"'+self.feats[i]['description']+'\\\"\\\\n\\\\n')\\n if 'prereq' in self.feats[i]:\\n new_file.write(\\\" Prerequisite: \\\"+self.feats[i]['prereq']+\\\"\\\\n\\\")\\n if 'benefit' in self.feats[i]:\\n new_file.write(\\\" Benefit: \\\"+self.feats[i]['benefit']+\\\"\\\\n\\\")\\n if 'effect' in self.feats[i]:\\n new_file(\\\" Effect: \\\"+self.feats[i]['effect']+\\\"\\\\n\\\")\\n \\n new_file.write(\\\"\\\\n\\\\n~~~~~~~~~ Background: \\\"+self.background+\\\" ~~~~~~~~\\\\n\\\")\\n if self.backgroundProfession == '':\\n pass\\n else:\\n new_file.write(\\\"Profession: \\\"+self.backgroundProfession)\\n new_file.write(\\\"\\\\n \\\"+self.backgroundStory)\\n \\n new_file.close()\\n print \\\"File \\\"+str(fileName)+\\\".txt saved.\\\"\",\n \"def write_output(self) -> None:\\n self.home.round(2).to_csv(var.indicators_base_cumsum + \\\"home_\\\" + str(self.year) + \\\".csv\\\")\\n self.away.round(2).to_csv(var.indicators_base_cumsum + \\\"away_\\\" + str(self.year) + \\\".csv\\\")\",\n \"def writeDataCards(opt,sigExp,bkgExp,shapesURL):\\n\\n #create a card per category\\n dcList=[]\\n for icat in range(len(opt.categs)):\\n cat='%s_a%d_%d'%(opt.chTag,opt.xangle,icat)\\n dcTxt='%s/shapes-parametric.datacard_%s.dat'%(opt.output,cat)\\n dcList.append(dcTxt)\\n with open(dcTxt,'w') as dc:\\n dc.write('#\\\\n')\\n dc.write('# datacard was automatically generated with generateWorkspace.py\\\\n')\\n dc.write('# the options passed are printed below\\\\n')\\n dc.write('# %s\\\\n'%opt)\\n dc.write('#\\\\n')\\n dc.write('imax *\\\\n')\\n dc.write('jmax *\\\\n')\\n dc.write('kmax *\\\\n')\\n dc.write('-'*50+'\\\\n')\\n dc.write('shapes * * {0} $PROCESS_{1} $PROCESS_$SYSTEMATIC\\\\n'.format(shapesURL,cat))\\n dc.write('shapes data_obs * {0} $PROCESS_{1}\\\\n'.format(shapesURL,cat))\\n dc.write('-'*50+'\\\\n')\\n dc.write('bin %s\\\\n'%cat)\\n dc.write('observation -1\\\\n')\\n dc.write('-'*50+'\\\\n')\\n dc.write('%15s %15s %15s\\\\n'%('bin',cat,cat))\\n dc.write('%15s %15s %15s\\\\n'%('process','sig','bkg'))\\n dc.write('%15s %15s %15s\\\\n'%('process','0', '1'))\\n dc.write('%15s %15s %15s\\\\n'%('rate','%3.2f'%sigExp[icat], '%3.2f'%bkgExp[icat]))\\n dc.write('-'*50+'\\\\n')\\n \\n #float the background normalization as well as the signal\\n dc.write('mu_bkg{0} rateParam {0} bkg 1\\\\n'.format(cat))\\n\\n #uncertainties\\n dc.write('lumi %8s %15s %15s\\\\n'%('lnN','1.027','-'))\\n dc.write('%s_sigShape %8s %15s %15s\\\\n'%(cat,'shape','1','-'))\\n dc.write('%s_bkgShape %8s %15s %15s\\\\n'%(cat,'shape','-','1'))\\n dc.write('{0} autoMCStats 0.0 1\\\\n'.format(cat))\\n \\n print '\\\\tshapes available @',shapesURL\\n print '\\\\tgenerated the following datacards',dcList\",\n \"def _write_sets(self, size, card_writer):\\n msg = []\\n if (self.sets or self.setsSuper or self.asets or self.bsets or\\n self.csets or self.qsets):\\n msg.append('$SETS\\\\n')\\n for (unused_id, set_obj) in sorted(self.sets.iteritems()): # dict\\n msg.append(set_obj.write_bdf(size, card_writer))\\n for set_obj in self.asets: # list\\n msg.append(set_obj.write_bdf(size, card_writer))\\n for set_obj in self.bsets: # list\\n msg.append(set_obj.write_bdf(size, card_writer))\\n for set_obj in self.csets: # list\\n msg.append(set_obj.write_bdf(size, card_writer))\\n for set_obj in self.qsets: # list\\n msg.append(set_obj.write_bdf(size, card_writer))\\n for (set_id, set_obj) in sorted(self.setsSuper.iteritems()): # dict\\n msg.append(set_obj.write_bdf(size, card_writer))\\n return ''.join(msg)\",\n \"def write_collected(self, names_file, kb_file, cat_file):\\n with open(names_file, 'w') as fp:\\n for kb_id, name in self.collected_names.items():\\n fp.write('\\\\t'.join(['name', kb_id, name]) + '\\\\n')\\n with open(kb_file, 'w') as fp:\\n for kb_id, tail_set in self.collected_edges.items():\\n for (rel, tail_id) in tail_set:\\n fp.write('\\\\t'.join([rel, kb_id, tail_id]) + '\\\\n')\\n with open(cat_file, 'w') as fp:\\n for c, ms in self.collected_cat_mems.items():\\n fp.write(c + '\\\\t' + self.kb[c].name + '\\\\t')\\n fp.write('|'.join(ms) + '\\\\n')\",\n \"def write():\\n pass\",\n \"def writeKittiSubmission(data, prefix, index, type='stereo'):\\r\\n if type=='stereo':\\r\\n data = data*256.0\\r\\n data[data<1.0] = 1.0\\r\\n data = data.astype(np.uint16)\\r\\n cv2.imwrite(prefix+'/%06d_10.png' % index, data)\\r\\n elif type=='flow':\\r\\n # TODO: I didn't check this part\\r\\n # please refer to io_flow.h in KITTI 2015 development KIT, if you have any questions\\r\\n # in BGR order\\r\\n flow = np.zeros(data.shape[:2]+(3,))\\r\\n flow[:, :, 1] = data[:, :, 1]\\r\\n flow[:, :, 2] = data[:, :, 0]\\r\\n flow[:, :, 1:] = flow[:, :, 1:] * 64.0 + 32768.0\\r\\n flow[flow<0.0] = 0.0\\r\\n flow[flow>65535] = 65535\\r\\n flow[:, :, 0] = 1\\r\\n flow = flow.astype(np.uint16)\\r\\n cv2.imwrite(prefix + '/%06d_10.png' % index, flow)\",\n \"def write(self):\\n self.output_directory.mkdir(parents=True, exist_ok=True)\\n parameter_set_files = [pathlib.Path(set_name) for set_name in\\n self.parameter_study.coords[_set_coordinate_key].values]\\n if self.write_meta and self.provided_output_file_template:\\n self._write_meta(parameter_set_files)\\n if self.output_file_type == 'h5':\\n self._write_dataset()\\n elif self.output_file_type == 'yaml':\\n self._write_yaml(parameter_set_files)\\n else:\\n raise ValueError(f\\\"Unsupported output file type '{self.output_file_type}'\\\")\",\n \"def write(self, unknown_category):\\n\\n self.unknown_category = unknown_category\\n rules, lexicon = self.generate_rules_and_lexicon()\\n self.rules_generated = u' '.join(map(u''.join, rules))\\n cPickle.dump(lexicon, open(self.get_file_path('lexicon'), 'wb'))\\n if not self.rich_upper:\\n dictionary = self.generate_dictionary(lexicon)\\n cPickle.dump(dictionary, open(self.get_file_path('dictionary'), 'wb'))\\n script_path = self.get_file_path('script')\\n binary_path = self.get_file_path('binary')\\n compiler_path = self.get_file_path('compiler')\\n with open(compiler_path, 'w') as f:\\n if self.script_type == 'lexc':\\n f.write('#!/bin/sh\\\\nfoma -e \\\"read lexc %s\\\" -e \\\"save stack %s\\\" -e \\\"quit\\\"' % (\\n script_path, binary_path))\\n else:\\n f.write('#!/bin/sh\\\\nfoma -e \\\"source %s\\\" -e \\\"regex morphology;\\\" '\\n '-e \\\"save stack %s\\\" -e \\\"quit\\\"' % (script_path, binary_path))\\n os.chmod(compiler_path, 0744)\\n morphology_generator = self.get_morphology_generator(rules, lexicon)\\n with codecs.open(script_path, 'w', 'utf8') as f:\\n for line in morphology_generator:\\n f.write(line)\",\n \"def write_type_scores(path, lines):\\n\\n print \\\"Opening %s for score output\\\" % base_name(path)\\n headers = [\\\"Type\\\", \\\"Total\\\", \\\"Detection\\\", \\\"Detection (%)\\\",\\n \\\"Recognition\\\", \\\"Recognition (%)\\\",\\n \\\"Correction\\\", \\\"Correction (%)\\\"]\\n\\n write_csv(path, lines, headers)\",\n \"def _write_executive_control_deck(self):\\n msg = ''\\n if self.executive_control_lines:\\n msg = '$EXECUTIVE CONTROL DECK\\\\n'\\n if self.sol == 600:\\n newSol = 'SOL 600,%s' % self.solMethod\\n else:\\n newSol = 'SOL %s' % self.sol\\n\\n if self.iSolLine is not None:\\n self.executive_control_lines[self.iSolLine] = newSol\\n\\n for line in self.executive_control_lines:\\n msg += line + '\\\\n'\\n return msg\",\n \"def write(self, mode):\\n if mode == \\\"pretrain\\\":\\n out_tmp = self.log_buffer.output\\n log_string = (\\\"Pre-Tr ep [{}/{}] it [{}/{}] BT {:.3f} DT {:.3f} acc {:.3f}\\\\n\\\"\\n \\\"loss_total {:.3f}\\\").format(\\n self.epoch+1, self.max_epochs, self.iter, self.max_iters,\\n out_tmp[\\\"batch_time\\\"], out_tmp[\\\"data_time\\\"],\\n self.acc, out_tmp[\\\"train/loss/total\\\"])\\n self.logger.info(log_string)\\n\\n elif mode == \\\"train\\\":\\n out_tmp = self.log_buffer.output\\n log_string = (\\\"Tr loop {} ep [{}/{}] it [{}/{}] BT {:.3f} DT {:.3f} acc {:.3f}\\\\n\\\"\\n \\\"loss_total {:.3f} loss_C {:.3f} loss_GD {:.3f}\\\\n\\\"\\n \\\"score: max {:.2f} min {:.2f} mean {:.2f} select {} samples in latest iteration\\\").format(\\n self.loop+1, self.epoch+1, self.max_epochs+self.cfg.warmup_epochs, self.iter, self.actual_max_iters,\\n out_tmp[\\\"batch_time\\\"], out_tmp[\\\"data_time\\\"], self.acc,\\n out_tmp[\\\"train/loss/total\\\"], out_tmp[\\\"train/loss/loss_C\\\"],\\n out_tmp[\\\"train/loss/loss_GD\\\"],\\n *self.meta[\\\"score_statistic\\\"],\\n self.meta[\\\"n_select\\\"])\\n\\n self.logger.info(log_string)\\n type(self).__base__.__base__.__base__.write(self)\\n\\n elif mode == \\\"eval\\\":\\n print_string = (\\\"Te it [{}/{}] Time {:.3f} \\\"\\n \\\"Target acc {:.3f} Best acc so far {:.3f} in epoch {}\\\").format(\\n self.iter, self.actual_max_iters,\\n self.timer.since_last(),\\n self.acc, self.best_acc, self.best_epoch)\\n self.logger.info(print_string + \\\"\\\\n\\\")\\n self.tb_writer.add_scalars(\\n \\\"acc\\\", {\\n \\\"test\\\": self.acc,\\n \\\"best_acc\\\": self.best_acc\\n }, self.iter)\\n\\n elif mode == \\\"loop\\\":\\n print_string = \\\" Test acc after loop {}: {:.2f}, the best is {:.2f} in loop {}\\\".format(\\n self.loop + 1, self.acc,\\n self.best_acc_loop, self.best_loop + 1)\\n self.logger.info(print_string + \\\"\\\\n\\\")\\n else:\\n raise NotImplementedError(\\\"mode: {} for Solver.write()\\\".format(mode))\",\n \"def write_data_card(spec, data_card, channels, path):\\n with open(path, \\\"w\\\") as f:\\n f.write(f\\\"imax {str(size(data_card.bins))}\\\" + \\\"\\\\n\\\")\\n f.write(\\n \\\"jmax \\\"\\n + str(size(data_card.processes) - size(data_card.isSignal.keys()))\\n + \\\"\\\\n\\\"\\n )\\n f.write(f\\\"kmax {str(size(data_card.systs, 0))}\\\" + \\\"\\\\n\\\")\\n\\n if data_card.hasShapes:\\n for channel in data_card.shapeMap.keys():\\n for sample in data_card.shapeMap[channel].keys():\\n f.write(\\n f\\\"shapes {sample} {channel} {data_card.shapeMap[channel][sample][0]} {data_card.shapeMap[channel][sample][1]}\\\"\\n )\\n if size(data_card.shapeMap[channel][sample]) > 2:\\n f.write(f\\\" {data_card.shapeMap[channel][sample][2]}\\\" + \\\"\\\\n\\\")\\n else:\\n f.write(\\\"\\\\n\\\")\\n\\n f.write(\\\"\\\\n---------------------------------\\\\n\\\")\\n f.write(\\\"bin \\\")\\n for bin in data_card.obs.keys():\\n f.write(f\\\"{bin} \\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"observation \\\")\\n for channel in data_card.obs.keys():\\n f.write(f\\\"{str(data_card.obs[channel])} \\\")\\n f.write(\\\"\\\\n---------------------------------\\\\n\\\")\\n f.write(\\\"bin \\\")\\n for channel in data_card.obs.keys():\\n for sample in data_card.exp[channel].keys():\\n f.write(f\\\"{channel} \\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"process \\\")\\n for channel in data_card.bins:\\n for sample in data_card.exp[channel].keys():\\n f.write(f\\\"{sample} \\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"process \\\")\\n for channel in data_card.bins:\\n for sample in data_card.exp[channel].keys():\\n if sample in data_card.signals:\\n f.write(f\\\"{str(-1 * data_card.processes.index(sample))} \\\")\\n else:\\n f.write(f\\\"{str(data_card.processes.index(sample) + 1)} \\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"rate \\\")\\n for channel in data_card.bins:\\n for sample in data_card.exp[channel].keys():\\n\\n f.write(f\\\"{str(data_card.exp[channel][sample])} \\\")\\n f.write(\\\"\\\\n---------------------------------\\\\n\\\")\\n for syst in data_card.systs:\\n f.write(f\\\"{syst[0]} {syst[2]} \\\")\\n for bin in syst[4].keys():\\n for sample in data_card.exp[bin].keys():\\n if syst[4][bin][sample] != 0:\\n f.write(f\\\"{str(syst[4][bin][sample])} \\\")\\n else:\\n f.write(\\\"- \\\")\\n\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"\\\\n---------------------------------\\\\n\\\")\\n for cAp in data_card.rateParams.keys():\\n _dir = cAp.split(\\\"AND\\\")\\n for i in range(size(data_card.rateParams[cAp], 0)):\\n if size(data_card.rateParams[cAp][i][0]) > 3:\\n f.write(\\n f\\\"{str(data_card.rateParams[cAp][i][0][0])} rateParam {_dir[0]} {_dir[1]} {str(data_card.rateParams[cAp][i][0][1])} {data_card.rateParams[cAp][i][0][3]}\\\"\\n )\\n else:\\n f.write(\\n f\\\"{str(data_card.rateParams[cAp][i][0][0])} rateParam {_dir[0]} {_dir[1]} {str(data_card.rateParams[cAp][i][0][1])}\\\"\\n )\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"\\\\n---------------------------------\\\\n\\\")\\n for idxc, channel in enumerate(channels):\\n if (\\n channel in data_card.binParFlags.keys()\\n and data_card.binParFlags[channel] == True\\n ):\\n # double check to be safe\\n shapesys = False\\n staterror = False\\n for sample in spec[\\\"channels\\\"][idxc][\\\"samples\\\"]:\\n mod_types = [mod[\\\"type\\\"] for mod in sample[\\\"modifiers\\\"]]\\n if \\\"shapesys\\\" in mod_types:\\n shapesys = True\\n elif \\\"staterror\\\" in mod_types:\\n staterror = True\\n\\n if shapesys:\\n f.write(f\\\"{channel} autoMCStats 100000 0 2\\\" + \\\"\\\\n\\\")\\n if staterror:\\n f.write(f\\\"{channel} autoMCStats 0 0 2\\\" + \\\"\\\\n\\\")\",\n \"def _write_nover():\\n return []\",\n \"def writeHoc(self):\\n print('Writing output file %s ...' % self.outFile)\\n with open(self.outFile, 'w') as fOut:\\n \\n def createSection(secNum):\\n fOut.write('create section_%i\\\\n' %secNum)\\n fOut.write('section_%i {\\\\n' %secNum)\\n fOut.write('pt3dclear()\\\\n')\\n for node in xrange(len(self.sections[secNum])):\\n fOut.write('pt3dadd(%.6f, %.6f, %.6f, %.6f)\\\\n' \\\\\\n % (self.sections[secNum][node][0],\\n self.sections[secNum][node][1],\\n self.sections[secNum][node][2],\\n self.secRads[secNum][node]))\\n fOut.write('}\\\\n')\\n \\n def createConnection():\\n for c in xrange(len(self.connections)):\\n fOut.write('connect section_%i(1), section_%i(0)\\\\n' \\\\\\n % (self.connections[c][0],self.connections[c][1]))\\n \\n \\n for sec in self.sections.keys():\\n createSection(sec)\\n createConnection()\\n \\n \\n return\",\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 \"def writeOutput(self):\\n\\n self.collect.writeOutput()\",\n \"def uitofp(self, typ):\",\n \"def output_file(cls, pki_type_enum, pki_id, raw_data, output_path):\\n pki_type = None\\n\\n for pki_type in cls.TYPE:\\n if cls.TYPE[pki_type] == pki_type_enum:\\n break\\n else:\\n raise StandardError(\\\"pki type not supported: 0x%02x\\\" % pki_type_enum)\\n\\n folder_path = os.path.join(output_path, pki_type)\\n if os.path.exists(folder_path) is False:\\n os.makedirs(folder_path)\\n\\n file_name = \\\"%s_%d.%s\\\" % (pki_type, pki_id, \\\"key\\\" if \\\"key\\\" in pki_type else \\\"cer\\\")\\n\\n with open(os.path.join(folder_path, file_name), \\\"wb+\\\") as _file:\\n _file.write(raw_data)\",\n \"def write(self, file):\\n\\n # Initialize output buffer\\n out = ''\\n\\n # Print specification\\n for key, value in self.specification.items():\\n out += f'{key} : {value}\\\\n'\\n\\n # Print the tour\\n if self.tour:\\n out += 'TOUR_SECTION\\\\n'\\n for s in self.tour:\\n out += str(s) + '\\\\n'\\n out += '-1\\\\n'\\n\\n # Append EOF\\n out += 'EOF\\\\n'\\n\\n # Write to file\\n with open(file, 'w') as f:\\n f.write(out)\",\n \"def _write_endcy():\\n return []\",\n \"def Writedata(self, tstep):\\n \\n nc = Dataset(self.outfile, 'a')\\n \\n nc.variables['time'][tstep] = self.time\\n nc.variables['salt'][tstep] = self.salt\\n nc.variables['temp'][tstep] = self.temp\\n nc.variables['uc'][tstep] = self.uc\\n nc.variables['vc'][tstep] = self.vc\\n nc.variables['nu_v'][tstep] = self.nu_v\\n nc.variables['rho'][tstep] = self.rho\\n nc.variables['tau_x'][tstep] = self.tau_x\\n nc.variables['tau_y'][tstep] = self.tau_y\\n nc.variables['eta'][tstep] = self.eta\\n \\n nc.close()\",\n \"def write_data():\",\n \"def write(self, entry):\\n if entry is \\\"all\\\":\\n for k, item in self.nodes.items():\\n if type(item) is list:\\n for node in item:\\n node.write()\\n else:\\n item.write()\\n else:\\n # other option is 'rooms'\\n for node in self.nodes[entry]:\\n node.write()\",\n \"def write_output_shifts_to_file(self, shift_output):\\n pass\",\n \"def save_to_poscar(self, filename,direct=False,species_line=False): \\n with open( filename, 'w' ) as F:\\n F.write( self.name )\\n F.write( \\\" 1.0\\\\n\\\" )\\n F.write( mat2str( self.unit_cell, \\\"%16.10f\\\" ) )\\n if species_line:\\n pos = 0\\n for n in self.num_per_type: \\n F.write('%s '%self.species[pos])\\n pos += n\\n F.write('\\\\n')\\n F.write(' '.join([str(n) for n in self.num_per_type]) )\\n F.write('\\\\n')\\n if not direct:\\n F.write(\\\"Cart\\\\n\\\")\\n F.write( mat2str( self.atoms, \\\"%16.10f\\\" ) )\\n else:\\n F.write(\\\"Direct\\\\n\\\")\\n F.write( mat2str( dot(self.atoms,self.recip_cell), \\\"%16.10f\\\" ) )\",\n \"def write_minisat(self):\\n num_variables = len(self.label_encodings)\\n num_clauses = self.num_clauses\\n clauses = self.clauses\\n outfile = MinisatRunner.temp_in\\n out = open(outfile,\\\"w\\\")\\n try:\\n out.write(\\\"p cnf %3d %3d\\\\n\\\" % (num_variables,num_clauses))\\n for clause in clauses:\\n for clause_variable in clause:\\n out.write(\\\" %3d\\\" % self.minisat_encode_label(clause_variable));\\n out.write(\\\" 0\\\\n\\\")\\n finally:\\n out.close()\",\n \"def write(data):\",\n \"def write(self):\\n #\\n if self.what == 'ecutwfc':\\n for i in range(self.Ndata):\\n self.pwinput.filename = self.inpFiles[i]\\n self.pwinput.SYSTEM.set_ecutwfc(self.values[i])\\n self.pwinput.write()\\n #\\n elif self.what == 'ecutrho':\\n for i in range(self.Ndata):\\n self.pwinput.filename = self.inpFiles[i]\\n self.pwinput.SYSTEM.ecutrho = self.values[i]\\n self.pwinput.write()\\n elif self.what == 'kpoints':\\n for i in range(self.Ndata):\\n self.pwinput.filename = self.inpFiles[i]\\n self.pwinput.Nk = self.values[i]\\n self.pwinput.write()\\n #\\n else:\\n raise RuntimeError('what = %s is not implemented yet' % (self.what))\\n #\\n self.inputs_have_been_written = True\",\n \"def _write(self, preset_type, data):\\n logger.debug('write presets for %s', self._device.name)\\n with self._file_open_rlock(preset_type) as f:\\n f.seek(0)\\n yaml.dump(data, f, default_flow_style=False)\\n f.truncate()\",\n \"def write(self, filename=None):\\n if filename == None:\\n filename = self.ofilename\\n\\n ofile = open(filename, 'w')\\n\\n ofile.write('# Susceptibility: %E d(susc): %E Coercivity: %E d(coer): %E\\\\n' % (self.susceptibility_mean, self.susceptibility_std, self.coercivity_mean, self.coercivity_std) )\\n ofile.write('# H[] M[] Mfit[]\\\\n')\\n\\n #for i in range(len(self.h)):\\n # ofile.write(\\\" %12.10f %12.10f %12.10f\\\\n\\\" % ( self.h[i], self.m[i], self.m_fit[i] ) )\\n\\n ofile.close()\",\n \"def _prepare_for_write(self):\\r\\n self._writer = tf.summary.FileWriter(self._model.output_path,\\r\\n self._tensorflow_session.graph)\\r\\n for mode in ('train', 'test', 'full_test'):\\r\\n self._expensive_ops[mode].update(self._cheap_ops[mode])\\r\\n self._ready_to_write = True\",\n \"def _writeOutput(self):\\n head = \\\"Station\\\\tX\\\\tY\\\\tZ\\\\tUEast\\\\tUNorth\\\\tUUp\\\\tSigEast\\\\tSigNorth\\\\tSigUp\\\\n\\\"\\n outFmt = \\\"%s\\\" + 9 * \\\"\\\\t%g\\\" + \\\"\\\\n\\\"\\n\\n f = open(self.outputFile, 'w')\\n f.write(head)\\n\\n for stationNum in range(self.numStations):\\n outLine = outFmt % (self.stations[stationNum],\\n self.coords[stationNum, 0], self.coords[stationNum, 1],\\n self.coords[stationNum, 2],\\n self.dispNoise[stationNum, 0],\\n self.dispNoise[stationNum, 1],\\n self.dispNoise[stationNum, 2],\\n self.sigmaEast, self.sigmaNorth, self.sigmaUp)\\n f.write(outLine)\\n\\n f.close()\\n\\n return\",\n \"def write_all(self):\\r\\n pass\",\n \"def _write_table(self, var_type, var_data, hierarchical, print_arrays, out_stream):\\n if out_stream is None:\\n return\\n\\n # Make a dict of variables. Makes it easier to work with in this method\\n var_dict = OrderedDict()\\n for name, vals in var_data:\\n var_dict[name] = vals\\n\\n # determine pathname of the system\\n if self.source in ('root', 'driver', 'problem', 'root.nonlinear_solver'):\\n pathname = ''\\n elif '|' in self.source:\\n pathname = get_source_system(self.source)\\n else:\\n pathname = self.source.replace('root.', '')\\n if pathname.endswith('.nonlinear_solver'):\\n pathname = pathname[:-17] # len('.nonlinear_solver') == 17\\n\\n # vars should be in execution order\\n if 'execution_order' in self._var_info:\\n var_order = self._var_info['execution_order']\\n var_list = [var_name for var_name in var_order if var_name in var_dict]\\n else:\\n # don't have execution order, just sort for determinism\\n var_list = sorted(var_dict.keys())\\n\\n top_name = pathname if pathname else 'model'\\n write_var_table(pathname, var_list, var_type, var_dict,\\n hierarchical=hierarchical, top_name=top_name,\\n print_arrays=print_arrays, out_stream=out_stream)\",\n \"def create_export_files(n,input_choice,timing,min_hull_per):\\n\\n\\n\\texists = os.path.isdir('analysis')\\n\\tif exists:\\n\\t\\tf = open('analysis/results.csv','a',newline='')\\n\\t\\tresults = csv.writer(f)\\n\\telse:\\n\\t\\tos.mkdir('analysis')\\n\\t\\tf = open('analysis/results.csv','w',newline='')\\n\\t\\tresults = csv.writer(f)\\n\\t\\tresults.writerow(['Algo','Size of Input','Min. Hull Pts Per','Type of Input','Timing'])\\n\\n\\n\\tresults.writerow(['Graham Scan',n,min_hull_per,input_choice,timing])\",\n \"def write_location(self, param_type, path, pool=None, cont=None):\\n self.run_ior_with_params(param_type, path, pool, cont,\\n self.test_file, self.ior_flags[0])\",\n \"def _save_chromosome_at_index(self, index, file_name):\\n how_to_open = 'w' if index == 0 else 'a'\\n with open(file_name, how_to_open) as out_file:\\n for category in self.population[index].get_genes():\\n out_file.write(''.join(category) + '\\\\t')\\n out_file.write(\\n '\\\\n{}\\\\n'.format(self.population[index].get_fitness())\\n )\",\n \"def _write_transact_types(self, file):\\n for tp in self._transact_types:\\n tp.write(file)\\n file.write('\\\\n')\",\n \"def write_compact(self, fout):\\n for ignored in self.ignored_rules:\\n fout.write(ignored)\\n self.sort_decls()\\n for (pos, (ss, pp)) in enumerate(self.cliques):\\n fout.write(','.join(sorted(ss)))\\n fout.write('{')\\n fout.write(';'.join(pp))\\n fout.write('}')\",\n \"def write(self, outfile, rebasings=None):\\r\\n raise NotImplementedError()\",\n \"def write_pypeit(self, output_path=None, cfg_lines=None,\\n write_bkg_pairs=False, write_manual=False,\\n configs=None, config_subdir=True,\\n version_override=None, date_override=None):\\n # Set output path\\n if output_path is None:\\n output_path = os.getcwd()\\n\\n # Find unique configurations, always ignoring any 'None'\\n # configurations...\\n cfg = self.unique_configurations(copy=True, rm_none=True)\\n\\n # Get the setups to write\\n if configs is None or configs == 'all' or configs == ['all']:\\n cfg_keys = list(cfg.keys())\\n else:\\n _configs = configs if isinstance(configs, list) else [configs]\\n cfg_keys = [key for key in cfg.keys() if key in _configs]\\n\\n if len(cfg_keys) == 0:\\n msgs.error('No setups to write!')\\n\\n # Grab output columns\\n output_cols = self.set_pypeit_cols(write_bkg_pairs=write_bkg_pairs,\\n write_manual=write_manual)\\n\\n # Write the pypeit files\\n ofiles = [None]*len(cfg_keys)\\n for j,setup in enumerate(cfg_keys):\\n # Create the output directory\\n root = '{0}_{1}'.format(self.spectrograph.name, setup)\\n if config_subdir:\\n odir = os.path.join(output_path, root)\\n if not os.path.isdir(odir):\\n os.makedirs(odir)\\n else:\\n odir = output_path\\n # Create the output file name\\n ofiles[j] = os.path.join(odir, '{0}.pypeit'.format(root))\\n\\n # Setup dict\\n setup_dict = {}\\n setup_dict[f'Setup {setup}'] = {}\\n for key in cfg[setup]:\\n setup_dict[f'Setup {setup}'][key] = cfg[setup][key]\\n \\n # Get the paths\\n in_cfg = np.array([setup in _set for _set in self.table['setup']])\\n if not np.any(in_cfg):\\n continue\\n paths = np.unique(self['directory'][in_cfg]).tolist()\\n\\n # Get the data lines\\n subtbl = self.table[output_cols][in_cfg]\\n if 'calib' in output_cols:\\n # calib can be a str with a list of values because in some cases (e.g. MOSFIRE) the same\\n # calibration files are used for different setups. Here we update calib to have only the\\n # value relevant for this setup.\\n # find the calib value in this setup that is not a list (which is probably a science/standard)\\n no_list = np.array([',' not in str(cc) for cc in subtbl['calib']])\\n if np.any(no_list):\\n # assign the calib value in this setup that is not a list to frames that have calib as a list\\n subtbl['calib'][np.logical_not(no_list)] = subtbl['calib'][no_list][0]\\n subtbl.sort(['frametype','filename'])\\n #with io.StringIO() as ff:\\n # subtbl.write(ff, format='ascii.fixed_width')\\n # data_lines = ff.getvalue().split('\\\\n')[:-1]\\n\\n # Config lines\\n if cfg_lines is None:\\n cfg_lines = ['[rdx]']\\n cfg_lines += [' spectrograph = {0}'.format(self.spectrograph.name)]\\n\\n # Instantiate a PypeItFile\\n pypeItFile = inputfiles.PypeItFile(cfg_lines, paths, subtbl, setup_dict)\\n # Write\\n pypeItFile.write(ofiles[j], version_override=version_override,\\n date_override=date_override) \\n\\n # Return\\n return ofiles\",\n \"def _write_dataset(self):\\n if self.output_file:\\n if self.dryrun:\\n sys.stdout.write(f\\\"{self.output_file.resolve()}\\\\n{self.parameter_study}\\\\n\\\")\\n else:\\n self.output_file.parent.mkdir(parents=True, exist_ok=True)\\n self._conditionally_write_dataset(self.output_file, self.parameter_study)\\n else:\\n for parameter_set_file, parameter_set in self.parameter_study.groupby(_set_coordinate_key):\\n parameter_set_file = pathlib.Path(parameter_set_file)\\n # If no output file template is provided, print to stdout\\n if not self.provided_output_file_template:\\n sys.stdout.write(f\\\"{parameter_set_file.name}\\\\n{parameter_set}\\\")\\n sys.stdout.write(\\\"\\\\n\\\")\\n # If overwrite is specified or if file doesn't exist\\n elif self.overwrite or not parameter_set_file.is_file():\\n # If dry run is specified, print the files that would have been written to stdout\\n if self.dryrun:\\n sys.stdout.write(f\\\"{parameter_set_file.resolve()}:\\\\n{parameter_set}\\\")\\n sys.stdout.write(\\\"\\\\n\\\")\\n else:\\n self._conditionally_write_dataset(parameter_set_file, parameter_set)\",\n \"def export_manual_pipetting(args):\\n if args.type == 'purify':\\n clarity_epp.export.manual_pipetting.samplesheet_purify(lims, args.process_id, args.output_file)\\n elif args.type == 'dilute_library_pool':\\n clarity_epp.export.manual_pipetting.samplesheet_dilute_library_pool(lims, args.process_id, args.output_file)\\n elif args.type == 'multiplex_library_pool':\\n clarity_epp.export.manual_pipetting.samplesheet_multiplex_library_pool(lims, args.process_id, args.output_file)\\n elif args.type == 'multiplex_sequence_pool':\\n clarity_epp.export.manual_pipetting.samplesheet_multiplex_sequence_pool(lims, args.process_id, args.output_file)\\n elif args.type == 'normalization':\\n clarity_epp.export.manual_pipetting.samplesheet_normalization(lims, args.process_id, args.output_file)\\n elif args.type == 'capture':\\n clarity_epp.export.manual_pipetting.samplesheet_capture(lims, args.process_id, args.output_file)\\n elif args.type == 'exonuclease':\\n clarity_epp.export.manual_pipetting.sammplesheet_exonuclease(lims, args.process_id, args.output_file)\\n elif args.type == 'pcr_exonuclease':\\n clarity_epp.export.manual_pipetting.sammplesheet_pcr_exonuclease(lims, args.process_id, args.output_file)\\n elif args.type == 'mip_multiplex_pool':\\n clarity_epp.export.manual_pipetting.samplesheet_mip_multiplex_pool(lims, args.process_id, args.output_file)\\n elif args.type == 'mip_dilute_pool':\\n clarity_epp.export.manual_pipetting.samplesheet_mip_pool_dilution(lims, args.process_id, args.output_file)\\n elif args.type == 'pool_samples':\\n clarity_epp.export.manual_pipetting.samplesheet_pool_samples(lims, args.process_id, args.output_file)\\n elif args.type == 'pool_magnis_pools':\\n clarity_epp.export.manual_pipetting.samplesheet_pool_magnis_pools(lims, args.process_id, args.output_file)\",\n \"def write_species(mcmc_set_name, model):\\n species_filename = '%s_species.txt' % mcmc_set_name\\n try:\\n with open(species_filename, 'w') as f:\\n #f.write('\\\\n'.join([str(s) for s in model.rules]))\\n #f.write('\\\\n')\\n f.write('\\\\n'.join([str(s) for s in model.species]))\\n except IOError as e:\\n pass\\n return species_filename\",\n \"def dump_parts(self, io):\\n\\n # XXX refactor with Tempita\\n title = \\\"Parts created by the docutils writer '%s'\\\" % self.strategy.name\\n io.say(title + os.linesep)\\n io.say(len(title) * '-')\\n io.say(2 * os.linesep)\\n io.say('Part keys: ' + 2 * os.linesep)\\n\\n parts = self.publish_parts(io)\\n io.say(os.linesep.join(sorted(parts.keys())))\\n io.say(2 * os.linesep)\\n for part in parts:\\n io.say(\\\"Value of part '%s':%s\\\" % (part, os.linesep))\\n io.say(parts[part].encode('utf-8') + os.linesep)\\n io.say(80*'-'+os.linesep)\\n io.say(os.linesep)\",\n \"def Writefile(self, outfile, verbose=True):\\n \\n self.outfile = outfile\\n \\n # Write SUNTANS grid to file\\n nc = Dataset(outfile, 'w', format='NETCDF3_CLASSIC')\\n nc.Description = 'SUNTANS subsetted history file'\\n nc.Author = ''\\n nc.Created = datetime.now().isoformat()\\n nc.type = 'SUNTANS HIS file'\\n #pdb.set_trace()\\n nc.createDimension('Nc', self.Nc)\\n nc.createDimension('Np', self.Np)\\n nc.createDimension('Ne', self.Ne)\\n nc.createDimension('Nk', self.Nk)\\n nc.createDimension('numsides', self.numsides)\\n \\n nc.createDimension('time', None)\\n \\n def write_nc_var(var, name, dimensions, units=None):\\n nc.createVariable(name, 'f8', dimensions)\\n if units is not None:\\n nc.variables[name].units = units\\n nc.variables[name][:] = var\\n if verbose:\\n print ' ... wrote ', name\\n \\n def create_nc_var(name, dimensions, units=None):\\n nc.createVariable(name, 'f8', dimensions)\\n if units is not None:\\n nc.variables[name].units = units\\n if verbose:\\n print ' ... wrote ', name\\n \\n # Grid variables\\n write_nc_var(self.xv, 'xv', ('Nc'))\\n write_nc_var(self.yv, 'yv', ('Nc'))\\n write_nc_var(self.xp, 'xp', ('Np'))\\n write_nc_var(self.yp, 'yp', ('Np'))\\n write_nc_var(self.xe, 'xe', ('Ne'))\\n write_nc_var(self.ye, 'ye', ('Ne'))\\n write_nc_var(self.dz, 'dz', ('Nk'))\\n write_nc_var(self.dv, 'dv', ('Nc'))\\n write_nc_var(self.Ac, 'Ac', ('Nc'))\\n write_nc_var(self.Nk, 'Nk', ('Nc'))\\n write_nc_var(self.face, 'face', ('Nc','numsides'))\\n write_nc_var(self.mark, 'mark', ('Ne'))\\n write_nc_var(self.cells, 'cells', ('Nc','numsides'))\\n \\n \\n # Create the data variables\\n create_nc_var('time',('time'),'seconds since 1990-01-01 00:00:00')\\n create_nc_var('salt',('time','Nk','Nc'),'psu')\\n create_nc_var('temp',('time','Nk','Nc'),'degrees C')\\n create_nc_var('uc',('time','Nk','Nc'),'meter second-1')\\n create_nc_var('vc',('time','Nk','Nc'),'meter second-1')\\n create_nc_var('nu_v',('time','Nk','Nc'),'m2 s-1')\\n create_nc_var('rho',('time','Nk','Nc'),'kg m-3')\\n create_nc_var('tau_x',('time','Nc'),'N m-2')\\n create_nc_var('tau_y',('time','Nc'),'N m-2')\\n create_nc_var('eta',('time','Nc'),'m')\\n \\n nc.close()\",\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 write(self, out, ignored, displayOptions=None):\\n # \\\"ignored\\\" argument for bw compat with rmake\\n if displayOptions is None:\\n displayOptions = {}\\n\\n if displayOptions.get('showLineOrigins', False):\\n lineStrs = []\\n curPath = None\\n for path, lineNum in self.origins:\\n if path == curPath:\\n continue\\n else:\\n lineStrs.append('%s' % (path,))\\n curPath = path\\n if lineStrs:\\n out.write('# %s: %s\\\\n' % (self.name, ' '.join(lineStrs)))\\n for line in self.valueType.toStrings(self.value, displayOptions):\\n out.write('%-25s %s\\\\n' % (self.name, line))\",\n \"def write_out(self, content_content: str):\\n print(\\\"[write_out] Computation name: \\\", self.comp_name)\\n # meta_title_content object creation to return as a first part\\n if self.write_out_part_counter < 0:\\n metatitle_content = Content(self.comp_name, \\\"sdo:\\\\n\\\" + str(self.comp_name) + \\\"/streaming/p*\\\")\\n self.queue_to_lower.put((self.packetid, metatitle_content))\\n # self.cs.add_content_object(metatitle_content) TODO not needed? \\n\\n # actual content_object for streaming\\n self.write_out_part_counter += 1\\n content_name = self.comp_name\\n content_name += \\\"/streaming/p\\\" + str(self.write_out_part_counter)\\n content_object = Content(content_name, content_content)\\n self.cs.add_content_object(content_object)\\n print(\\\"[write_out] Last entry in content store:\\\", self.cs.get_container()[-1].content.name,\\n self.cs.get_container()[-1].content.content)\",\n \"def save_csv(self, filename: str, type='n', **args):\\n if type == 'n':\\n df = self.export_nodes()\\n else:\\n df = self.export_edges()\\n df.to_csv(filename, index=False)\",\n \"def write_out_v(vc2ptmk, ofn):\\n print \\\"Writing out verbose to [{}]\\\".format(ofn)\\n with codecs.open(ofn, \\\"w\\\", \\\"utf8\\\") as ofd:\\n for (co, uri), infos in sorted(vc2ptmk.items()):\\n for di in infos:\\n ol = u\\\"{}\\\\t{}\\\\t{}\\\\t{}\\\\t{}\\\\n\\\".format(\\n co, uri, di[\\\"ptmk\\\"], di[\\\"spk\\\"], di[\\\"sco\\\"])\\n ofd.write(ol)\",\n \"def _write_stats(self, stat_type, user=None, summ_type=None):\\n if stat_type == \\\"full collection\\\":\\n self.summary_file.write(\\\"\\\\n\\\\nDataset: {c}\\\\n\\\".format(c=self.dataset_name))\\n self.summary_file.write(\\\"Number of unique urls: {u}\\\\nNumber of unique sites: {s}\\\\n\\\".format(u=len(set(self.stat_dict['urls'])), s=len(set(self.stat_dict['sites'])))\\n )\\n site_cnts = Counter(self.stat_dict['sites']).most_common()\\n for site in site_cnts:\\n self.summary_file.write(\\\"{s}: {n}\\\\n\\\".format(s=site[0], n=site[1]))\\n\\n if stat_type == \\\"token_counts\\\":\\n self.summary_file.write(\\\"\\\\n\\\\nDataset: {c}\\\\n\\\".format(c=self.dataset_name))\\n for doc_type in self.stat_dict:\\n if user is not None:\\n self.summary_file.write(\\\"\\\\n{0}, {1}\\\\n\\\".format(user, summ_type))\\n\\n self.summary_file.write(\\n \\\"\\\\nNumber of {d}s: {p}\\\\nAverage tokens/{d}: {t}\\\\nAverage sentences/{d}: {s}\\\\n\\\".format(\\n d=doc_type, p=len(self.stat_dict[doc_type][0]), t=sum(self.stat_dict[doc_type][1])/len(self.stat_dict[doc_type][1]), s=sum(self.stat_dict[doc_type][0])/len(self.stat_dict[doc_type][0])\\n )\\n )\\n\\n self.summary_file.write(\\n \\\"Median tokens/{d}: {p}\\\\nStandard deviation tokens/{d}: {t}\\\\n\\\".format(\\n d=doc_type, p=np.median(self.stat_dict[doc_type][1]), t=np.std(self.stat_dict[doc_type][1])\\n )\\n )\\n\\n self.summary_file.write(\\n \\\"Median sentences/{d}: {p}\\\\nStandard deviation sentences/{d}: {t}\\\\n\\\".format(\\n d=doc_type, p=np.median(self.stat_dict[doc_type][0]), t=np.std(self.stat_dict[doc_type][0])\\n )\\n )\",\n \"def write_output(label1, label2, label3, submission_file):\\n with open(submission_file, 'w') as f:\\n f.write('Id,Bound'+ '\\\\n')\\n for index, lab in enumerate(label1):\\n f.write(str(index) + ',' + str(int(lab)) + '\\\\n')\\n for index, lab in enumerate(label2):\\n f.write(str(len(label1) + index) + ',' + str(int(lab)) + '\\\\n')\\n for index, lab in enumerate(label3):\\n f.write(str(len(label1) + len(label2) + index) + ',' + str(int(lab)))\\n if index < len(label3) - 1:\\n f.write('\\\\n')\",\n \"def write(self,vname,kmz='out.kmz'):\\n\\n imgs=[] # to store a list of all images created\\n content=[] # the content of the main kml\\n vstr='files/%s_%05i.png' # format specification for images (all stored in `files/' subdirectory)\\n\\n # create empty files subdirectory for output images\\n try:\\n shutil.rmtree('files')\\n except:\\n pass\\n os.makedirs('files')\\n\\n # loop through all time slices and create the image data\\n # appending to the kml content string for each image\\n for i in xrange(0,self.nstep,1):\\n kml=ncNWRC(self.filename,istep=i)\\n img=vstr % (vname,i)\\n imgs.append(img)\\n content.append(kml.image2kml(vname,img))\\n\\n # create the main kml file\\n kml=ncNWRC.kmlstr % \\\\\\n {'content':'\\\\n'.join(content),\\\\\\n 'prog':ncNWRC.progname}\\n\\n # create a zipfile to store all images + kml into a single compressed file\\n z=zipfile.ZipFile(kmz,'w',compression=zipfile.ZIP_DEFLATED)\\n z.writestr(kmz[:-3]+'kml',kml)\\n for img in imgs:\\n z.write(img)\\n z.close()\",\n \"def write(self, cull=False):\\n if cull:\\n cull_prefixes(self).write()\\n else:\\n ser = self.g.serialize(format='nifttl', encoding='utf-8')\\n with open(self.filename, 'wb') as f:\\n f.write(ser)\\n #print('yes we wrote the first version...', self.name)\",\n \"def write(self, text):\\n text = open(text, 'w')\\n text.write('File type = \\\"ooTextFile\\\"\\\\n')\\n text.write('Object class = \\\"TextGrid\\\"\\\\n\\\\n')\\n text.write('xmin = %f\\\\n' % self.__xmin)\\n text.write('xmax = %f\\\\n' % self.__xmax)\\n text.write('tiers? <exists>\\\\n')\\n text.write('size = %d\\\\n' % self.__n)\\n text.write('item []:\\\\n')\\n for (tier, n) in zip(self.__tiers, range(1, self.__n + 1)):\\n text.write('\\\\titem [%d]:\\\\n' % n)\\n if tier.__class__ == IntervalTier: \\n text.write('\\\\t\\\\tclass = \\\"IntervalTier\\\"\\\\n')\\n text.write('\\\\t\\\\tname = \\\"%s\\\"\\\\n' % tier.name())\\n text.write('\\\\t\\\\txmin = %f\\\\n' % tier.xmin())\\n text.write('\\\\t\\\\txmax = %f\\\\n' % tier.xmax())\\n text.write('\\\\t\\\\tintervals: size = %d\\\\n' % len(tier))\\n for (interval, o) in zip(tier, range(1, len(tier) + 1)): \\n text.write('\\\\t\\\\t\\\\tintervals [%d]:\\\\n' % o)\\n text.write('\\\\t\\\\t\\\\t\\\\txmin = %f\\\\n' % interval.xmin())\\n text.write('\\\\t\\\\t\\\\t\\\\txmax = %f\\\\n' % interval.xmax())\\n text.write('\\\\t\\\\t\\\\t\\\\ttext = \\\"%s\\\"\\\\n' % interval.mark())\\n else: # PointTier\\n text.write('\\\\t\\\\tclass = \\\"TextTier\\\"\\\\n')\\n text.write('\\\\t\\\\tname = \\\"%s\\\"\\\\n' % tier.name())\\n text.write('\\\\t\\\\txmin = %f\\\\n' % tier.xmin())\\n text.write('\\\\t\\\\txmax = %f\\\\n' % tier.xmax())\\n text.write('\\\\t\\\\tpoints: size = %d\\\\n' % len(tier))\\n for (point, o) in zip(tier, range(1, len(tier) + 1)):\\n text.write('\\\\t\\\\t\\\\tpoints [%d]:\\\\n' % o)\\n text.write('\\\\t\\\\t\\\\t\\\\ttime = %f\\\\n' % point.time())\\n text.write('\\\\t\\\\t\\\\t\\\\tmark = \\\"%s\\\"\\\\n' % point.mark())\\n text.close()\",\n \"def _write_data_out(solutions, unable_to_resolve, unresolvables):\\n print('')\\n print('------------------------')\\n print('--- Progress So Far: ---')\\n print('Solved: ' + str(len(solutions)))\\n print('Error while resolving: ' + str(len(unable_to_resolve)))\\n print('Unresolvable conflicts: ' + str(len(unresolvables)))\\n print('Saving progress to json.')\\n print('------------------------')\\n print('')\\n json.dump(solutions, open(fname_solutions, 'w'))\\n json.dump(unable_to_resolve, open(fname_errors, 'w'))\\n json.dump(unresolvables, open(fname_unresolvables, 'w'))\",\n \"def ior_write_dataset(self):\\n for oclass in self.obj_class:\\n for sizes in self.ior_chu_trs_blk_size:\\n # Skip the object type if server count does not meet the minimum\\n # EC object server count\\n if oclass[1] > self.server_count:\\n continue\\n self.ior_param_update(oclass, sizes)\\n\\n # Create the new container with correct redundancy factor\\n # for EC object type\\n self.ec_contaier_create(oclass[0])\\n self.update_ior_cmd_with_pool(oclass=oclass[0],\\n create_cont=False)\\n # Start IOR Write\\n self.container.uuid = self.ec_container.uuid\\n self.start_ior_load(operation=\\\"WriteRead\\\", percent=1,\\n create_cont=False)\\n self.cont_uuid.append(self.ior_cmd.dfs_cont.value)\",\n \"def _write_rocks(parameters):\\n # Reorder rocks\\n if parameters[\\\"rocks_order\\\"] is not None:\\n order = parameters[\\\"rocks_order\\\"]\\n for rock in parameters[\\\"rocks\\\"].keys():\\n if rock not in order:\\n order.append(rock)\\n else:\\n order = parameters[\\\"rocks\\\"].keys()\\n\\n # Formats\\n fmt = block_to_format[\\\"ROCKS\\\"]\\n fmt1 = str2format(fmt[1])\\n fmt2 = str2format(fmt[2])\\n\\n fmt = block_to_format[\\\"RPCAP\\\"]\\n fmt3 = str2format(fmt)\\n\\n out = []\\n for k in order:\\n # Load data\\n data = parameters[\\\"rocks\\\"][k]\\n\\n # Number of additional lines to write per rock\\n cond = any(\\n data[k] is not None\\n for k in [\\n \\\"compressibility\\\",\\n \\\"expansivity\\\",\\n \\\"conductivity_dry\\\",\\n \\\"tortuosity\\\",\\n \\\"klinkenberg_parameter\\\",\\n \\\"distribution_coefficient_3\\\",\\n \\\"distribution_coefficient_4\\\",\\n ]\\n )\\n nad = (\\n 2\\n if \\\"relative_permeability\\\" in data.keys() or \\\"capillarity\\\" in data.keys()\\n else int(cond)\\n )\\n\\n # Permeability\\n per = data[\\\"permeability\\\"]\\n per = [per] * 3 if not numpy.ndim(per) else per\\n if not (isinstance(per, (list, tuple, numpy.ndarray)) and len(per) == 3):\\n raise TypeError()\\n\\n # Record 1\\n values = [\\n k,\\n nad if nad else \\\"\\\",\\n data[\\\"density\\\"],\\n data[\\\"porosity\\\"],\\n per[0],\\n per[1],\\n per[2],\\n data[\\\"conductivity\\\"],\\n data[\\\"specific_heat\\\"],\\n ]\\n out += write_record(values, fmt1)\\n\\n # Record 2\\n if cond:\\n values = [\\n data[\\\"compressibility\\\"],\\n data[\\\"expansivity\\\"],\\n data[\\\"conductivity_dry\\\"],\\n data[\\\"tortuosity\\\"],\\n data[\\\"klinkenberg_parameter\\\"],\\n data[\\\"distribution_coefficient_3\\\"],\\n data[\\\"distribution_coefficient_4\\\"],\\n ]\\n out += write_record(values, fmt2)\\n else:\\n out += write_record([], []) if nad == 2 else []\\n\\n # Relative permeability / Capillary pressure\\n if nad == 2:\\n for key in [\\\"relative_permeability\\\", \\\"capillarity\\\"]:\\n if key in data.keys():\\n values = [data[key][\\\"id\\\"], None]\\n values += list(data[key][\\\"parameters\\\"])\\n out += write_record(values, fmt3)\\n else:\\n out += write_record([], [])\\n\\n return out\",\n \"def write(self, outputFile):\\n \\n try: \\n f = open(outputFile + '.py', 'w')\\n for trail in self.trails: \\n f.write(\\\"[\\\")\\n for index in trail:\\n f.write(\\\"({0}, {1}), \\\".format(*index)) \\n f.write(\\\"]\\\\n\\\")\\n \\n except IOError, e:\\n msg = \\\"Exception encountered when attempting \\\" + \\\\\\n \\\"to write data to file: {0}.\\\" + \\\\\\n \\\"\\\\n\\\\t -- Exception was: {1}\\\" + \\\\\\n \\\"\\\\n\\\\t For help use --help\\\".format(outputFile, e)\\n raise Usage(e)\",\n \"def print_cat(self):\\n for ion in self.cations:\\n data_str = (\\\"HETATM\\\", int(self.nmb) + ion, self.cations[ion][0], \\\"\\\",\\n self.cations[ion][0],\\\"\\\", ion, \\\"\\\",\\n Vector.x(self.cations[ion][1]), Vector.y(self.cations[ion][1]),\\n Vector.z(self.cations[ion][1]), 1.00, 0.00,\\n self.cations[ion][0], \\\"\\\",\\\"\\\\n\\\")\\n out_str = self.pdb_format % data_str\\n self.output.write(out_str)\\n self.output.close()\\n return 1\",\n \"def write( data ):\",\n \"def write_file(self):\\n rl_df, lift_df = self.create_df()\\n\\n number = re.findall('\\\\d+', self.url)[0]\\n\\n if self.write is True:\\n with open('house_{}.csv'.format(number), 'w',\\n encoding='utf-8-sig') as file:\\n rl_df.to_csv(file, sep=';')\\n with open('house_lifts_{}.csv'.format(number), 'w',\\n encoding='utf-8-sig') as file2:\\n lift_df.to_csv(file2, sep=';')\",\n \"def write(name, keyword, domain, citation, author, description, species, version, contact, license, values, output):\\n write_namespace(\\n name, keyword, domain, author, citation, values,\\n namespace_description=description,\\n namespace_species=species,\\n namespace_version=version,\\n author_contact=contact,\\n author_copyright=license,\\n file=output,\\n )\",\n \"def write(self):\\n\\t\\traise NotImplementedError('%s: No write function implemented!' % self.name)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.55175173","0.5354752","0.53262687","0.52530247","0.52530247","0.5227527","0.5203227","0.5147186","0.5113114","0.5088805","0.5083531","0.5081513","0.5079073","0.5070704","0.5031757","0.50116146","0.49944216","0.4976218","0.49679434","0.4965163","0.49638355","0.49420896","0.49406436","0.49382824","0.4930062","0.49161944","0.49101913","0.49077344","0.49075034","0.49075034","0.49051678","0.4903888","0.48873538","0.4886703","0.4883068","0.4879201","0.48682767","0.48490152","0.48451948","0.48237723","0.4822621","0.48179036","0.4813153","0.48073673","0.47990203","0.47989547","0.47989106","0.4796384","0.47905886","0.47754845","0.47751337","0.4744116","0.47399798","0.47376123","0.47285652","0.47264627","0.4726446","0.47253665","0.47207078","0.4717973","0.4717821","0.47109413","0.4698698","0.46956265","0.46919566","0.46902812","0.46794719","0.46760723","0.46722263","0.46720192","0.46705952","0.46659726","0.4664864","0.4664065","0.46570903","0.46555915","0.46502474","0.46463642","0.46412328","0.464027","0.4632712","0.46308765","0.4627238","0.46264184","0.4607432","0.459859","0.45977858","0.45961845","0.45955577","0.45951152","0.45910856","0.45821458","0.45814675","0.45775452","0.45751217","0.45699745","0.45699057","0.45693618","0.45689428","0.45675093"],"string":"[\n \"0.55175173\",\n \"0.5354752\",\n \"0.53262687\",\n \"0.52530247\",\n \"0.52530247\",\n \"0.5227527\",\n \"0.5203227\",\n \"0.5147186\",\n \"0.5113114\",\n \"0.5088805\",\n \"0.5083531\",\n \"0.5081513\",\n \"0.5079073\",\n \"0.5070704\",\n \"0.5031757\",\n \"0.50116146\",\n \"0.49944216\",\n \"0.4976218\",\n \"0.49679434\",\n \"0.4965163\",\n \"0.49638355\",\n \"0.49420896\",\n \"0.49406436\",\n \"0.49382824\",\n \"0.4930062\",\n \"0.49161944\",\n \"0.49101913\",\n \"0.49077344\",\n \"0.49075034\",\n \"0.49075034\",\n \"0.49051678\",\n \"0.4903888\",\n \"0.48873538\",\n \"0.4886703\",\n \"0.4883068\",\n \"0.4879201\",\n \"0.48682767\",\n \"0.48490152\",\n \"0.48451948\",\n \"0.48237723\",\n \"0.4822621\",\n \"0.48179036\",\n \"0.4813153\",\n \"0.48073673\",\n \"0.47990203\",\n \"0.47989547\",\n \"0.47989106\",\n \"0.4796384\",\n \"0.47905886\",\n \"0.47754845\",\n \"0.47751337\",\n \"0.4744116\",\n \"0.47399798\",\n \"0.47376123\",\n \"0.47285652\",\n \"0.47264627\",\n \"0.4726446\",\n \"0.47253665\",\n \"0.47207078\",\n \"0.4717973\",\n \"0.4717821\",\n \"0.47109413\",\n \"0.4698698\",\n \"0.46956265\",\n \"0.46919566\",\n \"0.46902812\",\n \"0.46794719\",\n \"0.46760723\",\n \"0.46722263\",\n \"0.46720192\",\n \"0.46705952\",\n \"0.46659726\",\n \"0.4664864\",\n \"0.4664065\",\n \"0.46570903\",\n \"0.46555915\",\n \"0.46502474\",\n \"0.46463642\",\n \"0.46412328\",\n \"0.464027\",\n \"0.4632712\",\n \"0.46308765\",\n \"0.4627238\",\n \"0.46264184\",\n \"0.4607432\",\n \"0.459859\",\n \"0.45977858\",\n \"0.45961845\",\n \"0.45955577\",\n \"0.45951152\",\n \"0.45910856\",\n \"0.45821458\",\n \"0.45814675\",\n \"0.45775452\",\n \"0.45751217\",\n \"0.45699745\",\n \"0.45699057\",\n \"0.45693618\",\n \"0.45689428\",\n \"0.45675093\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5732155"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":195,"cells":{"query":{"kind":"string","value":"set the box sizes and start row for each psf image"},"document":{"kind":"string","value":"def _set_psf_layout_hst(self):\n\n print('setting psf layout for HST')\n obj_data=self.obj_data\n\n total_psf_pixels = 0\n psf_start_row = 0\n\n for iobj in range(obj_data.size):\n if (iobj+1) % 100 == 0:\n print(' %d/%d' % (iobj+1,obj_data.size))\n\n # note assuming same psf for all \"epochs\"\n psf_im = self.psf_data.get_psf(iobj)\n\n psf_shape = psf_im.shape\n psf_npix = psf_im.size\n\n cen = (np.array(psf_shape)-1.0)/2.0\n\n # we will expand the psfs\n\n for icut in range(obj_data['ncutout'][iobj]):\n\n obj_data['psf_row_size'][iobj,icut] = psf_shape[0]\n obj_data['psf_col_size'][iobj,icut] = psf_shape[1]\n obj_data['psf_cutout_row'][iobj,icut] = cen[0]\n obj_data['psf_cutout_col'][iobj,icut] = cen[1]\n obj_data['psf_start_row'][iobj,icut] = psf_start_row\n\n psf_start_row += psf_npix\n total_psf_pixels += psf_npix\n\n self.total_psf_pixels = total_psf_pixels"},"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 _set_psf_layout_psfex(self):\n\n print('setting psf layout for PSFEx')\n\n obj_data=self.obj_data\n psf_data=self.psf_data\n\n total_psf_pixels = 0\n\n #psf_npix = psf_size*psf_size\n\n psf_start_row = 0\n for iobj in range(obj_data.size):\n for icut in range(obj_data['ncutout'][iobj]):\n\n row = obj_data['orig_row'][iobj, icut]\n col = obj_data['orig_col'][iobj, icut]\n file_id = obj_data['file_id'][iobj,icut]\n\n p = psf_data[file_id]\n\n pim = p.get_rec(row,col)\n cen = p.get_center(row,col)\n\n psf_shape = pim.shape\n psf_npix = pim.size\n\n obj_data['psf_row_size'][iobj,icut] = psf_shape[0]\n obj_data['psf_col_size'][iobj,icut] = psf_shape[1]\n obj_data['psf_cutout_row'][iobj,icut] = cen[0]\n obj_data['psf_cutout_col'][iobj,icut] = cen[1]\n obj_data['psf_start_row'][iobj,icut] = psf_start_row\n\n psf_start_row += psf_npix\n total_psf_pixels += psf_npix\n\n\n self.total_psf_pixels = total_psf_pixels","def generate_boxes(self, img):\r\n return [Box(left, top, img) for (left, top) in self.coords]","def build_filler_images(self):","def draw_boxes(self, im, boxes):\n for bbox in boxes:\n l = [int(x) for x in bbox[\"coords\"]]\n l = self.scalebox(l)\n icon = self.classes_to_icons[bbox[\"label\"]]\n overlay_im_to_background(im, icon, l[0], l[1] - icon.shape[0] - 5)\n cv2.rectangle(im,(l[0],l[1]),(l[2],l[3]),self.color,2)","def makeImage(self):\n\n for row in range(self.height):\n self.makeRow(row)\n self.window.update() # display a row of pixels","def _get_boxes(self, idx):\n # Load Image\n path = self.df.hsi_path.iloc[idx]\n im = self._load_im(path)\n\n # Crop out box\n r_box_im = self.df.width.iloc[idx] / im.shape[-1] # Ratio of RGB im box coords to load im width (e.g., r=10 for hsi)\n box = np.array([self.df.ymin.iloc[idx], self.df.ymax.iloc[idx], self.df.xmin.iloc[idx], self.df.xmax.iloc[idx]])\n box = np.around(box / r_box_im).astype(int)\n\n crop_im = im[:, box[0]:box[1]+1, box[2]:box[3]+1]\n if np.any(np.array(crop_im.shape) == 0):\n print('[WARNING] Loaded box has zero shape and is sketchily inflated. TODO: skip this box with ID', idx)\n if box[0] == self.df.width.iloc[idx]/r_box_im: box[0] -= 1\n if box[2] == self.df.height.iloc[idx]/r_box_im: box[2] -= 1\n crop_im = im[:, box[0]:box[1]+1, box[2]:box[3]+1]\n\n target = {}\n target[\"labels\"] = self.df.class_id.iloc[idx]\n target[\"uid\"] = self.df.uid.iloc[idx]\n \n\n return crop_im, target","def _get_box_sizes(self, image_info, cat):\n\n\n file_id=0\n impath=image_info['image_path'][file_id].strip()\n ext=image_info['image_ext'][file_id]\n wcs_data = fitsio.read_header(impath, ext=ext)\n wcs = eu.wcsutil.WCS(wcs_data)\n\n\n jacob = wcs.get_jacobian(100,100)\n dudcol, dudrow, dvdcol, dvdrow = jacob\n\n det = dvdrow*dudcol - dvdcol*dudrow\n pixel_scale = np.sqrt(abs(det))\n print('found pixel scale:',pixel_scale)\n box_size = cat['box_size_arcsec']/pixel_scale\n\n # clip to range\n box_size.clip(\n min=self['min_box_size'],\n max=self['max_box_size'],\n out=box_size,\n )\n box_size = box_size.astype('i4')\n\n w,=np.where( ( (box_size % 2) != 0 ) )\n if w.size > 0:\n box_size[w] += 1\n\n return box_size","def setBoxsize(length,width,height):\n return length,width,height","def draw_boxs(img,boxs,width=3,color=(0,0,255)):\n box_img = copy.deepcopy(img)\n for i in range(boxs.shape[0]):\n # x1,y1,x2,y2=boxs[i]\n x1 = boxs[i][0]\n y1 = boxs[i][1]\n x2 = boxs[i][2]\n y2 = boxs[i][3]\n p1 = (int(round(x1)),int(round(y1)))\n p2 = (int(round(x2)),int(round(y2)))\n cv2.rectangle(box_img, p1, p2, color, width)\n\n return box_img","def setUp(self):\r\n center = [1,1]\r\n size = 1\r\n self.imageinfo = ImageInfo(center, size)","def setUp(self):\r\n center = [1,1]\r\n size = 1\r\n self.imageinfo = ImageInfo(center, size)","def setUp(self):\r\n center = [1,1]\r\n size = 1\r\n self.imageinfo = ImageInfo(center, size)","def setUp(self):\r\n center = [1,1]\r\n size = 1\r\n self.imageinfo = ImageInfo(center, size)","def setUp(self):\r\n center = [1,1]\r\n size = 1\r\n self.imageinfo = ImageInfo(center, size)","def __init__(self, nb_sub_images, window_size, recovery, image_horiz_size):\n self.nb_sub_images = nb_sub_images\n self.window_size = window_size\n self.recovery = recovery\n self.image_horiz_size = image_horiz_size","def _resize_bboxes(self, results):\n img_shape = results['img_shape']\n for key in results.get('bbox_fields', []):\n bboxes = []\n for box in results[key]:\n tmp_box = np.array(box, dtype=np.float32)\n tmp_box[0::2] *= results['scale_factor'][0]\n tmp_box[1::2] *= results['scale_factor'][1]\n if self.bbox_clip_border:\n tmp_box[0::2] = np.clip(tmp_box[0::2], 0, img_shape[1])\n tmp_box[1::2] = np.clip(tmp_box[1::2], 0, img_shape[0])\n bboxes.append(tmp_box)\n if len(results[key]) > 0:\n results[key] = bboxes","def _resize_bboxes(self, results):\n for key in results.get('bbox_fields', []):\n bboxes = results[key] * results['scale_factor']\n if self.bbox_clip_border:\n img_shape = results['img_shape']\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])\n results[key] = bboxes","def _resize_bboxes(self, results):\n for key in results.get('bbox_fields', []):\n bboxes = results[key] * results['scale_factor']\n if self.bbox_clip_border:\n img_shape = results['img_shape']\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])\n results[key] = bboxes","def set_box(self) -> None:\n from pymol import cmd\n\n # Delete Box object in PyMOL\n if \"box\" in cmd.get_names(\"selections\"):\n cmd.delete(\"box\")\n # Get dimensions of selected residues\n selection = \"sele\"\n if selection in cmd.get_names(\"selections\"):\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(selection)\n else:\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(\"\")\n \n # Get center of each dimension (x, y, z)\n self.x = (min_x + max_x) / 2\n self.y = (min_y + max_y) / 2\n self.z = (min_z + max_z) / 2\n\n # Set Box variables in interface\n self.min_x.setValue(round(self.x - (min_x - self.padding.value()), 1))\n self.max_x.setValue(round((max_x + self.padding.value()) - self.x, 1))\n self.min_y.setValue(round(self.y - (min_y - self.padding.value()), 1))\n self.max_y.setValue(round((max_y + self.padding.value()) - self.y, 1))\n self.min_z.setValue(round(self.z - (min_z - self.padding.value()), 1))\n self.max_z.setValue(round((max_z + self.padding.value()) - self.z, 1))\n self.angle1.setValue(0)\n self.angle2.setValue(0)\n\n # Setting background box values\n self.min_x_set = self.min_x.value()\n self.max_x_set = self.max_x.value()\n self.min_y_set = self.min_y.value()\n self.max_y_set = self.max_y.value()\n self.min_z_set = self.min_z.value()\n self.max_z_set = self.max_z.value()\n self.angle1_set = self.angle1.value()\n self.angle2_set = self.angle2.value()\n self.padding_set = self.padding.value()\n\n # Draw box\n self.draw_box()\n\n # Enable/Disable buttons\n self.button_draw_box.setEnabled(False)\n self.button_redraw_box.setEnabled(True)\n self.min_x.setEnabled(True)\n self.min_y.setEnabled(True)\n self.min_z.setEnabled(True)\n self.max_x.setEnabled(True)\n self.max_y.setEnabled(True)\n self.max_z.setEnabled(True)\n self.angle1.setEnabled(True)\n self.angle2.setEnabled(True)","def analyzeImages(path, name_type, box1_size, box2_size, box3_size, box4_size, box5_size):\n \n folders = [f for f in sorted(glob.glob(path + \"/**\"))]\n \n for folder in folders: \n \n # to save this data frame in a csv file\n \n files = [f for f in sorted(glob.glob(folder + \"/**\" + \".jpg\"))]\n \n centroidsDf = pd.DataFrame(np.zeros([len(files), 11]),columns=[\"frame\", \"fly1_x\", \"fly1_y\", \"fly2_x\", \"fly2_y\", \"fly3_x\", \"fly3_y\", \"fly4_x\", \"fly4_y\", \"fly5_x\", \"fly5_y\"]);\n headsDf = pd.DataFrame(np.zeros([len(files), 11]),columns=[\"frame\", \"fly1_x\", \"fly1_y\", \"fly2_x\", \"fly2_y\", \"fly3_x\", \"fly3_y\", \"fly4_x\", \"fly4_y\", \"fly5_x\", \"fly5_y\"]);\n \n img_array1 = []\n img_array2 = []\n img_array3 = []\n img_array4 = []\n img_array5 = []\n\n for file in files:\n \n print(file)\n \n centroidsDf[\"frame\"][files.index(file)] = files.index(file)+1\n headsDf[\"frame\"][files.index(file)] = files.index(file)+1\n \n img = cv2.imread(file)\n \n ## FLY 1 ##\n\n box1 = img[box1_size[0]:box1_size[1], box1_size[2]:box1_size[3]]\n \n # image processing to get the centroid and head positions\n x_centroid, y_centroid, x_head, y_head = findCentroid(box1, file) \n \n # add the centroid and head locations on the image \n box1 = cv2.circle(box1, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\n box1 = cv2.circle(box1, (x_head, y_head), 7, (0, 0, 255), -1)\n img_array1.append(box1)\n \n # add the positions in the final data frame\n centroidsDf[\"fly1_x\"][files.index(file)] = x_centroid\n centroidsDf[\"fly1_y\"][files.index(file)] = y_centroid\n \n headsDf[\"fly1_x\"][files.index(file)] = x_head\n headsDf[\"fly1_y\"][files.index(file)] = y_head\n \n ## FLY 2 ##\n \n box2 = img[box2_size[0]:box2_size[1], box2_size[2]:box2_size[3]]\n \n # image processing to get the centroid and head positions\n x_centroid, y_centroid, x_head, y_head = findCentroid(box2, file)\n \n # add the centroid and head locations on the image \n box2 = cv2.circle(box2, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\n box2 = cv2.circle(box2, (x_head, y_head), 7, (0, 0, 255), -1)\n img_array2.append(box2)\n \n # add the positions in the final data frame \n centroidsDf[\"fly2_x\"][files.index(file)] = x_centroid\n centroidsDf[\"fly2_y\"][files.index(file)] = y_centroid\n \n headsDf[\"fly2_x\"][files.index(file)] = x_head\n headsDf[\"fly2_y\"][files.index(file)] = y_head\n \n ## FLY 3 ##\n\n box3 = img[box3_size[0]:box3_size[1], box3_size[2]:box3_size[3]]\n \n # image processing to get the centroid and head positions\n x_centroid, y_centroid, x_head, y_head = findCentroid(box3, file)\n \n # add the centroid and head locations on the image \n box3 = cv2.circle(box3, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\n box3 = cv2.circle(box3, (x_head, y_head), 7, (0, 0, 255), -1)\n img_array3.append(box3)\n\n # add the positions in the final data frame\n centroidsDf[\"fly3_x\"][files.index(file)] = x_centroid\n centroidsDf[\"fly3_y\"][files.index(file)] = y_centroid\n \n headsDf[\"fly3_x\"][files.index(file)] = x_head\n headsDf[\"fly3_y\"][files.index(file)] = y_head\n \n ## FLY 4 ##\n \n box4 = img[box4_size[0]:box4_size[1], box4_size[2]:box4_size[3]]\n \n # image processing to get the centroid and head positions\n x_centroid, y_centroid, x_head, y_head = findCentroid(box4, file)\n \n # add the centroid and head locations on the image \n box4 = cv2.circle(box4, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\n box4 = cv2.circle(box4, (x_head, y_head), 7, (0, 0, 255), -1)\n img_array4.append(box4)\n \n # add the positions in the final data frame\n centroidsDf[\"fly4_x\"][files.index(file)] = x_centroid\n centroidsDf[\"fly4_y\"][files.index(file)] = y_centroid\n \n headsDf[\"fly4_x\"][files.index(file)] = x_head\n headsDf[\"fly4_y\"][files.index(file)] = y_head\n \n ## FLY 5 ##\n \n # the fifth fly is not present in all the genetic strains \n if (box5_size != []):\n box5 = img[box5_size[0]:box5_size[1], box5_size[2]:box5_size[3]]\n \n # image processing to get the centroid and head positions\n x_centroid, y_centroid, x_head, y_head = findCentroid(box5, file)\n \n # add the centroid and head locations on the image \n box5 = cv2.circle(box5, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\n box5 = cv2.circle(box5, (x_head, y_head), 7, (0, 0, 255), -1)\n img_array5.append(box5)\n \n # add the positions in the final data frame\n centroidsDf[\"fly5_x\"][files.index(file)] = x_centroid\n centroidsDf[\"fly5_y\"][files.index(file)] = y_centroid\n \n headsDf[\"fly5_x\"][files.index(file)] = x_head\n headsDf[\"fly5_y\"][files.index(file)] = y_head\n \n # save the data frame in a .csv file, \n # one for the centroids and one for the heads\n #centroidsDf.to_csv(folder+\"/centroids.csv\", index = None, header=True)\n #headsDf.to_csv(folder+\"/heads.csv\", index = None, header=True)\n \n \n ## CREATE THE VIDEOS ##\n \n height, width, _ = box1.shape\n size = (width,height)\n out = cv2.VideoWriter(folder+name_type+'_1_' + str(folders.index(folder)+1)+ '.mp4',cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\n for i in range(len(img_array1)):\n out.write(img_array1[i])\n out.release()\n \n height, width, _ = box2.shape\n size = (width,height)\n out = cv2.VideoWriter(folder+name_type+'_2_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\n for i in range(len(img_array2)):\n out.write(img_array2[i])\n out.release()\n \n height, width, _ = box3.shape\n size = (width,height)\n out = cv2.VideoWriter(folder+name_type+'_3_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\n for i in range(len(img_array3)):\n out.write(img_array3[i])\n out.release()\n \n height, width, _ = box4.shape\n size = (width,height)\n out = cv2.VideoWriter(folder+name_type+'_4_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\n for i in range(len(img_array4)):\n out.write(img_array4[i])\n out.release()\n \n if (box5_size != []):\n height, width, _ = box5.shape\n size = (width,height)\n out = cv2.VideoWriter(folder+name_type+'_5_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\n for i in range(len(img_array5)):\n out.write(img_array5[i])\n out.release()","def _iter_images_rects(self):\n image_x = self._margin\n image_y = self._margin\n total_width = self.width - 2 * self._margin\n total_height = self.height - self._texts_height - 2 * self._margin\n\n if len(self._images) == 1:\n image_width = total_width\n image_height = total_height\n elif 2 <= len(self._images) < 4:\n if self.is_portrait:\n image_width = total_width\n image_height = (total_height - (len(self._images) - 1) * self._margin) // len(self._images)\n else:\n image_width = (total_width - (len(self._images) - 1) * self._margin) // len(self._images)\n image_height = total_height\n else:\n image_width = (total_width - self._margin) // 2\n image_height = (total_height - self._margin) // 2\n\n yield image_x, image_y, image_width, image_height\n\n if 2 <= len(self._images) < 4:\n if self.is_portrait:\n image_y += image_height + self._margin\n else:\n image_x += image_width + self._margin\n yield image_x, image_y, image_width, image_height\n\n if 3 <= len(self._images) < 4:\n if self.is_portrait:\n image_y += image_height + self._margin\n else:\n image_x += image_width + self._margin\n yield image_x, image_y, image_width, image_height\n\n if len(self._images) == 4:\n image_x += image_width + self._margin\n yield image_x, image_y, image_width, image_height\n image_y += image_height + self._margin\n image_x = self._margin\n yield image_x, image_y, image_width, image_height\n image_x += image_width + self._margin\n yield image_x, image_y, image_width, image_height","def _assign_sizes(self):","def create_human_box(self, i):\n self.box = self.detections[0, 0, i, 3:7] * np.array([self.w, self.h, self.w, self.h])\n (self.startX, self.startY, self.endX, self.endY) = self.box.astype(\"int\")","def __init__(self, path_image, path_imagefile, path_bndboxfile, transform):\r\n # -------------------- DATA ARGUMENT\r\n self.shape = 446\r\n self.hue = 0.1\r\n self.saturation = 1.5\r\n self.exposure = 1.5\r\n self.imagelist = []\r\n self.labellist = []\r\n self.transform = transform\r\n label_dir = os.listdir(path_bndboxfile)\r\n image_dir = os.listdir(path_imagefile)\r\n\r\n # read imagepath\r\n for file in image_dir:\r\n file_name = os.path.join(path_imagefile, file)\r\n with open(file_name) as f:\r\n lines = f.readlines()\r\n for line in lines:\r\n image_name = line.split()[0] + '.JPEG'\r\n image = os.path.join(path_image, image_name)\r\n self.imagelist.append(image)\r\n\r\n # read imagelabel, i.e, (name, xmin, xmax, ymin, ymax)\r\n for file in label_dir:\r\n if file.split('.')[1] == 'xml':\r\n file_name = os.path.join(path_bndboxfile, file)\r\n with open(file_name) as f:\r\n xml_tree = parse(f).documentElement\r\n objects = xml_tree.getElementsByTagName('object')\r\n for object in objects:\r\n label = []\r\n name = object.getElementsByTagName('name')[0]\r\n label.append(name.childNodes[0].data)\r\n bndbox = object.getElementsByTagName('bndbox')[0]\r\n for node in bndbox.childNodes:\r\n if node.nodeType == node.ELEMENT_NODE:\r\n label.append(node.childNodes[0].data)\r\n self.labellist.append(label)\r\n else:\r\n print('Expect files in xml format. but get {}'.format(file.split('.')[1]))","def _images_and_boxes_preprocessing(self, imgs, boxes):\r\n # Image [0, 255] -> [0, 1].\r\n imgs = imgs.float()\r\n imgs = imgs / 255.0\r\n\r\n height, width = imgs.shape[2], imgs.shape[3]\r\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\r\n # range of [0, 1].\r\n boxes[:, [0, 2]] *= width\r\n boxes[:, [1, 3]] *= height\r\n boxes = transform.clip_boxes_to_image(boxes, height, width)\r\n\r\n if self._split == \"train\":\r\n # Train split\r\n imgs, boxes = transform.random_short_side_scale_jitter(\r\n imgs,\r\n min_size=self._jitter_min_scale,\r\n max_size=self._jitter_max_scale,\r\n boxes=boxes,\r\n )\r\n imgs, boxes = transform.random_crop(imgs, self._crop_size, boxes=boxes)\r\n\r\n # Random flip.\r\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\r\n elif self._split == \"val\":\r\n # Val split\r\n # Resize short side to crop_size. Non-local and STRG uses 256.\r\n imgs, boxes = transform.random_short_side_scale_jitter(\r\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\r\n )\r\n\r\n # Apply center crop for val split\r\n imgs, boxes = transform.uniform_crop(\r\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\r\n )\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\r\n elif self._split == \"test\":\r\n # Test split\r\n # Resize short side to crop_size. Non-local and STRG uses 256.\r\n imgs, boxes = transform.random_short_side_scale_jitter(\r\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\r\n )\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\r\n else:\r\n raise NotImplementedError(\"{} split not supported yet!\".format(self._split))\r\n\r\n # Do color augmentation (after divided by 255.0).\r\n if self._split == \"train\" and self._use_color_augmentation:\r\n if not self._pca_jitter_only:\r\n imgs = transform.color_jitter(\r\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\r\n )\r\n\r\n imgs = transform.lighting_jitter(\r\n imgs,\r\n alphastd=0.1,\r\n eigval=np.array(self._pca_eigval).astype(np.float32),\r\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\r\n )\r\n\r\n # Normalize images by mean and std.\r\n imgs = transform.color_normalization(\r\n imgs,\r\n np.array(self._data_mean, dtype=np.float32),\r\n np.array(self._data_std, dtype=np.float32),\r\n )\r\n\r\n if self._use_bgr:\r\n # Convert image format from RGB to BGR.\r\n # Note that Kinetics pre-training uses RGB!\r\n imgs = imgs[:, [2, 1, 0], ...]\r\n\r\n boxes = transform.clip_boxes_to_image(boxes, self._crop_size, self._crop_size)\r\n\r\n return imgs, boxes","def _resize_cbboxes(self, results):\n img_shape = results['img_shape']\n for key in results.get('cbbox_fields', []):\n cbboxes = []\n for cbox in results[key]:\n tmp_cbox = np.array(cbox, dtype=np.float32)\n new_tmp_cbox = []\n for ccbox in tmp_cbox:\n ccbox = np.array(ccbox, dtype=np.float32)\n ccbox[0::2] *= results['scale_factor'][0]\n ccbox[1::2] *= results['scale_factor'][1]\n new_tmp_cbox.append(ccbox)\n tmp_cbox = np.array(new_tmp_cbox, dtype=np.float32)\n if self.bbox_clip_border:\n tmp_cbox[:, 0::2] = np.clip(tmp_cbox[:, 0::2], 0, img_shape[1])\n tmp_cbox[:, 1::2] = np.clip(tmp_cbox[:, 1::2], 0, img_shape[0])\n cbboxes.append(tmp_cbox)\n results[key] = cbboxes","def drawBox (self, left, top, width, height, colour):\r\n w = self.bih_vals [bih_Width]\r\n h = self.bih_vals [bih_Height]\r\n\r\n cols = [left, left + width - 1]\r\n rows = [top, top + height - 1]\r\n \r\n x0 = max ((0,left))\r\n x1 = min ((cols[1]+1, w))\r\n y0 = max ((0,top))\r\n y1 = min ((rows [1]+1, h))\r\n\r\n # rows\r\n\r\n for r in rows:\r\n if r >= 0 and r < h:\r\n row = self.image [r]\r\n for x in range (x0, x1):\r\n row [x] = colour\r\n\r\n # columns\r\n \r\n for y in range (y0, y1):\r\n row = self.image [y]\r\n for c in cols:\r\n if c >= 0 and c < w :\r\n row [c] = colour","def OnSize(self, event):\r\n\r\n for pos, item in self._items.items():\r\n widget, horizontalalignment, verticalalignment = item.widget, item.horizontalalignment, item.verticalalignment\r\n\r\n rect = self.GetFieldRect(pos)\r\n widgetpos = widget.GetPosition()\r\n widgetsize = widget.GetSize()\r\n\r\n rect = self.GetFieldRect(pos)\r\n\r\n if horizontalalignment == ESB_EXACT_FIT:\r\n if verticalalignment == ESB_EXACT_FIT:\r\n widget.SetSize((rect.width-2, rect.height-2))\r\n widget.SetPosition((rect.x-1, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\r\n if widgetsize[1] < rect.width - 1:\r\n diffs = (rect.height - widgetsize[1])/2\r\n widget.SetSize((rect.width-2, widgetsize[1]))\r\n widget.SetPosition((rect.x-1, rect.y+diffs))\r\n else:\r\n widget.SetSize((rect.width-2, widgetsize[1]))\r\n widget.SetPosition((rect.x-1, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_TOP:\r\n widget.SetSize((rect.width-2, widgetsize[1]))\r\n widget.SetPosition((rect.x-1, rect.y))\r\n elif verticalalignment == ESB_ALIGN_BOTTOM:\r\n widget.SetSize((rect.width-2, widgetsize[1]))\r\n widget.SetPosition((rect.x-1, rect.height-widgetsize[1]))\r\n\r\n elif horizontalalignment == ESB_ALIGN_LEFT:\r\n\r\n xpos = rect.x - 1\r\n if verticalalignment == ESB_EXACT_FIT:\r\n widget.SetSize((widgetsize[0], rect.height-2))\r\n widget.SetPosition((xpos, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\r\n if widgetsize[1] < rect.height - 1:\r\n diffs = (rect.height - widgetsize[1])/2\r\n widget.SetPosition((xpos, rect.y+diffs))\r\n else:\r\n widget.SetSize((widgetsize[0], rect.height-2))\r\n widget.SetPosition((xpos, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_TOP:\r\n widget.SetPosition((xpos, rect.y))\r\n elif verticalalignment == ESB_ALIGN_BOTTOM:\r\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\r\n\r\n elif horizontalalignment == ESB_ALIGN_RIGHT:\r\n\r\n xpos = rect.x + rect.width - widgetsize[0] - 1\r\n if verticalalignment == ESB_EXACT_FIT:\r\n widget.SetSize((widgetsize[0], rect.height-2))\r\n widget.SetPosition((xpos, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\r\n if widgetsize[1] < rect.height - 1:\r\n diffs = (rect.height - widgetsize[1])/2\r\n widget.SetPosition((xpos, rect.y+diffs))\r\n else:\r\n widget.SetSize((widgetsize[0], rect.height-2))\r\n widget.SetPosition((xpos, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_TOP:\r\n widget.SetPosition((xpos, rect.y))\r\n elif verticalalignment == ESB_ALIGN_BOTTOM:\r\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\r\n\r\n elif horizontalalignment == ESB_ALIGN_CENTER_HORIZONTAL:\r\n\r\n xpos = rect.x + (rect.width - widgetsize[0])/2 - 1\r\n if verticalalignment == ESB_EXACT_FIT:\r\n widget.SetSize((widgetsize[0], rect.height))\r\n widget.SetPosition((xpos, rect.y))\r\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\r\n if widgetsize[1] < rect.height - 1:\r\n diffs = (rect.height - widgetsize[1])/2\r\n widget.SetPosition((xpos, rect.y+diffs))\r\n else:\r\n widget.SetSize((widgetsize[0], rect.height-1))\r\n widget.SetPosition((xpos, rect.y+1))\r\n elif verticalalignment == ESB_ALIGN_TOP:\r\n widget.SetPosition((xpos, rect.y))\r\n elif verticalalignment == ESB_ALIGN_BOTTOM:\r\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\r\n\r\n if event is not None:\r\n event.Skip()","def recreate_grid(self):\n\n self.print_numlist = arcade.SpriteList()\n for row in range(ROW_COUNT):\n for column in range(COLUMN_COUNT):\n sprite = arcade.Sprite(\n f\"Numbers/{self.grid[row][column]}.png\", scale=0.2\n )\n x = (MARGIN + WIDTH) * column + MARGIN + WIDTH // 2\n y = (MARGIN + HEIGHT) * row + MARGIN + HEIGHT // 2\n sprite.center_x = x\n sprite.center_y = y\n self.print_numlist.append(sprite)\n # Check to see if all squares have been filled in\n if 0 not in self.grid:\n # if Cameron.Check_for_Completion(self.grid) == True:\n self.done = True","def _draw_boxes(self, image, boxes, classes, thickness=4):\n for i in range(len(boxes)):\n bot, left, top, right = boxes[i, ...]\n class_id = int(classes[i]) - 1\n color = self.COLOR_LIST[class_id]\n cv2.rectangle(image, (left, top), (right, bot), color=color, thickness=thickness)","def scale_boxes(boxes, image_shape):\n height = image_shape[0]\n width = image_shape[1]\n image_dims = K.stack([height, width, height, width])\n image_dims = K.reshape(image_dims, [1, 4])\n boxes = boxes * image_dims\n return boxes","def place_images(self, final_list, points):\n\t\tfor i in range(8): \n # Please change this (8) into a class-level variable --KOH\n\t\t\timage_object = final_list[i]\n#\t\tif type(image_object) == 'CorrectImage':\n#\t\t\t\tself.correct = [i, points[i]]\n\t\t\timage = pygame.image.load(image_object.file_path)\n # Why can't these be stored as a property of the class --KOH\n\t\t\timagerect = image.get_rect()\n\t\t\treimage = pygame.transform.scale(image, image_object.size)\n\t\t\tself.screen.blit(reimage, points[i])","def _images_and_boxes_preprocessing(self, imgs, boxes, gt_boxes=None):\n # Image [0, 255] -> [0, 1].\n imgs = imgs.float()\n imgs = imgs / 255.0\n\n height, width = imgs.shape[2], imgs.shape[3]\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\n # range of [0, 1].\n # boxes[:, [0, 2]] *= width\n # boxes[:, [1, 3]] *= height\n boxes = transform.clip_boxes_to_image(boxes, height, width)\n\n if self._split == \"train\":\n # Train split\n imgs, boxes = transform.random_short_side_scale_jitter(\n imgs,\n min_size=self._jitter_min_scale,\n max_size=self._jitter_max_scale,\n boxes=boxes,\n )\n imgs, boxes = transform.random_crop(\n imgs, self._crop_size, boxes=boxes\n )\n\n # Random flip.\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\n elif self._split == \"val\":\n # Val split\n # Resize short side to crop_size. Non-local and STRG uses 256.\n imgs, boxes = transform.random_short_side_scale_jitter(\n imgs,\n min_size=self._crop_size,\n max_size=self._crop_size,\n boxes=boxes,\n )\n\n # Apply center crop for val split\n imgs, boxes = transform.uniform_crop(\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\n )\n\n if self._test_force_flip:\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\n elif self._split == \"test\":\n # Test split\n # Resize short side to crop_size. Non-local and STRG uses 256.\n imgs, boxes = transform.random_short_side_scale_jitter(\n imgs,\n min_size=self._crop_size,\n max_size=self._crop_size,\n boxes=boxes,\n )\n\n if self._test_force_flip:\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\n else:\n raise NotImplementedError(\n \"{} split not supported yet!\".format(self._split)\n )\n\n # Do color augmentation (after divided by 255.0).\n if self._split == \"train\" and self._use_color_augmentation:\n if not self._pca_jitter_only:\n imgs = transform.color_jitter(\n imgs,\n img_brightness=0.4,\n img_contrast=0.4,\n img_saturation=0.4,\n )\n\n imgs = transform.lighting_jitter(\n imgs,\n alphastd=0.1,\n eigval=np.array(self._pca_eigval).astype(np.float32),\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\n )\n\n # Normalize images by mean and std.\n imgs = transform.color_normalization(\n imgs,\n np.array(self._data_mean, dtype=np.float32),\n np.array(self._data_std, dtype=np.float32),\n )\n\n if not self._use_bgr:\n # Convert image format from BGR to RGB.\n # Note that Kinetics pre-training uses RGB!\n imgs = imgs[:, [2, 1, 0], ...]\n\n boxes = transform.clip_boxes_to_image(\n boxes, self._crop_size, self._crop_size\n )\n\n return imgs, boxes","def populate_images(self):\n print \"Populating images info...\"\n images = self.get_all_images()\n for i in images:\n\n associated_snapshots = self.get_snapshots_of(i)\n\n self.spreadsheet[i.id] = dict(name=i.name, Name_tag=self.get_name_tag(i), id=i.id,\n KEEP_tag=self.get_keep_tag(i), PROD_tag=self.is_production(i),\n region=i.region.name,\n created=i.creationDate,\n associated_snapshots=associated_snapshots,\n description=i.description)","def stage_one(self, imgs, threshold, factor, minsize, nms_threshold):\n\n width = imgs.shape[-2]\n height = imgs.shape[-1]\n num_img = imgs.shape[0]\n\n # Compute valid scales\n scales = []\n cur_width = width\n cur_height = height\n cur_factor = 1\n while cur_width >= 12 and cur_height >= 12:\n if 12 / cur_factor >= minsize: # Ignore boxes that smaller than minsize\n\n w = cur_width\n h = cur_height\n scales.append((w, h, cur_factor))\n\n cur_factor *= factor\n cur_width = math.ceil(cur_width * factor)\n cur_height = math.ceil(cur_height * factor)\n\n # Get candidate boxesi ph\n candidate_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\n candidate_scores = torch.empty(0, device=self.device)\n candidate_offsets = torch.empty(\n 0, dtype=torch.float32, device=self.device)\n all_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\n for w, h, f in scales:\n resize_img = torch.nn.functional.interpolate(\n imgs, size=(w, h), mode='bilinear')\n p_distribution, box_regs, _ = self.pnet(resize_img)\n\n candidate, scores, offsets, img_labels = self._generate_bboxes(\n p_distribution, box_regs, f, threshold)\n\n candidate_boxes = torch.cat([candidate_boxes, candidate])\n candidate_scores = torch.cat([candidate_scores, scores])\n candidate_offsets = torch.cat([candidate_offsets, offsets])\n all_img_labels = torch.cat([all_img_labels, img_labels])\n\n \n if candidate_boxes.shape[0] != 0:\n candidate_boxes = self._calibrate_box(\n candidate_boxes, candidate_offsets)\n candidate_boxes = self._convert_to_square(candidate_boxes)\n candidate_boxes = self._refine_boxes(\n candidate_boxes, width, height)\n \n final_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\n final_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\n for i in range(num_img):\n mask = all_img_labels == i\n keep = func.nms(candidate_boxes[mask].cpu().numpy(),\n candidate_scores[mask].cpu().numpy(), nms_threshold)\n final_boxes = torch.cat([final_boxes, candidate_boxes[mask][keep]])\n final_img_labels = torch.cat([final_img_labels, all_img_labels[mask][keep]])\n\n return torch.cat([final_boxes, final_img_labels.unsqueeze(1 )], -1)\n else:\n return candidate_boxes","def _images_and_boxes_preprocessing_cv2(self, imgs, boxes):\r\n\r\n height, width, _ = imgs[0].shape\r\n\r\n boxes[:, [0, 2]] *= width\r\n boxes[:, [1, 3]] *= height\r\n boxes = cv2_transform.clip_boxes_to_image(boxes, height, width)\r\n\r\n # `transform.py` is list of np.array. However, for AVA, we only have\r\n # one np.array.\r\n boxes = [boxes]\r\n # The image now is in HWC, BGR format.\r\n if self._split == \"train\": # \"train\"\r\n imgs, boxes = cv2_transform.random_short_side_scale_jitter_list(\r\n imgs,\r\n min_size=self._jitter_min_scale,\r\n max_size=self._jitter_max_scale,\r\n boxes=boxes,\r\n )\r\n imgs, boxes = cv2_transform.random_crop_list(\r\n imgs, self._crop_size, order=\"HWC\", boxes=boxes\r\n )\r\n if self.random_horizontal_flip:\r\n # random flip\r\n imgs, boxes = cv2_transform.horizontal_flip_list(\r\n 0.5, imgs, order=\"HWC\", boxes=boxes\r\n )\r\n elif self._split == \"val\":\r\n # Short side to test_scale. Non-local and STRG uses 256.\r\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\r\n boxes = [\r\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\r\n ]\r\n imgs, boxes = cv2_transform.spatial_shift_crop_list(\r\n self._crop_size, imgs, 1, boxes=boxes\r\n )\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = cv2_transform.horizontal_flip_list(\r\n 1, imgs, order=\"HWC\", boxes=boxes\r\n )\r\n elif self._split == \"test\":\r\n # Short side to test_scale. Non-local and STRG uses 256.\r\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\r\n boxes = [\r\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\r\n ]\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = cv2_transform.horizontal_flip_list(\r\n 1, imgs, order=\"HWC\", boxes=boxes\r\n )\r\n else:\r\n raise NotImplementedError(\"Unsupported split mode {}\".format(self._split))\r\n\r\n # Convert image to CHW keeping BGR order.\r\n imgs = [cv2_transform.HWC2CHW(img) for img in imgs]\r\n\r\n # Image [0, 255] -> [0, 1].\r\n imgs = [img / 255.0 for img in imgs]\r\n\r\n imgs = [\r\n np.ascontiguousarray(\r\n # img.reshape((3, self._crop_size, self._crop_size))\r\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\r\n ).astype(np.float32)\r\n for img in imgs\r\n ]\r\n\r\n # Do color augmentation (after divided by 255.0).\r\n if self._split == \"train\" and self._use_color_augmentation:\r\n if not self._pca_jitter_only:\r\n imgs = cv2_transform.color_jitter_list(\r\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\r\n )\r\n\r\n imgs = cv2_transform.lighting_list(\r\n imgs,\r\n alphastd=0.1,\r\n eigval=np.array(self._pca_eigval).astype(np.float32),\r\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\r\n )\r\n\r\n # Normalize images by mean and std.\r\n imgs = [\r\n cv2_transform.color_normalization(\r\n img,\r\n np.array(self._data_mean, dtype=np.float32),\r\n np.array(self._data_std, dtype=np.float32),\r\n )\r\n for img in imgs\r\n ]\r\n\r\n # Concat list of images to single ndarray.\r\n imgs = np.concatenate([np.expand_dims(img, axis=1) for img in imgs], axis=1)\r\n\r\n if not self._use_bgr:\r\n # Convert image format from BGR to RGB.\r\n imgs = imgs[::-1, ...]\r\n\r\n imgs = np.ascontiguousarray(imgs)\r\n imgs = torch.from_numpy(imgs)\r\n boxes = cv2_transform.clip_boxes_to_image(\r\n boxes[0], imgs[0].shape[1], imgs[0].shape[2]\r\n )\r\n return imgs, boxes","def __init__(self,jx,jy,img,geo,mbox=10,hist=False,zoomc=False,pfile=False):\n \n self.mbox = mbox # Box half-size\n self.nbox = 2*mbox + 1 # Box size\n # Adjust central pixel location to ensure box fits within full image\n self.ix = int( np.median( [ mbox, jx, img.nx-mbox-1 ] ) )\n self.iy = int( np.median( [ mbox, jy, img.ny-mbox-1 ] ) )\n iymin = self.iy - mbox\n iymax = self.iy + mbox\n ixmin = self.ix - mbox\n ixmax = self.ix + mbox\n label = img.label # Copy information from full disk image\n self.label = label\n self.desc = img.desc[label]\n self.img = img.images[label][iymin:iymax+1,ixmin:ixmax+1]\n self.disp(zoomc)\n if hist: self.hist(geo,pfile)","def _images_and_boxes_preprocessing_cv2(self, imgs, boxes, gt_boxes=None, min_scale=None, crop_size=None, n_imgs=0):\n\n height, width, _ = imgs[0].shape\n\n # boxes[:, [0, 2]] *= width\n # boxes[:, [1, 3]] *= height\n boxes = cv2_transform.clip_boxes_to_image(boxes, height, width)\n\n # `transform.py` is list of np.array. However, for AVA, we only have\n # one np.array.\n boxes = [boxes]\n\n crop_size = crop_size if self.multigrid_enabled and crop_size is not None else self._crop_size\n \n if self._split != 'train':\n assert gt_boxes is not None\n gt_boxes = cv2_transform.clip_boxes_to_image(gt_boxes, height, width)\n gt_boxes = [gt_boxes]\n\n # The image now is in HWC, BGR format.\n if self._split == \"train\": # \"train\"\n imgs, boxes = cv2_transform.random_short_side_scale_jitter_list(\n imgs,\n min_size=self._jitter_min_scale if not self.multigrid_enabled and min_scale is None else min_scale,\n max_size=self._jitter_max_scale,\n boxes=boxes,\n )\n imgs, boxes = cv2_transform.random_crop_list(\n imgs, crop_size, order=\"HWC\", boxes=boxes, n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\n )\n if self.random_horizontal_flip:\n # random flip\n # if self.cfg.MODEL.USE_SPA_CONF and len(imgs[n_imgs].shape) != 3:\n # for i in range(n_imgs, len(imgs) + 1):\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\n imgs, boxes = cv2_transform.horizontal_flip_list(\n 0.5, imgs, order=\"HWC\", boxes=boxes, \n n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\n )\n # elif self._split == \"val\":\n # # Short side to test_scale. Non-local and STRG uses 256.\n # imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\n # boxes, gt_boxes = cv2_transform.scale_boxes(\n # self._crop_size, boxes[0], height, width, gt_boxes=gt_boxes[0]\n # )\n # boxes, gt_boxes = [boxes], [gt_boxes]\n # imgs, boxes, gt_boxes = cv2_transform.spatial_shift_crop_list(\n # self._crop_size, imgs, 1, boxes=boxes, gt_boxes=gt_boxes\n # )\n\n # if self._test_force_flip:\n # imgs, boxes = cv2_transform.horizontal_flip_list(\n # 1, imgs, order=\"HWC\", boxes=boxes, gt_boxes=gt_boxes\n # )\n elif self._split == \"val\" or self._split == \"test\":\n # Short side to test_scale. Non-local and STRG uses 256.\n imgs = [cv2_transform.scale(crop_size, img) for img in imgs]\n boxes, gt_boxes = cv2_transform.scale_boxes(\n crop_size, boxes[0], height, width, gt_boxes=gt_boxes[0]\n )\n boxes, gt_boxes = [boxes], [gt_boxes]\n\n if self._test_force_flip:\n # if self.cfg.MODEL.USE_SPA_CONF and len(imgs[n_imgs].shape) != 3:\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\n # imgs[n_imgs:] = [np.expand_dims(img, axis=-1) for img in imgs[n_imgs:]]\n imgs, boxes = cv2_transform.horizontal_flip_list(\n 1, imgs, order=\"HWC\", boxes=boxes, gt_boxes=gt_boxes,\n n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\n )\n else:\n raise NotImplementedError(\n \"Unsupported split mode {}\".format(self._split)\n )\n\n # Convert image to CHW keeping BGR order.\n if self.cfg.MODEL.USE_SPA_CONF:\n try:\n if len(imgs[n_imgs].shape) == 2:\n imgs[n_imgs:] = [np.expand_dims(img, axis=-1) for img in imgs[n_imgs:]]\n elif len(imgs[n_imgs].shape) > 3:\n imgs[n_imgs:] = [np.expand_dims(img.squeeze(), axis=-1) for img in imgs[n_imgs:]]\n except:\n import pdb; pdb.set_trace()\n \n # for i in range(n_imgs, len(imgs) + 1):\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\n # try:\n imgs = [cv2_transform.HWC2CHW(img) for img in imgs]\n # except:\n # print('imgs[n_imgs].shape:', imgs[n_imgs].shape)\n # print('len(imgs):', len(imgs))\n # print('n_imgs:', n_imgs)\n # import pdb; pdb.set_trace()\n\n # Image [0, 255] -> [0, 1].\n if self.cfg.MODEL.USE_SPA_CONF:\n imgs[:n_imgs] = [img / 255.0 for img in imgs[:n_imgs]]\n else: \n imgs = [img / 255.0 for img in imgs]\n\n if self.cfg.MODEL.USE_SPA_CONF:\n imgs[:n_imgs] = [\n np.ascontiguousarray(\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\n ).astype(np.float32)\n for img in imgs[:n_imgs]\n ]\n imgs[n_imgs:] = [\n np.ascontiguousarray(\n img.reshape((1, imgs[0].shape[1], imgs[0].shape[2]))\n ).astype(np.float32)\n for img in imgs[n_imgs:]\n ]\n else:\n imgs = [\n np.ascontiguousarray(\n # img.reshape((3, self._crop_size, self._crop_size))\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\n ).astype(np.float32)\n for img in imgs\n ]\n\n # Do color augmentation (after divided by 255.0).\n if self.cfg.MODEL.USE_SPA_CONF:\n skeleton_imgs = imgs[n_imgs:]\n imgs = imgs[:n_imgs]\n if self._split == \"train\" and self._use_color_augmentation: # False\n if not self._pca_jitter_only:\n imgs = cv2_transform.color_jitter_list(\n imgs,\n img_brightness=0.4,\n img_contrast=0.4,\n img_saturation=0.4,\n )\n\n imgs = cv2_transform.lighting_list(\n imgs,\n alphastd=0.1,\n eigval=np.array(self._pca_eigval).astype(np.float32),\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\n )\n\n # Normalize images by mean and std.\n imgs = [\n cv2_transform.color_normalization(\n img,\n np.array(self._data_mean, dtype=np.float32),\n np.array(self._data_std, dtype=np.float32),\n )\n for img in imgs\n ]\n\n # Concat list of images to single ndarray.\n imgs = np.concatenate(\n [np.expand_dims(img, axis=1) for img in imgs], axis=1\n )\n\n if not self._use_bgr:\n # Convert image format from BGR to RGB.\n imgs = imgs[::-1, ...]\n\n imgs = np.ascontiguousarray(imgs)\n imgs = torch.from_numpy(imgs)\n \n if self.cfg.MODEL.USE_SPA_CONF:\n skeleton_imgs = np.concatenate(\n [np.expand_dims(img, axis=1) for img in skeleton_imgs], axis=1\n )\n skeleton_imgs = np.ascontiguousarray(skeleton_imgs)\n skeleton_imgs = torch.from_numpy(skeleton_imgs)\n\n boxes = cv2_transform.clip_boxes_to_image(\n boxes[0], imgs[0].shape[1], imgs[0].shape[2]\n )\n if gt_boxes is not None:\n gt_boxes = cv2_transform.clip_boxes_to_image(\n gt_boxes[0], imgs[0].shape[1], imgs[0].shape[2]\n )\n if self.cfg.MODEL.USE_SPA_CONF:\n return (imgs, skeleton_imgs, boxes) if gt_boxes is None else (imgs, skeleton_imgs, boxes, gt_boxes)\n else:\n return (imgs, boxes) if gt_boxes is None else (imgs, boxes, gt_boxes)","def set_figure_size(self):\n lims, _ = self.set_lims()\n size_fac = 50\n paperSizeFac = 0.65\n one_dec = 1.6\n xdecs = np.log10(lims(1)) - np.log10(lims(0))\n one_dec = one_dec * 4 / xdecs\n ydecs = np.log10(lims[3]) - np.log10(lims[2])\n paper_width = xdecs * one_dec\n paper_height = (ydecs + 3) * one_dec\n paper_height = min([paper_height, 9])\n rectScreen = [0.5, 0.5, paper_width, paper_height] * size_fac\n rectPaper = [1.0, 1.0, paper_width * paperSizeFac, paper_height * paperSizeFac]\n\n rectRho = [0.15, 0.15 + 2.3 / (ydecs + 3), 0.8, ydecs / (ydecs + 3) * 0.8]\n rectPhi = [0.15, 0.15, 0.8, 2 / (ydecs + 3) * 0.8]\n rects = {\n \"Screen\": rectScreen,\n \"Paper\": rectPaper,\n \"Rho\": rectRho,\n \"Phi\": rectPhi,\n }\n return rects","def define_box_location(self):\n self.contents['Box_ID'] = np.ones(self.numatom) * self.num_box","def configure_grid(self):\r\n\r\n for r in range(3):\r\n self.rowconfigure(r, weight=1)\r\n for c in range(3):\r\n self.columnconfigure(c, weight=1)","def create_prior_boxes(self):\n # value of k for each feature map to create k^2 boxes for each feature map\n feature_map_dims = {'conv4_3': 38, 'conv7': 19, 'conv8_2': 10, 'conv9_2': 5}\n\n # scale for boxes across different feature maps. boxes for inner feature maps\n # are scaled much lower to detect small objects\n obj_scales = {'conv4_3': 0.1, 'conv7': 0.21, 'conv8_2': 0.255, 'conv9_2': 0.30}\n\n # Defined aspect ratio calculated from mean of (w/h) across all bounding boxes\n # from the dataset. The mean is 0.66 with deviation of 0.07. So aspect ratio is kept\n # at 0.66 for all feature maps\n aspect_ratios = {'conv4_3': [0.5], 'conv7': [0.55], 'conv8_2': [0.6], 'conv9_2': [.66]}\n\n fmaps = list(feature_map_dims.keys())\n prior_boxes = []\n for k, fmap in enumerate(fmaps):\n # for each feature map, create k*k boxes\n for i in range(feature_map_dims[fmap]):\n for j in range(feature_map_dims[fmap]):\n # calculate center coordinates of boxes\n cx = (j + 0.5) / feature_map_dims[fmap]\n cy = (i + 0.5) / feature_map_dims[fmap]\n\n # For each\n for ratio in aspect_ratios[fmap]:\n prior_boxes.append([cx, cy, obj_scales[fmap] * sqrt(ratio), obj_scales[fmap] / sqrt(ratio)])\n\n prior_boxes = torch.FloatTensor(prior_boxes).to(device) # (1930, 4)\n prior_boxes.clamp_(0, 1) # (1930, 4)\n\n return prior_boxes","def setup_image(self):\n # Create the correct size image for the table\n rows = self.table.count('\\n')\n columns = self.table.split('\\n')[0].count('-') + self.table.split('\\n')[0].count('+')\n self.img = Image.new('RGB', ((columns * 12) + 24, rows * 21 + 48), color=(54, 57, 63))\n\n # Initialize font and drawing object\n self.font = ImageFont.truetype('../extra_files/cour.ttf', 20)\n self.draw = ImageDraw.Draw(self.img)\n\n # Draw the table without markings\n for x in range(5):\n self.draw.text((12, 12), self.table, font=self.font, fill=(255, 255, 255))","def boxes_postprocess(boxes, image_meta):\n if 'scales' in image_meta:\n boxes[:, [0, 2]] /= image_meta['scales'][1]\n boxes[:, [1, 3]] /= image_meta['scales'][0]\n\n if 'padding' in image_meta:\n boxes[:, [0, 2]] -= image_meta['padding'][2]\n boxes[:, [1, 3]] -= image_meta['padding'][0]\n\n if 'crops' in image_meta:\n boxes[:, [0, 2]] += image_meta['crops'][2]\n boxes[:, [1, 3]] += image_meta['crops'][0]\n\n if 'flipped' in image_meta and image_meta['flipped']:\n image_width = image_meta['drifted_size'][1] if 'drifted_size' in image_meta else \\\n image_meta['orig_size'][1]\n boxes_widths = boxes[:, 2] - boxes[:, 0] + 1.\n boxes[:, 0] = image_width - 1 - boxes[:, 2]\n boxes[:, 2] = boxes[:, 0] + boxes_widths - 1.\n\n if 'drifts' in image_meta:\n boxes[:, [0, 2]] += image_meta['drifts'][1]\n boxes[:, [1, 3]] += image_meta['drifts'][0]\n\n return boxes","def draw_boxes(bboxes: [[int]], img: 'np.array', line_width: int=2) -> 'np.array':\n for x, y, w, h in bboxes:\n cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), line_width)\n return img","def __call__(self, results):\n\n if 'img_fields' in results:\n assert results['img_fields'] == ['img'], \\\n 'Only single img_fields is allowed'\n img = results['img']\n assert 'bbox_fields' in results\n boxes = [results[key] for key in results['bbox_fields']]\n boxes = np.concatenate(boxes, 0)\n h, w, c = img.shape\n while True:\n mode = random.choice(self.sample_mode)\n self.mode = mode\n if mode == 1:\n return results\n\n min_iou = mode\n for i in range(50):\n new_w = random.uniform(self.min_crop_size * w, w)\n new_h = random.uniform(self.min_crop_size * h, h)\n\n # h / w in [0.5, 2]\n if new_h / new_w < 0.5 or new_h / new_w > 2:\n continue\n\n left = random.uniform(w - new_w)\n top = random.uniform(h - new_h)\n\n patch = np.array(\n (int(left), int(top), int(left + new_w), int(top + new_h)))\n # Line or point crop is not allowed\n if patch[2] == patch[0] or patch[3] == patch[1]:\n continue\n overlaps = bbox_overlaps(\n patch.reshape(-1, 4), boxes.reshape(-1, 4)).reshape(-1)\n if len(overlaps) > 0 and overlaps.min() < min_iou:\n continue\n\n # center of boxes should inside the crop img\n # only adjust boxes and instance masks when the gt is not empty\n if len(overlaps) > 0:\n # adjust boxes\n def is_center_of_bboxes_in_patch(boxes, patch):\n center = (boxes[:, :2] + boxes[:, 2:]) / 2\n mask = ((center[:, 0] > patch[0]) *\n (center[:, 1] > patch[1]) *\n (center[:, 0] < patch[2]) *\n (center[:, 1] < patch[3]))\n return mask\n\n mask = is_center_of_bboxes_in_patch(boxes, patch)\n if not mask.any():\n continue\n for key in results.get('bbox_fields', []):\n boxes = results[key].copy()\n mask = is_center_of_bboxes_in_patch(boxes, patch)\n boxes = boxes[mask]\n if self.bbox_clip_border:\n boxes[:, 2:] = boxes[:, 2:].clip(max=patch[2:])\n boxes[:, :2] = boxes[:, :2].clip(min=patch[:2])\n boxes -= np.tile(patch[:2], 2)\n\n results[key] = boxes\n # labels\n label_key = self.bbox2label.get(key)\n if label_key in results:\n results[label_key] = results[label_key][mask]\n\n # mask fields\n mask_key = self.bbox2mask.get(key)\n if mask_key in results:\n results[mask_key] = results[mask_key][\n mask.nonzero()[0]].crop(patch)\n # adjust the img no matter whether the gt is empty before crop\n img = img[patch[1]:patch[3], patch[0]:patch[2]]\n results['img'] = img\n results['img_shape'] = img.shape\n\n # seg fields\n for key in results.get('seg_fields', []):\n results[key] = results[key][patch[1]:patch[3],\n patch[0]:patch[2]]\n return results","def initialize_grid(self) -> None:\n for i in range(self.grid_size[0]):\n for j in range(self.grid_size[1]):\n self.set(i, j, self.base_color)","def fillingrid(self):\n\n if self.imagearray is None:\n if self.gs.isfixed:\n for n in range(0, self.numcols):\n self.vspins[n].setValue(self.currentvalues[n])\n elif self.gs.isperc:\n for n in range(0, self.numcols):\n self.fillinpercent(n)\n else:\n for n in range(0, self.numcols):\n self.nsspins[n].setValue(self.currentnsigs[n])\n else:\n for n in range(0, self.numcols):\n self.vspins[n].setValue(self.currentvalues[n])\n self.nsspins[n].setValue(self.currentnsigs[n])\n self.fillinpercent(n)","def create_flowbox(self, flowbox, frame_list):\n\n for num_frame in frame_list:\n grid = Gtk.Grid()\n btn = self.new_thumbnail_button(num_frame)\n\n widget_cls_label = Gtk.Label()\n widget_cls_label.set_text(\"?\")\n widget_cls_label.set_size_request(20, 20)\n widget_cls_label.connect(\"draw\", self.area_on_draw, {'frame': num_frame, 'widget_label': widget_cls_label})\n # Add drawing area\n grid.add(btn)\n grid.attach_next_to(widget_cls_label, btn, Gtk.PositionType.BOTTOM, 1, 2)\n\n flowbox.add(grid)\n self.flowbox_layout = flowbox","def updateFootprintBbox(self):\n # Pull out the image bounds of the parent Footprint\n self.bb = self.fp.getBBox()\n if not self.imbb.contains(self.bb):\n raise ValueError(('Footprint bounding-box %s extends outside image bounding-box %s') %\n (str(self.bb), str(self.imbb)))\n self.W, self.H = self.bb.getWidth(), self.bb.getHeight()\n self.x0, self.y0 = self.bb.getMinX(), self.bb.getMinY()\n self.x1, self.y1 = self.bb.getMaxX(), self.bb.getMaxY()","def boxer(imgfile, parttree, outstack, boxsize):\n imgarray = mrc.read(imgfile)\n boxedparticles = boxerMemory(imgarray, parttree, boxsize)\n apImagicFile.writeImagic(boxedparticles, outstack)\n return True","def build_boxes(self):\n for index in self.box_space.points:\n if self.rank_of_box[index] == self.my_rank:\n self.my_boxes.append(Box(self, index))","def __build__(self,data_index=0):\n \n super(Image,self).__build__()\n # -- How to read the image\n self._build_properties = dict(\n data_index = data_index,\n header_exptime = \"EXPTIME\",\n dataslice0=\"undefined\",\n dataslice1=\"undefined\",\n bkgdbox={\"bh\":100,\"bw\":100,\"fh\":3,\"fw\":3},\n )","def set_pic_size(self, im_name):\n im_vals = np.genfromtxt(im_name, delimiter=self.delim)\n self.pic_width = int(np.size(im_vals[0]) - 1) # the first column of ASCII image is row number\n try: self.pic_height = int(np.size(im_vals[:,0])) \n except IndexError: \n self.pic_width = int(np.size(im_vals) - 1)\n self.pic_height = 1\n self.create_rect_mask()\n return self.pic_width, self.pic_height","def preprocessing(image_data, max_height, max_width):\n img = image_data[\"image\"]\n img = resize_image(img, max_height, max_width)\n gt_boxes = image_data[\"objects\"][\"bbox\"]\n gt_labels = image_data[\"objects\"][\"label\"]\n return img, gt_boxes, gt_labels","def setpopbox(ty,slist,scaledtime,rootpop,poptree):\r\n wadjust = \"\"\r\n for i in range(numpops-1):\r\n wadjust += \"00\"\r\n if(scaledtime != []):\r\n minx_popbox = textwide(wadjust+\"0.00 MYR\", tfactor)\r\n else:\r\n minx_popbox = textwide(wadjust+\"0.00 tu\", tfactor)\r\n minx_popbox /= gv[\"globalscale\"]\r\n if gv[\"localxscale\"] > 0:\r\n minx_popbox /= gv[\"localxscale\"]\r\n\r\n popxvals = []\r\n## if scaledpop == [] then no text is written on time split line and there is more width to work with\r\n for i in range(2*numpops - 1):\r\n## left side temporarily at zero, right side temporarily at upper confidence interval\r\n popxvals.append( [0,slist[4][4][i][1]])\r\n (width,c,popxvals, leftpoint,rightpoint) = centerbox(rootpop,0,popxvals[rootpop][1],poptree,popxvals)\r\n popxvals = popadjustx(popxvals,minx_popbox)\r\n popbox = []\r\n\r\n ## maxwide will be used to adjust the width as a scaler so the part furthest to the right is not too far out\r\n maxwide = 0\r\n for i in range(2*numpops-1):\r\n if maxwide < (popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1])):\r\n maxwide = (popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1]))\r\n maxwide = maxwide/(1.0-minx_popbox)\r\n\r\n if gv[\"localxscale\"] > 0:\r\n maxwide *= gv[\"localxscale\"]\r\n\r\n farright = 0\r\n confint = []\r\n for i in range(2*numpops-1):\r\n confint.append([])\r\n confint[i].append(minx_popbox + ((popxvals[i][1] - (slist[4][4][i][1]-slist[4][4][i][2]))/maxwide))\r\n confint[i].append(minx_popbox + ((popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1]))/maxwide))\r\n if confint[i][1] > farright:\r\n farright = confint[i][1]\r\n popbox.append([[],[]])\r\n popbox[i][0].append(minx_popbox + popxvals[i][0]/maxwide)\r\n popbox[i][1].append(minx_popbox + popxvals[i][1]/maxwide)\r\n if poptree[i][1] == -1:\r\n popbox[i][0].append(gv[\"lineINFy\"])\r\n else:\r\n popbox[i][0].append(ty[poptree[i][1]-1][0])\r\n if poptree[i][0] == 0:\r\n popbox[i][1].append(gv[\"line0y\"])\r\n else:\r\n popbox[i][1].append(ty[poptree[i][0]-1][0])\r\n return popbox,maxwide, confint, farright","def plt_bboxes(img, classes, scores, bboxes, figsize=(10,10), linewidth=1.5):\n fig = plt.figure(figsize=figsize)\n plt.imshow(img)\n height = img.shape[0]\n width = img.shape[1]\n colors = dict()\n for i in range(classes.shape[0]):\n cls_id = int(classes[i])\n if cls_id >= 0:\n score = scores[i]\n if cls_id not in colors:\n colors[cls_id] = (random.random(), random.random(), random.random())\n ymin = int(bboxes[i, 0] * height)\n xmin = int(bboxes[i, 1] * width)\n ymax = int(bboxes[i, 2] * height)\n xmax = int(bboxes[i, 3] * width)\n# crop_img = img[xmin:(xmax - xmin),xmax:(ymax - ymin)]\n# misc.imsave('1.jpg', crop_img)\n rect = plt.Rectangle((xmin, ymin), xmax - xmin,\n ymax - ymin, fill=False,\n edgecolor=colors[cls_id],\n linewidth=linewidth)\n plt.gca().add_patch(rect)\n class_name = CLASSES[cls_id]\n plt.gca().text(xmin, ymin - 2,\n '{:s} | {:.3f}'.format(class_name, score),\n bbox=dict(facecolor=colors[cls_id], alpha=0.5),\n fontsize=12, color='white')\n plt.show()","def __init__(self,phosphene_resolution=(50,50), size=(480,480), jitter=0.35, intensity_var=0.9, aperture=.66, sigma=0.8, custom_grid=None):\n if custom_grid is None:\n self.phosphene_resolution = phosphene_resolution\n self.size = size\n self.phosphene_spacing = np.divide(size,phosphene_resolution)\n self.jitter = jitter\n self.intensity_var = intensity_var\n self.grid = self.create_regular_grid(self.phosphene_resolution,self.size,self.jitter,self.intensity_var)\n self.aperture = np.round(aperture*self.phosphene_spacing[0]).astype(int) #relative aperture > dilation kernel size\n else:\n self.grid = custom_grid\n self.aperture = aperture\n self.sigma = sigma\n self.dilation_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(self.aperture,self.aperture))\n self.k_size = 11 #np.round(4*sigma+1).astype(int) # rule of thumb: choose k_size>3*sigma","def sizes(options):\n # import data\n pixels = dict() # volumes are given in #pixels\n snap_mask = \"/net/astrogate/export/astrodata/jgacon/filex/processing/\" \\\n \"export/f8_h50_v100_objs_snap_%d.csv\"\n snap_ids = np.arange(2,28+1)\n z = snapid2z(snap_ids)\n print z\n\n for id in snap_ids:\n snap = snap_mask % (id - 1) # fix: snap number one too low in filename\n pixels[id] = np.genfromtxt(snap)[1:-1,1] # row 2 contains volumes\n # rm void & halo volumes\n\n # visualise\n if \"err\" in options.keys():\n nums = np.array([pixels[id].size for id in snap_ids])\n avgs = np.array([np.mean(pixels[id]) for id in snap_ids])\n mods = np.array([st.mode(pixels[id])[0][0] for id in snap_ids])\n meds = np.array([np.median(pixels[id]) for id in snap_ids])\n stds = np.array([np.std(pixels[id]) for id in snap_ids])\n\n print mods\n print mods.shape\n\n plt.figure()\n plt.title(\"Sizes of filaments as function of redshift\")\n plt.xlabel(\"Redshift $z$\")\n plt.xticks(snap_ids[::3], z[::3])\n\n plt.ylabel(\"Size in #pixels\")\n\n plt.errorbar(snap_ids, avgs, yerr=stds, label=\"Mean\")\n plt.plot(snap_ids, mods, \"g\", label=\"Mode\")\n plt.plot(snap_ids, meds, \"c\", label=\"Median\")\n plt.legend(loc=\"best\")\n\n plt.twinx()\n plt.ylabel(\"#Filaments\", color=\"r\")\n plt.tick_params(\"y\", colors=\"r\")\n\n plt.plot(snap_ids, nums, \"r--\")\n\n plt.savefig(options[\"err\"])\n\n if \"dist\" in options.keys():\n targets = np.array([5,10,15,20,25])\n plt.figure()\n plt.title(\"Volume distribution of filaments\")\n plt.xlabel(\"Volume $V$ in #pixels\")\n plt.ylabel(\"#Element with $V$ / Total #Elements\")\n plt.xlim([0,1000])\n for target in targets:\n sns.kdeplot(pixels[target], label=\"$z$ = %f\" % snapid2z(target))\n plt.legend(loc=\"best\")\n plt.savefig(options[\"dist\"])\n\n if \"dist_inter\" in options.keys():\n default = snap_ids[-1]\n fig, ax = plt.subplots()\n plt.subplots_adjust(bottom=0.25)\n sns.kdeplot(pixels[int(default - 2)], ax=ax)\n plt.xlim([0, 1000])\n plt.ylim([0, 0.01])\n plt.xlabel(\"Volume $V$ of filaments in #pixels\")\n plt.ylabel(\"#Filaments with volume $V$ / Total #Filaments\")\n\n nums = np.array([pixels[id].size for id in snap_ids])\n ax2 = ax.twinx()\n ax2.set_ylabel(\"#Filaments\", color=\"r\", alpha=0.5)\n ax2.tick_params(axis=\"y\", labelcolor=\"r\")\n ax2_x = np.linspace(0, 1000, nums.size)\n ax2.plot(ax2_x, nums, \"r--\", alpha=0.5)\n point, = ax2.plot(ax2_x[default - 2], nums[default - 2], \"ro\", alpha=0.5)\n\n axcolor = 'lightgoldenrodyellow'\n axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)\n sid = Slider(axfreq, \"ID\", 2, 28, valinit=default, valstep=1)\n ax.set_title(\"$z$ = %f\" % snapid2z(default))\n\n def update(val):\n id = sid.val\n\n print id\n #ax.clear()\n ax.set_ydata()\n ax.set_xdata()\n ax.set_title(\"$z$ = %f\" % snapid2z(int(id)))\n ax.set_xlim([0,1000])\n ax.set_ylim([0, 0.01])\n sns.kdeplot(pixels[int(id)], ax=ax)\n point.set_xdata(ax2_x[int(id) - 2])\n point.set_ydata(nums[int(id) - 2])\n fig.canvas.draw_idle()\n sid.on_changed(update)\n\n plt.show()\n\n\n if \"hist\" in options.keys():\n conc = None\n for id, vols in pixels.iteritems():\n data = np.empty((vols.size, 2))\n data[:,0] = id\n data[:,1] = vols\n\n if conc is None:\n conc = data\n else:\n conc = np.vstack((conc, data))\n\n plt.figure()\n plt.hist2d(conc[:,0], conc[:,1], bins=(snap_ids.size, 1000))\n plt.ylim([100,400])\n plt.savefig(options[\"hist\"])","def create_image_caption_pairs(self):","def _set_boxes(self, listOfBoxes):\n self._boxes = listOfBoxes","def generate_image_grid(sess, df, filenames,op, op2):\n #x_points = np.arange(0, 1, 1.5).astype(np.float32)\n #y_points = np.arange(0, 1, 1.5).astype(np.float32)\n\n nx, ny = 12, 1\n #plt.subplot()\n gs = gridspec.GridSpec(nx, ny, hspace=1, wspace=0.05)\n # input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\n #\n # plt.imshow(np.array(df[0].tolist()).reshape(28, 28), cmap='gray')\n # plt.show()\n # x = sess.run(op, feed_dict={decoder_input: input_x[0].reshape(1,2)})\n # img = np.array(x.tolist()).reshape(28, 28)\n #\n # plt.imshow(img, cmap='gray')\n # plt.show()\n\n \"\"\" grid \"\"\"\n input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\n for i, g in enumerate(gs):\n\n x = sess.run(op, feed_dict={decoder_input: input_x[i].reshape(1,2)})\n ax = plt.subplot(g)\n img = np.array(x.tolist()).reshape(28, 28)\n ax.imshow(img, cmap='gray')\n ax.set_xticks([])\n ax.set_yticks([])\n #ax.set_aspect('auto')\n ax.set_title(filenames[i])\n plt.show()\n\n for i, g in enumerate(gs):\n\n ax = plt.subplot(g)\n img = np.array(df[i].tolist()).reshape(28, 28)\n ax.imshow(img, cmap='gray')\n ax.set_xticks([])\n ax.set_yticks([])\n #ax.set_aspect('auto')\n ax.set_title(filenames[i])\n plt.show()","def plt_bboxes(img, classes, scores, bboxes, figsize=(17.78,10), linewidth=1.5):\n fig = plt.figure(figsize=figsize, frameon=False)\n ax = fig.add_axes([0, 0, 1, 1])\n ax.axis('off')\n plt.imshow(img)\n height = img.shape[0]\n width = img.shape[1]\n print (\"original height width\", height, width)\n if (classes.shape[0] > 0):\n print (\"This frame has class\")\n for i in range(classes.shape[0]):\n cls_id = int(classes[i])\n if cls_id >= 0:\n score = scores[i]\n if cls_id not in colors:\n colors[cls_id] = (random.random(), random.random(), random.random())\n ymin = int(bboxes[i, 0] * height)\n xmin = int(bboxes[i, 1] * width)\n ymax = int(bboxes[i, 2] * height)\n xmax = int(bboxes[i, 3] * width)\n rect = plt.Rectangle((xmin, ymin), xmax - xmin,\n ymax - ymin, fill=False,\n edgecolor=colors[cls_id],\n linewidth=linewidth)\n plt.gca().add_patch(rect)\n class_name = pascal_classes[cls_id]\n plt.gca().text(xmin, ymin - 2,\n '{:s} | {:.3f}'.format(class_name, score),\n bbox=dict(facecolor=colors[cls_id], alpha=0.5),\n fontsize=12, color='white')\n fig.canvas.draw()\n data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')\n data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n plt.close()\n print(\"Processed data with shape, \", data.shape)\n return data","def draw_boxes(indexes, frame, all_boxes):\n bbox = []\n mid_points = []\n\n for i in indexes:\n x = i[0]\n box = all_boxes[x]\n bbox.append(box)\n mid_points.append(mid_point(frame, box))\n x1, y1, w, h = box[0], box[1], box[2], box[3]\n x2, y2 = x1+w, y1+h\n\n cv2.rectangle(frame, (x1,y1),(x2,y2),(255,0,0),2) \n\n return mid_points, bbox","def __draw_boxes(self, img, bboxes, color=(128, 0, 0), thick=4):\n\n # Make a copy of the image\n imcopy = np.copy(img)\n # Iterate through the bounding boxes\n for bbox in bboxes:\n # Draw a rectangle given bbox coordinates\n cv2.rectangle(imcopy, bbox[0], bbox[1], color, thick)\n # Return the image copy with boxes drawn\n return imcopy","def setUp(self):\n img_path = osp.join(osp.dirname(__file__), '../../data/gray.jpg')\n self.results = {\n 'img_path':\n img_path,\n 'img_shape': (300, 400),\n 'instances': [{\n 'bbox': [0, 0, 10, 20],\n 'bbox_label': 1,\n 'mask': [[0, 0, 0, 20, 10, 20, 10, 0]],\n 'ignore_flag': 0\n }, {\n 'bbox': [10, 10, 110, 120],\n 'bbox_label': 2,\n 'mask': [[10, 10, 110, 10, 110, 120, 110, 10]],\n 'ignore_flag': 0\n }, {\n 'bbox': [50, 50, 60, 80],\n 'bbox_label': 2,\n 'mask': [[50, 50, 60, 50, 60, 80, 50, 80]],\n 'ignore_flag': 1\n }]\n }","def make_grid_bbox(tensor, box, nrow=8, padding=2,\n normalize=False, range=None, \n scale_each=False, pad_value=0, draw_line=False):\n\n # make the mini-batch of images into a grid\n # nmaps = tensor.size(0)\n nmaps = len(box)\n xmaps = min(nrow, nmaps)\n ymaps = int(math.ceil(float(nmaps) / xmaps))\n # height, width = int(tensor.size(2) + padding), int(tensor.size(3) + padding)\n height, width = int(256 + padding), int(256 + padding)\n tensor = torch.ones(())\n grid = tensor.new_full((3, height * ymaps + padding, width * xmaps + padding), pad_value)\n # # add the white image into the grid\n # block = tensor.new_full((3, height - padding, width - padding), 9.0/13)\n k = 0\n for y in irange(ymaps):\n for x in irange(xmaps):\n if k >= nmaps:\n break\n # add the white image into the grid\n block = tensor.new_full((3, height - padding, width - padding), 9.0/13)\n # print(box[0].size())\n # print(box[1].size())\n # assert False\n # num_curr_box = box[0][k].size(0)\n num_curr_box = box[k][0].size(0)\n for z in irange(num_curr_box):\n # label = box[1][k][z].item()\n try:\n label = box[k][1][z].item()\n except:\n print(box)\n print(k)\n assert False\n \n if label != -1:\n block = draw_box(block, box[k][0][z], label, draw_line)\n # print(k, z)\n else:\n break\n # copy to the grid\n grid.narrow(1, y * height + padding, height - padding)\\\n .narrow(2, x * width + padding, width - padding)\\\n .copy_(block)\n k = k + 1\n return grid","def _resize_bboxes(self, ori_bboxes, scale_factor):\n bboxes = ori_bboxes * scale_factor\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, self.img_shape[1])\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, self.img_shape[0])\n return bboxes","def draw_boxes_info(image, current_data):\n\n font_position1 = (50, 600)\n font_position2 = (50, 650)\n font_scale = .4\n font_thickness = 1\n\n locations = current_data[\"locations\"] #returns x1, y1, x2, y2\n frame_num = \"Frame Number: \" + str(current_data[\"frame_num\"])\n\n for box in locations:\n box_text = (\"Box locations are x1: {0}, y1: {1}, x2: {2}, y2: {3}\").format(box[1],box[3],box[0],box[2])\n\n cv2.rectangle(image, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 3)\n cv2.putText(image, box_text, font_position1, cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255),\n font_thickness, cv2.LINE_AA)\n\n cv2.putText(image, frame_num, font_position2, cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255),\n font_thickness, cv2.LINE_AA)\n\n return image","def display_precomputed_boxes(self, sample_index, all_boxes):\n image_rois = [class_detections[sample_index]\n for class_detections in all_boxes]\n\n image_rois_list = []\n image_classes = []\n for class_index, class_rois in enumerate(image_rois):\n if len(class_rois) > 0:\n classes = np.ones((class_rois.shape[0])) * class_index\n image_rois_list.extend(class_rois)\n image_classes.extend(classes)\n image_rois_list = np.array(image_rois_list)\n image_classes = np.array(image_classes)\n\n show_gt_boxes = False\n self.display_detections(image_rois_list, image_classes, \n self.data_loader.dataset.samples[sample_index])","def plot_n_box(img_prepro):\n print(img_prepro)\n h, w= img_prepro.shape\n boxes = pytesseract.image_to_boxes(img_prepro)\n for b in boxes.splitlines():\n b = b.split(' ')\n img_prepro = cv2.rectangle(img_prepro, (int(b[1]), h - int(b[2])), (int(b[3]), h - int(b[4])), (0, 255, 0), 2)\n cv2.imshow('img', img_prepro)\n cv2.waitKey(0)\n\n return","def setwinsize(self, rows, cols):","def onet_process(self, image, boxes, height, width):\n data = self.__padding(image, boxes, height, width)\n return data","def forward(self):\n priors = []\n for k, f in enumerate(self.feature_maps):\n scale = self.image_size / self.strides[k]\n # for i, j in product(range(f), repeat=2):\n for i in range(f[0]):\n for j in range(f[1]):\n # print(i, j)\n # unit center x,y\n cx = (j + 0.5) / scale\n cy = (i + 0.5) / scale\n\n # small sized square box\n size = self.min_sizes[k]\n h = w = size / self.image_size\n priors.append([cx, cy, w, h])\n\n # big sized square box\n size = sqrt(self.min_sizes[k] * self.max_sizes[k])\n h = w = size / self.image_size\n priors.append([cx, cy, w, h])\n\n # change h/w ratio of the small sized box\n size = self.min_sizes[k]\n h = w = size / self.image_size\n for ratio in self.aspect_ratios[k]:\n ratio = sqrt(ratio)\n priors.append([cx, cy, w * ratio, h / ratio])\n priors.append([cx, cy, w / ratio, h * ratio])\n\n priors = torch.Tensor(priors)\n if self.clip:\n priors.clamp_(max=1, min=0)\n return priors","def get_boxes():\n boxes = []\n\n box_sizes = [256]\n left_x_cords = [x for x in range(0,1280,12)]\n top_y_cords = [y for y in range(360,720,12)]\n\n for box_size in box_sizes:\n for x_cord in left_x_cords:\n for y_cord in top_y_cords:\n if box_size+x_cord < 1280 and box_size+y_cord < 720:\n boxes.append([x_cord, y_cord, x_cord+box_size, y_cord+box_size])\n\n return boxes","def __create_blank_page__(self):\n with open(\"active_weather.basic.exp\"+str(self.box_count)+\".box\",\"w\") as f:\n f.write(\"\")\n\n self.width = 2508\n # self.height = 200\n self.height = 4000\n self.training_page = np.zeros((self.height,self.width),dtype=np.uint8)\n self.training_page.fill(255)\n\n self.row_bitmaps = []\n self.row_characters = []\n\n self.row_pointer = spacing\n self.column_pointer = spacing\n\n\n # self.__box_file_flush__()\n self.box_file_entries = []\n self.used_height = spacing","def plot_image(image, boxes, class_dic, frame_n):\n im = np.array(image)\n print(im.shape)\n height, width, _ = im.shape\n\n # Create figure and axes\n # fig, ax = plt.subplots(1)\n # # Display the image\n # ax.imshow(im)\n\n fig = plt.figure()\n ax = fig.add_subplot(111, aspect='auto')\n ax.set_axis_off()\n fig.add_axes(ax)\n ax.imshow(im)\n # box[0] is x midpoint, box[2] is width\n # box[1] is y midpoint, box[3] is height\n\n # Create a Rectangle potch\n for box in boxes:\n class_ = int(box[0])\n confidence_ = box[1]\n box = box[2:]\n assert len(box) == 4, \"Got more values than in x, y, w, h, in a box!\"\n upper_left_x = box[0] - box[2] / 2\n upper_left_y = box[1] - box[3] / 2\n rect = patches.Rectangle(\n (upper_left_x * width, upper_left_y * height),\n box[2] * width,\n box[3] * height,\n linewidth=1,\n edgecolor=\"r\",\n facecolor=\"none\",\n )\n\n\n label_bbox = class_dic[class_] + \":::\" + f\"{100 * confidence_:.2f}\" + \"%\"\n plt.text(upper_left_x * width, upper_left_y * height - 10, label_bbox, size=10, rotation=0,\n ha=\"left\", va=\"bottom\",\n bbox=dict(boxstyle=\"square\",\n ec=(1, 0, 0),\n fc=(1, 0, 0),\n )\n )\n \n \n # Add the patch to the Axes\n ax.add_patch(rect)\n if frame_n:\n plt.savefig(str(frame_n) + '.png', dpi=200, bbox_inches=\"tight\", transparent=True, pad_inches=0)\n else:\n plt.show()","def setUp(self):\n self.single_box = [ScoredRect(Rect(0, 10, 0, 20), 0.0)]\n\n self.ground_truths = [ScoredRect(Rect(0, 10, 0, 10), 0.5),\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\n ScoredRect(Rect(-40, -30, -20, -10), 0.5),\n ]\n self.detections = [ScoredRect(Rect(0, 10, 0, 10), 0.5),\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\n ScoredRect(Rect(100, 110, 20, 30), 0.5),\n ]","def normalize_boxes(all_boxes, image_width, image_height):\n new_boxes = []\n for boxes_per_frame in all_boxes:\n new_boxes_per_frame = []\n for i, box in enumerate(boxes_per_frame):\n left, top, right, bottom = box\n new_boxes_per_frame.append((left / image_width, top / image_height, right / image_width, bottom / image_height))\n new_boxes.append(new_boxes_per_frame)\n\n assert(len(new_boxes) == len(all_boxes))\n for i, boxes_per_frame in enumerate(all_boxes):\n assert(len(boxes_per_frame) == len(new_boxes[i]))\n\n\n\n return new_boxes","def test_nominal_case(self):\n\n image_filename, boxes = list(annotation.read(self.filename))\n self.assertEqual(image_filename, 'image.jpg')\n self.assertEqual(len(boxes), 2)\n width = 400\n height = 300\n b = boxes[0]\n self.assertEqual(b.xmin, 10 / width)\n self.assertEqual(b.ymin, 20 / height)\n self.assertEqual(b.xmax, 30 / width)\n self.assertEqual(b.ymax, 40 / height)","def resize_spacing(img_sz,img_sp,factor):\n img_sz_np = np.array(list(img_sz))\n img_sp_np = np.array(list(img_sp))\n new_sz_np = img_sz_np*factor\n new_sp = img_sp_np*(img_sz_np-1)/(new_sz_np-1)\n return tuple(list(new_sp))","def __init__(self):\n toplevel_create_image = mw.tkinter.Toplevel(mw.MainWindow, bg = \"#a1a1a1\")\n \"\"\" top level window attributes\"\"\"\n toplevel_create_image.title(\"create new image\")\n toplevel_create_image.geometry(\"800x600+600+200\")\n toplevel_create_image.resizable(width = False, height = False)\n self. top_down = 60\n\n # UI\n image_width_label = mw.tkinter.Label(toplevel_create_image, text = \"Width: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n image_width_label.grid(row = 0, column = 0, padx = 20, pady = 20)\n image_height_label = mw.tkinter.Label(toplevel_create_image, text = \"Height: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n image_height_label.grid(row = 1, column = 0)\n\n # text box image size \n image_width_text_box = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n bg = \"grey\", fg = \"white\")\n image_width_text_box.grid(row = 0, column = 1, pady = 20)\n\n image_height_text_box = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n bg = \"grey\", fg = \"white\")\n image_height_text_box.grid(row = 1, column = 1)\n\n # color mode\n color_mode_combo_box = mw.tkinter.Label(toplevel_create_image, text = \"color mode: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n color_mode_combo_box.grid(row = 2, column = 0, padx = 20, pady = 20)\n\n # image_color_mode_text = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n # bg = \"grey\", fg = \"white\")\n # image_color_mode_text.grid(row = 2, column = 1)\n\n color_mode_combo_box = ttk.Combobox(toplevel_create_image, values = [\n \"RGB\",\n \"RGBA\",\n \"CYMA\"\n ])\n color_mode_combo_box.current(0)\n color_mode_combo_box.grid(row = 2, column = 1)\n\n # background color\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \"red: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n image_background_color_label.grid(row = 3, column = 0, padx = 30)\n\n image_background_color_text_red = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n bg = \"grey\", fg = \"white\")\n image_background_color_text_red.grid(row = 3, column = 1)\n# -----------------------------------------------------------------------------------------------------------\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \"green: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n image_background_color_label.grid(row = 4, column = 0, padx = 30)\n\n image_background_color_text_green = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n bg = \"grey\", fg = \"white\")\n image_background_color_text_green.grid(row = 4, column = 1)\n\n# ----------------------------------------------------------------------------------------------------------\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \"blue: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n image_background_color_label.grid(row = 5, column = 0, padx = 30)\n\n image_background_color_text_blue = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n bg = \"grey\", fg = \"white\")\n image_background_color_text_blue.grid(row = 5, column = 1)\n # create_new_image\n def create_new_image():\n new_image = Image.new(mode = (color_mode_combo_box.get()),\n size = (int(image_width_text_box.get(\"1.0\", mw.tkinter.END)),\n int(image_height_text_box.get(\"1.0\", mw.tkinter.END)) ),\n color = ((int(image_background_color_text_red.get(\"1.0\", mw.tkinter.END))),\n (int(image_background_color_text_green.get(\"1.0\", mw.tkinter.END))),\n (int(image_background_color_text_blue.get(\"1.0\", mw.tkinter.END)))))\n # get new image properties\n the_width, the_height = new_image.size\n # to-do clear the image\n new_image_compatible = ImageTk.PhotoImage(new_image)\n # load the image on the canvas \n app.default_image_canvas.delete(\"all\")\n # app.default_image_canvas = mw.tkinter.Canvas(toplevel_create_image, height = the_height, width = the_width)\n app.default_image_canvas.create_image(0,0, image = new_image_compatible, anchor = mw.tkinter.NW)\n # app.load_image_canvas.grid(row = 0, column = 1)\n toplevel_create_image.destroy()\n # to-do - correct error\n app.default_image_canvas.configure(mw.MainWindow)\n \n\n\n # create_image_button\n create_image_button = mw.tkinter.Button(toplevel_create_image, text = \"create image\",\n bg = \"grey\", fg = \"white\", font = (\"times\", 13,\"bold\"),\n command = create_new_image)\n create_image_button.grid(row = 6, column = 0, padx = 40, pady = 20)","def draw_boxes(self, image, boxes):\n return draw_boxes(image, boxes, self.labels)","def initrows(self):\n #~ self.initrows2()\n self.rows=[]\n for yy in range(self.height):\n row=[]\n for xx in range(self.width):\n if (xx,yy) in self.allsqs:\n row.append(0)\n #~ elif p in self.gatesqs:\n #~ row.append(0)\n else:\n row.append(1)\n self.rows.append(row)","def rescale_box(box, img_size_orig, img_size_new):\n orig_w, orig_h = img_size_orig\n new_w, new_h = img_size_new\n scale_x = new_w / orig_w\n scale_y = new_h / orig_h\n sx, sy, ex, ey = box\n return [sx * scale_x, sy * scale_y, ex * scale_x, ey * scale_y]","def __getitem__(self, index):\n image_id = self.image_ids[index]\n\n filename = self.image_id_to_filename[image_id]\n image_path = os.path.join(self.image_dir, filename)\n\n with open(image_path, 'rb') as f:\n with PIL.Image.open(f) as image:\n WW, HH = image.size\n image = self.transform(image.convert('RGB'))\n\n H, W = self.image_size\n objs, boxes, masks = [], [], []\n\n for object_data in self.image_id_to_objects[image_id]:\n # objs.append(object_data['category_id'])\n objs.append(int(object_data.find('name').get(\"id\")))\n\n bndbox = object_data.findall('bndbox')[0]\n xmin = int(bndbox.find('xmin').text)\n ymin = int(bndbox.find('ymin').text)\n xmax = int(bndbox.find('xmax').text)\n ymax = int(bndbox.find('ymax').text)\n w = xmax - xmin\n h = ymax - ymin\n\n boxes.append(torch.FloatTensor([xmin, ymin, xmax, ymax]))\n\n # This will give a numpy array of shape (HH, WW)\n mask = torch.zeros(1, H, W)\n # mask = seg_to_mask(object_data['segmentation'], WW, HH)\n mask[:, round(ymin * H):max(round(ymin * H) + 1, round(ymax * H)),\n round(xmin * W):max(round(xmin * W) + 1, round(xmax * W))] = 1\n masks.append(mask)\n # shuffle objs\n O = len(objs)\n rand_idx = list(range(O))\n random.shuffle(rand_idx)\n\n objs = [objs[i] for i in rand_idx]\n boxes = [boxes[i] for i in rand_idx]\n masks = [masks[i] for i in rand_idx]\n\n objs = torch.LongTensor(objs)\n boxes = torch.stack(boxes, dim=0)\n masks = torch.stack(masks, dim=0)\n\n # print(image_path)\n\n return image, objs, boxes, masks","def show_field(self, vehicles, type):\n\n # starting pixels x = 0, y = 0 on field image\n start_x = 78\n start_y = 45\n\n # block pixel width is slightly different per field size\n if self.size == 6:\n block_width = 72\n elif self.size == 9:\n block_width = 69\n elif self.size == 12:\n block_width = 68.5\n\n field = plt.imread(f\"data/RushHourImages/RushHour{self.size}.jpg\")\n fig, ax = plt.subplots()\n plt.imshow(field)\n plt.axis('off')\n\n for vehicle in vehicles:\n if vehicle.orientation == 'H':\n x = start_x + (vehicle.x * block_width)\n y = start_y + (vehicle.y * block_width)\n if vehicle.length == 2:\n car = plt.imread(f\"data/RushHourImages/Car{vehicle.id}.png\")\n else:\n car = plt.imread(f\"data/RushHourImages/Truck{vehicle.id}.png\")\n\n # truck: the image coordinate is his middle, which changes with the length of the car\n x += 40\n\n if vehicle.orientation == 'V':\n x = start_y + (vehicle.x * block_width)\n y = start_x + (vehicle.y * block_width)\n if vehicle.length == 2:\n car = plt.imread(f\"data/RushHourImages/Car-rotated{vehicle.id}.png\")\n else:\n car = plt.imread(f\"data/RushHourImages/Truck-rotated{vehicle.id}.png\")\n y += 40\n\n if self.size == 6:\n imagebox = OffsetImage(car, zoom=0.6)\n elif self.size == 9:\n imagebox = OffsetImage(car, zoom=0.4)\n elif self.size == 12:\n imagebox = OffsetImage(car, zoom=0.3)\n\n imagebox.image.axes = ax\n xy = (x, y)\n ab = AnnotationBbox(imagebox, xy, frameon=False)\n ax.add_artist(ab)\n\n if type == True:\n plt.show(block=False)\n plt.pause(0.001)\n plt.close()\n else:\n plt.show()","def proposal_boxes(self, fmap, im_sizes, image_offset, gt_boxes=None, gt_classes=None, gt_rels=None, train_anchor_inds=None, proposals=None):\n assert proposals is not None\n rois = filter_roi_proposals(proposals[:, 2:].data.contiguous(), proposals[:, 1].data.contiguous(), np.array([2000] * len(im_sizes)), nms_thresh=0.7, pre_nms_topn=12000 if self.training and self.mode == 'rpntrain' else 6000, post_nms_topn=2000 if self.training and self.mode == 'rpntrain' else 1000)\n if self.training:\n all_rois, labels, bbox_targets = proposal_assignments_det(rois, gt_boxes.data, gt_classes.data, image_offset, fg_thresh=0.5)\n all_rois = torch.cat((all_rois, Variable(rois)), 0)\n else:\n all_rois = Variable(rois, volatile=True)\n labels = None\n bbox_targets = None\n rpn_scores = None\n rpn_box_deltas = None\n rel_labels = None\n return all_rois, labels, bbox_targets, rpn_scores, rpn_box_deltas, rel_labels","def _to_image_coords(self, boxes, height, width):\n box_coords = np.zeros_like(boxes)\n box_coords[:, 0] = boxes[:, 0] * height\n box_coords[:, 1] = boxes[:, 1] * width\n box_coords[:, 2] = boxes[:, 2] * height\n box_coords[:, 3] = boxes[:, 3] * width\n \n return box_coords","def boxplots(self, groups, nrows, ncols, type):\n fig, axs = plt.subplots(nrows=nrows, ncols=ncols, figsize=(6, 9.3), sharey=\"row\")\n\n fig.subplots_adjust(left=0.03, right=0.97, hspace=0.3, wspace=0.05)\n\n for ax, (effs, dat) in zip(axs, groups):\n ax[0].boxplot(dat[\"perm\"])\n ax[1].boxplot(dat[\"t_test\"])\n ax[0].set_ylabel(\"Errors\")\n if type == \"es\":\n ax[0].set_title(f\"Effect size = {effs}, Test = Perm\")\n ax[1].set_title(f\"Effect size = {effs}, Test = t-test\")\n elif type == \"samp2\":\n ax[0].set_title(f\"Sample size = {effs}, Test = Perm\")\n ax[1].set_title(f\"Sample size = {effs}, Test = t-test\")\n\n\n plt.tight_layout()\n #plt.show()","def draw_bboxes_withindex(img,boxes, uids):\n source = Image.fromarray(img)\n draw = ImageDraw.Draw(source)\n w2,h2 = (img.shape[0],img.shape[1])\n \n font = ImageFont.truetype('/usr/share/fonts/truetype/freefont/FreeSerif.ttf', 40)\n #font = ImageFont.truetype('arial.ttf', 24)\n\n\n idx = 0\n\n for b in boxes:\n xmin,ymin,xmax,ymax = b\n \n for j in range(3):\n draw.rectangle(((xmin+j, ymin+j), (xmax+j, ymax+j)), outline=\"red\")\n draw.text((xmin+20, ymin+70), str(uids[idx]), font = font)\n idx +=1\n return source","def load_boxes(self, data):\r\n\r\n # worldbox represents the total map area\r\n self.worldbox = self.Box((0, 0), (len(data[0]) * self.cellwidth, len(data) * self.cellwidth))\r\n\r\n # create a box corresponding to each character/cell in the map file\r\n tl_x = 0\r\n tl_y = 0\r\n for row in data:\r\n for cell in row:\r\n if cell == \".\":\r\n self.wallboxes += [self.Box((tl_x, tl_y), (tl_x + self.cellwidth, tl_y + self.cellwidth))]\r\n elif cell == \"x\":\r\n self.targetboxes += [self.Box((tl_x, tl_y), (tl_x + self.cellwidth, tl_y + self.cellwidth))]\r\n tl_x += self.cellwidth\r\n tl_x = 0\r\n tl_y += self.cellwidth","def layout_graphics(self):\n # Graphics layout object to place viewboxes in\n self.g_layout = pg.GraphicsLayoutWidget(border=(80, 80, 80))\n self.g_layout.setCursor(QtCore.Qt.CrossCursor)\n\n # Viewboxes for images\n # aspect locked so that pixels are square\n # y inverted so that (0,0) is top left as in Thorlabs software\n options = {\"lockAspect\":True, \"invertY\":True}\n self.vb_image = self.g_layout.addViewBox(row=0, col=0, rowspan=2, **options)\n self.vb_zoom = self.g_layout.addViewBox(row=0, col=2, **options)\n self.vb_residuals = self.g_layout.addViewBox(row=1, col=2, **options)\n\n # Link zoom and residual views\n self.vb_zoom.setXLink(self.vb_residuals)\n self.vb_zoom.setYLink(self.vb_residuals)\n\n # Viewboxes for slice data\n # Both boxes have mouse disabled - range is fixed so we don't want to\n # scale them accidentally\n # Y box has y inverted to match the main image\n # Y box has x inverted so that zero pixel value is far from the image\n options = {\"enableMouse\":False, \"enableMenu\": False}\n self.vb_x = self.g_layout.addViewBox(row=2, col=0, **options)\n self.vb_y = self.g_layout.addViewBox(row=0, col=1, rowspan=2,\n invertX=True, invertY=True, **options)\n\n # Link the slice axes to the main image so that when we zoom/pan the\n # main image, our slices zoom/pan also\n self.vb_x.setXLink(self.vb_image)\n self.vb_y.setYLink(self.vb_image)\n\n # Disable autoscaling and fix range to maximum pixel intensity\n self.vb_x.setRange(yRange=(0,255))\n self.vb_y.setRange(xRange=(0,255))\n self.vb_x.disableAutoRange(axis=self.vb_x.YAxis)\n self.vb_y.disableAutoRange(axis=self.vb_y.XAxis)\n\n # Background color must not be black so that we can see where images\n # start/end\n color = pg.mkColor(40,40,40)\n self.vb_image.setBackgroundColor(color)\n self.vb_zoom.setBackgroundColor(color)\n self.vb_residuals.setBackgroundColor(color)\n self.vb_x.setBackgroundColor(color)\n self.vb_y.setBackgroundColor(color)\n self.g_layout.setBackground(color)\n\n self.vb_image.addItem(self.image)\n self.vb_image.addItem(self.fit_v_line)\n self.vb_image.addItem(self.fit_h_line)\n self.vb_image.addItem(self.mark_v_line)\n self.vb_image.addItem(self.mark_h_line)\n # self.vb_image.addItem(self.cursor_text)\n self.vb_image.addItem(self.cursor_delta)\n self.vb_image.addItem(self.beam_delta)\n self.vb_image.addItem(self.history_plot)\n # Figure out how to overlay properly?\n # self.vb_image.addItem(self.x_slice)\n # self.vb_image.addItem(self.x_fit)\n # self.vb_image.addItem(self.y_slice)\n # self.vb_image.addItem(self.y_fit)\n self.vb_zoom.addItem(self.zoom)\n self.vb_zoom.addItem(self.fit_maj_line)\n self.vb_zoom.addItem(self.fit_min_line)\n self.vb_zoom.addItem(self.zoom_text)\n self.vb_residuals.addItem(self.residuals)\n self.vb_residuals.addItem(self.residuals_text)\n self.vb_x.addItem(self.x_slice)\n self.vb_x.addItem(self.x_fit)\n self.vb_x.addItem(self.cursor_v)\n self.vb_y.addItem(self.y_slice)\n self.vb_y.addItem(self.y_fit)\n self.vb_y.addItem(self.cursor_h)\n\n self.res_legend.setParentItem(self.vb_residuals)\n self.cursor_text.setParentItem(self.vb_image)\n\n self.vb_image.setRange(QtCore.QRectF(0, 0, 1280, 1024))\n self.vb_zoom.setRange(QtCore.QRectF(0, 0, 50, 50))\n self.vb_residuals.setRange(QtCore.QRectF(0, 0, 50, 50))\n\n #\n # Size hints below here\n #\n self.g_layout.ci.layout.setColumnStretchFactor(0, 4)\n self.g_layout.ci.layout.setColumnStretchFactor(1, 1)\n self.g_layout.ci.layout.setColumnStretchFactor(2, 2)\n self.g_layout.ci.layout.setRowStretchFactor(0, 2)\n self.g_layout.ci.layout.setRowStretchFactor(1, 2)\n self.g_layout.ci.layout.setRowStretchFactor(2, 1)\n\n self.vb_x.setMinimumHeight(50)\n self.vb_y.setMinimumWidth(50)\n self.vb_x.setMaximumHeight(100)\n self.vb_y.setMaximumWidth(100)\n self.vb_image.setMinimumSize(640, 512)\n self.vb_zoom.setMinimumSize(320, 320)\n self.vb_residuals.setMinimumSize(320, 320)\n\n self.g_layout.setMinimumSize(1100,562)","def plantGrid(name, minimum, maximum, spacing):\n name = sys.argv[1]\n minimum = sys.argv[2]\n maximum = sys.argv[3]\n minimum = int(minimum)\n maximum = int(maximum)\n #convert to flux\n min1 = conversion(minimum)\n max1 = conversion(maximum)\n min1 = int(min1)\n max1 = int(max1)\n #brightness = [random.uniform(min1, max1) for _ in xrange(len(position))]\n #print brightness\n spacing = sys.argv[4]\n spacing = float(spacing)\n print len(data1)\n #create the position array for x values\n x = np.arange(6, len(data1), spacing)\n #create the position array for y values\n y = np.arange(6, len(data1), spacing)\n x2 = np.arange(6, len(data1), spacing)\n y2 = np.flipud(y)\n \n #combine both arrays to form a grid\n position = np.column_stack((x,y))\n position2 = np.column_stack((x2,y2))\n \n #combine both lines of grid to one array\n position = np.concatenate((position, position2), axis = 0)\n \n #create a random brightness array between the min and max values\n brightness = np.array([random.uniform(min1, max1) for _ in range(0,len(position))])\n \n #add to image file and subtract\n fakestars.addtofits(name, out_file, psf, position, brightness, coordsys, verbose)\n fakestars.addtofits(name, outfile2, psf, position, brightness, coordsys, verbose)\n imarith.imsubtract(out_file, outfile2, differenceFile, clobber=True)","def prepare_map(self):\n for y, row in enumerate(self.contents):\n for x, tile in enumerate(row):\n bm = self.get_tile(tile)\n self.image[\n y * TILE_SIZE : (y + 1) * TILE_SIZE,\n x * TILE_SIZE : (x + 1) * TILE_SIZE,\n ] = bm","def scale_box(box, img_size):\n xscale = img_size[0] / FLAGS.size\n yscale = img_size[1] / FLAGS.size\n x0, y0, x1, y1 = box\n return [\n float(x0) * xscale,\n float(y0) * yscale,\n float(x1) * xscale,\n float(y1) * yscale,\n ]","def initialize(self, frame):\n self.grid_size = 5\n\n Label(frame, text=\"Grid Size:\").grid(row=0)\n\n self.e1 = Scale(frame, from_=self.grid_size, to=25, orient=HORIZONTAL)\n self.e1.grid(row=0, column=1)\n\n return self.e1","def make(self) -> None:\n\n # arbitrarily selecting the first image from the list, index 0\n with Image.open(self.image_list[0]) as first_frame_image_in_list:\n\n # Find the width and height of the first image of the list.\n # Assuming all the images have same size.\n frame_image_width, frame_image_height = first_frame_image_in_list.size\n\n # scale is the ratio of collage_image_width and product of\n # images_per_row_in_collage with frame_image_width.\n\n # The scale will always lie between 0 and 1, which implies that\n # the images are always going to get downsized.\n scale = (self.collage_image_width) / (\n self.images_per_row_in_collage * frame_image_width\n )\n\n # Calculating the scaled height and width for the frame image.\n scaled_frame_image_width = ceil(frame_image_width * scale)\n scaled_frame_image_height = ceil(frame_image_height * scale)\n\n # Divide the number of images by images_per_row_in_collage. The later\n # was calculated by taking the square root of total number of images.\n number_of_rows = ceil(self.number_of_images / self.images_per_row_in_collage)\n\n # Multiplying the height of one downsized image with number of rows.\n # Height of 1 downsized image is product of scale and frame_image_height\n # Total height is number of rows times the height of one downsized image.\n self.collage_image_height = ceil(scale * frame_image_height * number_of_rows)\n\n # Create an image of passed collage_image_width and calculated collage_image_height.\n # The downsized images will be pasted on this new base image.\n # The image is 0,0,0 RGB(black).\n collage_image = Image.new(\n \"RGB\", (self.collage_image_width, self.collage_image_height)\n )\n\n # keep track of the x and y coordinates of the resized frame images\n i, j = (0, 0)\n\n # iterate the frames and paste them on their position on the collage_image\n for count, frame_path in enumerate(self.image_list):\n\n # Set the x coordinate to zero if we are on the first column\n # If self.images_per_row_in_collage is 4\n # then 0,4,8 and so on should have their x coordinate as 0\n if (count % self.images_per_row_in_collage) == 0:\n i = 0\n\n # open the frame image, must open it to resize it using the thumbnail method\n frame = Image.open(frame_path)\n\n # scale the opened frame images\n frame.thumbnail(\n (scaled_frame_image_width, scaled_frame_image_height), Image.ANTIALIAS\n )\n\n # set the value of x to that of i's value.\n # i is set to 0 if we are on the first column.\n x = i\n\n # It ensures that y coordinate stays the same for any given row.\n # The floor of a real number is the largest integer that is less\n # than or equal to the number. floor division is used because of\n # the zero based indexing, the floor of the division stays same\n # for an entier row as the decimal values are negled by the floor.\n # for the first row the result of floor division is always zero and\n # the product of 0 with scaled_frame_image_height is also zero, they\n # y coordinate for the first row is 0.\n # For the second row the result of floor division is one and the prodcut\n # with scaled_frame_image_height ensures that the y coordinate is\n # scaled_frame_image_height below the first row.\n y = (j // self.images_per_row_in_collage) * scaled_frame_image_height\n\n # paste the frame image on the newly created base image(base image is black)\n collage_image.paste(frame, (x, y))\n frame.close()\n\n # increase the x coordinate by scaled_frame_image_width\n # to get the x coordinate of the next frame. unless the next image\n # will be on the very first column this will be the x coordinate.\n i = i + scaled_frame_image_width\n\n # increase the value of j by 1, this is to calculate the y coordinate of\n # next image. The increased number will be floor divided by images_per_row_in_collage\n # therefore the y coordinate stays the same for any given row.\n j += 1\n\n # save the base image with all the scaled frame images embeded on it.\n collage_image.save(self.output_path)\n collage_image.close()","def _build_meds_layout(self):\n\n\n nim = self.image_info.size\n nobj = self.obj_data.size\n\n trim_to_coadd = self.get('trim_to_coadd',False)\n if trim_to_coadd:\n print(' trimming to coadd')\n coadd_wcs, coadd_pos, coadd_bnds, coadd_q = \\\n self._get_pos_and_bounds(self.obj_data, 0)\n in_bnds = coadd_bnds.contains_points(coadd_pos['zrow'], coadd_pos['zcol'])\n w_in_bnds, = np.where(in_bnds == True)\n assert w_in_bnds.size > 0,\"none found in coadd\"\n\n w_in_bnds = coadd_q[w_in_bnds]\n self.obj_data = self.obj_data[w_in_bnds]\n\n self._do_psf_setup()\n\n # box sizes are even\n half_box_size = self.obj_data['box_size']//2\n\n for file_id in range(nim):\n\n wcs, pos, bnds, q = self._get_pos_and_bounds(self.obj_data, file_id)\n\n # do the test\n in_bnds = bnds.contains_points(pos['zrow'], pos['zcol'])\n q_rc, = np.where(in_bnds == True)\n print(' second cut: %6d of %6d objects' % (len(q_rc),len(q)))\n\n # now make sure everything is there\n if self['check_in_first_image']:\n if file_id == 0 and len(self.obj_data['ra']) != len(q_rc):\n raise MEDSCreationError('Not all objects were found in first image for '\n 'MEDS making (which is the coadd/detection '\n 'image by convention).')\n # compose them\n q = q[q_rc]\n\n # fill in the object_data structure\n\n # note q_rc since pos was created using obj_data[q]\n qrow = pos['zrow'][q_rc]\n qcol = pos['zcol'][q_rc]\n\n icut = self.obj_data['ncutout'][q]\n self.obj_data['file_id'][q,icut] = file_id\n self.obj_data['orig_row'][q,icut] = qrow\n self.obj_data['orig_col'][q,icut] = qcol\n\n # this results in the object center being close to\n # the natural center (dim-1.)/2.\n ostart_row = qrow.astype('i4') - half_box_size[q] + 1\n ostart_col = qcol.astype('i4') - half_box_size[q] + 1\n crow = qrow - ostart_row\n ccol = qcol - ostart_col\n\n self.obj_data['orig_start_row'][q,icut] = ostart_row\n self.obj_data['orig_start_col'][q,icut] = ostart_col\n self.obj_data['cutout_row'][q,icut] = crow\n self.obj_data['cutout_col'][q,icut] = ccol\n\n # do jacobian, in original, not-offset coords\n # note q_rc since pos was created using self.obj_data[q]\n jacob = wcs.get_jacobian(\n x=pos['wcs_col'][q_rc],\n y=pos['wcs_row'][q_rc])\n\n # jacob is a tuple of arrays\n self.obj_data['dudcol'][q,icut] = jacob[0]\n self.obj_data['dudrow'][q,icut] = jacob[1]\n self.obj_data['dvdcol'][q,icut] = jacob[2]\n self.obj_data['dvdrow'][q,icut] = jacob[3]\n\n # increment\n self.obj_data['ncutout'][q] += 1\n\n w,=np.where(self.obj_data['ncutout'] > 0)\n print('%d/%d had ncut > 0' % (w.size, self.obj_data.size))\n #self.obj_data = self.obj_data[w]\n\n self.obj_data = self._make_resized_data(self.obj_data)\n print('setting number field as sequential')\n self.obj_data['number'] = 1+np.arange(self.obj_data.size)\n\n\n self._set_start_rows_and_pixel_count()\n\n if self['survey']=='cosmos':\n self._set_psf_layout_hst()\n else:\n self._set_psf_layout_psfex()","def set_default_parameters(self):\n super().set_default_parameters()\n if not \"region_size\" in vars(self):\n self.region_size = 0.08\n if not \"RGB_bands\" in vars(self):\n self.RGB_bands = [\"B4\",\"B3\",\"B2\"]\n if not \"split_RGB_images\" in vars(self):\n self.split_RGB_images = True\n # in PROCESSED dir we expect RGB. NDVI, BWNDVI\n self.num_files_per_point = 3"],"string":"[\n \"def _set_psf_layout_psfex(self):\\n\\n print('setting psf layout for PSFEx')\\n\\n obj_data=self.obj_data\\n psf_data=self.psf_data\\n\\n total_psf_pixels = 0\\n\\n #psf_npix = psf_size*psf_size\\n\\n psf_start_row = 0\\n for iobj in range(obj_data.size):\\n for icut in range(obj_data['ncutout'][iobj]):\\n\\n row = obj_data['orig_row'][iobj, icut]\\n col = obj_data['orig_col'][iobj, icut]\\n file_id = obj_data['file_id'][iobj,icut]\\n\\n p = psf_data[file_id]\\n\\n pim = p.get_rec(row,col)\\n cen = p.get_center(row,col)\\n\\n psf_shape = pim.shape\\n psf_npix = pim.size\\n\\n obj_data['psf_row_size'][iobj,icut] = psf_shape[0]\\n obj_data['psf_col_size'][iobj,icut] = psf_shape[1]\\n obj_data['psf_cutout_row'][iobj,icut] = cen[0]\\n obj_data['psf_cutout_col'][iobj,icut] = cen[1]\\n obj_data['psf_start_row'][iobj,icut] = psf_start_row\\n\\n psf_start_row += psf_npix\\n total_psf_pixels += psf_npix\\n\\n\\n self.total_psf_pixels = total_psf_pixels\",\n \"def generate_boxes(self, img):\\r\\n return [Box(left, top, img) for (left, top) in self.coords]\",\n \"def build_filler_images(self):\",\n \"def draw_boxes(self, im, boxes):\\n for bbox in boxes:\\n l = [int(x) for x in bbox[\\\"coords\\\"]]\\n l = self.scalebox(l)\\n icon = self.classes_to_icons[bbox[\\\"label\\\"]]\\n overlay_im_to_background(im, icon, l[0], l[1] - icon.shape[0] - 5)\\n cv2.rectangle(im,(l[0],l[1]),(l[2],l[3]),self.color,2)\",\n \"def makeImage(self):\\n\\n for row in range(self.height):\\n self.makeRow(row)\\n self.window.update() # display a row of pixels\",\n \"def _get_boxes(self, idx):\\n # Load Image\\n path = self.df.hsi_path.iloc[idx]\\n im = self._load_im(path)\\n\\n # Crop out box\\n r_box_im = self.df.width.iloc[idx] / im.shape[-1] # Ratio of RGB im box coords to load im width (e.g., r=10 for hsi)\\n box = np.array([self.df.ymin.iloc[idx], self.df.ymax.iloc[idx], self.df.xmin.iloc[idx], self.df.xmax.iloc[idx]])\\n box = np.around(box / r_box_im).astype(int)\\n\\n crop_im = im[:, box[0]:box[1]+1, box[2]:box[3]+1]\\n if np.any(np.array(crop_im.shape) == 0):\\n print('[WARNING] Loaded box has zero shape and is sketchily inflated. TODO: skip this box with ID', idx)\\n if box[0] == self.df.width.iloc[idx]/r_box_im: box[0] -= 1\\n if box[2] == self.df.height.iloc[idx]/r_box_im: box[2] -= 1\\n crop_im = im[:, box[0]:box[1]+1, box[2]:box[3]+1]\\n\\n target = {}\\n target[\\\"labels\\\"] = self.df.class_id.iloc[idx]\\n target[\\\"uid\\\"] = self.df.uid.iloc[idx]\\n \\n\\n return crop_im, target\",\n \"def _get_box_sizes(self, image_info, cat):\\n\\n\\n file_id=0\\n impath=image_info['image_path'][file_id].strip()\\n ext=image_info['image_ext'][file_id]\\n wcs_data = fitsio.read_header(impath, ext=ext)\\n wcs = eu.wcsutil.WCS(wcs_data)\\n\\n\\n jacob = wcs.get_jacobian(100,100)\\n dudcol, dudrow, dvdcol, dvdrow = jacob\\n\\n det = dvdrow*dudcol - dvdcol*dudrow\\n pixel_scale = np.sqrt(abs(det))\\n print('found pixel scale:',pixel_scale)\\n box_size = cat['box_size_arcsec']/pixel_scale\\n\\n # clip to range\\n box_size.clip(\\n min=self['min_box_size'],\\n max=self['max_box_size'],\\n out=box_size,\\n )\\n box_size = box_size.astype('i4')\\n\\n w,=np.where( ( (box_size % 2) != 0 ) )\\n if w.size > 0:\\n box_size[w] += 1\\n\\n return box_size\",\n \"def setBoxsize(length,width,height):\\n return length,width,height\",\n \"def draw_boxs(img,boxs,width=3,color=(0,0,255)):\\n box_img = copy.deepcopy(img)\\n for i in range(boxs.shape[0]):\\n # x1,y1,x2,y2=boxs[i]\\n x1 = boxs[i][0]\\n y1 = boxs[i][1]\\n x2 = boxs[i][2]\\n y2 = boxs[i][3]\\n p1 = (int(round(x1)),int(round(y1)))\\n p2 = (int(round(x2)),int(round(y2)))\\n cv2.rectangle(box_img, p1, p2, color, width)\\n\\n return box_img\",\n \"def setUp(self):\\r\\n center = [1,1]\\r\\n size = 1\\r\\n self.imageinfo = ImageInfo(center, size)\",\n \"def setUp(self):\\r\\n center = [1,1]\\r\\n size = 1\\r\\n self.imageinfo = ImageInfo(center, size)\",\n \"def setUp(self):\\r\\n center = [1,1]\\r\\n size = 1\\r\\n self.imageinfo = ImageInfo(center, size)\",\n \"def setUp(self):\\r\\n center = [1,1]\\r\\n size = 1\\r\\n self.imageinfo = ImageInfo(center, size)\",\n \"def setUp(self):\\r\\n center = [1,1]\\r\\n size = 1\\r\\n self.imageinfo = ImageInfo(center, size)\",\n \"def __init__(self, nb_sub_images, window_size, recovery, image_horiz_size):\\n self.nb_sub_images = nb_sub_images\\n self.window_size = window_size\\n self.recovery = recovery\\n self.image_horiz_size = image_horiz_size\",\n \"def _resize_bboxes(self, results):\\n img_shape = results['img_shape']\\n for key in results.get('bbox_fields', []):\\n bboxes = []\\n for box in results[key]:\\n tmp_box = np.array(box, dtype=np.float32)\\n tmp_box[0::2] *= results['scale_factor'][0]\\n tmp_box[1::2] *= results['scale_factor'][1]\\n if self.bbox_clip_border:\\n tmp_box[0::2] = np.clip(tmp_box[0::2], 0, img_shape[1])\\n tmp_box[1::2] = np.clip(tmp_box[1::2], 0, img_shape[0])\\n bboxes.append(tmp_box)\\n if len(results[key]) > 0:\\n results[key] = bboxes\",\n \"def _resize_bboxes(self, results):\\n for key in results.get('bbox_fields', []):\\n bboxes = results[key] * results['scale_factor']\\n if self.bbox_clip_border:\\n img_shape = results['img_shape']\\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])\\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])\\n results[key] = bboxes\",\n \"def _resize_bboxes(self, results):\\n for key in results.get('bbox_fields', []):\\n bboxes = results[key] * results['scale_factor']\\n if self.bbox_clip_border:\\n img_shape = results['img_shape']\\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])\\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])\\n results[key] = bboxes\",\n \"def set_box(self) -> None:\\n from pymol import cmd\\n\\n # Delete Box object in PyMOL\\n if \\\"box\\\" in cmd.get_names(\\\"selections\\\"):\\n cmd.delete(\\\"box\\\")\\n # Get dimensions of selected residues\\n selection = \\\"sele\\\"\\n if selection in cmd.get_names(\\\"selections\\\"):\\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(selection)\\n else:\\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(\\\"\\\")\\n \\n # Get center of each dimension (x, y, z)\\n self.x = (min_x + max_x) / 2\\n self.y = (min_y + max_y) / 2\\n self.z = (min_z + max_z) / 2\\n\\n # Set Box variables in interface\\n self.min_x.setValue(round(self.x - (min_x - self.padding.value()), 1))\\n self.max_x.setValue(round((max_x + self.padding.value()) - self.x, 1))\\n self.min_y.setValue(round(self.y - (min_y - self.padding.value()), 1))\\n self.max_y.setValue(round((max_y + self.padding.value()) - self.y, 1))\\n self.min_z.setValue(round(self.z - (min_z - self.padding.value()), 1))\\n self.max_z.setValue(round((max_z + self.padding.value()) - self.z, 1))\\n self.angle1.setValue(0)\\n self.angle2.setValue(0)\\n\\n # Setting background box values\\n self.min_x_set = self.min_x.value()\\n self.max_x_set = self.max_x.value()\\n self.min_y_set = self.min_y.value()\\n self.max_y_set = self.max_y.value()\\n self.min_z_set = self.min_z.value()\\n self.max_z_set = self.max_z.value()\\n self.angle1_set = self.angle1.value()\\n self.angle2_set = self.angle2.value()\\n self.padding_set = self.padding.value()\\n\\n # Draw box\\n self.draw_box()\\n\\n # Enable/Disable buttons\\n self.button_draw_box.setEnabled(False)\\n self.button_redraw_box.setEnabled(True)\\n self.min_x.setEnabled(True)\\n self.min_y.setEnabled(True)\\n self.min_z.setEnabled(True)\\n self.max_x.setEnabled(True)\\n self.max_y.setEnabled(True)\\n self.max_z.setEnabled(True)\\n self.angle1.setEnabled(True)\\n self.angle2.setEnabled(True)\",\n \"def analyzeImages(path, name_type, box1_size, box2_size, box3_size, box4_size, box5_size):\\n \\n folders = [f for f in sorted(glob.glob(path + \\\"/**\\\"))]\\n \\n for folder in folders: \\n \\n # to save this data frame in a csv file\\n \\n files = [f for f in sorted(glob.glob(folder + \\\"/**\\\" + \\\".jpg\\\"))]\\n \\n centroidsDf = pd.DataFrame(np.zeros([len(files), 11]),columns=[\\\"frame\\\", \\\"fly1_x\\\", \\\"fly1_y\\\", \\\"fly2_x\\\", \\\"fly2_y\\\", \\\"fly3_x\\\", \\\"fly3_y\\\", \\\"fly4_x\\\", \\\"fly4_y\\\", \\\"fly5_x\\\", \\\"fly5_y\\\"]);\\n headsDf = pd.DataFrame(np.zeros([len(files), 11]),columns=[\\\"frame\\\", \\\"fly1_x\\\", \\\"fly1_y\\\", \\\"fly2_x\\\", \\\"fly2_y\\\", \\\"fly3_x\\\", \\\"fly3_y\\\", \\\"fly4_x\\\", \\\"fly4_y\\\", \\\"fly5_x\\\", \\\"fly5_y\\\"]);\\n \\n img_array1 = []\\n img_array2 = []\\n img_array3 = []\\n img_array4 = []\\n img_array5 = []\\n\\n for file in files:\\n \\n print(file)\\n \\n centroidsDf[\\\"frame\\\"][files.index(file)] = files.index(file)+1\\n headsDf[\\\"frame\\\"][files.index(file)] = files.index(file)+1\\n \\n img = cv2.imread(file)\\n \\n ## FLY 1 ##\\n\\n box1 = img[box1_size[0]:box1_size[1], box1_size[2]:box1_size[3]]\\n \\n # image processing to get the centroid and head positions\\n x_centroid, y_centroid, x_head, y_head = findCentroid(box1, file) \\n \\n # add the centroid and head locations on the image \\n box1 = cv2.circle(box1, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\\n box1 = cv2.circle(box1, (x_head, y_head), 7, (0, 0, 255), -1)\\n img_array1.append(box1)\\n \\n # add the positions in the final data frame\\n centroidsDf[\\\"fly1_x\\\"][files.index(file)] = x_centroid\\n centroidsDf[\\\"fly1_y\\\"][files.index(file)] = y_centroid\\n \\n headsDf[\\\"fly1_x\\\"][files.index(file)] = x_head\\n headsDf[\\\"fly1_y\\\"][files.index(file)] = y_head\\n \\n ## FLY 2 ##\\n \\n box2 = img[box2_size[0]:box2_size[1], box2_size[2]:box2_size[3]]\\n \\n # image processing to get the centroid and head positions\\n x_centroid, y_centroid, x_head, y_head = findCentroid(box2, file)\\n \\n # add the centroid and head locations on the image \\n box2 = cv2.circle(box2, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\\n box2 = cv2.circle(box2, (x_head, y_head), 7, (0, 0, 255), -1)\\n img_array2.append(box2)\\n \\n # add the positions in the final data frame \\n centroidsDf[\\\"fly2_x\\\"][files.index(file)] = x_centroid\\n centroidsDf[\\\"fly2_y\\\"][files.index(file)] = y_centroid\\n \\n headsDf[\\\"fly2_x\\\"][files.index(file)] = x_head\\n headsDf[\\\"fly2_y\\\"][files.index(file)] = y_head\\n \\n ## FLY 3 ##\\n\\n box3 = img[box3_size[0]:box3_size[1], box3_size[2]:box3_size[3]]\\n \\n # image processing to get the centroid and head positions\\n x_centroid, y_centroid, x_head, y_head = findCentroid(box3, file)\\n \\n # add the centroid and head locations on the image \\n box3 = cv2.circle(box3, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\\n box3 = cv2.circle(box3, (x_head, y_head), 7, (0, 0, 255), -1)\\n img_array3.append(box3)\\n\\n # add the positions in the final data frame\\n centroidsDf[\\\"fly3_x\\\"][files.index(file)] = x_centroid\\n centroidsDf[\\\"fly3_y\\\"][files.index(file)] = y_centroid\\n \\n headsDf[\\\"fly3_x\\\"][files.index(file)] = x_head\\n headsDf[\\\"fly3_y\\\"][files.index(file)] = y_head\\n \\n ## FLY 4 ##\\n \\n box4 = img[box4_size[0]:box4_size[1], box4_size[2]:box4_size[3]]\\n \\n # image processing to get the centroid and head positions\\n x_centroid, y_centroid, x_head, y_head = findCentroid(box4, file)\\n \\n # add the centroid and head locations on the image \\n box4 = cv2.circle(box4, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\\n box4 = cv2.circle(box4, (x_head, y_head), 7, (0, 0, 255), -1)\\n img_array4.append(box4)\\n \\n # add the positions in the final data frame\\n centroidsDf[\\\"fly4_x\\\"][files.index(file)] = x_centroid\\n centroidsDf[\\\"fly4_y\\\"][files.index(file)] = y_centroid\\n \\n headsDf[\\\"fly4_x\\\"][files.index(file)] = x_head\\n headsDf[\\\"fly4_y\\\"][files.index(file)] = y_head\\n \\n ## FLY 5 ##\\n \\n # the fifth fly is not present in all the genetic strains \\n if (box5_size != []):\\n box5 = img[box5_size[0]:box5_size[1], box5_size[2]:box5_size[3]]\\n \\n # image processing to get the centroid and head positions\\n x_centroid, y_centroid, x_head, y_head = findCentroid(box5, file)\\n \\n # add the centroid and head locations on the image \\n box5 = cv2.circle(box5, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\\n box5 = cv2.circle(box5, (x_head, y_head), 7, (0, 0, 255), -1)\\n img_array5.append(box5)\\n \\n # add the positions in the final data frame\\n centroidsDf[\\\"fly5_x\\\"][files.index(file)] = x_centroid\\n centroidsDf[\\\"fly5_y\\\"][files.index(file)] = y_centroid\\n \\n headsDf[\\\"fly5_x\\\"][files.index(file)] = x_head\\n headsDf[\\\"fly5_y\\\"][files.index(file)] = y_head\\n \\n # save the data frame in a .csv file, \\n # one for the centroids and one for the heads\\n #centroidsDf.to_csv(folder+\\\"/centroids.csv\\\", index = None, header=True)\\n #headsDf.to_csv(folder+\\\"/heads.csv\\\", index = None, header=True)\\n \\n \\n ## CREATE THE VIDEOS ##\\n \\n height, width, _ = box1.shape\\n size = (width,height)\\n out = cv2.VideoWriter(folder+name_type+'_1_' + str(folders.index(folder)+1)+ '.mp4',cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\\n for i in range(len(img_array1)):\\n out.write(img_array1[i])\\n out.release()\\n \\n height, width, _ = box2.shape\\n size = (width,height)\\n out = cv2.VideoWriter(folder+name_type+'_2_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\\n for i in range(len(img_array2)):\\n out.write(img_array2[i])\\n out.release()\\n \\n height, width, _ = box3.shape\\n size = (width,height)\\n out = cv2.VideoWriter(folder+name_type+'_3_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\\n for i in range(len(img_array3)):\\n out.write(img_array3[i])\\n out.release()\\n \\n height, width, _ = box4.shape\\n size = (width,height)\\n out = cv2.VideoWriter(folder+name_type+'_4_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\\n for i in range(len(img_array4)):\\n out.write(img_array4[i])\\n out.release()\\n \\n if (box5_size != []):\\n height, width, _ = box5.shape\\n size = (width,height)\\n out = cv2.VideoWriter(folder+name_type+'_5_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\\n for i in range(len(img_array5)):\\n out.write(img_array5[i])\\n out.release()\",\n \"def _iter_images_rects(self):\\n image_x = self._margin\\n image_y = self._margin\\n total_width = self.width - 2 * self._margin\\n total_height = self.height - self._texts_height - 2 * self._margin\\n\\n if len(self._images) == 1:\\n image_width = total_width\\n image_height = total_height\\n elif 2 <= len(self._images) < 4:\\n if self.is_portrait:\\n image_width = total_width\\n image_height = (total_height - (len(self._images) - 1) * self._margin) // len(self._images)\\n else:\\n image_width = (total_width - (len(self._images) - 1) * self._margin) // len(self._images)\\n image_height = total_height\\n else:\\n image_width = (total_width - self._margin) // 2\\n image_height = (total_height - self._margin) // 2\\n\\n yield image_x, image_y, image_width, image_height\\n\\n if 2 <= len(self._images) < 4:\\n if self.is_portrait:\\n image_y += image_height + self._margin\\n else:\\n image_x += image_width + self._margin\\n yield image_x, image_y, image_width, image_height\\n\\n if 3 <= len(self._images) < 4:\\n if self.is_portrait:\\n image_y += image_height + self._margin\\n else:\\n image_x += image_width + self._margin\\n yield image_x, image_y, image_width, image_height\\n\\n if len(self._images) == 4:\\n image_x += image_width + self._margin\\n yield image_x, image_y, image_width, image_height\\n image_y += image_height + self._margin\\n image_x = self._margin\\n yield image_x, image_y, image_width, image_height\\n image_x += image_width + self._margin\\n yield image_x, image_y, image_width, image_height\",\n \"def _assign_sizes(self):\",\n \"def create_human_box(self, i):\\n self.box = self.detections[0, 0, i, 3:7] * np.array([self.w, self.h, self.w, self.h])\\n (self.startX, self.startY, self.endX, self.endY) = self.box.astype(\\\"int\\\")\",\n \"def __init__(self, path_image, path_imagefile, path_bndboxfile, transform):\\r\\n # -------------------- DATA ARGUMENT\\r\\n self.shape = 446\\r\\n self.hue = 0.1\\r\\n self.saturation = 1.5\\r\\n self.exposure = 1.5\\r\\n self.imagelist = []\\r\\n self.labellist = []\\r\\n self.transform = transform\\r\\n label_dir = os.listdir(path_bndboxfile)\\r\\n image_dir = os.listdir(path_imagefile)\\r\\n\\r\\n # read imagepath\\r\\n for file in image_dir:\\r\\n file_name = os.path.join(path_imagefile, file)\\r\\n with open(file_name) as f:\\r\\n lines = f.readlines()\\r\\n for line in lines:\\r\\n image_name = line.split()[0] + '.JPEG'\\r\\n image = os.path.join(path_image, image_name)\\r\\n self.imagelist.append(image)\\r\\n\\r\\n # read imagelabel, i.e, (name, xmin, xmax, ymin, ymax)\\r\\n for file in label_dir:\\r\\n if file.split('.')[1] == 'xml':\\r\\n file_name = os.path.join(path_bndboxfile, file)\\r\\n with open(file_name) as f:\\r\\n xml_tree = parse(f).documentElement\\r\\n objects = xml_tree.getElementsByTagName('object')\\r\\n for object in objects:\\r\\n label = []\\r\\n name = object.getElementsByTagName('name')[0]\\r\\n label.append(name.childNodes[0].data)\\r\\n bndbox = object.getElementsByTagName('bndbox')[0]\\r\\n for node in bndbox.childNodes:\\r\\n if node.nodeType == node.ELEMENT_NODE:\\r\\n label.append(node.childNodes[0].data)\\r\\n self.labellist.append(label)\\r\\n else:\\r\\n print('Expect files in xml format. but get {}'.format(file.split('.')[1]))\",\n \"def _images_and_boxes_preprocessing(self, imgs, boxes):\\r\\n # Image [0, 255] -> [0, 1].\\r\\n imgs = imgs.float()\\r\\n imgs = imgs / 255.0\\r\\n\\r\\n height, width = imgs.shape[2], imgs.shape[3]\\r\\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\\r\\n # range of [0, 1].\\r\\n boxes[:, [0, 2]] *= width\\r\\n boxes[:, [1, 3]] *= height\\r\\n boxes = transform.clip_boxes_to_image(boxes, height, width)\\r\\n\\r\\n if self._split == \\\"train\\\":\\r\\n # Train split\\r\\n imgs, boxes = transform.random_short_side_scale_jitter(\\r\\n imgs,\\r\\n min_size=self._jitter_min_scale,\\r\\n max_size=self._jitter_max_scale,\\r\\n boxes=boxes,\\r\\n )\\r\\n imgs, boxes = transform.random_crop(imgs, self._crop_size, boxes=boxes)\\r\\n\\r\\n # Random flip.\\r\\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\\r\\n elif self._split == \\\"val\\\":\\r\\n # Val split\\r\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\r\\n imgs, boxes = transform.random_short_side_scale_jitter(\\r\\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\\r\\n )\\r\\n\\r\\n # Apply center crop for val split\\r\\n imgs, boxes = transform.uniform_crop(\\r\\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\\r\\n )\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\r\\n elif self._split == \\\"test\\\":\\r\\n # Test split\\r\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\r\\n imgs, boxes = transform.random_short_side_scale_jitter(\\r\\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\\r\\n )\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\r\\n else:\\r\\n raise NotImplementedError(\\\"{} split not supported yet!\\\".format(self._split))\\r\\n\\r\\n # Do color augmentation (after divided by 255.0).\\r\\n if self._split == \\\"train\\\" and self._use_color_augmentation:\\r\\n if not self._pca_jitter_only:\\r\\n imgs = transform.color_jitter(\\r\\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\\r\\n )\\r\\n\\r\\n imgs = transform.lighting_jitter(\\r\\n imgs,\\r\\n alphastd=0.1,\\r\\n eigval=np.array(self._pca_eigval).astype(np.float32),\\r\\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\\r\\n )\\r\\n\\r\\n # Normalize images by mean and std.\\r\\n imgs = transform.color_normalization(\\r\\n imgs,\\r\\n np.array(self._data_mean, dtype=np.float32),\\r\\n np.array(self._data_std, dtype=np.float32),\\r\\n )\\r\\n\\r\\n if self._use_bgr:\\r\\n # Convert image format from RGB to BGR.\\r\\n # Note that Kinetics pre-training uses RGB!\\r\\n imgs = imgs[:, [2, 1, 0], ...]\\r\\n\\r\\n boxes = transform.clip_boxes_to_image(boxes, self._crop_size, self._crop_size)\\r\\n\\r\\n return imgs, boxes\",\n \"def _resize_cbboxes(self, results):\\n img_shape = results['img_shape']\\n for key in results.get('cbbox_fields', []):\\n cbboxes = []\\n for cbox in results[key]:\\n tmp_cbox = np.array(cbox, dtype=np.float32)\\n new_tmp_cbox = []\\n for ccbox in tmp_cbox:\\n ccbox = np.array(ccbox, dtype=np.float32)\\n ccbox[0::2] *= results['scale_factor'][0]\\n ccbox[1::2] *= results['scale_factor'][1]\\n new_tmp_cbox.append(ccbox)\\n tmp_cbox = np.array(new_tmp_cbox, dtype=np.float32)\\n if self.bbox_clip_border:\\n tmp_cbox[:, 0::2] = np.clip(tmp_cbox[:, 0::2], 0, img_shape[1])\\n tmp_cbox[:, 1::2] = np.clip(tmp_cbox[:, 1::2], 0, img_shape[0])\\n cbboxes.append(tmp_cbox)\\n results[key] = cbboxes\",\n \"def drawBox (self, left, top, width, height, colour):\\r\\n w = self.bih_vals [bih_Width]\\r\\n h = self.bih_vals [bih_Height]\\r\\n\\r\\n cols = [left, left + width - 1]\\r\\n rows = [top, top + height - 1]\\r\\n \\r\\n x0 = max ((0,left))\\r\\n x1 = min ((cols[1]+1, w))\\r\\n y0 = max ((0,top))\\r\\n y1 = min ((rows [1]+1, h))\\r\\n\\r\\n # rows\\r\\n\\r\\n for r in rows:\\r\\n if r >= 0 and r < h:\\r\\n row = self.image [r]\\r\\n for x in range (x0, x1):\\r\\n row [x] = colour\\r\\n\\r\\n # columns\\r\\n \\r\\n for y in range (y0, y1):\\r\\n row = self.image [y]\\r\\n for c in cols:\\r\\n if c >= 0 and c < w :\\r\\n row [c] = colour\",\n \"def OnSize(self, event):\\r\\n\\r\\n for pos, item in self._items.items():\\r\\n widget, horizontalalignment, verticalalignment = item.widget, item.horizontalalignment, item.verticalalignment\\r\\n\\r\\n rect = self.GetFieldRect(pos)\\r\\n widgetpos = widget.GetPosition()\\r\\n widgetsize = widget.GetSize()\\r\\n\\r\\n rect = self.GetFieldRect(pos)\\r\\n\\r\\n if horizontalalignment == ESB_EXACT_FIT:\\r\\n if verticalalignment == ESB_EXACT_FIT:\\r\\n widget.SetSize((rect.width-2, rect.height-2))\\r\\n widget.SetPosition((rect.x-1, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\\r\\n if widgetsize[1] < rect.width - 1:\\r\\n diffs = (rect.height - widgetsize[1])/2\\r\\n widget.SetSize((rect.width-2, widgetsize[1]))\\r\\n widget.SetPosition((rect.x-1, rect.y+diffs))\\r\\n else:\\r\\n widget.SetSize((rect.width-2, widgetsize[1]))\\r\\n widget.SetPosition((rect.x-1, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_TOP:\\r\\n widget.SetSize((rect.width-2, widgetsize[1]))\\r\\n widget.SetPosition((rect.x-1, rect.y))\\r\\n elif verticalalignment == ESB_ALIGN_BOTTOM:\\r\\n widget.SetSize((rect.width-2, widgetsize[1]))\\r\\n widget.SetPosition((rect.x-1, rect.height-widgetsize[1]))\\r\\n\\r\\n elif horizontalalignment == ESB_ALIGN_LEFT:\\r\\n\\r\\n xpos = rect.x - 1\\r\\n if verticalalignment == ESB_EXACT_FIT:\\r\\n widget.SetSize((widgetsize[0], rect.height-2))\\r\\n widget.SetPosition((xpos, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\\r\\n if widgetsize[1] < rect.height - 1:\\r\\n diffs = (rect.height - widgetsize[1])/2\\r\\n widget.SetPosition((xpos, rect.y+diffs))\\r\\n else:\\r\\n widget.SetSize((widgetsize[0], rect.height-2))\\r\\n widget.SetPosition((xpos, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_TOP:\\r\\n widget.SetPosition((xpos, rect.y))\\r\\n elif verticalalignment == ESB_ALIGN_BOTTOM:\\r\\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\\r\\n\\r\\n elif horizontalalignment == ESB_ALIGN_RIGHT:\\r\\n\\r\\n xpos = rect.x + rect.width - widgetsize[0] - 1\\r\\n if verticalalignment == ESB_EXACT_FIT:\\r\\n widget.SetSize((widgetsize[0], rect.height-2))\\r\\n widget.SetPosition((xpos, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\\r\\n if widgetsize[1] < rect.height - 1:\\r\\n diffs = (rect.height - widgetsize[1])/2\\r\\n widget.SetPosition((xpos, rect.y+diffs))\\r\\n else:\\r\\n widget.SetSize((widgetsize[0], rect.height-2))\\r\\n widget.SetPosition((xpos, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_TOP:\\r\\n widget.SetPosition((xpos, rect.y))\\r\\n elif verticalalignment == ESB_ALIGN_BOTTOM:\\r\\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\\r\\n\\r\\n elif horizontalalignment == ESB_ALIGN_CENTER_HORIZONTAL:\\r\\n\\r\\n xpos = rect.x + (rect.width - widgetsize[0])/2 - 1\\r\\n if verticalalignment == ESB_EXACT_FIT:\\r\\n widget.SetSize((widgetsize[0], rect.height))\\r\\n widget.SetPosition((xpos, rect.y))\\r\\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\\r\\n if widgetsize[1] < rect.height - 1:\\r\\n diffs = (rect.height - widgetsize[1])/2\\r\\n widget.SetPosition((xpos, rect.y+diffs))\\r\\n else:\\r\\n widget.SetSize((widgetsize[0], rect.height-1))\\r\\n widget.SetPosition((xpos, rect.y+1))\\r\\n elif verticalalignment == ESB_ALIGN_TOP:\\r\\n widget.SetPosition((xpos, rect.y))\\r\\n elif verticalalignment == ESB_ALIGN_BOTTOM:\\r\\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\\r\\n\\r\\n if event is not None:\\r\\n event.Skip()\",\n \"def recreate_grid(self):\\n\\n self.print_numlist = arcade.SpriteList()\\n for row in range(ROW_COUNT):\\n for column in range(COLUMN_COUNT):\\n sprite = arcade.Sprite(\\n f\\\"Numbers/{self.grid[row][column]}.png\\\", scale=0.2\\n )\\n x = (MARGIN + WIDTH) * column + MARGIN + WIDTH // 2\\n y = (MARGIN + HEIGHT) * row + MARGIN + HEIGHT // 2\\n sprite.center_x = x\\n sprite.center_y = y\\n self.print_numlist.append(sprite)\\n # Check to see if all squares have been filled in\\n if 0 not in self.grid:\\n # if Cameron.Check_for_Completion(self.grid) == True:\\n self.done = True\",\n \"def _draw_boxes(self, image, boxes, classes, thickness=4):\\n for i in range(len(boxes)):\\n bot, left, top, right = boxes[i, ...]\\n class_id = int(classes[i]) - 1\\n color = self.COLOR_LIST[class_id]\\n cv2.rectangle(image, (left, top), (right, bot), color=color, thickness=thickness)\",\n \"def scale_boxes(boxes, image_shape):\\n height = image_shape[0]\\n width = image_shape[1]\\n image_dims = K.stack([height, width, height, width])\\n image_dims = K.reshape(image_dims, [1, 4])\\n boxes = boxes * image_dims\\n return boxes\",\n \"def place_images(self, final_list, points):\\n\\t\\tfor i in range(8): \\n # Please change this (8) into a class-level variable --KOH\\n\\t\\t\\timage_object = final_list[i]\\n#\\t\\tif type(image_object) == 'CorrectImage':\\n#\\t\\t\\t\\tself.correct = [i, points[i]]\\n\\t\\t\\timage = pygame.image.load(image_object.file_path)\\n # Why can't these be stored as a property of the class --KOH\\n\\t\\t\\timagerect = image.get_rect()\\n\\t\\t\\treimage = pygame.transform.scale(image, image_object.size)\\n\\t\\t\\tself.screen.blit(reimage, points[i])\",\n \"def _images_and_boxes_preprocessing(self, imgs, boxes, gt_boxes=None):\\n # Image [0, 255] -> [0, 1].\\n imgs = imgs.float()\\n imgs = imgs / 255.0\\n\\n height, width = imgs.shape[2], imgs.shape[3]\\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\\n # range of [0, 1].\\n # boxes[:, [0, 2]] *= width\\n # boxes[:, [1, 3]] *= height\\n boxes = transform.clip_boxes_to_image(boxes, height, width)\\n\\n if self._split == \\\"train\\\":\\n # Train split\\n imgs, boxes = transform.random_short_side_scale_jitter(\\n imgs,\\n min_size=self._jitter_min_scale,\\n max_size=self._jitter_max_scale,\\n boxes=boxes,\\n )\\n imgs, boxes = transform.random_crop(\\n imgs, self._crop_size, boxes=boxes\\n )\\n\\n # Random flip.\\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\\n elif self._split == \\\"val\\\":\\n # Val split\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\n imgs, boxes = transform.random_short_side_scale_jitter(\\n imgs,\\n min_size=self._crop_size,\\n max_size=self._crop_size,\\n boxes=boxes,\\n )\\n\\n # Apply center crop for val split\\n imgs, boxes = transform.uniform_crop(\\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\\n )\\n\\n if self._test_force_flip:\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\n elif self._split == \\\"test\\\":\\n # Test split\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\n imgs, boxes = transform.random_short_side_scale_jitter(\\n imgs,\\n min_size=self._crop_size,\\n max_size=self._crop_size,\\n boxes=boxes,\\n )\\n\\n if self._test_force_flip:\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\n else:\\n raise NotImplementedError(\\n \\\"{} split not supported yet!\\\".format(self._split)\\n )\\n\\n # Do color augmentation (after divided by 255.0).\\n if self._split == \\\"train\\\" and self._use_color_augmentation:\\n if not self._pca_jitter_only:\\n imgs = transform.color_jitter(\\n imgs,\\n img_brightness=0.4,\\n img_contrast=0.4,\\n img_saturation=0.4,\\n )\\n\\n imgs = transform.lighting_jitter(\\n imgs,\\n alphastd=0.1,\\n eigval=np.array(self._pca_eigval).astype(np.float32),\\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\\n )\\n\\n # Normalize images by mean and std.\\n imgs = transform.color_normalization(\\n imgs,\\n np.array(self._data_mean, dtype=np.float32),\\n np.array(self._data_std, dtype=np.float32),\\n )\\n\\n if not self._use_bgr:\\n # Convert image format from BGR to RGB.\\n # Note that Kinetics pre-training uses RGB!\\n imgs = imgs[:, [2, 1, 0], ...]\\n\\n boxes = transform.clip_boxes_to_image(\\n boxes, self._crop_size, self._crop_size\\n )\\n\\n return imgs, boxes\",\n \"def populate_images(self):\\n print \\\"Populating images info...\\\"\\n images = self.get_all_images()\\n for i in images:\\n\\n associated_snapshots = self.get_snapshots_of(i)\\n\\n self.spreadsheet[i.id] = dict(name=i.name, Name_tag=self.get_name_tag(i), id=i.id,\\n KEEP_tag=self.get_keep_tag(i), PROD_tag=self.is_production(i),\\n region=i.region.name,\\n created=i.creationDate,\\n associated_snapshots=associated_snapshots,\\n description=i.description)\",\n \"def stage_one(self, imgs, threshold, factor, minsize, nms_threshold):\\n\\n width = imgs.shape[-2]\\n height = imgs.shape[-1]\\n num_img = imgs.shape[0]\\n\\n # Compute valid scales\\n scales = []\\n cur_width = width\\n cur_height = height\\n cur_factor = 1\\n while cur_width >= 12 and cur_height >= 12:\\n if 12 / cur_factor >= minsize: # Ignore boxes that smaller than minsize\\n\\n w = cur_width\\n h = cur_height\\n scales.append((w, h, cur_factor))\\n\\n cur_factor *= factor\\n cur_width = math.ceil(cur_width * factor)\\n cur_height = math.ceil(cur_height * factor)\\n\\n # Get candidate boxesi ph\\n candidate_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\\n candidate_scores = torch.empty(0, device=self.device)\\n candidate_offsets = torch.empty(\\n 0, dtype=torch.float32, device=self.device)\\n all_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\\n for w, h, f in scales:\\n resize_img = torch.nn.functional.interpolate(\\n imgs, size=(w, h), mode='bilinear')\\n p_distribution, box_regs, _ = self.pnet(resize_img)\\n\\n candidate, scores, offsets, img_labels = self._generate_bboxes(\\n p_distribution, box_regs, f, threshold)\\n\\n candidate_boxes = torch.cat([candidate_boxes, candidate])\\n candidate_scores = torch.cat([candidate_scores, scores])\\n candidate_offsets = torch.cat([candidate_offsets, offsets])\\n all_img_labels = torch.cat([all_img_labels, img_labels])\\n\\n \\n if candidate_boxes.shape[0] != 0:\\n candidate_boxes = self._calibrate_box(\\n candidate_boxes, candidate_offsets)\\n candidate_boxes = self._convert_to_square(candidate_boxes)\\n candidate_boxes = self._refine_boxes(\\n candidate_boxes, width, height)\\n \\n final_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\\n final_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\\n for i in range(num_img):\\n mask = all_img_labels == i\\n keep = func.nms(candidate_boxes[mask].cpu().numpy(),\\n candidate_scores[mask].cpu().numpy(), nms_threshold)\\n final_boxes = torch.cat([final_boxes, candidate_boxes[mask][keep]])\\n final_img_labels = torch.cat([final_img_labels, all_img_labels[mask][keep]])\\n\\n return torch.cat([final_boxes, final_img_labels.unsqueeze(1 )], -1)\\n else:\\n return candidate_boxes\",\n \"def _images_and_boxes_preprocessing_cv2(self, imgs, boxes):\\r\\n\\r\\n height, width, _ = imgs[0].shape\\r\\n\\r\\n boxes[:, [0, 2]] *= width\\r\\n boxes[:, [1, 3]] *= height\\r\\n boxes = cv2_transform.clip_boxes_to_image(boxes, height, width)\\r\\n\\r\\n # `transform.py` is list of np.array. However, for AVA, we only have\\r\\n # one np.array.\\r\\n boxes = [boxes]\\r\\n # The image now is in HWC, BGR format.\\r\\n if self._split == \\\"train\\\": # \\\"train\\\"\\r\\n imgs, boxes = cv2_transform.random_short_side_scale_jitter_list(\\r\\n imgs,\\r\\n min_size=self._jitter_min_scale,\\r\\n max_size=self._jitter_max_scale,\\r\\n boxes=boxes,\\r\\n )\\r\\n imgs, boxes = cv2_transform.random_crop_list(\\r\\n imgs, self._crop_size, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n if self.random_horizontal_flip:\\r\\n # random flip\\r\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\r\\n 0.5, imgs, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n elif self._split == \\\"val\\\":\\r\\n # Short side to test_scale. Non-local and STRG uses 256.\\r\\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\\r\\n boxes = [\\r\\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\\r\\n ]\\r\\n imgs, boxes = cv2_transform.spatial_shift_crop_list(\\r\\n self._crop_size, imgs, 1, boxes=boxes\\r\\n )\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\r\\n 1, imgs, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n elif self._split == \\\"test\\\":\\r\\n # Short side to test_scale. Non-local and STRG uses 256.\\r\\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\\r\\n boxes = [\\r\\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\\r\\n ]\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\r\\n 1, imgs, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n else:\\r\\n raise NotImplementedError(\\\"Unsupported split mode {}\\\".format(self._split))\\r\\n\\r\\n # Convert image to CHW keeping BGR order.\\r\\n imgs = [cv2_transform.HWC2CHW(img) for img in imgs]\\r\\n\\r\\n # Image [0, 255] -> [0, 1].\\r\\n imgs = [img / 255.0 for img in imgs]\\r\\n\\r\\n imgs = [\\r\\n np.ascontiguousarray(\\r\\n # img.reshape((3, self._crop_size, self._crop_size))\\r\\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\\r\\n ).astype(np.float32)\\r\\n for img in imgs\\r\\n ]\\r\\n\\r\\n # Do color augmentation (after divided by 255.0).\\r\\n if self._split == \\\"train\\\" and self._use_color_augmentation:\\r\\n if not self._pca_jitter_only:\\r\\n imgs = cv2_transform.color_jitter_list(\\r\\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\\r\\n )\\r\\n\\r\\n imgs = cv2_transform.lighting_list(\\r\\n imgs,\\r\\n alphastd=0.1,\\r\\n eigval=np.array(self._pca_eigval).astype(np.float32),\\r\\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\\r\\n )\\r\\n\\r\\n # Normalize images by mean and std.\\r\\n imgs = [\\r\\n cv2_transform.color_normalization(\\r\\n img,\\r\\n np.array(self._data_mean, dtype=np.float32),\\r\\n np.array(self._data_std, dtype=np.float32),\\r\\n )\\r\\n for img in imgs\\r\\n ]\\r\\n\\r\\n # Concat list of images to single ndarray.\\r\\n imgs = np.concatenate([np.expand_dims(img, axis=1) for img in imgs], axis=1)\\r\\n\\r\\n if not self._use_bgr:\\r\\n # Convert image format from BGR to RGB.\\r\\n imgs = imgs[::-1, ...]\\r\\n\\r\\n imgs = np.ascontiguousarray(imgs)\\r\\n imgs = torch.from_numpy(imgs)\\r\\n boxes = cv2_transform.clip_boxes_to_image(\\r\\n boxes[0], imgs[0].shape[1], imgs[0].shape[2]\\r\\n )\\r\\n return imgs, boxes\",\n \"def __init__(self,jx,jy,img,geo,mbox=10,hist=False,zoomc=False,pfile=False):\\n \\n self.mbox = mbox # Box half-size\\n self.nbox = 2*mbox + 1 # Box size\\n # Adjust central pixel location to ensure box fits within full image\\n self.ix = int( np.median( [ mbox, jx, img.nx-mbox-1 ] ) )\\n self.iy = int( np.median( [ mbox, jy, img.ny-mbox-1 ] ) )\\n iymin = self.iy - mbox\\n iymax = self.iy + mbox\\n ixmin = self.ix - mbox\\n ixmax = self.ix + mbox\\n label = img.label # Copy information from full disk image\\n self.label = label\\n self.desc = img.desc[label]\\n self.img = img.images[label][iymin:iymax+1,ixmin:ixmax+1]\\n self.disp(zoomc)\\n if hist: self.hist(geo,pfile)\",\n \"def _images_and_boxes_preprocessing_cv2(self, imgs, boxes, gt_boxes=None, min_scale=None, crop_size=None, n_imgs=0):\\n\\n height, width, _ = imgs[0].shape\\n\\n # boxes[:, [0, 2]] *= width\\n # boxes[:, [1, 3]] *= height\\n boxes = cv2_transform.clip_boxes_to_image(boxes, height, width)\\n\\n # `transform.py` is list of np.array. However, for AVA, we only have\\n # one np.array.\\n boxes = [boxes]\\n\\n crop_size = crop_size if self.multigrid_enabled and crop_size is not None else self._crop_size\\n \\n if self._split != 'train':\\n assert gt_boxes is not None\\n gt_boxes = cv2_transform.clip_boxes_to_image(gt_boxes, height, width)\\n gt_boxes = [gt_boxes]\\n\\n # The image now is in HWC, BGR format.\\n if self._split == \\\"train\\\": # \\\"train\\\"\\n imgs, boxes = cv2_transform.random_short_side_scale_jitter_list(\\n imgs,\\n min_size=self._jitter_min_scale if not self.multigrid_enabled and min_scale is None else min_scale,\\n max_size=self._jitter_max_scale,\\n boxes=boxes,\\n )\\n imgs, boxes = cv2_transform.random_crop_list(\\n imgs, crop_size, order=\\\"HWC\\\", boxes=boxes, n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\\n )\\n if self.random_horizontal_flip:\\n # random flip\\n # if self.cfg.MODEL.USE_SPA_CONF and len(imgs[n_imgs].shape) != 3:\\n # for i in range(n_imgs, len(imgs) + 1):\\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\n 0.5, imgs, order=\\\"HWC\\\", boxes=boxes, \\n n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\\n )\\n # elif self._split == \\\"val\\\":\\n # # Short side to test_scale. Non-local and STRG uses 256.\\n # imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\\n # boxes, gt_boxes = cv2_transform.scale_boxes(\\n # self._crop_size, boxes[0], height, width, gt_boxes=gt_boxes[0]\\n # )\\n # boxes, gt_boxes = [boxes], [gt_boxes]\\n # imgs, boxes, gt_boxes = cv2_transform.spatial_shift_crop_list(\\n # self._crop_size, imgs, 1, boxes=boxes, gt_boxes=gt_boxes\\n # )\\n\\n # if self._test_force_flip:\\n # imgs, boxes = cv2_transform.horizontal_flip_list(\\n # 1, imgs, order=\\\"HWC\\\", boxes=boxes, gt_boxes=gt_boxes\\n # )\\n elif self._split == \\\"val\\\" or self._split == \\\"test\\\":\\n # Short side to test_scale. Non-local and STRG uses 256.\\n imgs = [cv2_transform.scale(crop_size, img) for img in imgs]\\n boxes, gt_boxes = cv2_transform.scale_boxes(\\n crop_size, boxes[0], height, width, gt_boxes=gt_boxes[0]\\n )\\n boxes, gt_boxes = [boxes], [gt_boxes]\\n\\n if self._test_force_flip:\\n # if self.cfg.MODEL.USE_SPA_CONF and len(imgs[n_imgs].shape) != 3:\\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\\n # imgs[n_imgs:] = [np.expand_dims(img, axis=-1) for img in imgs[n_imgs:]]\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\n 1, imgs, order=\\\"HWC\\\", boxes=boxes, gt_boxes=gt_boxes,\\n n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\\n )\\n else:\\n raise NotImplementedError(\\n \\\"Unsupported split mode {}\\\".format(self._split)\\n )\\n\\n # Convert image to CHW keeping BGR order.\\n if self.cfg.MODEL.USE_SPA_CONF:\\n try:\\n if len(imgs[n_imgs].shape) == 2:\\n imgs[n_imgs:] = [np.expand_dims(img, axis=-1) for img in imgs[n_imgs:]]\\n elif len(imgs[n_imgs].shape) > 3:\\n imgs[n_imgs:] = [np.expand_dims(img.squeeze(), axis=-1) for img in imgs[n_imgs:]]\\n except:\\n import pdb; pdb.set_trace()\\n \\n # for i in range(n_imgs, len(imgs) + 1):\\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\\n # try:\\n imgs = [cv2_transform.HWC2CHW(img) for img in imgs]\\n # except:\\n # print('imgs[n_imgs].shape:', imgs[n_imgs].shape)\\n # print('len(imgs):', len(imgs))\\n # print('n_imgs:', n_imgs)\\n # import pdb; pdb.set_trace()\\n\\n # Image [0, 255] -> [0, 1].\\n if self.cfg.MODEL.USE_SPA_CONF:\\n imgs[:n_imgs] = [img / 255.0 for img in imgs[:n_imgs]]\\n else: \\n imgs = [img / 255.0 for img in imgs]\\n\\n if self.cfg.MODEL.USE_SPA_CONF:\\n imgs[:n_imgs] = [\\n np.ascontiguousarray(\\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\\n ).astype(np.float32)\\n for img in imgs[:n_imgs]\\n ]\\n imgs[n_imgs:] = [\\n np.ascontiguousarray(\\n img.reshape((1, imgs[0].shape[1], imgs[0].shape[2]))\\n ).astype(np.float32)\\n for img in imgs[n_imgs:]\\n ]\\n else:\\n imgs = [\\n np.ascontiguousarray(\\n # img.reshape((3, self._crop_size, self._crop_size))\\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\\n ).astype(np.float32)\\n for img in imgs\\n ]\\n\\n # Do color augmentation (after divided by 255.0).\\n if self.cfg.MODEL.USE_SPA_CONF:\\n skeleton_imgs = imgs[n_imgs:]\\n imgs = imgs[:n_imgs]\\n if self._split == \\\"train\\\" and self._use_color_augmentation: # False\\n if not self._pca_jitter_only:\\n imgs = cv2_transform.color_jitter_list(\\n imgs,\\n img_brightness=0.4,\\n img_contrast=0.4,\\n img_saturation=0.4,\\n )\\n\\n imgs = cv2_transform.lighting_list(\\n imgs,\\n alphastd=0.1,\\n eigval=np.array(self._pca_eigval).astype(np.float32),\\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\\n )\\n\\n # Normalize images by mean and std.\\n imgs = [\\n cv2_transform.color_normalization(\\n img,\\n np.array(self._data_mean, dtype=np.float32),\\n np.array(self._data_std, dtype=np.float32),\\n )\\n for img in imgs\\n ]\\n\\n # Concat list of images to single ndarray.\\n imgs = np.concatenate(\\n [np.expand_dims(img, axis=1) for img in imgs], axis=1\\n )\\n\\n if not self._use_bgr:\\n # Convert image format from BGR to RGB.\\n imgs = imgs[::-1, ...]\\n\\n imgs = np.ascontiguousarray(imgs)\\n imgs = torch.from_numpy(imgs)\\n \\n if self.cfg.MODEL.USE_SPA_CONF:\\n skeleton_imgs = np.concatenate(\\n [np.expand_dims(img, axis=1) for img in skeleton_imgs], axis=1\\n )\\n skeleton_imgs = np.ascontiguousarray(skeleton_imgs)\\n skeleton_imgs = torch.from_numpy(skeleton_imgs)\\n\\n boxes = cv2_transform.clip_boxes_to_image(\\n boxes[0], imgs[0].shape[1], imgs[0].shape[2]\\n )\\n if gt_boxes is not None:\\n gt_boxes = cv2_transform.clip_boxes_to_image(\\n gt_boxes[0], imgs[0].shape[1], imgs[0].shape[2]\\n )\\n if self.cfg.MODEL.USE_SPA_CONF:\\n return (imgs, skeleton_imgs, boxes) if gt_boxes is None else (imgs, skeleton_imgs, boxes, gt_boxes)\\n else:\\n return (imgs, boxes) if gt_boxes is None else (imgs, boxes, gt_boxes)\",\n \"def set_figure_size(self):\\n lims, _ = self.set_lims()\\n size_fac = 50\\n paperSizeFac = 0.65\\n one_dec = 1.6\\n xdecs = np.log10(lims(1)) - np.log10(lims(0))\\n one_dec = one_dec * 4 / xdecs\\n ydecs = np.log10(lims[3]) - np.log10(lims[2])\\n paper_width = xdecs * one_dec\\n paper_height = (ydecs + 3) * one_dec\\n paper_height = min([paper_height, 9])\\n rectScreen = [0.5, 0.5, paper_width, paper_height] * size_fac\\n rectPaper = [1.0, 1.0, paper_width * paperSizeFac, paper_height * paperSizeFac]\\n\\n rectRho = [0.15, 0.15 + 2.3 / (ydecs + 3), 0.8, ydecs / (ydecs + 3) * 0.8]\\n rectPhi = [0.15, 0.15, 0.8, 2 / (ydecs + 3) * 0.8]\\n rects = {\\n \\\"Screen\\\": rectScreen,\\n \\\"Paper\\\": rectPaper,\\n \\\"Rho\\\": rectRho,\\n \\\"Phi\\\": rectPhi,\\n }\\n return rects\",\n \"def define_box_location(self):\\n self.contents['Box_ID'] = np.ones(self.numatom) * self.num_box\",\n \"def configure_grid(self):\\r\\n\\r\\n for r in range(3):\\r\\n self.rowconfigure(r, weight=1)\\r\\n for c in range(3):\\r\\n self.columnconfigure(c, weight=1)\",\n \"def create_prior_boxes(self):\\n # value of k for each feature map to create k^2 boxes for each feature map\\n feature_map_dims = {'conv4_3': 38, 'conv7': 19, 'conv8_2': 10, 'conv9_2': 5}\\n\\n # scale for boxes across different feature maps. boxes for inner feature maps\\n # are scaled much lower to detect small objects\\n obj_scales = {'conv4_3': 0.1, 'conv7': 0.21, 'conv8_2': 0.255, 'conv9_2': 0.30}\\n\\n # Defined aspect ratio calculated from mean of (w/h) across all bounding boxes\\n # from the dataset. The mean is 0.66 with deviation of 0.07. So aspect ratio is kept\\n # at 0.66 for all feature maps\\n aspect_ratios = {'conv4_3': [0.5], 'conv7': [0.55], 'conv8_2': [0.6], 'conv9_2': [.66]}\\n\\n fmaps = list(feature_map_dims.keys())\\n prior_boxes = []\\n for k, fmap in enumerate(fmaps):\\n # for each feature map, create k*k boxes\\n for i in range(feature_map_dims[fmap]):\\n for j in range(feature_map_dims[fmap]):\\n # calculate center coordinates of boxes\\n cx = (j + 0.5) / feature_map_dims[fmap]\\n cy = (i + 0.5) / feature_map_dims[fmap]\\n\\n # For each\\n for ratio in aspect_ratios[fmap]:\\n prior_boxes.append([cx, cy, obj_scales[fmap] * sqrt(ratio), obj_scales[fmap] / sqrt(ratio)])\\n\\n prior_boxes = torch.FloatTensor(prior_boxes).to(device) # (1930, 4)\\n prior_boxes.clamp_(0, 1) # (1930, 4)\\n\\n return prior_boxes\",\n \"def setup_image(self):\\n # Create the correct size image for the table\\n rows = self.table.count('\\\\n')\\n columns = self.table.split('\\\\n')[0].count('-') + self.table.split('\\\\n')[0].count('+')\\n self.img = Image.new('RGB', ((columns * 12) + 24, rows * 21 + 48), color=(54, 57, 63))\\n\\n # Initialize font and drawing object\\n self.font = ImageFont.truetype('../extra_files/cour.ttf', 20)\\n self.draw = ImageDraw.Draw(self.img)\\n\\n # Draw the table without markings\\n for x in range(5):\\n self.draw.text((12, 12), self.table, font=self.font, fill=(255, 255, 255))\",\n \"def boxes_postprocess(boxes, image_meta):\\n if 'scales' in image_meta:\\n boxes[:, [0, 2]] /= image_meta['scales'][1]\\n boxes[:, [1, 3]] /= image_meta['scales'][0]\\n\\n if 'padding' in image_meta:\\n boxes[:, [0, 2]] -= image_meta['padding'][2]\\n boxes[:, [1, 3]] -= image_meta['padding'][0]\\n\\n if 'crops' in image_meta:\\n boxes[:, [0, 2]] += image_meta['crops'][2]\\n boxes[:, [1, 3]] += image_meta['crops'][0]\\n\\n if 'flipped' in image_meta and image_meta['flipped']:\\n image_width = image_meta['drifted_size'][1] if 'drifted_size' in image_meta else \\\\\\n image_meta['orig_size'][1]\\n boxes_widths = boxes[:, 2] - boxes[:, 0] + 1.\\n boxes[:, 0] = image_width - 1 - boxes[:, 2]\\n boxes[:, 2] = boxes[:, 0] + boxes_widths - 1.\\n\\n if 'drifts' in image_meta:\\n boxes[:, [0, 2]] += image_meta['drifts'][1]\\n boxes[:, [1, 3]] += image_meta['drifts'][0]\\n\\n return boxes\",\n \"def draw_boxes(bboxes: [[int]], img: 'np.array', line_width: int=2) -> 'np.array':\\n for x, y, w, h in bboxes:\\n cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), line_width)\\n return img\",\n \"def __call__(self, results):\\n\\n if 'img_fields' in results:\\n assert results['img_fields'] == ['img'], \\\\\\n 'Only single img_fields is allowed'\\n img = results['img']\\n assert 'bbox_fields' in results\\n boxes = [results[key] for key in results['bbox_fields']]\\n boxes = np.concatenate(boxes, 0)\\n h, w, c = img.shape\\n while True:\\n mode = random.choice(self.sample_mode)\\n self.mode = mode\\n if mode == 1:\\n return results\\n\\n min_iou = mode\\n for i in range(50):\\n new_w = random.uniform(self.min_crop_size * w, w)\\n new_h = random.uniform(self.min_crop_size * h, h)\\n\\n # h / w in [0.5, 2]\\n if new_h / new_w < 0.5 or new_h / new_w > 2:\\n continue\\n\\n left = random.uniform(w - new_w)\\n top = random.uniform(h - new_h)\\n\\n patch = np.array(\\n (int(left), int(top), int(left + new_w), int(top + new_h)))\\n # Line or point crop is not allowed\\n if patch[2] == patch[0] or patch[3] == patch[1]:\\n continue\\n overlaps = bbox_overlaps(\\n patch.reshape(-1, 4), boxes.reshape(-1, 4)).reshape(-1)\\n if len(overlaps) > 0 and overlaps.min() < min_iou:\\n continue\\n\\n # center of boxes should inside the crop img\\n # only adjust boxes and instance masks when the gt is not empty\\n if len(overlaps) > 0:\\n # adjust boxes\\n def is_center_of_bboxes_in_patch(boxes, patch):\\n center = (boxes[:, :2] + boxes[:, 2:]) / 2\\n mask = ((center[:, 0] > patch[0]) *\\n (center[:, 1] > patch[1]) *\\n (center[:, 0] < patch[2]) *\\n (center[:, 1] < patch[3]))\\n return mask\\n\\n mask = is_center_of_bboxes_in_patch(boxes, patch)\\n if not mask.any():\\n continue\\n for key in results.get('bbox_fields', []):\\n boxes = results[key].copy()\\n mask = is_center_of_bboxes_in_patch(boxes, patch)\\n boxes = boxes[mask]\\n if self.bbox_clip_border:\\n boxes[:, 2:] = boxes[:, 2:].clip(max=patch[2:])\\n boxes[:, :2] = boxes[:, :2].clip(min=patch[:2])\\n boxes -= np.tile(patch[:2], 2)\\n\\n results[key] = boxes\\n # labels\\n label_key = self.bbox2label.get(key)\\n if label_key in results:\\n results[label_key] = results[label_key][mask]\\n\\n # mask fields\\n mask_key = self.bbox2mask.get(key)\\n if mask_key in results:\\n results[mask_key] = results[mask_key][\\n mask.nonzero()[0]].crop(patch)\\n # adjust the img no matter whether the gt is empty before crop\\n img = img[patch[1]:patch[3], patch[0]:patch[2]]\\n results['img'] = img\\n results['img_shape'] = img.shape\\n\\n # seg fields\\n for key in results.get('seg_fields', []):\\n results[key] = results[key][patch[1]:patch[3],\\n patch[0]:patch[2]]\\n return results\",\n \"def initialize_grid(self) -> None:\\n for i in range(self.grid_size[0]):\\n for j in range(self.grid_size[1]):\\n self.set(i, j, self.base_color)\",\n \"def fillingrid(self):\\n\\n if self.imagearray is None:\\n if self.gs.isfixed:\\n for n in range(0, self.numcols):\\n self.vspins[n].setValue(self.currentvalues[n])\\n elif self.gs.isperc:\\n for n in range(0, self.numcols):\\n self.fillinpercent(n)\\n else:\\n for n in range(0, self.numcols):\\n self.nsspins[n].setValue(self.currentnsigs[n])\\n else:\\n for n in range(0, self.numcols):\\n self.vspins[n].setValue(self.currentvalues[n])\\n self.nsspins[n].setValue(self.currentnsigs[n])\\n self.fillinpercent(n)\",\n \"def create_flowbox(self, flowbox, frame_list):\\n\\n for num_frame in frame_list:\\n grid = Gtk.Grid()\\n btn = self.new_thumbnail_button(num_frame)\\n\\n widget_cls_label = Gtk.Label()\\n widget_cls_label.set_text(\\\"?\\\")\\n widget_cls_label.set_size_request(20, 20)\\n widget_cls_label.connect(\\\"draw\\\", self.area_on_draw, {'frame': num_frame, 'widget_label': widget_cls_label})\\n # Add drawing area\\n grid.add(btn)\\n grid.attach_next_to(widget_cls_label, btn, Gtk.PositionType.BOTTOM, 1, 2)\\n\\n flowbox.add(grid)\\n self.flowbox_layout = flowbox\",\n \"def updateFootprintBbox(self):\\n # Pull out the image bounds of the parent Footprint\\n self.bb = self.fp.getBBox()\\n if not self.imbb.contains(self.bb):\\n raise ValueError(('Footprint bounding-box %s extends outside image bounding-box %s') %\\n (str(self.bb), str(self.imbb)))\\n self.W, self.H = self.bb.getWidth(), self.bb.getHeight()\\n self.x0, self.y0 = self.bb.getMinX(), self.bb.getMinY()\\n self.x1, self.y1 = self.bb.getMaxX(), self.bb.getMaxY()\",\n \"def boxer(imgfile, parttree, outstack, boxsize):\\n imgarray = mrc.read(imgfile)\\n boxedparticles = boxerMemory(imgarray, parttree, boxsize)\\n apImagicFile.writeImagic(boxedparticles, outstack)\\n return True\",\n \"def build_boxes(self):\\n for index in self.box_space.points:\\n if self.rank_of_box[index] == self.my_rank:\\n self.my_boxes.append(Box(self, index))\",\n \"def __build__(self,data_index=0):\\n \\n super(Image,self).__build__()\\n # -- How to read the image\\n self._build_properties = dict(\\n data_index = data_index,\\n header_exptime = \\\"EXPTIME\\\",\\n dataslice0=\\\"undefined\\\",\\n dataslice1=\\\"undefined\\\",\\n bkgdbox={\\\"bh\\\":100,\\\"bw\\\":100,\\\"fh\\\":3,\\\"fw\\\":3},\\n )\",\n \"def set_pic_size(self, im_name):\\n im_vals = np.genfromtxt(im_name, delimiter=self.delim)\\n self.pic_width = int(np.size(im_vals[0]) - 1) # the first column of ASCII image is row number\\n try: self.pic_height = int(np.size(im_vals[:,0])) \\n except IndexError: \\n self.pic_width = int(np.size(im_vals) - 1)\\n self.pic_height = 1\\n self.create_rect_mask()\\n return self.pic_width, self.pic_height\",\n \"def preprocessing(image_data, max_height, max_width):\\n img = image_data[\\\"image\\\"]\\n img = resize_image(img, max_height, max_width)\\n gt_boxes = image_data[\\\"objects\\\"][\\\"bbox\\\"]\\n gt_labels = image_data[\\\"objects\\\"][\\\"label\\\"]\\n return img, gt_boxes, gt_labels\",\n \"def setpopbox(ty,slist,scaledtime,rootpop,poptree):\\r\\n wadjust = \\\"\\\"\\r\\n for i in range(numpops-1):\\r\\n wadjust += \\\"00\\\"\\r\\n if(scaledtime != []):\\r\\n minx_popbox = textwide(wadjust+\\\"0.00 MYR\\\", tfactor)\\r\\n else:\\r\\n minx_popbox = textwide(wadjust+\\\"0.00 tu\\\", tfactor)\\r\\n minx_popbox /= gv[\\\"globalscale\\\"]\\r\\n if gv[\\\"localxscale\\\"] > 0:\\r\\n minx_popbox /= gv[\\\"localxscale\\\"]\\r\\n\\r\\n popxvals = []\\r\\n## if scaledpop == [] then no text is written on time split line and there is more width to work with\\r\\n for i in range(2*numpops - 1):\\r\\n## left side temporarily at zero, right side temporarily at upper confidence interval\\r\\n popxvals.append( [0,slist[4][4][i][1]])\\r\\n (width,c,popxvals, leftpoint,rightpoint) = centerbox(rootpop,0,popxvals[rootpop][1],poptree,popxvals)\\r\\n popxvals = popadjustx(popxvals,minx_popbox)\\r\\n popbox = []\\r\\n\\r\\n ## maxwide will be used to adjust the width as a scaler so the part furthest to the right is not too far out\\r\\n maxwide = 0\\r\\n for i in range(2*numpops-1):\\r\\n if maxwide < (popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1])):\\r\\n maxwide = (popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1]))\\r\\n maxwide = maxwide/(1.0-minx_popbox)\\r\\n\\r\\n if gv[\\\"localxscale\\\"] > 0:\\r\\n maxwide *= gv[\\\"localxscale\\\"]\\r\\n\\r\\n farright = 0\\r\\n confint = []\\r\\n for i in range(2*numpops-1):\\r\\n confint.append([])\\r\\n confint[i].append(minx_popbox + ((popxvals[i][1] - (slist[4][4][i][1]-slist[4][4][i][2]))/maxwide))\\r\\n confint[i].append(minx_popbox + ((popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1]))/maxwide))\\r\\n if confint[i][1] > farright:\\r\\n farright = confint[i][1]\\r\\n popbox.append([[],[]])\\r\\n popbox[i][0].append(minx_popbox + popxvals[i][0]/maxwide)\\r\\n popbox[i][1].append(minx_popbox + popxvals[i][1]/maxwide)\\r\\n if poptree[i][1] == -1:\\r\\n popbox[i][0].append(gv[\\\"lineINFy\\\"])\\r\\n else:\\r\\n popbox[i][0].append(ty[poptree[i][1]-1][0])\\r\\n if poptree[i][0] == 0:\\r\\n popbox[i][1].append(gv[\\\"line0y\\\"])\\r\\n else:\\r\\n popbox[i][1].append(ty[poptree[i][0]-1][0])\\r\\n return popbox,maxwide, confint, farright\",\n \"def plt_bboxes(img, classes, scores, bboxes, figsize=(10,10), linewidth=1.5):\\n fig = plt.figure(figsize=figsize)\\n plt.imshow(img)\\n height = img.shape[0]\\n width = img.shape[1]\\n colors = dict()\\n for i in range(classes.shape[0]):\\n cls_id = int(classes[i])\\n if cls_id >= 0:\\n score = scores[i]\\n if cls_id not in colors:\\n colors[cls_id] = (random.random(), random.random(), random.random())\\n ymin = int(bboxes[i, 0] * height)\\n xmin = int(bboxes[i, 1] * width)\\n ymax = int(bboxes[i, 2] * height)\\n xmax = int(bboxes[i, 3] * width)\\n# crop_img = img[xmin:(xmax - xmin),xmax:(ymax - ymin)]\\n# misc.imsave('1.jpg', crop_img)\\n rect = plt.Rectangle((xmin, ymin), xmax - xmin,\\n ymax - ymin, fill=False,\\n edgecolor=colors[cls_id],\\n linewidth=linewidth)\\n plt.gca().add_patch(rect)\\n class_name = CLASSES[cls_id]\\n plt.gca().text(xmin, ymin - 2,\\n '{:s} | {:.3f}'.format(class_name, score),\\n bbox=dict(facecolor=colors[cls_id], alpha=0.5),\\n fontsize=12, color='white')\\n plt.show()\",\n \"def __init__(self,phosphene_resolution=(50,50), size=(480,480), jitter=0.35, intensity_var=0.9, aperture=.66, sigma=0.8, custom_grid=None):\\n if custom_grid is None:\\n self.phosphene_resolution = phosphene_resolution\\n self.size = size\\n self.phosphene_spacing = np.divide(size,phosphene_resolution)\\n self.jitter = jitter\\n self.intensity_var = intensity_var\\n self.grid = self.create_regular_grid(self.phosphene_resolution,self.size,self.jitter,self.intensity_var)\\n self.aperture = np.round(aperture*self.phosphene_spacing[0]).astype(int) #relative aperture > dilation kernel size\\n else:\\n self.grid = custom_grid\\n self.aperture = aperture\\n self.sigma = sigma\\n self.dilation_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(self.aperture,self.aperture))\\n self.k_size = 11 #np.round(4*sigma+1).astype(int) # rule of thumb: choose k_size>3*sigma\",\n \"def sizes(options):\\n # import data\\n pixels = dict() # volumes are given in #pixels\\n snap_mask = \\\"/net/astrogate/export/astrodata/jgacon/filex/processing/\\\" \\\\\\n \\\"export/f8_h50_v100_objs_snap_%d.csv\\\"\\n snap_ids = np.arange(2,28+1)\\n z = snapid2z(snap_ids)\\n print z\\n\\n for id in snap_ids:\\n snap = snap_mask % (id - 1) # fix: snap number one too low in filename\\n pixels[id] = np.genfromtxt(snap)[1:-1,1] # row 2 contains volumes\\n # rm void & halo volumes\\n\\n # visualise\\n if \\\"err\\\" in options.keys():\\n nums = np.array([pixels[id].size for id in snap_ids])\\n avgs = np.array([np.mean(pixels[id]) for id in snap_ids])\\n mods = np.array([st.mode(pixels[id])[0][0] for id in snap_ids])\\n meds = np.array([np.median(pixels[id]) for id in snap_ids])\\n stds = np.array([np.std(pixels[id]) for id in snap_ids])\\n\\n print mods\\n print mods.shape\\n\\n plt.figure()\\n plt.title(\\\"Sizes of filaments as function of redshift\\\")\\n plt.xlabel(\\\"Redshift $z$\\\")\\n plt.xticks(snap_ids[::3], z[::3])\\n\\n plt.ylabel(\\\"Size in #pixels\\\")\\n\\n plt.errorbar(snap_ids, avgs, yerr=stds, label=\\\"Mean\\\")\\n plt.plot(snap_ids, mods, \\\"g\\\", label=\\\"Mode\\\")\\n plt.plot(snap_ids, meds, \\\"c\\\", label=\\\"Median\\\")\\n plt.legend(loc=\\\"best\\\")\\n\\n plt.twinx()\\n plt.ylabel(\\\"#Filaments\\\", color=\\\"r\\\")\\n plt.tick_params(\\\"y\\\", colors=\\\"r\\\")\\n\\n plt.plot(snap_ids, nums, \\\"r--\\\")\\n\\n plt.savefig(options[\\\"err\\\"])\\n\\n if \\\"dist\\\" in options.keys():\\n targets = np.array([5,10,15,20,25])\\n plt.figure()\\n plt.title(\\\"Volume distribution of filaments\\\")\\n plt.xlabel(\\\"Volume $V$ in #pixels\\\")\\n plt.ylabel(\\\"#Element with $V$ / Total #Elements\\\")\\n plt.xlim([0,1000])\\n for target in targets:\\n sns.kdeplot(pixels[target], label=\\\"$z$ = %f\\\" % snapid2z(target))\\n plt.legend(loc=\\\"best\\\")\\n plt.savefig(options[\\\"dist\\\"])\\n\\n if \\\"dist_inter\\\" in options.keys():\\n default = snap_ids[-1]\\n fig, ax = plt.subplots()\\n plt.subplots_adjust(bottom=0.25)\\n sns.kdeplot(pixels[int(default - 2)], ax=ax)\\n plt.xlim([0, 1000])\\n plt.ylim([0, 0.01])\\n plt.xlabel(\\\"Volume $V$ of filaments in #pixels\\\")\\n plt.ylabel(\\\"#Filaments with volume $V$ / Total #Filaments\\\")\\n\\n nums = np.array([pixels[id].size for id in snap_ids])\\n ax2 = ax.twinx()\\n ax2.set_ylabel(\\\"#Filaments\\\", color=\\\"r\\\", alpha=0.5)\\n ax2.tick_params(axis=\\\"y\\\", labelcolor=\\\"r\\\")\\n ax2_x = np.linspace(0, 1000, nums.size)\\n ax2.plot(ax2_x, nums, \\\"r--\\\", alpha=0.5)\\n point, = ax2.plot(ax2_x[default - 2], nums[default - 2], \\\"ro\\\", alpha=0.5)\\n\\n axcolor = 'lightgoldenrodyellow'\\n axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)\\n sid = Slider(axfreq, \\\"ID\\\", 2, 28, valinit=default, valstep=1)\\n ax.set_title(\\\"$z$ = %f\\\" % snapid2z(default))\\n\\n def update(val):\\n id = sid.val\\n\\n print id\\n #ax.clear()\\n ax.set_ydata()\\n ax.set_xdata()\\n ax.set_title(\\\"$z$ = %f\\\" % snapid2z(int(id)))\\n ax.set_xlim([0,1000])\\n ax.set_ylim([0, 0.01])\\n sns.kdeplot(pixels[int(id)], ax=ax)\\n point.set_xdata(ax2_x[int(id) - 2])\\n point.set_ydata(nums[int(id) - 2])\\n fig.canvas.draw_idle()\\n sid.on_changed(update)\\n\\n plt.show()\\n\\n\\n if \\\"hist\\\" in options.keys():\\n conc = None\\n for id, vols in pixels.iteritems():\\n data = np.empty((vols.size, 2))\\n data[:,0] = id\\n data[:,1] = vols\\n\\n if conc is None:\\n conc = data\\n else:\\n conc = np.vstack((conc, data))\\n\\n plt.figure()\\n plt.hist2d(conc[:,0], conc[:,1], bins=(snap_ids.size, 1000))\\n plt.ylim([100,400])\\n plt.savefig(options[\\\"hist\\\"])\",\n \"def create_image_caption_pairs(self):\",\n \"def _set_boxes(self, listOfBoxes):\\n self._boxes = listOfBoxes\",\n \"def generate_image_grid(sess, df, filenames,op, op2):\\n #x_points = np.arange(0, 1, 1.5).astype(np.float32)\\n #y_points = np.arange(0, 1, 1.5).astype(np.float32)\\n\\n nx, ny = 12, 1\\n #plt.subplot()\\n gs = gridspec.GridSpec(nx, ny, hspace=1, wspace=0.05)\\n # input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\\n #\\n # plt.imshow(np.array(df[0].tolist()).reshape(28, 28), cmap='gray')\\n # plt.show()\\n # x = sess.run(op, feed_dict={decoder_input: input_x[0].reshape(1,2)})\\n # img = np.array(x.tolist()).reshape(28, 28)\\n #\\n # plt.imshow(img, cmap='gray')\\n # plt.show()\\n\\n \\\"\\\"\\\" grid \\\"\\\"\\\"\\n input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\\n for i, g in enumerate(gs):\\n\\n x = sess.run(op, feed_dict={decoder_input: input_x[i].reshape(1,2)})\\n ax = plt.subplot(g)\\n img = np.array(x.tolist()).reshape(28, 28)\\n ax.imshow(img, cmap='gray')\\n ax.set_xticks([])\\n ax.set_yticks([])\\n #ax.set_aspect('auto')\\n ax.set_title(filenames[i])\\n plt.show()\\n\\n for i, g in enumerate(gs):\\n\\n ax = plt.subplot(g)\\n img = np.array(df[i].tolist()).reshape(28, 28)\\n ax.imshow(img, cmap='gray')\\n ax.set_xticks([])\\n ax.set_yticks([])\\n #ax.set_aspect('auto')\\n ax.set_title(filenames[i])\\n plt.show()\",\n \"def plt_bboxes(img, classes, scores, bboxes, figsize=(17.78,10), linewidth=1.5):\\n fig = plt.figure(figsize=figsize, frameon=False)\\n ax = fig.add_axes([0, 0, 1, 1])\\n ax.axis('off')\\n plt.imshow(img)\\n height = img.shape[0]\\n width = img.shape[1]\\n print (\\\"original height width\\\", height, width)\\n if (classes.shape[0] > 0):\\n print (\\\"This frame has class\\\")\\n for i in range(classes.shape[0]):\\n cls_id = int(classes[i])\\n if cls_id >= 0:\\n score = scores[i]\\n if cls_id not in colors:\\n colors[cls_id] = (random.random(), random.random(), random.random())\\n ymin = int(bboxes[i, 0] * height)\\n xmin = int(bboxes[i, 1] * width)\\n ymax = int(bboxes[i, 2] * height)\\n xmax = int(bboxes[i, 3] * width)\\n rect = plt.Rectangle((xmin, ymin), xmax - xmin,\\n ymax - ymin, fill=False,\\n edgecolor=colors[cls_id],\\n linewidth=linewidth)\\n plt.gca().add_patch(rect)\\n class_name = pascal_classes[cls_id]\\n plt.gca().text(xmin, ymin - 2,\\n '{:s} | {:.3f}'.format(class_name, score),\\n bbox=dict(facecolor=colors[cls_id], alpha=0.5),\\n fontsize=12, color='white')\\n fig.canvas.draw()\\n data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')\\n data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))\\n plt.close()\\n print(\\\"Processed data with shape, \\\", data.shape)\\n return data\",\n \"def draw_boxes(indexes, frame, all_boxes):\\n bbox = []\\n mid_points = []\\n\\n for i in indexes:\\n x = i[0]\\n box = all_boxes[x]\\n bbox.append(box)\\n mid_points.append(mid_point(frame, box))\\n x1, y1, w, h = box[0], box[1], box[2], box[3]\\n x2, y2 = x1+w, y1+h\\n\\n cv2.rectangle(frame, (x1,y1),(x2,y2),(255,0,0),2) \\n\\n return mid_points, bbox\",\n \"def __draw_boxes(self, img, bboxes, color=(128, 0, 0), thick=4):\\n\\n # Make a copy of the image\\n imcopy = np.copy(img)\\n # Iterate through the bounding boxes\\n for bbox in bboxes:\\n # Draw a rectangle given bbox coordinates\\n cv2.rectangle(imcopy, bbox[0], bbox[1], color, thick)\\n # Return the image copy with boxes drawn\\n return imcopy\",\n \"def setUp(self):\\n img_path = osp.join(osp.dirname(__file__), '../../data/gray.jpg')\\n self.results = {\\n 'img_path':\\n img_path,\\n 'img_shape': (300, 400),\\n 'instances': [{\\n 'bbox': [0, 0, 10, 20],\\n 'bbox_label': 1,\\n 'mask': [[0, 0, 0, 20, 10, 20, 10, 0]],\\n 'ignore_flag': 0\\n }, {\\n 'bbox': [10, 10, 110, 120],\\n 'bbox_label': 2,\\n 'mask': [[10, 10, 110, 10, 110, 120, 110, 10]],\\n 'ignore_flag': 0\\n }, {\\n 'bbox': [50, 50, 60, 80],\\n 'bbox_label': 2,\\n 'mask': [[50, 50, 60, 50, 60, 80, 50, 80]],\\n 'ignore_flag': 1\\n }]\\n }\",\n \"def make_grid_bbox(tensor, box, nrow=8, padding=2,\\n normalize=False, range=None, \\n scale_each=False, pad_value=0, draw_line=False):\\n\\n # make the mini-batch of images into a grid\\n # nmaps = tensor.size(0)\\n nmaps = len(box)\\n xmaps = min(nrow, nmaps)\\n ymaps = int(math.ceil(float(nmaps) / xmaps))\\n # height, width = int(tensor.size(2) + padding), int(tensor.size(3) + padding)\\n height, width = int(256 + padding), int(256 + padding)\\n tensor = torch.ones(())\\n grid = tensor.new_full((3, height * ymaps + padding, width * xmaps + padding), pad_value)\\n # # add the white image into the grid\\n # block = tensor.new_full((3, height - padding, width - padding), 9.0/13)\\n k = 0\\n for y in irange(ymaps):\\n for x in irange(xmaps):\\n if k >= nmaps:\\n break\\n # add the white image into the grid\\n block = tensor.new_full((3, height - padding, width - padding), 9.0/13)\\n # print(box[0].size())\\n # print(box[1].size())\\n # assert False\\n # num_curr_box = box[0][k].size(0)\\n num_curr_box = box[k][0].size(0)\\n for z in irange(num_curr_box):\\n # label = box[1][k][z].item()\\n try:\\n label = box[k][1][z].item()\\n except:\\n print(box)\\n print(k)\\n assert False\\n \\n if label != -1:\\n block = draw_box(block, box[k][0][z], label, draw_line)\\n # print(k, z)\\n else:\\n break\\n # copy to the grid\\n grid.narrow(1, y * height + padding, height - padding)\\\\\\n .narrow(2, x * width + padding, width - padding)\\\\\\n .copy_(block)\\n k = k + 1\\n return grid\",\n \"def _resize_bboxes(self, ori_bboxes, scale_factor):\\n bboxes = ori_bboxes * scale_factor\\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, self.img_shape[1])\\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, self.img_shape[0])\\n return bboxes\",\n \"def draw_boxes_info(image, current_data):\\n\\n font_position1 = (50, 600)\\n font_position2 = (50, 650)\\n font_scale = .4\\n font_thickness = 1\\n\\n locations = current_data[\\\"locations\\\"] #returns x1, y1, x2, y2\\n frame_num = \\\"Frame Number: \\\" + str(current_data[\\\"frame_num\\\"])\\n\\n for box in locations:\\n box_text = (\\\"Box locations are x1: {0}, y1: {1}, x2: {2}, y2: {3}\\\").format(box[1],box[3],box[0],box[2])\\n\\n cv2.rectangle(image, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 3)\\n cv2.putText(image, box_text, font_position1, cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255),\\n font_thickness, cv2.LINE_AA)\\n\\n cv2.putText(image, frame_num, font_position2, cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255),\\n font_thickness, cv2.LINE_AA)\\n\\n return image\",\n \"def display_precomputed_boxes(self, sample_index, all_boxes):\\n image_rois = [class_detections[sample_index]\\n for class_detections in all_boxes]\\n\\n image_rois_list = []\\n image_classes = []\\n for class_index, class_rois in enumerate(image_rois):\\n if len(class_rois) > 0:\\n classes = np.ones((class_rois.shape[0])) * class_index\\n image_rois_list.extend(class_rois)\\n image_classes.extend(classes)\\n image_rois_list = np.array(image_rois_list)\\n image_classes = np.array(image_classes)\\n\\n show_gt_boxes = False\\n self.display_detections(image_rois_list, image_classes, \\n self.data_loader.dataset.samples[sample_index])\",\n \"def plot_n_box(img_prepro):\\n print(img_prepro)\\n h, w= img_prepro.shape\\n boxes = pytesseract.image_to_boxes(img_prepro)\\n for b in boxes.splitlines():\\n b = b.split(' ')\\n img_prepro = cv2.rectangle(img_prepro, (int(b[1]), h - int(b[2])), (int(b[3]), h - int(b[4])), (0, 255, 0), 2)\\n cv2.imshow('img', img_prepro)\\n cv2.waitKey(0)\\n\\n return\",\n \"def setwinsize(self, rows, cols):\",\n \"def onet_process(self, image, boxes, height, width):\\n data = self.__padding(image, boxes, height, width)\\n return data\",\n \"def forward(self):\\n priors = []\\n for k, f in enumerate(self.feature_maps):\\n scale = self.image_size / self.strides[k]\\n # for i, j in product(range(f), repeat=2):\\n for i in range(f[0]):\\n for j in range(f[1]):\\n # print(i, j)\\n # unit center x,y\\n cx = (j + 0.5) / scale\\n cy = (i + 0.5) / scale\\n\\n # small sized square box\\n size = self.min_sizes[k]\\n h = w = size / self.image_size\\n priors.append([cx, cy, w, h])\\n\\n # big sized square box\\n size = sqrt(self.min_sizes[k] * self.max_sizes[k])\\n h = w = size / self.image_size\\n priors.append([cx, cy, w, h])\\n\\n # change h/w ratio of the small sized box\\n size = self.min_sizes[k]\\n h = w = size / self.image_size\\n for ratio in self.aspect_ratios[k]:\\n ratio = sqrt(ratio)\\n priors.append([cx, cy, w * ratio, h / ratio])\\n priors.append([cx, cy, w / ratio, h * ratio])\\n\\n priors = torch.Tensor(priors)\\n if self.clip:\\n priors.clamp_(max=1, min=0)\\n return priors\",\n \"def get_boxes():\\n boxes = []\\n\\n box_sizes = [256]\\n left_x_cords = [x for x in range(0,1280,12)]\\n top_y_cords = [y for y in range(360,720,12)]\\n\\n for box_size in box_sizes:\\n for x_cord in left_x_cords:\\n for y_cord in top_y_cords:\\n if box_size+x_cord < 1280 and box_size+y_cord < 720:\\n boxes.append([x_cord, y_cord, x_cord+box_size, y_cord+box_size])\\n\\n return boxes\",\n \"def __create_blank_page__(self):\\n with open(\\\"active_weather.basic.exp\\\"+str(self.box_count)+\\\".box\\\",\\\"w\\\") as f:\\n f.write(\\\"\\\")\\n\\n self.width = 2508\\n # self.height = 200\\n self.height = 4000\\n self.training_page = np.zeros((self.height,self.width),dtype=np.uint8)\\n self.training_page.fill(255)\\n\\n self.row_bitmaps = []\\n self.row_characters = []\\n\\n self.row_pointer = spacing\\n self.column_pointer = spacing\\n\\n\\n # self.__box_file_flush__()\\n self.box_file_entries = []\\n self.used_height = spacing\",\n \"def plot_image(image, boxes, class_dic, frame_n):\\n im = np.array(image)\\n print(im.shape)\\n height, width, _ = im.shape\\n\\n # Create figure and axes\\n # fig, ax = plt.subplots(1)\\n # # Display the image\\n # ax.imshow(im)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111, aspect='auto')\\n ax.set_axis_off()\\n fig.add_axes(ax)\\n ax.imshow(im)\\n # box[0] is x midpoint, box[2] is width\\n # box[1] is y midpoint, box[3] is height\\n\\n # Create a Rectangle potch\\n for box in boxes:\\n class_ = int(box[0])\\n confidence_ = box[1]\\n box = box[2:]\\n assert len(box) == 4, \\\"Got more values than in x, y, w, h, in a box!\\\"\\n upper_left_x = box[0] - box[2] / 2\\n upper_left_y = box[1] - box[3] / 2\\n rect = patches.Rectangle(\\n (upper_left_x * width, upper_left_y * height),\\n box[2] * width,\\n box[3] * height,\\n linewidth=1,\\n edgecolor=\\\"r\\\",\\n facecolor=\\\"none\\\",\\n )\\n\\n\\n label_bbox = class_dic[class_] + \\\":::\\\" + f\\\"{100 * confidence_:.2f}\\\" + \\\"%\\\"\\n plt.text(upper_left_x * width, upper_left_y * height - 10, label_bbox, size=10, rotation=0,\\n ha=\\\"left\\\", va=\\\"bottom\\\",\\n bbox=dict(boxstyle=\\\"square\\\",\\n ec=(1, 0, 0),\\n fc=(1, 0, 0),\\n )\\n )\\n \\n \\n # Add the patch to the Axes\\n ax.add_patch(rect)\\n if frame_n:\\n plt.savefig(str(frame_n) + '.png', dpi=200, bbox_inches=\\\"tight\\\", transparent=True, pad_inches=0)\\n else:\\n plt.show()\",\n \"def setUp(self):\\n self.single_box = [ScoredRect(Rect(0, 10, 0, 20), 0.0)]\\n\\n self.ground_truths = [ScoredRect(Rect(0, 10, 0, 10), 0.5),\\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\\n ScoredRect(Rect(-40, -30, -20, -10), 0.5),\\n ]\\n self.detections = [ScoredRect(Rect(0, 10, 0, 10), 0.5),\\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\\n ScoredRect(Rect(100, 110, 20, 30), 0.5),\\n ]\",\n \"def normalize_boxes(all_boxes, image_width, image_height):\\n new_boxes = []\\n for boxes_per_frame in all_boxes:\\n new_boxes_per_frame = []\\n for i, box in enumerate(boxes_per_frame):\\n left, top, right, bottom = box\\n new_boxes_per_frame.append((left / image_width, top / image_height, right / image_width, bottom / image_height))\\n new_boxes.append(new_boxes_per_frame)\\n\\n assert(len(new_boxes) == len(all_boxes))\\n for i, boxes_per_frame in enumerate(all_boxes):\\n assert(len(boxes_per_frame) == len(new_boxes[i]))\\n\\n\\n\\n return new_boxes\",\n \"def test_nominal_case(self):\\n\\n image_filename, boxes = list(annotation.read(self.filename))\\n self.assertEqual(image_filename, 'image.jpg')\\n self.assertEqual(len(boxes), 2)\\n width = 400\\n height = 300\\n b = boxes[0]\\n self.assertEqual(b.xmin, 10 / width)\\n self.assertEqual(b.ymin, 20 / height)\\n self.assertEqual(b.xmax, 30 / width)\\n self.assertEqual(b.ymax, 40 / height)\",\n \"def resize_spacing(img_sz,img_sp,factor):\\n img_sz_np = np.array(list(img_sz))\\n img_sp_np = np.array(list(img_sp))\\n new_sz_np = img_sz_np*factor\\n new_sp = img_sp_np*(img_sz_np-1)/(new_sz_np-1)\\n return tuple(list(new_sp))\",\n \"def __init__(self):\\n toplevel_create_image = mw.tkinter.Toplevel(mw.MainWindow, bg = \\\"#a1a1a1\\\")\\n \\\"\\\"\\\" top level window attributes\\\"\\\"\\\"\\n toplevel_create_image.title(\\\"create new image\\\")\\n toplevel_create_image.geometry(\\\"800x600+600+200\\\")\\n toplevel_create_image.resizable(width = False, height = False)\\n self. top_down = 60\\n\\n # UI\\n image_width_label = mw.tkinter.Label(toplevel_create_image, text = \\\"Width: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n image_width_label.grid(row = 0, column = 0, padx = 20, pady = 20)\\n image_height_label = mw.tkinter.Label(toplevel_create_image, text = \\\"Height: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n image_height_label.grid(row = 1, column = 0)\\n\\n # text box image size \\n image_width_text_box = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n bg = \\\"grey\\\", fg = \\\"white\\\")\\n image_width_text_box.grid(row = 0, column = 1, pady = 20)\\n\\n image_height_text_box = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n bg = \\\"grey\\\", fg = \\\"white\\\")\\n image_height_text_box.grid(row = 1, column = 1)\\n\\n # color mode\\n color_mode_combo_box = mw.tkinter.Label(toplevel_create_image, text = \\\"color mode: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n color_mode_combo_box.grid(row = 2, column = 0, padx = 20, pady = 20)\\n\\n # image_color_mode_text = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n # bg = \\\"grey\\\", fg = \\\"white\\\")\\n # image_color_mode_text.grid(row = 2, column = 1)\\n\\n color_mode_combo_box = ttk.Combobox(toplevel_create_image, values = [\\n \\\"RGB\\\",\\n \\\"RGBA\\\",\\n \\\"CYMA\\\"\\n ])\\n color_mode_combo_box.current(0)\\n color_mode_combo_box.grid(row = 2, column = 1)\\n\\n # background color\\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \\\"red: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n image_background_color_label.grid(row = 3, column = 0, padx = 30)\\n\\n image_background_color_text_red = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n bg = \\\"grey\\\", fg = \\\"white\\\")\\n image_background_color_text_red.grid(row = 3, column = 1)\\n# -----------------------------------------------------------------------------------------------------------\\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \\\"green: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n image_background_color_label.grid(row = 4, column = 0, padx = 30)\\n\\n image_background_color_text_green = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n bg = \\\"grey\\\", fg = \\\"white\\\")\\n image_background_color_text_green.grid(row = 4, column = 1)\\n\\n# ----------------------------------------------------------------------------------------------------------\\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \\\"blue: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n image_background_color_label.grid(row = 5, column = 0, padx = 30)\\n\\n image_background_color_text_blue = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n bg = \\\"grey\\\", fg = \\\"white\\\")\\n image_background_color_text_blue.grid(row = 5, column = 1)\\n # create_new_image\\n def create_new_image():\\n new_image = Image.new(mode = (color_mode_combo_box.get()),\\n size = (int(image_width_text_box.get(\\\"1.0\\\", mw.tkinter.END)),\\n int(image_height_text_box.get(\\\"1.0\\\", mw.tkinter.END)) ),\\n color = ((int(image_background_color_text_red.get(\\\"1.0\\\", mw.tkinter.END))),\\n (int(image_background_color_text_green.get(\\\"1.0\\\", mw.tkinter.END))),\\n (int(image_background_color_text_blue.get(\\\"1.0\\\", mw.tkinter.END)))))\\n # get new image properties\\n the_width, the_height = new_image.size\\n # to-do clear the image\\n new_image_compatible = ImageTk.PhotoImage(new_image)\\n # load the image on the canvas \\n app.default_image_canvas.delete(\\\"all\\\")\\n # app.default_image_canvas = mw.tkinter.Canvas(toplevel_create_image, height = the_height, width = the_width)\\n app.default_image_canvas.create_image(0,0, image = new_image_compatible, anchor = mw.tkinter.NW)\\n # app.load_image_canvas.grid(row = 0, column = 1)\\n toplevel_create_image.destroy()\\n # to-do - correct error\\n app.default_image_canvas.configure(mw.MainWindow)\\n \\n\\n\\n # create_image_button\\n create_image_button = mw.tkinter.Button(toplevel_create_image, text = \\\"create image\\\",\\n bg = \\\"grey\\\", fg = \\\"white\\\", font = (\\\"times\\\", 13,\\\"bold\\\"),\\n command = create_new_image)\\n create_image_button.grid(row = 6, column = 0, padx = 40, pady = 20)\",\n \"def draw_boxes(self, image, boxes):\\n return draw_boxes(image, boxes, self.labels)\",\n \"def initrows(self):\\n #~ self.initrows2()\\n self.rows=[]\\n for yy in range(self.height):\\n row=[]\\n for xx in range(self.width):\\n if (xx,yy) in self.allsqs:\\n row.append(0)\\n #~ elif p in self.gatesqs:\\n #~ row.append(0)\\n else:\\n row.append(1)\\n self.rows.append(row)\",\n \"def rescale_box(box, img_size_orig, img_size_new):\\n orig_w, orig_h = img_size_orig\\n new_w, new_h = img_size_new\\n scale_x = new_w / orig_w\\n scale_y = new_h / orig_h\\n sx, sy, ex, ey = box\\n return [sx * scale_x, sy * scale_y, ex * scale_x, ey * scale_y]\",\n \"def __getitem__(self, index):\\n image_id = self.image_ids[index]\\n\\n filename = self.image_id_to_filename[image_id]\\n image_path = os.path.join(self.image_dir, filename)\\n\\n with open(image_path, 'rb') as f:\\n with PIL.Image.open(f) as image:\\n WW, HH = image.size\\n image = self.transform(image.convert('RGB'))\\n\\n H, W = self.image_size\\n objs, boxes, masks = [], [], []\\n\\n for object_data in self.image_id_to_objects[image_id]:\\n # objs.append(object_data['category_id'])\\n objs.append(int(object_data.find('name').get(\\\"id\\\")))\\n\\n bndbox = object_data.findall('bndbox')[0]\\n xmin = int(bndbox.find('xmin').text)\\n ymin = int(bndbox.find('ymin').text)\\n xmax = int(bndbox.find('xmax').text)\\n ymax = int(bndbox.find('ymax').text)\\n w = xmax - xmin\\n h = ymax - ymin\\n\\n boxes.append(torch.FloatTensor([xmin, ymin, xmax, ymax]))\\n\\n # This will give a numpy array of shape (HH, WW)\\n mask = torch.zeros(1, H, W)\\n # mask = seg_to_mask(object_data['segmentation'], WW, HH)\\n mask[:, round(ymin * H):max(round(ymin * H) + 1, round(ymax * H)),\\n round(xmin * W):max(round(xmin * W) + 1, round(xmax * W))] = 1\\n masks.append(mask)\\n # shuffle objs\\n O = len(objs)\\n rand_idx = list(range(O))\\n random.shuffle(rand_idx)\\n\\n objs = [objs[i] for i in rand_idx]\\n boxes = [boxes[i] for i in rand_idx]\\n masks = [masks[i] for i in rand_idx]\\n\\n objs = torch.LongTensor(objs)\\n boxes = torch.stack(boxes, dim=0)\\n masks = torch.stack(masks, dim=0)\\n\\n # print(image_path)\\n\\n return image, objs, boxes, masks\",\n \"def show_field(self, vehicles, type):\\n\\n # starting pixels x = 0, y = 0 on field image\\n start_x = 78\\n start_y = 45\\n\\n # block pixel width is slightly different per field size\\n if self.size == 6:\\n block_width = 72\\n elif self.size == 9:\\n block_width = 69\\n elif self.size == 12:\\n block_width = 68.5\\n\\n field = plt.imread(f\\\"data/RushHourImages/RushHour{self.size}.jpg\\\")\\n fig, ax = plt.subplots()\\n plt.imshow(field)\\n plt.axis('off')\\n\\n for vehicle in vehicles:\\n if vehicle.orientation == 'H':\\n x = start_x + (vehicle.x * block_width)\\n y = start_y + (vehicle.y * block_width)\\n if vehicle.length == 2:\\n car = plt.imread(f\\\"data/RushHourImages/Car{vehicle.id}.png\\\")\\n else:\\n car = plt.imread(f\\\"data/RushHourImages/Truck{vehicle.id}.png\\\")\\n\\n # truck: the image coordinate is his middle, which changes with the length of the car\\n x += 40\\n\\n if vehicle.orientation == 'V':\\n x = start_y + (vehicle.x * block_width)\\n y = start_x + (vehicle.y * block_width)\\n if vehicle.length == 2:\\n car = plt.imread(f\\\"data/RushHourImages/Car-rotated{vehicle.id}.png\\\")\\n else:\\n car = plt.imread(f\\\"data/RushHourImages/Truck-rotated{vehicle.id}.png\\\")\\n y += 40\\n\\n if self.size == 6:\\n imagebox = OffsetImage(car, zoom=0.6)\\n elif self.size == 9:\\n imagebox = OffsetImage(car, zoom=0.4)\\n elif self.size == 12:\\n imagebox = OffsetImage(car, zoom=0.3)\\n\\n imagebox.image.axes = ax\\n xy = (x, y)\\n ab = AnnotationBbox(imagebox, xy, frameon=False)\\n ax.add_artist(ab)\\n\\n if type == True:\\n plt.show(block=False)\\n plt.pause(0.001)\\n plt.close()\\n else:\\n plt.show()\",\n \"def proposal_boxes(self, fmap, im_sizes, image_offset, gt_boxes=None, gt_classes=None, gt_rels=None, train_anchor_inds=None, proposals=None):\\n assert proposals is not None\\n rois = filter_roi_proposals(proposals[:, 2:].data.contiguous(), proposals[:, 1].data.contiguous(), np.array([2000] * len(im_sizes)), nms_thresh=0.7, pre_nms_topn=12000 if self.training and self.mode == 'rpntrain' else 6000, post_nms_topn=2000 if self.training and self.mode == 'rpntrain' else 1000)\\n if self.training:\\n all_rois, labels, bbox_targets = proposal_assignments_det(rois, gt_boxes.data, gt_classes.data, image_offset, fg_thresh=0.5)\\n all_rois = torch.cat((all_rois, Variable(rois)), 0)\\n else:\\n all_rois = Variable(rois, volatile=True)\\n labels = None\\n bbox_targets = None\\n rpn_scores = None\\n rpn_box_deltas = None\\n rel_labels = None\\n return all_rois, labels, bbox_targets, rpn_scores, rpn_box_deltas, rel_labels\",\n \"def _to_image_coords(self, boxes, height, width):\\n box_coords = np.zeros_like(boxes)\\n box_coords[:, 0] = boxes[:, 0] * height\\n box_coords[:, 1] = boxes[:, 1] * width\\n box_coords[:, 2] = boxes[:, 2] * height\\n box_coords[:, 3] = boxes[:, 3] * width\\n \\n return box_coords\",\n \"def boxplots(self, groups, nrows, ncols, type):\\n fig, axs = plt.subplots(nrows=nrows, ncols=ncols, figsize=(6, 9.3), sharey=\\\"row\\\")\\n\\n fig.subplots_adjust(left=0.03, right=0.97, hspace=0.3, wspace=0.05)\\n\\n for ax, (effs, dat) in zip(axs, groups):\\n ax[0].boxplot(dat[\\\"perm\\\"])\\n ax[1].boxplot(dat[\\\"t_test\\\"])\\n ax[0].set_ylabel(\\\"Errors\\\")\\n if type == \\\"es\\\":\\n ax[0].set_title(f\\\"Effect size = {effs}, Test = Perm\\\")\\n ax[1].set_title(f\\\"Effect size = {effs}, Test = t-test\\\")\\n elif type == \\\"samp2\\\":\\n ax[0].set_title(f\\\"Sample size = {effs}, Test = Perm\\\")\\n ax[1].set_title(f\\\"Sample size = {effs}, Test = t-test\\\")\\n\\n\\n plt.tight_layout()\\n #plt.show()\",\n \"def draw_bboxes_withindex(img,boxes, uids):\\n source = Image.fromarray(img)\\n draw = ImageDraw.Draw(source)\\n w2,h2 = (img.shape[0],img.shape[1])\\n \\n font = ImageFont.truetype('/usr/share/fonts/truetype/freefont/FreeSerif.ttf', 40)\\n #font = ImageFont.truetype('arial.ttf', 24)\\n\\n\\n idx = 0\\n\\n for b in boxes:\\n xmin,ymin,xmax,ymax = b\\n \\n for j in range(3):\\n draw.rectangle(((xmin+j, ymin+j), (xmax+j, ymax+j)), outline=\\\"red\\\")\\n draw.text((xmin+20, ymin+70), str(uids[idx]), font = font)\\n idx +=1\\n return source\",\n \"def load_boxes(self, data):\\r\\n\\r\\n # worldbox represents the total map area\\r\\n self.worldbox = self.Box((0, 0), (len(data[0]) * self.cellwidth, len(data) * self.cellwidth))\\r\\n\\r\\n # create a box corresponding to each character/cell in the map file\\r\\n tl_x = 0\\r\\n tl_y = 0\\r\\n for row in data:\\r\\n for cell in row:\\r\\n if cell == \\\".\\\":\\r\\n self.wallboxes += [self.Box((tl_x, tl_y), (tl_x + self.cellwidth, tl_y + self.cellwidth))]\\r\\n elif cell == \\\"x\\\":\\r\\n self.targetboxes += [self.Box((tl_x, tl_y), (tl_x + self.cellwidth, tl_y + self.cellwidth))]\\r\\n tl_x += self.cellwidth\\r\\n tl_x = 0\\r\\n tl_y += self.cellwidth\",\n \"def layout_graphics(self):\\n # Graphics layout object to place viewboxes in\\n self.g_layout = pg.GraphicsLayoutWidget(border=(80, 80, 80))\\n self.g_layout.setCursor(QtCore.Qt.CrossCursor)\\n\\n # Viewboxes for images\\n # aspect locked so that pixels are square\\n # y inverted so that (0,0) is top left as in Thorlabs software\\n options = {\\\"lockAspect\\\":True, \\\"invertY\\\":True}\\n self.vb_image = self.g_layout.addViewBox(row=0, col=0, rowspan=2, **options)\\n self.vb_zoom = self.g_layout.addViewBox(row=0, col=2, **options)\\n self.vb_residuals = self.g_layout.addViewBox(row=1, col=2, **options)\\n\\n # Link zoom and residual views\\n self.vb_zoom.setXLink(self.vb_residuals)\\n self.vb_zoom.setYLink(self.vb_residuals)\\n\\n # Viewboxes for slice data\\n # Both boxes have mouse disabled - range is fixed so we don't want to\\n # scale them accidentally\\n # Y box has y inverted to match the main image\\n # Y box has x inverted so that zero pixel value is far from the image\\n options = {\\\"enableMouse\\\":False, \\\"enableMenu\\\": False}\\n self.vb_x = self.g_layout.addViewBox(row=2, col=0, **options)\\n self.vb_y = self.g_layout.addViewBox(row=0, col=1, rowspan=2,\\n invertX=True, invertY=True, **options)\\n\\n # Link the slice axes to the main image so that when we zoom/pan the\\n # main image, our slices zoom/pan also\\n self.vb_x.setXLink(self.vb_image)\\n self.vb_y.setYLink(self.vb_image)\\n\\n # Disable autoscaling and fix range to maximum pixel intensity\\n self.vb_x.setRange(yRange=(0,255))\\n self.vb_y.setRange(xRange=(0,255))\\n self.vb_x.disableAutoRange(axis=self.vb_x.YAxis)\\n self.vb_y.disableAutoRange(axis=self.vb_y.XAxis)\\n\\n # Background color must not be black so that we can see where images\\n # start/end\\n color = pg.mkColor(40,40,40)\\n self.vb_image.setBackgroundColor(color)\\n self.vb_zoom.setBackgroundColor(color)\\n self.vb_residuals.setBackgroundColor(color)\\n self.vb_x.setBackgroundColor(color)\\n self.vb_y.setBackgroundColor(color)\\n self.g_layout.setBackground(color)\\n\\n self.vb_image.addItem(self.image)\\n self.vb_image.addItem(self.fit_v_line)\\n self.vb_image.addItem(self.fit_h_line)\\n self.vb_image.addItem(self.mark_v_line)\\n self.vb_image.addItem(self.mark_h_line)\\n # self.vb_image.addItem(self.cursor_text)\\n self.vb_image.addItem(self.cursor_delta)\\n self.vb_image.addItem(self.beam_delta)\\n self.vb_image.addItem(self.history_plot)\\n # Figure out how to overlay properly?\\n # self.vb_image.addItem(self.x_slice)\\n # self.vb_image.addItem(self.x_fit)\\n # self.vb_image.addItem(self.y_slice)\\n # self.vb_image.addItem(self.y_fit)\\n self.vb_zoom.addItem(self.zoom)\\n self.vb_zoom.addItem(self.fit_maj_line)\\n self.vb_zoom.addItem(self.fit_min_line)\\n self.vb_zoom.addItem(self.zoom_text)\\n self.vb_residuals.addItem(self.residuals)\\n self.vb_residuals.addItem(self.residuals_text)\\n self.vb_x.addItem(self.x_slice)\\n self.vb_x.addItem(self.x_fit)\\n self.vb_x.addItem(self.cursor_v)\\n self.vb_y.addItem(self.y_slice)\\n self.vb_y.addItem(self.y_fit)\\n self.vb_y.addItem(self.cursor_h)\\n\\n self.res_legend.setParentItem(self.vb_residuals)\\n self.cursor_text.setParentItem(self.vb_image)\\n\\n self.vb_image.setRange(QtCore.QRectF(0, 0, 1280, 1024))\\n self.vb_zoom.setRange(QtCore.QRectF(0, 0, 50, 50))\\n self.vb_residuals.setRange(QtCore.QRectF(0, 0, 50, 50))\\n\\n #\\n # Size hints below here\\n #\\n self.g_layout.ci.layout.setColumnStretchFactor(0, 4)\\n self.g_layout.ci.layout.setColumnStretchFactor(1, 1)\\n self.g_layout.ci.layout.setColumnStretchFactor(2, 2)\\n self.g_layout.ci.layout.setRowStretchFactor(0, 2)\\n self.g_layout.ci.layout.setRowStretchFactor(1, 2)\\n self.g_layout.ci.layout.setRowStretchFactor(2, 1)\\n\\n self.vb_x.setMinimumHeight(50)\\n self.vb_y.setMinimumWidth(50)\\n self.vb_x.setMaximumHeight(100)\\n self.vb_y.setMaximumWidth(100)\\n self.vb_image.setMinimumSize(640, 512)\\n self.vb_zoom.setMinimumSize(320, 320)\\n self.vb_residuals.setMinimumSize(320, 320)\\n\\n self.g_layout.setMinimumSize(1100,562)\",\n \"def plantGrid(name, minimum, maximum, spacing):\\n name = sys.argv[1]\\n minimum = sys.argv[2]\\n maximum = sys.argv[3]\\n minimum = int(minimum)\\n maximum = int(maximum)\\n #convert to flux\\n min1 = conversion(minimum)\\n max1 = conversion(maximum)\\n min1 = int(min1)\\n max1 = int(max1)\\n #brightness = [random.uniform(min1, max1) for _ in xrange(len(position))]\\n #print brightness\\n spacing = sys.argv[4]\\n spacing = float(spacing)\\n print len(data1)\\n #create the position array for x values\\n x = np.arange(6, len(data1), spacing)\\n #create the position array for y values\\n y = np.arange(6, len(data1), spacing)\\n x2 = np.arange(6, len(data1), spacing)\\n y2 = np.flipud(y)\\n \\n #combine both arrays to form a grid\\n position = np.column_stack((x,y))\\n position2 = np.column_stack((x2,y2))\\n \\n #combine both lines of grid to one array\\n position = np.concatenate((position, position2), axis = 0)\\n \\n #create a random brightness array between the min and max values\\n brightness = np.array([random.uniform(min1, max1) for _ in range(0,len(position))])\\n \\n #add to image file and subtract\\n fakestars.addtofits(name, out_file, psf, position, brightness, coordsys, verbose)\\n fakestars.addtofits(name, outfile2, psf, position, brightness, coordsys, verbose)\\n imarith.imsubtract(out_file, outfile2, differenceFile, clobber=True)\",\n \"def prepare_map(self):\\n for y, row in enumerate(self.contents):\\n for x, tile in enumerate(row):\\n bm = self.get_tile(tile)\\n self.image[\\n y * TILE_SIZE : (y + 1) * TILE_SIZE,\\n x * TILE_SIZE : (x + 1) * TILE_SIZE,\\n ] = bm\",\n \"def scale_box(box, img_size):\\n xscale = img_size[0] / FLAGS.size\\n yscale = img_size[1] / FLAGS.size\\n x0, y0, x1, y1 = box\\n return [\\n float(x0) * xscale,\\n float(y0) * yscale,\\n float(x1) * xscale,\\n float(y1) * yscale,\\n ]\",\n \"def initialize(self, frame):\\n self.grid_size = 5\\n\\n Label(frame, text=\\\"Grid Size:\\\").grid(row=0)\\n\\n self.e1 = Scale(frame, from_=self.grid_size, to=25, orient=HORIZONTAL)\\n self.e1.grid(row=0, column=1)\\n\\n return self.e1\",\n \"def make(self) -> None:\\n\\n # arbitrarily selecting the first image from the list, index 0\\n with Image.open(self.image_list[0]) as first_frame_image_in_list:\\n\\n # Find the width and height of the first image of the list.\\n # Assuming all the images have same size.\\n frame_image_width, frame_image_height = first_frame_image_in_list.size\\n\\n # scale is the ratio of collage_image_width and product of\\n # images_per_row_in_collage with frame_image_width.\\n\\n # The scale will always lie between 0 and 1, which implies that\\n # the images are always going to get downsized.\\n scale = (self.collage_image_width) / (\\n self.images_per_row_in_collage * frame_image_width\\n )\\n\\n # Calculating the scaled height and width for the frame image.\\n scaled_frame_image_width = ceil(frame_image_width * scale)\\n scaled_frame_image_height = ceil(frame_image_height * scale)\\n\\n # Divide the number of images by images_per_row_in_collage. The later\\n # was calculated by taking the square root of total number of images.\\n number_of_rows = ceil(self.number_of_images / self.images_per_row_in_collage)\\n\\n # Multiplying the height of one downsized image with number of rows.\\n # Height of 1 downsized image is product of scale and frame_image_height\\n # Total height is number of rows times the height of one downsized image.\\n self.collage_image_height = ceil(scale * frame_image_height * number_of_rows)\\n\\n # Create an image of passed collage_image_width and calculated collage_image_height.\\n # The downsized images will be pasted on this new base image.\\n # The image is 0,0,0 RGB(black).\\n collage_image = Image.new(\\n \\\"RGB\\\", (self.collage_image_width, self.collage_image_height)\\n )\\n\\n # keep track of the x and y coordinates of the resized frame images\\n i, j = (0, 0)\\n\\n # iterate the frames and paste them on their position on the collage_image\\n for count, frame_path in enumerate(self.image_list):\\n\\n # Set the x coordinate to zero if we are on the first column\\n # If self.images_per_row_in_collage is 4\\n # then 0,4,8 and so on should have their x coordinate as 0\\n if (count % self.images_per_row_in_collage) == 0:\\n i = 0\\n\\n # open the frame image, must open it to resize it using the thumbnail method\\n frame = Image.open(frame_path)\\n\\n # scale the opened frame images\\n frame.thumbnail(\\n (scaled_frame_image_width, scaled_frame_image_height), Image.ANTIALIAS\\n )\\n\\n # set the value of x to that of i's value.\\n # i is set to 0 if we are on the first column.\\n x = i\\n\\n # It ensures that y coordinate stays the same for any given row.\\n # The floor of a real number is the largest integer that is less\\n # than or equal to the number. floor division is used because of\\n # the zero based indexing, the floor of the division stays same\\n # for an entier row as the decimal values are negled by the floor.\\n # for the first row the result of floor division is always zero and\\n # the product of 0 with scaled_frame_image_height is also zero, they\\n # y coordinate for the first row is 0.\\n # For the second row the result of floor division is one and the prodcut\\n # with scaled_frame_image_height ensures that the y coordinate is\\n # scaled_frame_image_height below the first row.\\n y = (j // self.images_per_row_in_collage) * scaled_frame_image_height\\n\\n # paste the frame image on the newly created base image(base image is black)\\n collage_image.paste(frame, (x, y))\\n frame.close()\\n\\n # increase the x coordinate by scaled_frame_image_width\\n # to get the x coordinate of the next frame. unless the next image\\n # will be on the very first column this will be the x coordinate.\\n i = i + scaled_frame_image_width\\n\\n # increase the value of j by 1, this is to calculate the y coordinate of\\n # next image. The increased number will be floor divided by images_per_row_in_collage\\n # therefore the y coordinate stays the same for any given row.\\n j += 1\\n\\n # save the base image with all the scaled frame images embeded on it.\\n collage_image.save(self.output_path)\\n collage_image.close()\",\n \"def _build_meds_layout(self):\\n\\n\\n nim = self.image_info.size\\n nobj = self.obj_data.size\\n\\n trim_to_coadd = self.get('trim_to_coadd',False)\\n if trim_to_coadd:\\n print(' trimming to coadd')\\n coadd_wcs, coadd_pos, coadd_bnds, coadd_q = \\\\\\n self._get_pos_and_bounds(self.obj_data, 0)\\n in_bnds = coadd_bnds.contains_points(coadd_pos['zrow'], coadd_pos['zcol'])\\n w_in_bnds, = np.where(in_bnds == True)\\n assert w_in_bnds.size > 0,\\\"none found in coadd\\\"\\n\\n w_in_bnds = coadd_q[w_in_bnds]\\n self.obj_data = self.obj_data[w_in_bnds]\\n\\n self._do_psf_setup()\\n\\n # box sizes are even\\n half_box_size = self.obj_data['box_size']//2\\n\\n for file_id in range(nim):\\n\\n wcs, pos, bnds, q = self._get_pos_and_bounds(self.obj_data, file_id)\\n\\n # do the test\\n in_bnds = bnds.contains_points(pos['zrow'], pos['zcol'])\\n q_rc, = np.where(in_bnds == True)\\n print(' second cut: %6d of %6d objects' % (len(q_rc),len(q)))\\n\\n # now make sure everything is there\\n if self['check_in_first_image']:\\n if file_id == 0 and len(self.obj_data['ra']) != len(q_rc):\\n raise MEDSCreationError('Not all objects were found in first image for '\\n 'MEDS making (which is the coadd/detection '\\n 'image by convention).')\\n # compose them\\n q = q[q_rc]\\n\\n # fill in the object_data structure\\n\\n # note q_rc since pos was created using obj_data[q]\\n qrow = pos['zrow'][q_rc]\\n qcol = pos['zcol'][q_rc]\\n\\n icut = self.obj_data['ncutout'][q]\\n self.obj_data['file_id'][q,icut] = file_id\\n self.obj_data['orig_row'][q,icut] = qrow\\n self.obj_data['orig_col'][q,icut] = qcol\\n\\n # this results in the object center being close to\\n # the natural center (dim-1.)/2.\\n ostart_row = qrow.astype('i4') - half_box_size[q] + 1\\n ostart_col = qcol.astype('i4') - half_box_size[q] + 1\\n crow = qrow - ostart_row\\n ccol = qcol - ostart_col\\n\\n self.obj_data['orig_start_row'][q,icut] = ostart_row\\n self.obj_data['orig_start_col'][q,icut] = ostart_col\\n self.obj_data['cutout_row'][q,icut] = crow\\n self.obj_data['cutout_col'][q,icut] = ccol\\n\\n # do jacobian, in original, not-offset coords\\n # note q_rc since pos was created using self.obj_data[q]\\n jacob = wcs.get_jacobian(\\n x=pos['wcs_col'][q_rc],\\n y=pos['wcs_row'][q_rc])\\n\\n # jacob is a tuple of arrays\\n self.obj_data['dudcol'][q,icut] = jacob[0]\\n self.obj_data['dudrow'][q,icut] = jacob[1]\\n self.obj_data['dvdcol'][q,icut] = jacob[2]\\n self.obj_data['dvdrow'][q,icut] = jacob[3]\\n\\n # increment\\n self.obj_data['ncutout'][q] += 1\\n\\n w,=np.where(self.obj_data['ncutout'] > 0)\\n print('%d/%d had ncut > 0' % (w.size, self.obj_data.size))\\n #self.obj_data = self.obj_data[w]\\n\\n self.obj_data = self._make_resized_data(self.obj_data)\\n print('setting number field as sequential')\\n self.obj_data['number'] = 1+np.arange(self.obj_data.size)\\n\\n\\n self._set_start_rows_and_pixel_count()\\n\\n if self['survey']=='cosmos':\\n self._set_psf_layout_hst()\\n else:\\n self._set_psf_layout_psfex()\",\n \"def set_default_parameters(self):\\n super().set_default_parameters()\\n if not \\\"region_size\\\" in vars(self):\\n self.region_size = 0.08\\n if not \\\"RGB_bands\\\" in vars(self):\\n self.RGB_bands = [\\\"B4\\\",\\\"B3\\\",\\\"B2\\\"]\\n if not \\\"split_RGB_images\\\" in vars(self):\\n self.split_RGB_images = True\\n # in PROCESSED dir we expect RGB. NDVI, BWNDVI\\n self.num_files_per_point = 3\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6761654","0.6085298","0.6009164","0.58949316","0.58541226","0.58446145","0.5767578","0.5712032","0.5706543","0.5674811","0.5674811","0.5674811","0.5674811","0.5674811","0.5668548","0.5650026","0.5615289","0.5615289","0.5593645","0.55755764","0.55713177","0.55709535","0.5566756","0.5561757","0.55550766","0.55439216","0.55324256","0.5499715","0.5493037","0.5491024","0.5488773","0.54860556","0.5479351","0.5477189","0.54661876","0.54654974","0.5462513","0.5436562","0.54347384","0.5429081","0.54147685","0.5409667","0.54019666","0.5395863","0.5394675","0.5392269","0.5371903","0.53668004","0.53408337","0.53349805","0.533052","0.53242874","0.52984256","0.529094","0.5273975","0.5269214","0.5264517","0.5261543","0.5260264","0.5256314","0.52466404","0.52401096","0.52370954","0.52364236","0.52281755","0.52137214","0.52120256","0.5209313","0.52089477","0.5208163","0.5206278","0.52018976","0.51996654","0.51974803","0.5184914","0.51843166","0.51824045","0.5175214","0.517447","0.51738864","0.517314","0.51640254","0.5162107","0.51584274","0.5151213","0.51493704","0.5145289","0.5140283","0.51401466","0.51368606","0.5136106","0.51344085","0.51342916","0.5132771","0.5125228","0.5124148","0.512393","0.512312","0.5120537","0.51197904"],"string":"[\n \"0.6761654\",\n \"0.6085298\",\n \"0.6009164\",\n \"0.58949316\",\n \"0.58541226\",\n \"0.58446145\",\n \"0.5767578\",\n \"0.5712032\",\n \"0.5706543\",\n \"0.5674811\",\n \"0.5674811\",\n \"0.5674811\",\n \"0.5674811\",\n \"0.5674811\",\n \"0.5668548\",\n \"0.5650026\",\n \"0.5615289\",\n \"0.5615289\",\n \"0.5593645\",\n \"0.55755764\",\n \"0.55713177\",\n \"0.55709535\",\n \"0.5566756\",\n \"0.5561757\",\n \"0.55550766\",\n \"0.55439216\",\n \"0.55324256\",\n \"0.5499715\",\n \"0.5493037\",\n \"0.5491024\",\n \"0.5488773\",\n \"0.54860556\",\n \"0.5479351\",\n \"0.5477189\",\n \"0.54661876\",\n \"0.54654974\",\n \"0.5462513\",\n \"0.5436562\",\n \"0.54347384\",\n \"0.5429081\",\n \"0.54147685\",\n \"0.5409667\",\n \"0.54019666\",\n \"0.5395863\",\n \"0.5394675\",\n \"0.5392269\",\n \"0.5371903\",\n \"0.53668004\",\n \"0.53408337\",\n \"0.53349805\",\n \"0.533052\",\n \"0.53242874\",\n \"0.52984256\",\n \"0.529094\",\n \"0.5273975\",\n \"0.5269214\",\n \"0.5264517\",\n \"0.5261543\",\n \"0.5260264\",\n \"0.5256314\",\n \"0.52466404\",\n \"0.52401096\",\n \"0.52370954\",\n \"0.52364236\",\n \"0.52281755\",\n \"0.52137214\",\n \"0.52120256\",\n \"0.5209313\",\n \"0.52089477\",\n \"0.5208163\",\n \"0.5206278\",\n \"0.52018976\",\n \"0.51996654\",\n \"0.51974803\",\n \"0.5184914\",\n \"0.51843166\",\n \"0.51824045\",\n \"0.5175214\",\n \"0.517447\",\n \"0.51738864\",\n \"0.517314\",\n \"0.51640254\",\n \"0.5162107\",\n \"0.51584274\",\n \"0.5151213\",\n \"0.51493704\",\n \"0.5145289\",\n \"0.5140283\",\n \"0.51401466\",\n \"0.51368606\",\n \"0.5136106\",\n \"0.51344085\",\n \"0.51342916\",\n \"0.5132771\",\n \"0.5125228\",\n \"0.5124148\",\n \"0.512393\",\n \"0.512312\",\n \"0.5120537\",\n \"0.51197904\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62900573"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":196,"cells":{"query":{"kind":"string","value":"set the box sizes and start row for each psf image"},"document":{"kind":"string","value":"def _set_psf_layout_psfex(self):\n\n print('setting psf layout for PSFEx')\n\n obj_data=self.obj_data\n psf_data=self.psf_data\n\n total_psf_pixels = 0\n\n #psf_npix = psf_size*psf_size\n\n psf_start_row = 0\n for iobj in range(obj_data.size):\n for icut in range(obj_data['ncutout'][iobj]):\n\n row = obj_data['orig_row'][iobj, icut]\n col = obj_data['orig_col'][iobj, icut]\n file_id = obj_data['file_id'][iobj,icut]\n\n p = psf_data[file_id]\n\n pim = p.get_rec(row,col)\n cen = p.get_center(row,col)\n\n psf_shape = pim.shape\n psf_npix = pim.size\n\n obj_data['psf_row_size'][iobj,icut] = psf_shape[0]\n obj_data['psf_col_size'][iobj,icut] = psf_shape[1]\n obj_data['psf_cutout_row'][iobj,icut] = cen[0]\n obj_data['psf_cutout_col'][iobj,icut] = cen[1]\n obj_data['psf_start_row'][iobj,icut] = psf_start_row\n\n psf_start_row += psf_npix\n total_psf_pixels += psf_npix\n\n\n self.total_psf_pixels = total_psf_pixels"},"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 _set_psf_layout_hst(self):\n\n print('setting psf layout for HST')\n obj_data=self.obj_data\n\n total_psf_pixels = 0\n psf_start_row = 0\n\n for iobj in range(obj_data.size):\n if (iobj+1) % 100 == 0:\n print(' %d/%d' % (iobj+1,obj_data.size))\n\n # note assuming same psf for all \"epochs\"\n psf_im = self.psf_data.get_psf(iobj)\n\n psf_shape = psf_im.shape\n psf_npix = psf_im.size\n\n cen = (np.array(psf_shape)-1.0)/2.0\n\n # we will expand the psfs\n\n for icut in range(obj_data['ncutout'][iobj]):\n\n obj_data['psf_row_size'][iobj,icut] = psf_shape[0]\n obj_data['psf_col_size'][iobj,icut] = psf_shape[1]\n obj_data['psf_cutout_row'][iobj,icut] = cen[0]\n obj_data['psf_cutout_col'][iobj,icut] = cen[1]\n obj_data['psf_start_row'][iobj,icut] = psf_start_row\n\n psf_start_row += psf_npix\n total_psf_pixels += psf_npix\n\n self.total_psf_pixels = total_psf_pixels","def generate_boxes(self, img):\r\n return [Box(left, top, img) for (left, top) in self.coords]","def build_filler_images(self):","def draw_boxes(self, im, boxes):\n for bbox in boxes:\n l = [int(x) for x in bbox[\"coords\"]]\n l = self.scalebox(l)\n icon = self.classes_to_icons[bbox[\"label\"]]\n overlay_im_to_background(im, icon, l[0], l[1] - icon.shape[0] - 5)\n cv2.rectangle(im,(l[0],l[1]),(l[2],l[3]),self.color,2)","def makeImage(self):\n\n for row in range(self.height):\n self.makeRow(row)\n self.window.update() # display a row of pixels","def _get_boxes(self, idx):\n # Load Image\n path = self.df.hsi_path.iloc[idx]\n im = self._load_im(path)\n\n # Crop out box\n r_box_im = self.df.width.iloc[idx] / im.shape[-1] # Ratio of RGB im box coords to load im width (e.g., r=10 for hsi)\n box = np.array([self.df.ymin.iloc[idx], self.df.ymax.iloc[idx], self.df.xmin.iloc[idx], self.df.xmax.iloc[idx]])\n box = np.around(box / r_box_im).astype(int)\n\n crop_im = im[:, box[0]:box[1]+1, box[2]:box[3]+1]\n if np.any(np.array(crop_im.shape) == 0):\n print('[WARNING] Loaded box has zero shape and is sketchily inflated. TODO: skip this box with ID', idx)\n if box[0] == self.df.width.iloc[idx]/r_box_im: box[0] -= 1\n if box[2] == self.df.height.iloc[idx]/r_box_im: box[2] -= 1\n crop_im = im[:, box[0]:box[1]+1, box[2]:box[3]+1]\n\n target = {}\n target[\"labels\"] = self.df.class_id.iloc[idx]\n target[\"uid\"] = self.df.uid.iloc[idx]\n \n\n return crop_im, target","def _get_box_sizes(self, image_info, cat):\n\n\n file_id=0\n impath=image_info['image_path'][file_id].strip()\n ext=image_info['image_ext'][file_id]\n wcs_data = fitsio.read_header(impath, ext=ext)\n wcs = eu.wcsutil.WCS(wcs_data)\n\n\n jacob = wcs.get_jacobian(100,100)\n dudcol, dudrow, dvdcol, dvdrow = jacob\n\n det = dvdrow*dudcol - dvdcol*dudrow\n pixel_scale = np.sqrt(abs(det))\n print('found pixel scale:',pixel_scale)\n box_size = cat['box_size_arcsec']/pixel_scale\n\n # clip to range\n box_size.clip(\n min=self['min_box_size'],\n max=self['max_box_size'],\n out=box_size,\n )\n box_size = box_size.astype('i4')\n\n w,=np.where( ( (box_size % 2) != 0 ) )\n if w.size > 0:\n box_size[w] += 1\n\n return box_size","def setBoxsize(length,width,height):\n return length,width,height","def draw_boxs(img,boxs,width=3,color=(0,0,255)):\n box_img = copy.deepcopy(img)\n for i in range(boxs.shape[0]):\n # x1,y1,x2,y2=boxs[i]\n x1 = boxs[i][0]\n y1 = boxs[i][1]\n x2 = boxs[i][2]\n y2 = boxs[i][3]\n p1 = (int(round(x1)),int(round(y1)))\n p2 = (int(round(x2)),int(round(y2)))\n cv2.rectangle(box_img, p1, p2, color, width)\n\n return box_img","def setUp(self):\r\n center = [1,1]\r\n size = 1\r\n self.imageinfo = ImageInfo(center, size)","def setUp(self):\r\n center = [1,1]\r\n size = 1\r\n self.imageinfo = ImageInfo(center, size)","def setUp(self):\r\n center = [1,1]\r\n size = 1\r\n self.imageinfo = ImageInfo(center, size)","def setUp(self):\r\n center = [1,1]\r\n size = 1\r\n self.imageinfo = ImageInfo(center, size)","def setUp(self):\r\n center = [1,1]\r\n size = 1\r\n self.imageinfo = ImageInfo(center, size)","def __init__(self, nb_sub_images, window_size, recovery, image_horiz_size):\n self.nb_sub_images = nb_sub_images\n self.window_size = window_size\n self.recovery = recovery\n self.image_horiz_size = image_horiz_size","def _resize_bboxes(self, results):\n img_shape = results['img_shape']\n for key in results.get('bbox_fields', []):\n bboxes = []\n for box in results[key]:\n tmp_box = np.array(box, dtype=np.float32)\n tmp_box[0::2] *= results['scale_factor'][0]\n tmp_box[1::2] *= results['scale_factor'][1]\n if self.bbox_clip_border:\n tmp_box[0::2] = np.clip(tmp_box[0::2], 0, img_shape[1])\n tmp_box[1::2] = np.clip(tmp_box[1::2], 0, img_shape[0])\n bboxes.append(tmp_box)\n if len(results[key]) > 0:\n results[key] = bboxes","def _resize_bboxes(self, results):\n for key in results.get('bbox_fields', []):\n bboxes = results[key] * results['scale_factor']\n if self.bbox_clip_border:\n img_shape = results['img_shape']\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])\n results[key] = bboxes","def _resize_bboxes(self, results):\n for key in results.get('bbox_fields', []):\n bboxes = results[key] * results['scale_factor']\n if self.bbox_clip_border:\n img_shape = results['img_shape']\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])\n results[key] = bboxes","def set_box(self) -> None:\n from pymol import cmd\n\n # Delete Box object in PyMOL\n if \"box\" in cmd.get_names(\"selections\"):\n cmd.delete(\"box\")\n # Get dimensions of selected residues\n selection = \"sele\"\n if selection in cmd.get_names(\"selections\"):\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(selection)\n else:\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(\"\")\n \n # Get center of each dimension (x, y, z)\n self.x = (min_x + max_x) / 2\n self.y = (min_y + max_y) / 2\n self.z = (min_z + max_z) / 2\n\n # Set Box variables in interface\n self.min_x.setValue(round(self.x - (min_x - self.padding.value()), 1))\n self.max_x.setValue(round((max_x + self.padding.value()) - self.x, 1))\n self.min_y.setValue(round(self.y - (min_y - self.padding.value()), 1))\n self.max_y.setValue(round((max_y + self.padding.value()) - self.y, 1))\n self.min_z.setValue(round(self.z - (min_z - self.padding.value()), 1))\n self.max_z.setValue(round((max_z + self.padding.value()) - self.z, 1))\n self.angle1.setValue(0)\n self.angle2.setValue(0)\n\n # Setting background box values\n self.min_x_set = self.min_x.value()\n self.max_x_set = self.max_x.value()\n self.min_y_set = self.min_y.value()\n self.max_y_set = self.max_y.value()\n self.min_z_set = self.min_z.value()\n self.max_z_set = self.max_z.value()\n self.angle1_set = self.angle1.value()\n self.angle2_set = self.angle2.value()\n self.padding_set = self.padding.value()\n\n # Draw box\n self.draw_box()\n\n # Enable/Disable buttons\n self.button_draw_box.setEnabled(False)\n self.button_redraw_box.setEnabled(True)\n self.min_x.setEnabled(True)\n self.min_y.setEnabled(True)\n self.min_z.setEnabled(True)\n self.max_x.setEnabled(True)\n self.max_y.setEnabled(True)\n self.max_z.setEnabled(True)\n self.angle1.setEnabled(True)\n self.angle2.setEnabled(True)","def analyzeImages(path, name_type, box1_size, box2_size, box3_size, box4_size, box5_size):\n \n folders = [f for f in sorted(glob.glob(path + \"/**\"))]\n \n for folder in folders: \n \n # to save this data frame in a csv file\n \n files = [f for f in sorted(glob.glob(folder + \"/**\" + \".jpg\"))]\n \n centroidsDf = pd.DataFrame(np.zeros([len(files), 11]),columns=[\"frame\", \"fly1_x\", \"fly1_y\", \"fly2_x\", \"fly2_y\", \"fly3_x\", \"fly3_y\", \"fly4_x\", \"fly4_y\", \"fly5_x\", \"fly5_y\"]);\n headsDf = pd.DataFrame(np.zeros([len(files), 11]),columns=[\"frame\", \"fly1_x\", \"fly1_y\", \"fly2_x\", \"fly2_y\", \"fly3_x\", \"fly3_y\", \"fly4_x\", \"fly4_y\", \"fly5_x\", \"fly5_y\"]);\n \n img_array1 = []\n img_array2 = []\n img_array3 = []\n img_array4 = []\n img_array5 = []\n\n for file in files:\n \n print(file)\n \n centroidsDf[\"frame\"][files.index(file)] = files.index(file)+1\n headsDf[\"frame\"][files.index(file)] = files.index(file)+1\n \n img = cv2.imread(file)\n \n ## FLY 1 ##\n\n box1 = img[box1_size[0]:box1_size[1], box1_size[2]:box1_size[3]]\n \n # image processing to get the centroid and head positions\n x_centroid, y_centroid, x_head, y_head = findCentroid(box1, file) \n \n # add the centroid and head locations on the image \n box1 = cv2.circle(box1, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\n box1 = cv2.circle(box1, (x_head, y_head), 7, (0, 0, 255), -1)\n img_array1.append(box1)\n \n # add the positions in the final data frame\n centroidsDf[\"fly1_x\"][files.index(file)] = x_centroid\n centroidsDf[\"fly1_y\"][files.index(file)] = y_centroid\n \n headsDf[\"fly1_x\"][files.index(file)] = x_head\n headsDf[\"fly1_y\"][files.index(file)] = y_head\n \n ## FLY 2 ##\n \n box2 = img[box2_size[0]:box2_size[1], box2_size[2]:box2_size[3]]\n \n # image processing to get the centroid and head positions\n x_centroid, y_centroid, x_head, y_head = findCentroid(box2, file)\n \n # add the centroid and head locations on the image \n box2 = cv2.circle(box2, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\n box2 = cv2.circle(box2, (x_head, y_head), 7, (0, 0, 255), -1)\n img_array2.append(box2)\n \n # add the positions in the final data frame \n centroidsDf[\"fly2_x\"][files.index(file)] = x_centroid\n centroidsDf[\"fly2_y\"][files.index(file)] = y_centroid\n \n headsDf[\"fly2_x\"][files.index(file)] = x_head\n headsDf[\"fly2_y\"][files.index(file)] = y_head\n \n ## FLY 3 ##\n\n box3 = img[box3_size[0]:box3_size[1], box3_size[2]:box3_size[3]]\n \n # image processing to get the centroid and head positions\n x_centroid, y_centroid, x_head, y_head = findCentroid(box3, file)\n \n # add the centroid and head locations on the image \n box3 = cv2.circle(box3, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\n box3 = cv2.circle(box3, (x_head, y_head), 7, (0, 0, 255), -1)\n img_array3.append(box3)\n\n # add the positions in the final data frame\n centroidsDf[\"fly3_x\"][files.index(file)] = x_centroid\n centroidsDf[\"fly3_y\"][files.index(file)] = y_centroid\n \n headsDf[\"fly3_x\"][files.index(file)] = x_head\n headsDf[\"fly3_y\"][files.index(file)] = y_head\n \n ## FLY 4 ##\n \n box4 = img[box4_size[0]:box4_size[1], box4_size[2]:box4_size[3]]\n \n # image processing to get the centroid and head positions\n x_centroid, y_centroid, x_head, y_head = findCentroid(box4, file)\n \n # add the centroid and head locations on the image \n box4 = cv2.circle(box4, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\n box4 = cv2.circle(box4, (x_head, y_head), 7, (0, 0, 255), -1)\n img_array4.append(box4)\n \n # add the positions in the final data frame\n centroidsDf[\"fly4_x\"][files.index(file)] = x_centroid\n centroidsDf[\"fly4_y\"][files.index(file)] = y_centroid\n \n headsDf[\"fly4_x\"][files.index(file)] = x_head\n headsDf[\"fly4_y\"][files.index(file)] = y_head\n \n ## FLY 5 ##\n \n # the fifth fly is not present in all the genetic strains \n if (box5_size != []):\n box5 = img[box5_size[0]:box5_size[1], box5_size[2]:box5_size[3]]\n \n # image processing to get the centroid and head positions\n x_centroid, y_centroid, x_head, y_head = findCentroid(box5, file)\n \n # add the centroid and head locations on the image \n box5 = cv2.circle(box5, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\n box5 = cv2.circle(box5, (x_head, y_head), 7, (0, 0, 255), -1)\n img_array5.append(box5)\n \n # add the positions in the final data frame\n centroidsDf[\"fly5_x\"][files.index(file)] = x_centroid\n centroidsDf[\"fly5_y\"][files.index(file)] = y_centroid\n \n headsDf[\"fly5_x\"][files.index(file)] = x_head\n headsDf[\"fly5_y\"][files.index(file)] = y_head\n \n # save the data frame in a .csv file, \n # one for the centroids and one for the heads\n #centroidsDf.to_csv(folder+\"/centroids.csv\", index = None, header=True)\n #headsDf.to_csv(folder+\"/heads.csv\", index = None, header=True)\n \n \n ## CREATE THE VIDEOS ##\n \n height, width, _ = box1.shape\n size = (width,height)\n out = cv2.VideoWriter(folder+name_type+'_1_' + str(folders.index(folder)+1)+ '.mp4',cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\n for i in range(len(img_array1)):\n out.write(img_array1[i])\n out.release()\n \n height, width, _ = box2.shape\n size = (width,height)\n out = cv2.VideoWriter(folder+name_type+'_2_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\n for i in range(len(img_array2)):\n out.write(img_array2[i])\n out.release()\n \n height, width, _ = box3.shape\n size = (width,height)\n out = cv2.VideoWriter(folder+name_type+'_3_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\n for i in range(len(img_array3)):\n out.write(img_array3[i])\n out.release()\n \n height, width, _ = box4.shape\n size = (width,height)\n out = cv2.VideoWriter(folder+name_type+'_4_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\n for i in range(len(img_array4)):\n out.write(img_array4[i])\n out.release()\n \n if (box5_size != []):\n height, width, _ = box5.shape\n size = (width,height)\n out = cv2.VideoWriter(folder+name_type+'_5_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\n for i in range(len(img_array5)):\n out.write(img_array5[i])\n out.release()","def _iter_images_rects(self):\n image_x = self._margin\n image_y = self._margin\n total_width = self.width - 2 * self._margin\n total_height = self.height - self._texts_height - 2 * self._margin\n\n if len(self._images) == 1:\n image_width = total_width\n image_height = total_height\n elif 2 <= len(self._images) < 4:\n if self.is_portrait:\n image_width = total_width\n image_height = (total_height - (len(self._images) - 1) * self._margin) // len(self._images)\n else:\n image_width = (total_width - (len(self._images) - 1) * self._margin) // len(self._images)\n image_height = total_height\n else:\n image_width = (total_width - self._margin) // 2\n image_height = (total_height - self._margin) // 2\n\n yield image_x, image_y, image_width, image_height\n\n if 2 <= len(self._images) < 4:\n if self.is_portrait:\n image_y += image_height + self._margin\n else:\n image_x += image_width + self._margin\n yield image_x, image_y, image_width, image_height\n\n if 3 <= len(self._images) < 4:\n if self.is_portrait:\n image_y += image_height + self._margin\n else:\n image_x += image_width + self._margin\n yield image_x, image_y, image_width, image_height\n\n if len(self._images) == 4:\n image_x += image_width + self._margin\n yield image_x, image_y, image_width, image_height\n image_y += image_height + self._margin\n image_x = self._margin\n yield image_x, image_y, image_width, image_height\n image_x += image_width + self._margin\n yield image_x, image_y, image_width, image_height","def _assign_sizes(self):","def create_human_box(self, i):\n self.box = self.detections[0, 0, i, 3:7] * np.array([self.w, self.h, self.w, self.h])\n (self.startX, self.startY, self.endX, self.endY) = self.box.astype(\"int\")","def __init__(self, path_image, path_imagefile, path_bndboxfile, transform):\r\n # -------------------- DATA ARGUMENT\r\n self.shape = 446\r\n self.hue = 0.1\r\n self.saturation = 1.5\r\n self.exposure = 1.5\r\n self.imagelist = []\r\n self.labellist = []\r\n self.transform = transform\r\n label_dir = os.listdir(path_bndboxfile)\r\n image_dir = os.listdir(path_imagefile)\r\n\r\n # read imagepath\r\n for file in image_dir:\r\n file_name = os.path.join(path_imagefile, file)\r\n with open(file_name) as f:\r\n lines = f.readlines()\r\n for line in lines:\r\n image_name = line.split()[0] + '.JPEG'\r\n image = os.path.join(path_image, image_name)\r\n self.imagelist.append(image)\r\n\r\n # read imagelabel, i.e, (name, xmin, xmax, ymin, ymax)\r\n for file in label_dir:\r\n if file.split('.')[1] == 'xml':\r\n file_name = os.path.join(path_bndboxfile, file)\r\n with open(file_name) as f:\r\n xml_tree = parse(f).documentElement\r\n objects = xml_tree.getElementsByTagName('object')\r\n for object in objects:\r\n label = []\r\n name = object.getElementsByTagName('name')[0]\r\n label.append(name.childNodes[0].data)\r\n bndbox = object.getElementsByTagName('bndbox')[0]\r\n for node in bndbox.childNodes:\r\n if node.nodeType == node.ELEMENT_NODE:\r\n label.append(node.childNodes[0].data)\r\n self.labellist.append(label)\r\n else:\r\n print('Expect files in xml format. but get {}'.format(file.split('.')[1]))","def _images_and_boxes_preprocessing(self, imgs, boxes):\r\n # Image [0, 255] -> [0, 1].\r\n imgs = imgs.float()\r\n imgs = imgs / 255.0\r\n\r\n height, width = imgs.shape[2], imgs.shape[3]\r\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\r\n # range of [0, 1].\r\n boxes[:, [0, 2]] *= width\r\n boxes[:, [1, 3]] *= height\r\n boxes = transform.clip_boxes_to_image(boxes, height, width)\r\n\r\n if self._split == \"train\":\r\n # Train split\r\n imgs, boxes = transform.random_short_side_scale_jitter(\r\n imgs,\r\n min_size=self._jitter_min_scale,\r\n max_size=self._jitter_max_scale,\r\n boxes=boxes,\r\n )\r\n imgs, boxes = transform.random_crop(imgs, self._crop_size, boxes=boxes)\r\n\r\n # Random flip.\r\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\r\n elif self._split == \"val\":\r\n # Val split\r\n # Resize short side to crop_size. Non-local and STRG uses 256.\r\n imgs, boxes = transform.random_short_side_scale_jitter(\r\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\r\n )\r\n\r\n # Apply center crop for val split\r\n imgs, boxes = transform.uniform_crop(\r\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\r\n )\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\r\n elif self._split == \"test\":\r\n # Test split\r\n # Resize short side to crop_size. Non-local and STRG uses 256.\r\n imgs, boxes = transform.random_short_side_scale_jitter(\r\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\r\n )\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\r\n else:\r\n raise NotImplementedError(\"{} split not supported yet!\".format(self._split))\r\n\r\n # Do color augmentation (after divided by 255.0).\r\n if self._split == \"train\" and self._use_color_augmentation:\r\n if not self._pca_jitter_only:\r\n imgs = transform.color_jitter(\r\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\r\n )\r\n\r\n imgs = transform.lighting_jitter(\r\n imgs,\r\n alphastd=0.1,\r\n eigval=np.array(self._pca_eigval).astype(np.float32),\r\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\r\n )\r\n\r\n # Normalize images by mean and std.\r\n imgs = transform.color_normalization(\r\n imgs,\r\n np.array(self._data_mean, dtype=np.float32),\r\n np.array(self._data_std, dtype=np.float32),\r\n )\r\n\r\n if self._use_bgr:\r\n # Convert image format from RGB to BGR.\r\n # Note that Kinetics pre-training uses RGB!\r\n imgs = imgs[:, [2, 1, 0], ...]\r\n\r\n boxes = transform.clip_boxes_to_image(boxes, self._crop_size, self._crop_size)\r\n\r\n return imgs, boxes","def _resize_cbboxes(self, results):\n img_shape = results['img_shape']\n for key in results.get('cbbox_fields', []):\n cbboxes = []\n for cbox in results[key]:\n tmp_cbox = np.array(cbox, dtype=np.float32)\n new_tmp_cbox = []\n for ccbox in tmp_cbox:\n ccbox = np.array(ccbox, dtype=np.float32)\n ccbox[0::2] *= results['scale_factor'][0]\n ccbox[1::2] *= results['scale_factor'][1]\n new_tmp_cbox.append(ccbox)\n tmp_cbox = np.array(new_tmp_cbox, dtype=np.float32)\n if self.bbox_clip_border:\n tmp_cbox[:, 0::2] = np.clip(tmp_cbox[:, 0::2], 0, img_shape[1])\n tmp_cbox[:, 1::2] = np.clip(tmp_cbox[:, 1::2], 0, img_shape[0])\n cbboxes.append(tmp_cbox)\n results[key] = cbboxes","def drawBox (self, left, top, width, height, colour):\r\n w = self.bih_vals [bih_Width]\r\n h = self.bih_vals [bih_Height]\r\n\r\n cols = [left, left + width - 1]\r\n rows = [top, top + height - 1]\r\n \r\n x0 = max ((0,left))\r\n x1 = min ((cols[1]+1, w))\r\n y0 = max ((0,top))\r\n y1 = min ((rows [1]+1, h))\r\n\r\n # rows\r\n\r\n for r in rows:\r\n if r >= 0 and r < h:\r\n row = self.image [r]\r\n for x in range (x0, x1):\r\n row [x] = colour\r\n\r\n # columns\r\n \r\n for y in range (y0, y1):\r\n row = self.image [y]\r\n for c in cols:\r\n if c >= 0 and c < w :\r\n row [c] = colour","def OnSize(self, event):\r\n\r\n for pos, item in self._items.items():\r\n widget, horizontalalignment, verticalalignment = item.widget, item.horizontalalignment, item.verticalalignment\r\n\r\n rect = self.GetFieldRect(pos)\r\n widgetpos = widget.GetPosition()\r\n widgetsize = widget.GetSize()\r\n\r\n rect = self.GetFieldRect(pos)\r\n\r\n if horizontalalignment == ESB_EXACT_FIT:\r\n if verticalalignment == ESB_EXACT_FIT:\r\n widget.SetSize((rect.width-2, rect.height-2))\r\n widget.SetPosition((rect.x-1, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\r\n if widgetsize[1] < rect.width - 1:\r\n diffs = (rect.height - widgetsize[1])/2\r\n widget.SetSize((rect.width-2, widgetsize[1]))\r\n widget.SetPosition((rect.x-1, rect.y+diffs))\r\n else:\r\n widget.SetSize((rect.width-2, widgetsize[1]))\r\n widget.SetPosition((rect.x-1, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_TOP:\r\n widget.SetSize((rect.width-2, widgetsize[1]))\r\n widget.SetPosition((rect.x-1, rect.y))\r\n elif verticalalignment == ESB_ALIGN_BOTTOM:\r\n widget.SetSize((rect.width-2, widgetsize[1]))\r\n widget.SetPosition((rect.x-1, rect.height-widgetsize[1]))\r\n\r\n elif horizontalalignment == ESB_ALIGN_LEFT:\r\n\r\n xpos = rect.x - 1\r\n if verticalalignment == ESB_EXACT_FIT:\r\n widget.SetSize((widgetsize[0], rect.height-2))\r\n widget.SetPosition((xpos, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\r\n if widgetsize[1] < rect.height - 1:\r\n diffs = (rect.height - widgetsize[1])/2\r\n widget.SetPosition((xpos, rect.y+diffs))\r\n else:\r\n widget.SetSize((widgetsize[0], rect.height-2))\r\n widget.SetPosition((xpos, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_TOP:\r\n widget.SetPosition((xpos, rect.y))\r\n elif verticalalignment == ESB_ALIGN_BOTTOM:\r\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\r\n\r\n elif horizontalalignment == ESB_ALIGN_RIGHT:\r\n\r\n xpos = rect.x + rect.width - widgetsize[0] - 1\r\n if verticalalignment == ESB_EXACT_FIT:\r\n widget.SetSize((widgetsize[0], rect.height-2))\r\n widget.SetPosition((xpos, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\r\n if widgetsize[1] < rect.height - 1:\r\n diffs = (rect.height - widgetsize[1])/2\r\n widget.SetPosition((xpos, rect.y+diffs))\r\n else:\r\n widget.SetSize((widgetsize[0], rect.height-2))\r\n widget.SetPosition((xpos, rect.y-1))\r\n elif verticalalignment == ESB_ALIGN_TOP:\r\n widget.SetPosition((xpos, rect.y))\r\n elif verticalalignment == ESB_ALIGN_BOTTOM:\r\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\r\n\r\n elif horizontalalignment == ESB_ALIGN_CENTER_HORIZONTAL:\r\n\r\n xpos = rect.x + (rect.width - widgetsize[0])/2 - 1\r\n if verticalalignment == ESB_EXACT_FIT:\r\n widget.SetSize((widgetsize[0], rect.height))\r\n widget.SetPosition((xpos, rect.y))\r\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\r\n if widgetsize[1] < rect.height - 1:\r\n diffs = (rect.height - widgetsize[1])/2\r\n widget.SetPosition((xpos, rect.y+diffs))\r\n else:\r\n widget.SetSize((widgetsize[0], rect.height-1))\r\n widget.SetPosition((xpos, rect.y+1))\r\n elif verticalalignment == ESB_ALIGN_TOP:\r\n widget.SetPosition((xpos, rect.y))\r\n elif verticalalignment == ESB_ALIGN_BOTTOM:\r\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\r\n\r\n if event is not None:\r\n event.Skip()","def recreate_grid(self):\n\n self.print_numlist = arcade.SpriteList()\n for row in range(ROW_COUNT):\n for column in range(COLUMN_COUNT):\n sprite = arcade.Sprite(\n f\"Numbers/{self.grid[row][column]}.png\", scale=0.2\n )\n x = (MARGIN + WIDTH) * column + MARGIN + WIDTH // 2\n y = (MARGIN + HEIGHT) * row + MARGIN + HEIGHT // 2\n sprite.center_x = x\n sprite.center_y = y\n self.print_numlist.append(sprite)\n # Check to see if all squares have been filled in\n if 0 not in self.grid:\n # if Cameron.Check_for_Completion(self.grid) == True:\n self.done = True","def _draw_boxes(self, image, boxes, classes, thickness=4):\n for i in range(len(boxes)):\n bot, left, top, right = boxes[i, ...]\n class_id = int(classes[i]) - 1\n color = self.COLOR_LIST[class_id]\n cv2.rectangle(image, (left, top), (right, bot), color=color, thickness=thickness)","def scale_boxes(boxes, image_shape):\n height = image_shape[0]\n width = image_shape[1]\n image_dims = K.stack([height, width, height, width])\n image_dims = K.reshape(image_dims, [1, 4])\n boxes = boxes * image_dims\n return boxes","def place_images(self, final_list, points):\n\t\tfor i in range(8): \n # Please change this (8) into a class-level variable --KOH\n\t\t\timage_object = final_list[i]\n#\t\tif type(image_object) == 'CorrectImage':\n#\t\t\t\tself.correct = [i, points[i]]\n\t\t\timage = pygame.image.load(image_object.file_path)\n # Why can't these be stored as a property of the class --KOH\n\t\t\timagerect = image.get_rect()\n\t\t\treimage = pygame.transform.scale(image, image_object.size)\n\t\t\tself.screen.blit(reimage, points[i])","def _images_and_boxes_preprocessing(self, imgs, boxes, gt_boxes=None):\n # Image [0, 255] -> [0, 1].\n imgs = imgs.float()\n imgs = imgs / 255.0\n\n height, width = imgs.shape[2], imgs.shape[3]\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\n # range of [0, 1].\n # boxes[:, [0, 2]] *= width\n # boxes[:, [1, 3]] *= height\n boxes = transform.clip_boxes_to_image(boxes, height, width)\n\n if self._split == \"train\":\n # Train split\n imgs, boxes = transform.random_short_side_scale_jitter(\n imgs,\n min_size=self._jitter_min_scale,\n max_size=self._jitter_max_scale,\n boxes=boxes,\n )\n imgs, boxes = transform.random_crop(\n imgs, self._crop_size, boxes=boxes\n )\n\n # Random flip.\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\n elif self._split == \"val\":\n # Val split\n # Resize short side to crop_size. Non-local and STRG uses 256.\n imgs, boxes = transform.random_short_side_scale_jitter(\n imgs,\n min_size=self._crop_size,\n max_size=self._crop_size,\n boxes=boxes,\n )\n\n # Apply center crop for val split\n imgs, boxes = transform.uniform_crop(\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\n )\n\n if self._test_force_flip:\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\n elif self._split == \"test\":\n # Test split\n # Resize short side to crop_size. Non-local and STRG uses 256.\n imgs, boxes = transform.random_short_side_scale_jitter(\n imgs,\n min_size=self._crop_size,\n max_size=self._crop_size,\n boxes=boxes,\n )\n\n if self._test_force_flip:\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\n else:\n raise NotImplementedError(\n \"{} split not supported yet!\".format(self._split)\n )\n\n # Do color augmentation (after divided by 255.0).\n if self._split == \"train\" and self._use_color_augmentation:\n if not self._pca_jitter_only:\n imgs = transform.color_jitter(\n imgs,\n img_brightness=0.4,\n img_contrast=0.4,\n img_saturation=0.4,\n )\n\n imgs = transform.lighting_jitter(\n imgs,\n alphastd=0.1,\n eigval=np.array(self._pca_eigval).astype(np.float32),\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\n )\n\n # Normalize images by mean and std.\n imgs = transform.color_normalization(\n imgs,\n np.array(self._data_mean, dtype=np.float32),\n np.array(self._data_std, dtype=np.float32),\n )\n\n if not self._use_bgr:\n # Convert image format from BGR to RGB.\n # Note that Kinetics pre-training uses RGB!\n imgs = imgs[:, [2, 1, 0], ...]\n\n boxes = transform.clip_boxes_to_image(\n boxes, self._crop_size, self._crop_size\n )\n\n return imgs, boxes","def populate_images(self):\n print \"Populating images info...\"\n images = self.get_all_images()\n for i in images:\n\n associated_snapshots = self.get_snapshots_of(i)\n\n self.spreadsheet[i.id] = dict(name=i.name, Name_tag=self.get_name_tag(i), id=i.id,\n KEEP_tag=self.get_keep_tag(i), PROD_tag=self.is_production(i),\n region=i.region.name,\n created=i.creationDate,\n associated_snapshots=associated_snapshots,\n description=i.description)","def stage_one(self, imgs, threshold, factor, minsize, nms_threshold):\n\n width = imgs.shape[-2]\n height = imgs.shape[-1]\n num_img = imgs.shape[0]\n\n # Compute valid scales\n scales = []\n cur_width = width\n cur_height = height\n cur_factor = 1\n while cur_width >= 12 and cur_height >= 12:\n if 12 / cur_factor >= minsize: # Ignore boxes that smaller than minsize\n\n w = cur_width\n h = cur_height\n scales.append((w, h, cur_factor))\n\n cur_factor *= factor\n cur_width = math.ceil(cur_width * factor)\n cur_height = math.ceil(cur_height * factor)\n\n # Get candidate boxesi ph\n candidate_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\n candidate_scores = torch.empty(0, device=self.device)\n candidate_offsets = torch.empty(\n 0, dtype=torch.float32, device=self.device)\n all_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\n for w, h, f in scales:\n resize_img = torch.nn.functional.interpolate(\n imgs, size=(w, h), mode='bilinear')\n p_distribution, box_regs, _ = self.pnet(resize_img)\n\n candidate, scores, offsets, img_labels = self._generate_bboxes(\n p_distribution, box_regs, f, threshold)\n\n candidate_boxes = torch.cat([candidate_boxes, candidate])\n candidate_scores = torch.cat([candidate_scores, scores])\n candidate_offsets = torch.cat([candidate_offsets, offsets])\n all_img_labels = torch.cat([all_img_labels, img_labels])\n\n \n if candidate_boxes.shape[0] != 0:\n candidate_boxes = self._calibrate_box(\n candidate_boxes, candidate_offsets)\n candidate_boxes = self._convert_to_square(candidate_boxes)\n candidate_boxes = self._refine_boxes(\n candidate_boxes, width, height)\n \n final_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\n final_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\n for i in range(num_img):\n mask = all_img_labels == i\n keep = func.nms(candidate_boxes[mask].cpu().numpy(),\n candidate_scores[mask].cpu().numpy(), nms_threshold)\n final_boxes = torch.cat([final_boxes, candidate_boxes[mask][keep]])\n final_img_labels = torch.cat([final_img_labels, all_img_labels[mask][keep]])\n\n return torch.cat([final_boxes, final_img_labels.unsqueeze(1 )], -1)\n else:\n return candidate_boxes","def _images_and_boxes_preprocessing_cv2(self, imgs, boxes):\r\n\r\n height, width, _ = imgs[0].shape\r\n\r\n boxes[:, [0, 2]] *= width\r\n boxes[:, [1, 3]] *= height\r\n boxes = cv2_transform.clip_boxes_to_image(boxes, height, width)\r\n\r\n # `transform.py` is list of np.array. However, for AVA, we only have\r\n # one np.array.\r\n boxes = [boxes]\r\n # The image now is in HWC, BGR format.\r\n if self._split == \"train\": # \"train\"\r\n imgs, boxes = cv2_transform.random_short_side_scale_jitter_list(\r\n imgs,\r\n min_size=self._jitter_min_scale,\r\n max_size=self._jitter_max_scale,\r\n boxes=boxes,\r\n )\r\n imgs, boxes = cv2_transform.random_crop_list(\r\n imgs, self._crop_size, order=\"HWC\", boxes=boxes\r\n )\r\n if self.random_horizontal_flip:\r\n # random flip\r\n imgs, boxes = cv2_transform.horizontal_flip_list(\r\n 0.5, imgs, order=\"HWC\", boxes=boxes\r\n )\r\n elif self._split == \"val\":\r\n # Short side to test_scale. Non-local and STRG uses 256.\r\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\r\n boxes = [\r\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\r\n ]\r\n imgs, boxes = cv2_transform.spatial_shift_crop_list(\r\n self._crop_size, imgs, 1, boxes=boxes\r\n )\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = cv2_transform.horizontal_flip_list(\r\n 1, imgs, order=\"HWC\", boxes=boxes\r\n )\r\n elif self._split == \"test\":\r\n # Short side to test_scale. Non-local and STRG uses 256.\r\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\r\n boxes = [\r\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\r\n ]\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = cv2_transform.horizontal_flip_list(\r\n 1, imgs, order=\"HWC\", boxes=boxes\r\n )\r\n else:\r\n raise NotImplementedError(\"Unsupported split mode {}\".format(self._split))\r\n\r\n # Convert image to CHW keeping BGR order.\r\n imgs = [cv2_transform.HWC2CHW(img) for img in imgs]\r\n\r\n # Image [0, 255] -> [0, 1].\r\n imgs = [img / 255.0 for img in imgs]\r\n\r\n imgs = [\r\n np.ascontiguousarray(\r\n # img.reshape((3, self._crop_size, self._crop_size))\r\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\r\n ).astype(np.float32)\r\n for img in imgs\r\n ]\r\n\r\n # Do color augmentation (after divided by 255.0).\r\n if self._split == \"train\" and self._use_color_augmentation:\r\n if not self._pca_jitter_only:\r\n imgs = cv2_transform.color_jitter_list(\r\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\r\n )\r\n\r\n imgs = cv2_transform.lighting_list(\r\n imgs,\r\n alphastd=0.1,\r\n eigval=np.array(self._pca_eigval).astype(np.float32),\r\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\r\n )\r\n\r\n # Normalize images by mean and std.\r\n imgs = [\r\n cv2_transform.color_normalization(\r\n img,\r\n np.array(self._data_mean, dtype=np.float32),\r\n np.array(self._data_std, dtype=np.float32),\r\n )\r\n for img in imgs\r\n ]\r\n\r\n # Concat list of images to single ndarray.\r\n imgs = np.concatenate([np.expand_dims(img, axis=1) for img in imgs], axis=1)\r\n\r\n if not self._use_bgr:\r\n # Convert image format from BGR to RGB.\r\n imgs = imgs[::-1, ...]\r\n\r\n imgs = np.ascontiguousarray(imgs)\r\n imgs = torch.from_numpy(imgs)\r\n boxes = cv2_transform.clip_boxes_to_image(\r\n boxes[0], imgs[0].shape[1], imgs[0].shape[2]\r\n )\r\n return imgs, boxes","def __init__(self,jx,jy,img,geo,mbox=10,hist=False,zoomc=False,pfile=False):\n \n self.mbox = mbox # Box half-size\n self.nbox = 2*mbox + 1 # Box size\n # Adjust central pixel location to ensure box fits within full image\n self.ix = int( np.median( [ mbox, jx, img.nx-mbox-1 ] ) )\n self.iy = int( np.median( [ mbox, jy, img.ny-mbox-1 ] ) )\n iymin = self.iy - mbox\n iymax = self.iy + mbox\n ixmin = self.ix - mbox\n ixmax = self.ix + mbox\n label = img.label # Copy information from full disk image\n self.label = label\n self.desc = img.desc[label]\n self.img = img.images[label][iymin:iymax+1,ixmin:ixmax+1]\n self.disp(zoomc)\n if hist: self.hist(geo,pfile)","def _images_and_boxes_preprocessing_cv2(self, imgs, boxes, gt_boxes=None, min_scale=None, crop_size=None, n_imgs=0):\n\n height, width, _ = imgs[0].shape\n\n # boxes[:, [0, 2]] *= width\n # boxes[:, [1, 3]] *= height\n boxes = cv2_transform.clip_boxes_to_image(boxes, height, width)\n\n # `transform.py` is list of np.array. However, for AVA, we only have\n # one np.array.\n boxes = [boxes]\n\n crop_size = crop_size if self.multigrid_enabled and crop_size is not None else self._crop_size\n \n if self._split != 'train':\n assert gt_boxes is not None\n gt_boxes = cv2_transform.clip_boxes_to_image(gt_boxes, height, width)\n gt_boxes = [gt_boxes]\n\n # The image now is in HWC, BGR format.\n if self._split == \"train\": # \"train\"\n imgs, boxes = cv2_transform.random_short_side_scale_jitter_list(\n imgs,\n min_size=self._jitter_min_scale if not self.multigrid_enabled and min_scale is None else min_scale,\n max_size=self._jitter_max_scale,\n boxes=boxes,\n )\n imgs, boxes = cv2_transform.random_crop_list(\n imgs, crop_size, order=\"HWC\", boxes=boxes, n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\n )\n if self.random_horizontal_flip:\n # random flip\n # if self.cfg.MODEL.USE_SPA_CONF and len(imgs[n_imgs].shape) != 3:\n # for i in range(n_imgs, len(imgs) + 1):\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\n imgs, boxes = cv2_transform.horizontal_flip_list(\n 0.5, imgs, order=\"HWC\", boxes=boxes, \n n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\n )\n # elif self._split == \"val\":\n # # Short side to test_scale. Non-local and STRG uses 256.\n # imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\n # boxes, gt_boxes = cv2_transform.scale_boxes(\n # self._crop_size, boxes[0], height, width, gt_boxes=gt_boxes[0]\n # )\n # boxes, gt_boxes = [boxes], [gt_boxes]\n # imgs, boxes, gt_boxes = cv2_transform.spatial_shift_crop_list(\n # self._crop_size, imgs, 1, boxes=boxes, gt_boxes=gt_boxes\n # )\n\n # if self._test_force_flip:\n # imgs, boxes = cv2_transform.horizontal_flip_list(\n # 1, imgs, order=\"HWC\", boxes=boxes, gt_boxes=gt_boxes\n # )\n elif self._split == \"val\" or self._split == \"test\":\n # Short side to test_scale. Non-local and STRG uses 256.\n imgs = [cv2_transform.scale(crop_size, img) for img in imgs]\n boxes, gt_boxes = cv2_transform.scale_boxes(\n crop_size, boxes[0], height, width, gt_boxes=gt_boxes[0]\n )\n boxes, gt_boxes = [boxes], [gt_boxes]\n\n if self._test_force_flip:\n # if self.cfg.MODEL.USE_SPA_CONF and len(imgs[n_imgs].shape) != 3:\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\n # imgs[n_imgs:] = [np.expand_dims(img, axis=-1) for img in imgs[n_imgs:]]\n imgs, boxes = cv2_transform.horizontal_flip_list(\n 1, imgs, order=\"HWC\", boxes=boxes, gt_boxes=gt_boxes,\n n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\n )\n else:\n raise NotImplementedError(\n \"Unsupported split mode {}\".format(self._split)\n )\n\n # Convert image to CHW keeping BGR order.\n if self.cfg.MODEL.USE_SPA_CONF:\n try:\n if len(imgs[n_imgs].shape) == 2:\n imgs[n_imgs:] = [np.expand_dims(img, axis=-1) for img in imgs[n_imgs:]]\n elif len(imgs[n_imgs].shape) > 3:\n imgs[n_imgs:] = [np.expand_dims(img.squeeze(), axis=-1) for img in imgs[n_imgs:]]\n except:\n import pdb; pdb.set_trace()\n \n # for i in range(n_imgs, len(imgs) + 1):\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\n # try:\n imgs = [cv2_transform.HWC2CHW(img) for img in imgs]\n # except:\n # print('imgs[n_imgs].shape:', imgs[n_imgs].shape)\n # print('len(imgs):', len(imgs))\n # print('n_imgs:', n_imgs)\n # import pdb; pdb.set_trace()\n\n # Image [0, 255] -> [0, 1].\n if self.cfg.MODEL.USE_SPA_CONF:\n imgs[:n_imgs] = [img / 255.0 for img in imgs[:n_imgs]]\n else: \n imgs = [img / 255.0 for img in imgs]\n\n if self.cfg.MODEL.USE_SPA_CONF:\n imgs[:n_imgs] = [\n np.ascontiguousarray(\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\n ).astype(np.float32)\n for img in imgs[:n_imgs]\n ]\n imgs[n_imgs:] = [\n np.ascontiguousarray(\n img.reshape((1, imgs[0].shape[1], imgs[0].shape[2]))\n ).astype(np.float32)\n for img in imgs[n_imgs:]\n ]\n else:\n imgs = [\n np.ascontiguousarray(\n # img.reshape((3, self._crop_size, self._crop_size))\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\n ).astype(np.float32)\n for img in imgs\n ]\n\n # Do color augmentation (after divided by 255.0).\n if self.cfg.MODEL.USE_SPA_CONF:\n skeleton_imgs = imgs[n_imgs:]\n imgs = imgs[:n_imgs]\n if self._split == \"train\" and self._use_color_augmentation: # False\n if not self._pca_jitter_only:\n imgs = cv2_transform.color_jitter_list(\n imgs,\n img_brightness=0.4,\n img_contrast=0.4,\n img_saturation=0.4,\n )\n\n imgs = cv2_transform.lighting_list(\n imgs,\n alphastd=0.1,\n eigval=np.array(self._pca_eigval).astype(np.float32),\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\n )\n\n # Normalize images by mean and std.\n imgs = [\n cv2_transform.color_normalization(\n img,\n np.array(self._data_mean, dtype=np.float32),\n np.array(self._data_std, dtype=np.float32),\n )\n for img in imgs\n ]\n\n # Concat list of images to single ndarray.\n imgs = np.concatenate(\n [np.expand_dims(img, axis=1) for img in imgs], axis=1\n )\n\n if not self._use_bgr:\n # Convert image format from BGR to RGB.\n imgs = imgs[::-1, ...]\n\n imgs = np.ascontiguousarray(imgs)\n imgs = torch.from_numpy(imgs)\n \n if self.cfg.MODEL.USE_SPA_CONF:\n skeleton_imgs = np.concatenate(\n [np.expand_dims(img, axis=1) for img in skeleton_imgs], axis=1\n )\n skeleton_imgs = np.ascontiguousarray(skeleton_imgs)\n skeleton_imgs = torch.from_numpy(skeleton_imgs)\n\n boxes = cv2_transform.clip_boxes_to_image(\n boxes[0], imgs[0].shape[1], imgs[0].shape[2]\n )\n if gt_boxes is not None:\n gt_boxes = cv2_transform.clip_boxes_to_image(\n gt_boxes[0], imgs[0].shape[1], imgs[0].shape[2]\n )\n if self.cfg.MODEL.USE_SPA_CONF:\n return (imgs, skeleton_imgs, boxes) if gt_boxes is None else (imgs, skeleton_imgs, boxes, gt_boxes)\n else:\n return (imgs, boxes) if gt_boxes is None else (imgs, boxes, gt_boxes)","def set_figure_size(self):\n lims, _ = self.set_lims()\n size_fac = 50\n paperSizeFac = 0.65\n one_dec = 1.6\n xdecs = np.log10(lims(1)) - np.log10(lims(0))\n one_dec = one_dec * 4 / xdecs\n ydecs = np.log10(lims[3]) - np.log10(lims[2])\n paper_width = xdecs * one_dec\n paper_height = (ydecs + 3) * one_dec\n paper_height = min([paper_height, 9])\n rectScreen = [0.5, 0.5, paper_width, paper_height] * size_fac\n rectPaper = [1.0, 1.0, paper_width * paperSizeFac, paper_height * paperSizeFac]\n\n rectRho = [0.15, 0.15 + 2.3 / (ydecs + 3), 0.8, ydecs / (ydecs + 3) * 0.8]\n rectPhi = [0.15, 0.15, 0.8, 2 / (ydecs + 3) * 0.8]\n rects = {\n \"Screen\": rectScreen,\n \"Paper\": rectPaper,\n \"Rho\": rectRho,\n \"Phi\": rectPhi,\n }\n return rects","def define_box_location(self):\n self.contents['Box_ID'] = np.ones(self.numatom) * self.num_box","def configure_grid(self):\r\n\r\n for r in range(3):\r\n self.rowconfigure(r, weight=1)\r\n for c in range(3):\r\n self.columnconfigure(c, weight=1)","def create_prior_boxes(self):\n # value of k for each feature map to create k^2 boxes for each feature map\n feature_map_dims = {'conv4_3': 38, 'conv7': 19, 'conv8_2': 10, 'conv9_2': 5}\n\n # scale for boxes across different feature maps. boxes for inner feature maps\n # are scaled much lower to detect small objects\n obj_scales = {'conv4_3': 0.1, 'conv7': 0.21, 'conv8_2': 0.255, 'conv9_2': 0.30}\n\n # Defined aspect ratio calculated from mean of (w/h) across all bounding boxes\n # from the dataset. The mean is 0.66 with deviation of 0.07. So aspect ratio is kept\n # at 0.66 for all feature maps\n aspect_ratios = {'conv4_3': [0.5], 'conv7': [0.55], 'conv8_2': [0.6], 'conv9_2': [.66]}\n\n fmaps = list(feature_map_dims.keys())\n prior_boxes = []\n for k, fmap in enumerate(fmaps):\n # for each feature map, create k*k boxes\n for i in range(feature_map_dims[fmap]):\n for j in range(feature_map_dims[fmap]):\n # calculate center coordinates of boxes\n cx = (j + 0.5) / feature_map_dims[fmap]\n cy = (i + 0.5) / feature_map_dims[fmap]\n\n # For each\n for ratio in aspect_ratios[fmap]:\n prior_boxes.append([cx, cy, obj_scales[fmap] * sqrt(ratio), obj_scales[fmap] / sqrt(ratio)])\n\n prior_boxes = torch.FloatTensor(prior_boxes).to(device) # (1930, 4)\n prior_boxes.clamp_(0, 1) # (1930, 4)\n\n return prior_boxes","def setup_image(self):\n # Create the correct size image for the table\n rows = self.table.count('\\n')\n columns = self.table.split('\\n')[0].count('-') + self.table.split('\\n')[0].count('+')\n self.img = Image.new('RGB', ((columns * 12) + 24, rows * 21 + 48), color=(54, 57, 63))\n\n # Initialize font and drawing object\n self.font = ImageFont.truetype('../extra_files/cour.ttf', 20)\n self.draw = ImageDraw.Draw(self.img)\n\n # Draw the table without markings\n for x in range(5):\n self.draw.text((12, 12), self.table, font=self.font, fill=(255, 255, 255))","def boxes_postprocess(boxes, image_meta):\n if 'scales' in image_meta:\n boxes[:, [0, 2]] /= image_meta['scales'][1]\n boxes[:, [1, 3]] /= image_meta['scales'][0]\n\n if 'padding' in image_meta:\n boxes[:, [0, 2]] -= image_meta['padding'][2]\n boxes[:, [1, 3]] -= image_meta['padding'][0]\n\n if 'crops' in image_meta:\n boxes[:, [0, 2]] += image_meta['crops'][2]\n boxes[:, [1, 3]] += image_meta['crops'][0]\n\n if 'flipped' in image_meta and image_meta['flipped']:\n image_width = image_meta['drifted_size'][1] if 'drifted_size' in image_meta else \\\n image_meta['orig_size'][1]\n boxes_widths = boxes[:, 2] - boxes[:, 0] + 1.\n boxes[:, 0] = image_width - 1 - boxes[:, 2]\n boxes[:, 2] = boxes[:, 0] + boxes_widths - 1.\n\n if 'drifts' in image_meta:\n boxes[:, [0, 2]] += image_meta['drifts'][1]\n boxes[:, [1, 3]] += image_meta['drifts'][0]\n\n return boxes","def draw_boxes(bboxes: [[int]], img: 'np.array', line_width: int=2) -> 'np.array':\n for x, y, w, h in bboxes:\n cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), line_width)\n return img","def __call__(self, results):\n\n if 'img_fields' in results:\n assert results['img_fields'] == ['img'], \\\n 'Only single img_fields is allowed'\n img = results['img']\n assert 'bbox_fields' in results\n boxes = [results[key] for key in results['bbox_fields']]\n boxes = np.concatenate(boxes, 0)\n h, w, c = img.shape\n while True:\n mode = random.choice(self.sample_mode)\n self.mode = mode\n if mode == 1:\n return results\n\n min_iou = mode\n for i in range(50):\n new_w = random.uniform(self.min_crop_size * w, w)\n new_h = random.uniform(self.min_crop_size * h, h)\n\n # h / w in [0.5, 2]\n if new_h / new_w < 0.5 or new_h / new_w > 2:\n continue\n\n left = random.uniform(w - new_w)\n top = random.uniform(h - new_h)\n\n patch = np.array(\n (int(left), int(top), int(left + new_w), int(top + new_h)))\n # Line or point crop is not allowed\n if patch[2] == patch[0] or patch[3] == patch[1]:\n continue\n overlaps = bbox_overlaps(\n patch.reshape(-1, 4), boxes.reshape(-1, 4)).reshape(-1)\n if len(overlaps) > 0 and overlaps.min() < min_iou:\n continue\n\n # center of boxes should inside the crop img\n # only adjust boxes and instance masks when the gt is not empty\n if len(overlaps) > 0:\n # adjust boxes\n def is_center_of_bboxes_in_patch(boxes, patch):\n center = (boxes[:, :2] + boxes[:, 2:]) / 2\n mask = ((center[:, 0] > patch[0]) *\n (center[:, 1] > patch[1]) *\n (center[:, 0] < patch[2]) *\n (center[:, 1] < patch[3]))\n return mask\n\n mask = is_center_of_bboxes_in_patch(boxes, patch)\n if not mask.any():\n continue\n for key in results.get('bbox_fields', []):\n boxes = results[key].copy()\n mask = is_center_of_bboxes_in_patch(boxes, patch)\n boxes = boxes[mask]\n if self.bbox_clip_border:\n boxes[:, 2:] = boxes[:, 2:].clip(max=patch[2:])\n boxes[:, :2] = boxes[:, :2].clip(min=patch[:2])\n boxes -= np.tile(patch[:2], 2)\n\n results[key] = boxes\n # labels\n label_key = self.bbox2label.get(key)\n if label_key in results:\n results[label_key] = results[label_key][mask]\n\n # mask fields\n mask_key = self.bbox2mask.get(key)\n if mask_key in results:\n results[mask_key] = results[mask_key][\n mask.nonzero()[0]].crop(patch)\n # adjust the img no matter whether the gt is empty before crop\n img = img[patch[1]:patch[3], patch[0]:patch[2]]\n results['img'] = img\n results['img_shape'] = img.shape\n\n # seg fields\n for key in results.get('seg_fields', []):\n results[key] = results[key][patch[1]:patch[3],\n patch[0]:patch[2]]\n return results","def initialize_grid(self) -> None:\n for i in range(self.grid_size[0]):\n for j in range(self.grid_size[1]):\n self.set(i, j, self.base_color)","def fillingrid(self):\n\n if self.imagearray is None:\n if self.gs.isfixed:\n for n in range(0, self.numcols):\n self.vspins[n].setValue(self.currentvalues[n])\n elif self.gs.isperc:\n for n in range(0, self.numcols):\n self.fillinpercent(n)\n else:\n for n in range(0, self.numcols):\n self.nsspins[n].setValue(self.currentnsigs[n])\n else:\n for n in range(0, self.numcols):\n self.vspins[n].setValue(self.currentvalues[n])\n self.nsspins[n].setValue(self.currentnsigs[n])\n self.fillinpercent(n)","def create_flowbox(self, flowbox, frame_list):\n\n for num_frame in frame_list:\n grid = Gtk.Grid()\n btn = self.new_thumbnail_button(num_frame)\n\n widget_cls_label = Gtk.Label()\n widget_cls_label.set_text(\"?\")\n widget_cls_label.set_size_request(20, 20)\n widget_cls_label.connect(\"draw\", self.area_on_draw, {'frame': num_frame, 'widget_label': widget_cls_label})\n # Add drawing area\n grid.add(btn)\n grid.attach_next_to(widget_cls_label, btn, Gtk.PositionType.BOTTOM, 1, 2)\n\n flowbox.add(grid)\n self.flowbox_layout = flowbox","def updateFootprintBbox(self):\n # Pull out the image bounds of the parent Footprint\n self.bb = self.fp.getBBox()\n if not self.imbb.contains(self.bb):\n raise ValueError(('Footprint bounding-box %s extends outside image bounding-box %s') %\n (str(self.bb), str(self.imbb)))\n self.W, self.H = self.bb.getWidth(), self.bb.getHeight()\n self.x0, self.y0 = self.bb.getMinX(), self.bb.getMinY()\n self.x1, self.y1 = self.bb.getMaxX(), self.bb.getMaxY()","def boxer(imgfile, parttree, outstack, boxsize):\n imgarray = mrc.read(imgfile)\n boxedparticles = boxerMemory(imgarray, parttree, boxsize)\n apImagicFile.writeImagic(boxedparticles, outstack)\n return True","def build_boxes(self):\n for index in self.box_space.points:\n if self.rank_of_box[index] == self.my_rank:\n self.my_boxes.append(Box(self, index))","def __build__(self,data_index=0):\n \n super(Image,self).__build__()\n # -- How to read the image\n self._build_properties = dict(\n data_index = data_index,\n header_exptime = \"EXPTIME\",\n dataslice0=\"undefined\",\n dataslice1=\"undefined\",\n bkgdbox={\"bh\":100,\"bw\":100,\"fh\":3,\"fw\":3},\n )","def set_pic_size(self, im_name):\n im_vals = np.genfromtxt(im_name, delimiter=self.delim)\n self.pic_width = int(np.size(im_vals[0]) - 1) # the first column of ASCII image is row number\n try: self.pic_height = int(np.size(im_vals[:,0])) \n except IndexError: \n self.pic_width = int(np.size(im_vals) - 1)\n self.pic_height = 1\n self.create_rect_mask()\n return self.pic_width, self.pic_height","def preprocessing(image_data, max_height, max_width):\n img = image_data[\"image\"]\n img = resize_image(img, max_height, max_width)\n gt_boxes = image_data[\"objects\"][\"bbox\"]\n gt_labels = image_data[\"objects\"][\"label\"]\n return img, gt_boxes, gt_labels","def setpopbox(ty,slist,scaledtime,rootpop,poptree):\r\n wadjust = \"\"\r\n for i in range(numpops-1):\r\n wadjust += \"00\"\r\n if(scaledtime != []):\r\n minx_popbox = textwide(wadjust+\"0.00 MYR\", tfactor)\r\n else:\r\n minx_popbox = textwide(wadjust+\"0.00 tu\", tfactor)\r\n minx_popbox /= gv[\"globalscale\"]\r\n if gv[\"localxscale\"] > 0:\r\n minx_popbox /= gv[\"localxscale\"]\r\n\r\n popxvals = []\r\n## if scaledpop == [] then no text is written on time split line and there is more width to work with\r\n for i in range(2*numpops - 1):\r\n## left side temporarily at zero, right side temporarily at upper confidence interval\r\n popxvals.append( [0,slist[4][4][i][1]])\r\n (width,c,popxvals, leftpoint,rightpoint) = centerbox(rootpop,0,popxvals[rootpop][1],poptree,popxvals)\r\n popxvals = popadjustx(popxvals,minx_popbox)\r\n popbox = []\r\n\r\n ## maxwide will be used to adjust the width as a scaler so the part furthest to the right is not too far out\r\n maxwide = 0\r\n for i in range(2*numpops-1):\r\n if maxwide < (popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1])):\r\n maxwide = (popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1]))\r\n maxwide = maxwide/(1.0-minx_popbox)\r\n\r\n if gv[\"localxscale\"] > 0:\r\n maxwide *= gv[\"localxscale\"]\r\n\r\n farright = 0\r\n confint = []\r\n for i in range(2*numpops-1):\r\n confint.append([])\r\n confint[i].append(minx_popbox + ((popxvals[i][1] - (slist[4][4][i][1]-slist[4][4][i][2]))/maxwide))\r\n confint[i].append(minx_popbox + ((popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1]))/maxwide))\r\n if confint[i][1] > farright:\r\n farright = confint[i][1]\r\n popbox.append([[],[]])\r\n popbox[i][0].append(minx_popbox + popxvals[i][0]/maxwide)\r\n popbox[i][1].append(minx_popbox + popxvals[i][1]/maxwide)\r\n if poptree[i][1] == -1:\r\n popbox[i][0].append(gv[\"lineINFy\"])\r\n else:\r\n popbox[i][0].append(ty[poptree[i][1]-1][0])\r\n if poptree[i][0] == 0:\r\n popbox[i][1].append(gv[\"line0y\"])\r\n else:\r\n popbox[i][1].append(ty[poptree[i][0]-1][0])\r\n return popbox,maxwide, confint, farright","def plt_bboxes(img, classes, scores, bboxes, figsize=(10,10), linewidth=1.5):\n fig = plt.figure(figsize=figsize)\n plt.imshow(img)\n height = img.shape[0]\n width = img.shape[1]\n colors = dict()\n for i in range(classes.shape[0]):\n cls_id = int(classes[i])\n if cls_id >= 0:\n score = scores[i]\n if cls_id not in colors:\n colors[cls_id] = (random.random(), random.random(), random.random())\n ymin = int(bboxes[i, 0] * height)\n xmin = int(bboxes[i, 1] * width)\n ymax = int(bboxes[i, 2] * height)\n xmax = int(bboxes[i, 3] * width)\n# crop_img = img[xmin:(xmax - xmin),xmax:(ymax - ymin)]\n# misc.imsave('1.jpg', crop_img)\n rect = plt.Rectangle((xmin, ymin), xmax - xmin,\n ymax - ymin, fill=False,\n edgecolor=colors[cls_id],\n linewidth=linewidth)\n plt.gca().add_patch(rect)\n class_name = CLASSES[cls_id]\n plt.gca().text(xmin, ymin - 2,\n '{:s} | {:.3f}'.format(class_name, score),\n bbox=dict(facecolor=colors[cls_id], alpha=0.5),\n fontsize=12, color='white')\n plt.show()","def __init__(self,phosphene_resolution=(50,50), size=(480,480), jitter=0.35, intensity_var=0.9, aperture=.66, sigma=0.8, custom_grid=None):\n if custom_grid is None:\n self.phosphene_resolution = phosphene_resolution\n self.size = size\n self.phosphene_spacing = np.divide(size,phosphene_resolution)\n self.jitter = jitter\n self.intensity_var = intensity_var\n self.grid = self.create_regular_grid(self.phosphene_resolution,self.size,self.jitter,self.intensity_var)\n self.aperture = np.round(aperture*self.phosphene_spacing[0]).astype(int) #relative aperture > dilation kernel size\n else:\n self.grid = custom_grid\n self.aperture = aperture\n self.sigma = sigma\n self.dilation_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(self.aperture,self.aperture))\n self.k_size = 11 #np.round(4*sigma+1).astype(int) # rule of thumb: choose k_size>3*sigma","def sizes(options):\n # import data\n pixels = dict() # volumes are given in #pixels\n snap_mask = \"/net/astrogate/export/astrodata/jgacon/filex/processing/\" \\\n \"export/f8_h50_v100_objs_snap_%d.csv\"\n snap_ids = np.arange(2,28+1)\n z = snapid2z(snap_ids)\n print z\n\n for id in snap_ids:\n snap = snap_mask % (id - 1) # fix: snap number one too low in filename\n pixels[id] = np.genfromtxt(snap)[1:-1,1] # row 2 contains volumes\n # rm void & halo volumes\n\n # visualise\n if \"err\" in options.keys():\n nums = np.array([pixels[id].size for id in snap_ids])\n avgs = np.array([np.mean(pixels[id]) for id in snap_ids])\n mods = np.array([st.mode(pixels[id])[0][0] for id in snap_ids])\n meds = np.array([np.median(pixels[id]) for id in snap_ids])\n stds = np.array([np.std(pixels[id]) for id in snap_ids])\n\n print mods\n print mods.shape\n\n plt.figure()\n plt.title(\"Sizes of filaments as function of redshift\")\n plt.xlabel(\"Redshift $z$\")\n plt.xticks(snap_ids[::3], z[::3])\n\n plt.ylabel(\"Size in #pixels\")\n\n plt.errorbar(snap_ids, avgs, yerr=stds, label=\"Mean\")\n plt.plot(snap_ids, mods, \"g\", label=\"Mode\")\n plt.plot(snap_ids, meds, \"c\", label=\"Median\")\n plt.legend(loc=\"best\")\n\n plt.twinx()\n plt.ylabel(\"#Filaments\", color=\"r\")\n plt.tick_params(\"y\", colors=\"r\")\n\n plt.plot(snap_ids, nums, \"r--\")\n\n plt.savefig(options[\"err\"])\n\n if \"dist\" in options.keys():\n targets = np.array([5,10,15,20,25])\n plt.figure()\n plt.title(\"Volume distribution of filaments\")\n plt.xlabel(\"Volume $V$ in #pixels\")\n plt.ylabel(\"#Element with $V$ / Total #Elements\")\n plt.xlim([0,1000])\n for target in targets:\n sns.kdeplot(pixels[target], label=\"$z$ = %f\" % snapid2z(target))\n plt.legend(loc=\"best\")\n plt.savefig(options[\"dist\"])\n\n if \"dist_inter\" in options.keys():\n default = snap_ids[-1]\n fig, ax = plt.subplots()\n plt.subplots_adjust(bottom=0.25)\n sns.kdeplot(pixels[int(default - 2)], ax=ax)\n plt.xlim([0, 1000])\n plt.ylim([0, 0.01])\n plt.xlabel(\"Volume $V$ of filaments in #pixels\")\n plt.ylabel(\"#Filaments with volume $V$ / Total #Filaments\")\n\n nums = np.array([pixels[id].size for id in snap_ids])\n ax2 = ax.twinx()\n ax2.set_ylabel(\"#Filaments\", color=\"r\", alpha=0.5)\n ax2.tick_params(axis=\"y\", labelcolor=\"r\")\n ax2_x = np.linspace(0, 1000, nums.size)\n ax2.plot(ax2_x, nums, \"r--\", alpha=0.5)\n point, = ax2.plot(ax2_x[default - 2], nums[default - 2], \"ro\", alpha=0.5)\n\n axcolor = 'lightgoldenrodyellow'\n axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)\n sid = Slider(axfreq, \"ID\", 2, 28, valinit=default, valstep=1)\n ax.set_title(\"$z$ = %f\" % snapid2z(default))\n\n def update(val):\n id = sid.val\n\n print id\n #ax.clear()\n ax.set_ydata()\n ax.set_xdata()\n ax.set_title(\"$z$ = %f\" % snapid2z(int(id)))\n ax.set_xlim([0,1000])\n ax.set_ylim([0, 0.01])\n sns.kdeplot(pixels[int(id)], ax=ax)\n point.set_xdata(ax2_x[int(id) - 2])\n point.set_ydata(nums[int(id) - 2])\n fig.canvas.draw_idle()\n sid.on_changed(update)\n\n plt.show()\n\n\n if \"hist\" in options.keys():\n conc = None\n for id, vols in pixels.iteritems():\n data = np.empty((vols.size, 2))\n data[:,0] = id\n data[:,1] = vols\n\n if conc is None:\n conc = data\n else:\n conc = np.vstack((conc, data))\n\n plt.figure()\n plt.hist2d(conc[:,0], conc[:,1], bins=(snap_ids.size, 1000))\n plt.ylim([100,400])\n plt.savefig(options[\"hist\"])","def create_image_caption_pairs(self):","def _set_boxes(self, listOfBoxes):\n self._boxes = listOfBoxes","def generate_image_grid(sess, df, filenames,op, op2):\n #x_points = np.arange(0, 1, 1.5).astype(np.float32)\n #y_points = np.arange(0, 1, 1.5).astype(np.float32)\n\n nx, ny = 12, 1\n #plt.subplot()\n gs = gridspec.GridSpec(nx, ny, hspace=1, wspace=0.05)\n # input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\n #\n # plt.imshow(np.array(df[0].tolist()).reshape(28, 28), cmap='gray')\n # plt.show()\n # x = sess.run(op, feed_dict={decoder_input: input_x[0].reshape(1,2)})\n # img = np.array(x.tolist()).reshape(28, 28)\n #\n # plt.imshow(img, cmap='gray')\n # plt.show()\n\n \"\"\" grid \"\"\"\n input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\n for i, g in enumerate(gs):\n\n x = sess.run(op, feed_dict={decoder_input: input_x[i].reshape(1,2)})\n ax = plt.subplot(g)\n img = np.array(x.tolist()).reshape(28, 28)\n ax.imshow(img, cmap='gray')\n ax.set_xticks([])\n ax.set_yticks([])\n #ax.set_aspect('auto')\n ax.set_title(filenames[i])\n plt.show()\n\n for i, g in enumerate(gs):\n\n ax = plt.subplot(g)\n img = np.array(df[i].tolist()).reshape(28, 28)\n ax.imshow(img, cmap='gray')\n ax.set_xticks([])\n ax.set_yticks([])\n #ax.set_aspect('auto')\n ax.set_title(filenames[i])\n plt.show()","def plt_bboxes(img, classes, scores, bboxes, figsize=(17.78,10), linewidth=1.5):\n fig = plt.figure(figsize=figsize, frameon=False)\n ax = fig.add_axes([0, 0, 1, 1])\n ax.axis('off')\n plt.imshow(img)\n height = img.shape[0]\n width = img.shape[1]\n print (\"original height width\", height, width)\n if (classes.shape[0] > 0):\n print (\"This frame has class\")\n for i in range(classes.shape[0]):\n cls_id = int(classes[i])\n if cls_id >= 0:\n score = scores[i]\n if cls_id not in colors:\n colors[cls_id] = (random.random(), random.random(), random.random())\n ymin = int(bboxes[i, 0] * height)\n xmin = int(bboxes[i, 1] * width)\n ymax = int(bboxes[i, 2] * height)\n xmax = int(bboxes[i, 3] * width)\n rect = plt.Rectangle((xmin, ymin), xmax - xmin,\n ymax - ymin, fill=False,\n edgecolor=colors[cls_id],\n linewidth=linewidth)\n plt.gca().add_patch(rect)\n class_name = pascal_classes[cls_id]\n plt.gca().text(xmin, ymin - 2,\n '{:s} | {:.3f}'.format(class_name, score),\n bbox=dict(facecolor=colors[cls_id], alpha=0.5),\n fontsize=12, color='white')\n fig.canvas.draw()\n data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')\n data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n plt.close()\n print(\"Processed data with shape, \", data.shape)\n return data","def draw_boxes(indexes, frame, all_boxes):\n bbox = []\n mid_points = []\n\n for i in indexes:\n x = i[0]\n box = all_boxes[x]\n bbox.append(box)\n mid_points.append(mid_point(frame, box))\n x1, y1, w, h = box[0], box[1], box[2], box[3]\n x2, y2 = x1+w, y1+h\n\n cv2.rectangle(frame, (x1,y1),(x2,y2),(255,0,0),2) \n\n return mid_points, bbox","def __draw_boxes(self, img, bboxes, color=(128, 0, 0), thick=4):\n\n # Make a copy of the image\n imcopy = np.copy(img)\n # Iterate through the bounding boxes\n for bbox in bboxes:\n # Draw a rectangle given bbox coordinates\n cv2.rectangle(imcopy, bbox[0], bbox[1], color, thick)\n # Return the image copy with boxes drawn\n return imcopy","def setUp(self):\n img_path = osp.join(osp.dirname(__file__), '../../data/gray.jpg')\n self.results = {\n 'img_path':\n img_path,\n 'img_shape': (300, 400),\n 'instances': [{\n 'bbox': [0, 0, 10, 20],\n 'bbox_label': 1,\n 'mask': [[0, 0, 0, 20, 10, 20, 10, 0]],\n 'ignore_flag': 0\n }, {\n 'bbox': [10, 10, 110, 120],\n 'bbox_label': 2,\n 'mask': [[10, 10, 110, 10, 110, 120, 110, 10]],\n 'ignore_flag': 0\n }, {\n 'bbox': [50, 50, 60, 80],\n 'bbox_label': 2,\n 'mask': [[50, 50, 60, 50, 60, 80, 50, 80]],\n 'ignore_flag': 1\n }]\n }","def make_grid_bbox(tensor, box, nrow=8, padding=2,\n normalize=False, range=None, \n scale_each=False, pad_value=0, draw_line=False):\n\n # make the mini-batch of images into a grid\n # nmaps = tensor.size(0)\n nmaps = len(box)\n xmaps = min(nrow, nmaps)\n ymaps = int(math.ceil(float(nmaps) / xmaps))\n # height, width = int(tensor.size(2) + padding), int(tensor.size(3) + padding)\n height, width = int(256 + padding), int(256 + padding)\n tensor = torch.ones(())\n grid = tensor.new_full((3, height * ymaps + padding, width * xmaps + padding), pad_value)\n # # add the white image into the grid\n # block = tensor.new_full((3, height - padding, width - padding), 9.0/13)\n k = 0\n for y in irange(ymaps):\n for x in irange(xmaps):\n if k >= nmaps:\n break\n # add the white image into the grid\n block = tensor.new_full((3, height - padding, width - padding), 9.0/13)\n # print(box[0].size())\n # print(box[1].size())\n # assert False\n # num_curr_box = box[0][k].size(0)\n num_curr_box = box[k][0].size(0)\n for z in irange(num_curr_box):\n # label = box[1][k][z].item()\n try:\n label = box[k][1][z].item()\n except:\n print(box)\n print(k)\n assert False\n \n if label != -1:\n block = draw_box(block, box[k][0][z], label, draw_line)\n # print(k, z)\n else:\n break\n # copy to the grid\n grid.narrow(1, y * height + padding, height - padding)\\\n .narrow(2, x * width + padding, width - padding)\\\n .copy_(block)\n k = k + 1\n return grid","def _resize_bboxes(self, ori_bboxes, scale_factor):\n bboxes = ori_bboxes * scale_factor\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, self.img_shape[1])\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, self.img_shape[0])\n return bboxes","def draw_boxes_info(image, current_data):\n\n font_position1 = (50, 600)\n font_position2 = (50, 650)\n font_scale = .4\n font_thickness = 1\n\n locations = current_data[\"locations\"] #returns x1, y1, x2, y2\n frame_num = \"Frame Number: \" + str(current_data[\"frame_num\"])\n\n for box in locations:\n box_text = (\"Box locations are x1: {0}, y1: {1}, x2: {2}, y2: {3}\").format(box[1],box[3],box[0],box[2])\n\n cv2.rectangle(image, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 3)\n cv2.putText(image, box_text, font_position1, cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255),\n font_thickness, cv2.LINE_AA)\n\n cv2.putText(image, frame_num, font_position2, cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255),\n font_thickness, cv2.LINE_AA)\n\n return image","def display_precomputed_boxes(self, sample_index, all_boxes):\n image_rois = [class_detections[sample_index]\n for class_detections in all_boxes]\n\n image_rois_list = []\n image_classes = []\n for class_index, class_rois in enumerate(image_rois):\n if len(class_rois) > 0:\n classes = np.ones((class_rois.shape[0])) * class_index\n image_rois_list.extend(class_rois)\n image_classes.extend(classes)\n image_rois_list = np.array(image_rois_list)\n image_classes = np.array(image_classes)\n\n show_gt_boxes = False\n self.display_detections(image_rois_list, image_classes, \n self.data_loader.dataset.samples[sample_index])","def plot_n_box(img_prepro):\n print(img_prepro)\n h, w= img_prepro.shape\n boxes = pytesseract.image_to_boxes(img_prepro)\n for b in boxes.splitlines():\n b = b.split(' ')\n img_prepro = cv2.rectangle(img_prepro, (int(b[1]), h - int(b[2])), (int(b[3]), h - int(b[4])), (0, 255, 0), 2)\n cv2.imshow('img', img_prepro)\n cv2.waitKey(0)\n\n return","def setwinsize(self, rows, cols):","def onet_process(self, image, boxes, height, width):\n data = self.__padding(image, boxes, height, width)\n return data","def forward(self):\n priors = []\n for k, f in enumerate(self.feature_maps):\n scale = self.image_size / self.strides[k]\n # for i, j in product(range(f), repeat=2):\n for i in range(f[0]):\n for j in range(f[1]):\n # print(i, j)\n # unit center x,y\n cx = (j + 0.5) / scale\n cy = (i + 0.5) / scale\n\n # small sized square box\n size = self.min_sizes[k]\n h = w = size / self.image_size\n priors.append([cx, cy, w, h])\n\n # big sized square box\n size = sqrt(self.min_sizes[k] * self.max_sizes[k])\n h = w = size / self.image_size\n priors.append([cx, cy, w, h])\n\n # change h/w ratio of the small sized box\n size = self.min_sizes[k]\n h = w = size / self.image_size\n for ratio in self.aspect_ratios[k]:\n ratio = sqrt(ratio)\n priors.append([cx, cy, w * ratio, h / ratio])\n priors.append([cx, cy, w / ratio, h * ratio])\n\n priors = torch.Tensor(priors)\n if self.clip:\n priors.clamp_(max=1, min=0)\n return priors","def get_boxes():\n boxes = []\n\n box_sizes = [256]\n left_x_cords = [x for x in range(0,1280,12)]\n top_y_cords = [y for y in range(360,720,12)]\n\n for box_size in box_sizes:\n for x_cord in left_x_cords:\n for y_cord in top_y_cords:\n if box_size+x_cord < 1280 and box_size+y_cord < 720:\n boxes.append([x_cord, y_cord, x_cord+box_size, y_cord+box_size])\n\n return boxes","def __create_blank_page__(self):\n with open(\"active_weather.basic.exp\"+str(self.box_count)+\".box\",\"w\") as f:\n f.write(\"\")\n\n self.width = 2508\n # self.height = 200\n self.height = 4000\n self.training_page = np.zeros((self.height,self.width),dtype=np.uint8)\n self.training_page.fill(255)\n\n self.row_bitmaps = []\n self.row_characters = []\n\n self.row_pointer = spacing\n self.column_pointer = spacing\n\n\n # self.__box_file_flush__()\n self.box_file_entries = []\n self.used_height = spacing","def plot_image(image, boxes, class_dic, frame_n):\n im = np.array(image)\n print(im.shape)\n height, width, _ = im.shape\n\n # Create figure and axes\n # fig, ax = plt.subplots(1)\n # # Display the image\n # ax.imshow(im)\n\n fig = plt.figure()\n ax = fig.add_subplot(111, aspect='auto')\n ax.set_axis_off()\n fig.add_axes(ax)\n ax.imshow(im)\n # box[0] is x midpoint, box[2] is width\n # box[1] is y midpoint, box[3] is height\n\n # Create a Rectangle potch\n for box in boxes:\n class_ = int(box[0])\n confidence_ = box[1]\n box = box[2:]\n assert len(box) == 4, \"Got more values than in x, y, w, h, in a box!\"\n upper_left_x = box[0] - box[2] / 2\n upper_left_y = box[1] - box[3] / 2\n rect = patches.Rectangle(\n (upper_left_x * width, upper_left_y * height),\n box[2] * width,\n box[3] * height,\n linewidth=1,\n edgecolor=\"r\",\n facecolor=\"none\",\n )\n\n\n label_bbox = class_dic[class_] + \":::\" + f\"{100 * confidence_:.2f}\" + \"%\"\n plt.text(upper_left_x * width, upper_left_y * height - 10, label_bbox, size=10, rotation=0,\n ha=\"left\", va=\"bottom\",\n bbox=dict(boxstyle=\"square\",\n ec=(1, 0, 0),\n fc=(1, 0, 0),\n )\n )\n \n \n # Add the patch to the Axes\n ax.add_patch(rect)\n if frame_n:\n plt.savefig(str(frame_n) + '.png', dpi=200, bbox_inches=\"tight\", transparent=True, pad_inches=0)\n else:\n plt.show()","def setUp(self):\n self.single_box = [ScoredRect(Rect(0, 10, 0, 20), 0.0)]\n\n self.ground_truths = [ScoredRect(Rect(0, 10, 0, 10), 0.5),\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\n ScoredRect(Rect(-40, -30, -20, -10), 0.5),\n ]\n self.detections = [ScoredRect(Rect(0, 10, 0, 10), 0.5),\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\n ScoredRect(Rect(100, 110, 20, 30), 0.5),\n ]","def normalize_boxes(all_boxes, image_width, image_height):\n new_boxes = []\n for boxes_per_frame in all_boxes:\n new_boxes_per_frame = []\n for i, box in enumerate(boxes_per_frame):\n left, top, right, bottom = box\n new_boxes_per_frame.append((left / image_width, top / image_height, right / image_width, bottom / image_height))\n new_boxes.append(new_boxes_per_frame)\n\n assert(len(new_boxes) == len(all_boxes))\n for i, boxes_per_frame in enumerate(all_boxes):\n assert(len(boxes_per_frame) == len(new_boxes[i]))\n\n\n\n return new_boxes","def test_nominal_case(self):\n\n image_filename, boxes = list(annotation.read(self.filename))\n self.assertEqual(image_filename, 'image.jpg')\n self.assertEqual(len(boxes), 2)\n width = 400\n height = 300\n b = boxes[0]\n self.assertEqual(b.xmin, 10 / width)\n self.assertEqual(b.ymin, 20 / height)\n self.assertEqual(b.xmax, 30 / width)\n self.assertEqual(b.ymax, 40 / height)","def resize_spacing(img_sz,img_sp,factor):\n img_sz_np = np.array(list(img_sz))\n img_sp_np = np.array(list(img_sp))\n new_sz_np = img_sz_np*factor\n new_sp = img_sp_np*(img_sz_np-1)/(new_sz_np-1)\n return tuple(list(new_sp))","def __init__(self):\n toplevel_create_image = mw.tkinter.Toplevel(mw.MainWindow, bg = \"#a1a1a1\")\n \"\"\" top level window attributes\"\"\"\n toplevel_create_image.title(\"create new image\")\n toplevel_create_image.geometry(\"800x600+600+200\")\n toplevel_create_image.resizable(width = False, height = False)\n self. top_down = 60\n\n # UI\n image_width_label = mw.tkinter.Label(toplevel_create_image, text = \"Width: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n image_width_label.grid(row = 0, column = 0, padx = 20, pady = 20)\n image_height_label = mw.tkinter.Label(toplevel_create_image, text = \"Height: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n image_height_label.grid(row = 1, column = 0)\n\n # text box image size \n image_width_text_box = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n bg = \"grey\", fg = \"white\")\n image_width_text_box.grid(row = 0, column = 1, pady = 20)\n\n image_height_text_box = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n bg = \"grey\", fg = \"white\")\n image_height_text_box.grid(row = 1, column = 1)\n\n # color mode\n color_mode_combo_box = mw.tkinter.Label(toplevel_create_image, text = \"color mode: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n color_mode_combo_box.grid(row = 2, column = 0, padx = 20, pady = 20)\n\n # image_color_mode_text = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n # bg = \"grey\", fg = \"white\")\n # image_color_mode_text.grid(row = 2, column = 1)\n\n color_mode_combo_box = ttk.Combobox(toplevel_create_image, values = [\n \"RGB\",\n \"RGBA\",\n \"CYMA\"\n ])\n color_mode_combo_box.current(0)\n color_mode_combo_box.grid(row = 2, column = 1)\n\n # background color\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \"red: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n image_background_color_label.grid(row = 3, column = 0, padx = 30)\n\n image_background_color_text_red = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n bg = \"grey\", fg = \"white\")\n image_background_color_text_red.grid(row = 3, column = 1)\n# -----------------------------------------------------------------------------------------------------------\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \"green: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n image_background_color_label.grid(row = 4, column = 0, padx = 30)\n\n image_background_color_text_green = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n bg = \"grey\", fg = \"white\")\n image_background_color_text_green.grid(row = 4, column = 1)\n\n# ----------------------------------------------------------------------------------------------------------\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \"blue: \",\n font = (\"\", 15), bg = \"#a1a1a1\", fg = \"white\")\n image_background_color_label.grid(row = 5, column = 0, padx = 30)\n\n image_background_color_text_blue = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\n bg = \"grey\", fg = \"white\")\n image_background_color_text_blue.grid(row = 5, column = 1)\n # create_new_image\n def create_new_image():\n new_image = Image.new(mode = (color_mode_combo_box.get()),\n size = (int(image_width_text_box.get(\"1.0\", mw.tkinter.END)),\n int(image_height_text_box.get(\"1.0\", mw.tkinter.END)) ),\n color = ((int(image_background_color_text_red.get(\"1.0\", mw.tkinter.END))),\n (int(image_background_color_text_green.get(\"1.0\", mw.tkinter.END))),\n (int(image_background_color_text_blue.get(\"1.0\", mw.tkinter.END)))))\n # get new image properties\n the_width, the_height = new_image.size\n # to-do clear the image\n new_image_compatible = ImageTk.PhotoImage(new_image)\n # load the image on the canvas \n app.default_image_canvas.delete(\"all\")\n # app.default_image_canvas = mw.tkinter.Canvas(toplevel_create_image, height = the_height, width = the_width)\n app.default_image_canvas.create_image(0,0, image = new_image_compatible, anchor = mw.tkinter.NW)\n # app.load_image_canvas.grid(row = 0, column = 1)\n toplevel_create_image.destroy()\n # to-do - correct error\n app.default_image_canvas.configure(mw.MainWindow)\n \n\n\n # create_image_button\n create_image_button = mw.tkinter.Button(toplevel_create_image, text = \"create image\",\n bg = \"grey\", fg = \"white\", font = (\"times\", 13,\"bold\"),\n command = create_new_image)\n create_image_button.grid(row = 6, column = 0, padx = 40, pady = 20)","def draw_boxes(self, image, boxes):\n return draw_boxes(image, boxes, self.labels)","def initrows(self):\n #~ self.initrows2()\n self.rows=[]\n for yy in range(self.height):\n row=[]\n for xx in range(self.width):\n if (xx,yy) in self.allsqs:\n row.append(0)\n #~ elif p in self.gatesqs:\n #~ row.append(0)\n else:\n row.append(1)\n self.rows.append(row)","def rescale_box(box, img_size_orig, img_size_new):\n orig_w, orig_h = img_size_orig\n new_w, new_h = img_size_new\n scale_x = new_w / orig_w\n scale_y = new_h / orig_h\n sx, sy, ex, ey = box\n return [sx * scale_x, sy * scale_y, ex * scale_x, ey * scale_y]","def __getitem__(self, index):\n image_id = self.image_ids[index]\n\n filename = self.image_id_to_filename[image_id]\n image_path = os.path.join(self.image_dir, filename)\n\n with open(image_path, 'rb') as f:\n with PIL.Image.open(f) as image:\n WW, HH = image.size\n image = self.transform(image.convert('RGB'))\n\n H, W = self.image_size\n objs, boxes, masks = [], [], []\n\n for object_data in self.image_id_to_objects[image_id]:\n # objs.append(object_data['category_id'])\n objs.append(int(object_data.find('name').get(\"id\")))\n\n bndbox = object_data.findall('bndbox')[0]\n xmin = int(bndbox.find('xmin').text)\n ymin = int(bndbox.find('ymin').text)\n xmax = int(bndbox.find('xmax').text)\n ymax = int(bndbox.find('ymax').text)\n w = xmax - xmin\n h = ymax - ymin\n\n boxes.append(torch.FloatTensor([xmin, ymin, xmax, ymax]))\n\n # This will give a numpy array of shape (HH, WW)\n mask = torch.zeros(1, H, W)\n # mask = seg_to_mask(object_data['segmentation'], WW, HH)\n mask[:, round(ymin * H):max(round(ymin * H) + 1, round(ymax * H)),\n round(xmin * W):max(round(xmin * W) + 1, round(xmax * W))] = 1\n masks.append(mask)\n # shuffle objs\n O = len(objs)\n rand_idx = list(range(O))\n random.shuffle(rand_idx)\n\n objs = [objs[i] for i in rand_idx]\n boxes = [boxes[i] for i in rand_idx]\n masks = [masks[i] for i in rand_idx]\n\n objs = torch.LongTensor(objs)\n boxes = torch.stack(boxes, dim=0)\n masks = torch.stack(masks, dim=0)\n\n # print(image_path)\n\n return image, objs, boxes, masks","def show_field(self, vehicles, type):\n\n # starting pixels x = 0, y = 0 on field image\n start_x = 78\n start_y = 45\n\n # block pixel width is slightly different per field size\n if self.size == 6:\n block_width = 72\n elif self.size == 9:\n block_width = 69\n elif self.size == 12:\n block_width = 68.5\n\n field = plt.imread(f\"data/RushHourImages/RushHour{self.size}.jpg\")\n fig, ax = plt.subplots()\n plt.imshow(field)\n plt.axis('off')\n\n for vehicle in vehicles:\n if vehicle.orientation == 'H':\n x = start_x + (vehicle.x * block_width)\n y = start_y + (vehicle.y * block_width)\n if vehicle.length == 2:\n car = plt.imread(f\"data/RushHourImages/Car{vehicle.id}.png\")\n else:\n car = plt.imread(f\"data/RushHourImages/Truck{vehicle.id}.png\")\n\n # truck: the image coordinate is his middle, which changes with the length of the car\n x += 40\n\n if vehicle.orientation == 'V':\n x = start_y + (vehicle.x * block_width)\n y = start_x + (vehicle.y * block_width)\n if vehicle.length == 2:\n car = plt.imread(f\"data/RushHourImages/Car-rotated{vehicle.id}.png\")\n else:\n car = plt.imread(f\"data/RushHourImages/Truck-rotated{vehicle.id}.png\")\n y += 40\n\n if self.size == 6:\n imagebox = OffsetImage(car, zoom=0.6)\n elif self.size == 9:\n imagebox = OffsetImage(car, zoom=0.4)\n elif self.size == 12:\n imagebox = OffsetImage(car, zoom=0.3)\n\n imagebox.image.axes = ax\n xy = (x, y)\n ab = AnnotationBbox(imagebox, xy, frameon=False)\n ax.add_artist(ab)\n\n if type == True:\n plt.show(block=False)\n plt.pause(0.001)\n plt.close()\n else:\n plt.show()","def proposal_boxes(self, fmap, im_sizes, image_offset, gt_boxes=None, gt_classes=None, gt_rels=None, train_anchor_inds=None, proposals=None):\n assert proposals is not None\n rois = filter_roi_proposals(proposals[:, 2:].data.contiguous(), proposals[:, 1].data.contiguous(), np.array([2000] * len(im_sizes)), nms_thresh=0.7, pre_nms_topn=12000 if self.training and self.mode == 'rpntrain' else 6000, post_nms_topn=2000 if self.training and self.mode == 'rpntrain' else 1000)\n if self.training:\n all_rois, labels, bbox_targets = proposal_assignments_det(rois, gt_boxes.data, gt_classes.data, image_offset, fg_thresh=0.5)\n all_rois = torch.cat((all_rois, Variable(rois)), 0)\n else:\n all_rois = Variable(rois, volatile=True)\n labels = None\n bbox_targets = None\n rpn_scores = None\n rpn_box_deltas = None\n rel_labels = None\n return all_rois, labels, bbox_targets, rpn_scores, rpn_box_deltas, rel_labels","def _to_image_coords(self, boxes, height, width):\n box_coords = np.zeros_like(boxes)\n box_coords[:, 0] = boxes[:, 0] * height\n box_coords[:, 1] = boxes[:, 1] * width\n box_coords[:, 2] = boxes[:, 2] * height\n box_coords[:, 3] = boxes[:, 3] * width\n \n return box_coords","def boxplots(self, groups, nrows, ncols, type):\n fig, axs = plt.subplots(nrows=nrows, ncols=ncols, figsize=(6, 9.3), sharey=\"row\")\n\n fig.subplots_adjust(left=0.03, right=0.97, hspace=0.3, wspace=0.05)\n\n for ax, (effs, dat) in zip(axs, groups):\n ax[0].boxplot(dat[\"perm\"])\n ax[1].boxplot(dat[\"t_test\"])\n ax[0].set_ylabel(\"Errors\")\n if type == \"es\":\n ax[0].set_title(f\"Effect size = {effs}, Test = Perm\")\n ax[1].set_title(f\"Effect size = {effs}, Test = t-test\")\n elif type == \"samp2\":\n ax[0].set_title(f\"Sample size = {effs}, Test = Perm\")\n ax[1].set_title(f\"Sample size = {effs}, Test = t-test\")\n\n\n plt.tight_layout()\n #plt.show()","def draw_bboxes_withindex(img,boxes, uids):\n source = Image.fromarray(img)\n draw = ImageDraw.Draw(source)\n w2,h2 = (img.shape[0],img.shape[1])\n \n font = ImageFont.truetype('/usr/share/fonts/truetype/freefont/FreeSerif.ttf', 40)\n #font = ImageFont.truetype('arial.ttf', 24)\n\n\n idx = 0\n\n for b in boxes:\n xmin,ymin,xmax,ymax = b\n \n for j in range(3):\n draw.rectangle(((xmin+j, ymin+j), (xmax+j, ymax+j)), outline=\"red\")\n draw.text((xmin+20, ymin+70), str(uids[idx]), font = font)\n idx +=1\n return source","def load_boxes(self, data):\r\n\r\n # worldbox represents the total map area\r\n self.worldbox = self.Box((0, 0), (len(data[0]) * self.cellwidth, len(data) * self.cellwidth))\r\n\r\n # create a box corresponding to each character/cell in the map file\r\n tl_x = 0\r\n tl_y = 0\r\n for row in data:\r\n for cell in row:\r\n if cell == \".\":\r\n self.wallboxes += [self.Box((tl_x, tl_y), (tl_x + self.cellwidth, tl_y + self.cellwidth))]\r\n elif cell == \"x\":\r\n self.targetboxes += [self.Box((tl_x, tl_y), (tl_x + self.cellwidth, tl_y + self.cellwidth))]\r\n tl_x += self.cellwidth\r\n tl_x = 0\r\n tl_y += self.cellwidth","def layout_graphics(self):\n # Graphics layout object to place viewboxes in\n self.g_layout = pg.GraphicsLayoutWidget(border=(80, 80, 80))\n self.g_layout.setCursor(QtCore.Qt.CrossCursor)\n\n # Viewboxes for images\n # aspect locked so that pixels are square\n # y inverted so that (0,0) is top left as in Thorlabs software\n options = {\"lockAspect\":True, \"invertY\":True}\n self.vb_image = self.g_layout.addViewBox(row=0, col=0, rowspan=2, **options)\n self.vb_zoom = self.g_layout.addViewBox(row=0, col=2, **options)\n self.vb_residuals = self.g_layout.addViewBox(row=1, col=2, **options)\n\n # Link zoom and residual views\n self.vb_zoom.setXLink(self.vb_residuals)\n self.vb_zoom.setYLink(self.vb_residuals)\n\n # Viewboxes for slice data\n # Both boxes have mouse disabled - range is fixed so we don't want to\n # scale them accidentally\n # Y box has y inverted to match the main image\n # Y box has x inverted so that zero pixel value is far from the image\n options = {\"enableMouse\":False, \"enableMenu\": False}\n self.vb_x = self.g_layout.addViewBox(row=2, col=0, **options)\n self.vb_y = self.g_layout.addViewBox(row=0, col=1, rowspan=2,\n invertX=True, invertY=True, **options)\n\n # Link the slice axes to the main image so that when we zoom/pan the\n # main image, our slices zoom/pan also\n self.vb_x.setXLink(self.vb_image)\n self.vb_y.setYLink(self.vb_image)\n\n # Disable autoscaling and fix range to maximum pixel intensity\n self.vb_x.setRange(yRange=(0,255))\n self.vb_y.setRange(xRange=(0,255))\n self.vb_x.disableAutoRange(axis=self.vb_x.YAxis)\n self.vb_y.disableAutoRange(axis=self.vb_y.XAxis)\n\n # Background color must not be black so that we can see where images\n # start/end\n color = pg.mkColor(40,40,40)\n self.vb_image.setBackgroundColor(color)\n self.vb_zoom.setBackgroundColor(color)\n self.vb_residuals.setBackgroundColor(color)\n self.vb_x.setBackgroundColor(color)\n self.vb_y.setBackgroundColor(color)\n self.g_layout.setBackground(color)\n\n self.vb_image.addItem(self.image)\n self.vb_image.addItem(self.fit_v_line)\n self.vb_image.addItem(self.fit_h_line)\n self.vb_image.addItem(self.mark_v_line)\n self.vb_image.addItem(self.mark_h_line)\n # self.vb_image.addItem(self.cursor_text)\n self.vb_image.addItem(self.cursor_delta)\n self.vb_image.addItem(self.beam_delta)\n self.vb_image.addItem(self.history_plot)\n # Figure out how to overlay properly?\n # self.vb_image.addItem(self.x_slice)\n # self.vb_image.addItem(self.x_fit)\n # self.vb_image.addItem(self.y_slice)\n # self.vb_image.addItem(self.y_fit)\n self.vb_zoom.addItem(self.zoom)\n self.vb_zoom.addItem(self.fit_maj_line)\n self.vb_zoom.addItem(self.fit_min_line)\n self.vb_zoom.addItem(self.zoom_text)\n self.vb_residuals.addItem(self.residuals)\n self.vb_residuals.addItem(self.residuals_text)\n self.vb_x.addItem(self.x_slice)\n self.vb_x.addItem(self.x_fit)\n self.vb_x.addItem(self.cursor_v)\n self.vb_y.addItem(self.y_slice)\n self.vb_y.addItem(self.y_fit)\n self.vb_y.addItem(self.cursor_h)\n\n self.res_legend.setParentItem(self.vb_residuals)\n self.cursor_text.setParentItem(self.vb_image)\n\n self.vb_image.setRange(QtCore.QRectF(0, 0, 1280, 1024))\n self.vb_zoom.setRange(QtCore.QRectF(0, 0, 50, 50))\n self.vb_residuals.setRange(QtCore.QRectF(0, 0, 50, 50))\n\n #\n # Size hints below here\n #\n self.g_layout.ci.layout.setColumnStretchFactor(0, 4)\n self.g_layout.ci.layout.setColumnStretchFactor(1, 1)\n self.g_layout.ci.layout.setColumnStretchFactor(2, 2)\n self.g_layout.ci.layout.setRowStretchFactor(0, 2)\n self.g_layout.ci.layout.setRowStretchFactor(1, 2)\n self.g_layout.ci.layout.setRowStretchFactor(2, 1)\n\n self.vb_x.setMinimumHeight(50)\n self.vb_y.setMinimumWidth(50)\n self.vb_x.setMaximumHeight(100)\n self.vb_y.setMaximumWidth(100)\n self.vb_image.setMinimumSize(640, 512)\n self.vb_zoom.setMinimumSize(320, 320)\n self.vb_residuals.setMinimumSize(320, 320)\n\n self.g_layout.setMinimumSize(1100,562)","def plantGrid(name, minimum, maximum, spacing):\n name = sys.argv[1]\n minimum = sys.argv[2]\n maximum = sys.argv[3]\n minimum = int(minimum)\n maximum = int(maximum)\n #convert to flux\n min1 = conversion(minimum)\n max1 = conversion(maximum)\n min1 = int(min1)\n max1 = int(max1)\n #brightness = [random.uniform(min1, max1) for _ in xrange(len(position))]\n #print brightness\n spacing = sys.argv[4]\n spacing = float(spacing)\n print len(data1)\n #create the position array for x values\n x = np.arange(6, len(data1), spacing)\n #create the position array for y values\n y = np.arange(6, len(data1), spacing)\n x2 = np.arange(6, len(data1), spacing)\n y2 = np.flipud(y)\n \n #combine both arrays to form a grid\n position = np.column_stack((x,y))\n position2 = np.column_stack((x2,y2))\n \n #combine both lines of grid to one array\n position = np.concatenate((position, position2), axis = 0)\n \n #create a random brightness array between the min and max values\n brightness = np.array([random.uniform(min1, max1) for _ in range(0,len(position))])\n \n #add to image file and subtract\n fakestars.addtofits(name, out_file, psf, position, brightness, coordsys, verbose)\n fakestars.addtofits(name, outfile2, psf, position, brightness, coordsys, verbose)\n imarith.imsubtract(out_file, outfile2, differenceFile, clobber=True)","def prepare_map(self):\n for y, row in enumerate(self.contents):\n for x, tile in enumerate(row):\n bm = self.get_tile(tile)\n self.image[\n y * TILE_SIZE : (y + 1) * TILE_SIZE,\n x * TILE_SIZE : (x + 1) * TILE_SIZE,\n ] = bm","def scale_box(box, img_size):\n xscale = img_size[0] / FLAGS.size\n yscale = img_size[1] / FLAGS.size\n x0, y0, x1, y1 = box\n return [\n float(x0) * xscale,\n float(y0) * yscale,\n float(x1) * xscale,\n float(y1) * yscale,\n ]","def initialize(self, frame):\n self.grid_size = 5\n\n Label(frame, text=\"Grid Size:\").grid(row=0)\n\n self.e1 = Scale(frame, from_=self.grid_size, to=25, orient=HORIZONTAL)\n self.e1.grid(row=0, column=1)\n\n return self.e1","def make(self) -> None:\n\n # arbitrarily selecting the first image from the list, index 0\n with Image.open(self.image_list[0]) as first_frame_image_in_list:\n\n # Find the width and height of the first image of the list.\n # Assuming all the images have same size.\n frame_image_width, frame_image_height = first_frame_image_in_list.size\n\n # scale is the ratio of collage_image_width and product of\n # images_per_row_in_collage with frame_image_width.\n\n # The scale will always lie between 0 and 1, which implies that\n # the images are always going to get downsized.\n scale = (self.collage_image_width) / (\n self.images_per_row_in_collage * frame_image_width\n )\n\n # Calculating the scaled height and width for the frame image.\n scaled_frame_image_width = ceil(frame_image_width * scale)\n scaled_frame_image_height = ceil(frame_image_height * scale)\n\n # Divide the number of images by images_per_row_in_collage. The later\n # was calculated by taking the square root of total number of images.\n number_of_rows = ceil(self.number_of_images / self.images_per_row_in_collage)\n\n # Multiplying the height of one downsized image with number of rows.\n # Height of 1 downsized image is product of scale and frame_image_height\n # Total height is number of rows times the height of one downsized image.\n self.collage_image_height = ceil(scale * frame_image_height * number_of_rows)\n\n # Create an image of passed collage_image_width and calculated collage_image_height.\n # The downsized images will be pasted on this new base image.\n # The image is 0,0,0 RGB(black).\n collage_image = Image.new(\n \"RGB\", (self.collage_image_width, self.collage_image_height)\n )\n\n # keep track of the x and y coordinates of the resized frame images\n i, j = (0, 0)\n\n # iterate the frames and paste them on their position on the collage_image\n for count, frame_path in enumerate(self.image_list):\n\n # Set the x coordinate to zero if we are on the first column\n # If self.images_per_row_in_collage is 4\n # then 0,4,8 and so on should have their x coordinate as 0\n if (count % self.images_per_row_in_collage) == 0:\n i = 0\n\n # open the frame image, must open it to resize it using the thumbnail method\n frame = Image.open(frame_path)\n\n # scale the opened frame images\n frame.thumbnail(\n (scaled_frame_image_width, scaled_frame_image_height), Image.ANTIALIAS\n )\n\n # set the value of x to that of i's value.\n # i is set to 0 if we are on the first column.\n x = i\n\n # It ensures that y coordinate stays the same for any given row.\n # The floor of a real number is the largest integer that is less\n # than or equal to the number. floor division is used because of\n # the zero based indexing, the floor of the division stays same\n # for an entier row as the decimal values are negled by the floor.\n # for the first row the result of floor division is always zero and\n # the product of 0 with scaled_frame_image_height is also zero, they\n # y coordinate for the first row is 0.\n # For the second row the result of floor division is one and the prodcut\n # with scaled_frame_image_height ensures that the y coordinate is\n # scaled_frame_image_height below the first row.\n y = (j // self.images_per_row_in_collage) * scaled_frame_image_height\n\n # paste the frame image on the newly created base image(base image is black)\n collage_image.paste(frame, (x, y))\n frame.close()\n\n # increase the x coordinate by scaled_frame_image_width\n # to get the x coordinate of the next frame. unless the next image\n # will be on the very first column this will be the x coordinate.\n i = i + scaled_frame_image_width\n\n # increase the value of j by 1, this is to calculate the y coordinate of\n # next image. The increased number will be floor divided by images_per_row_in_collage\n # therefore the y coordinate stays the same for any given row.\n j += 1\n\n # save the base image with all the scaled frame images embeded on it.\n collage_image.save(self.output_path)\n collage_image.close()","def _build_meds_layout(self):\n\n\n nim = self.image_info.size\n nobj = self.obj_data.size\n\n trim_to_coadd = self.get('trim_to_coadd',False)\n if trim_to_coadd:\n print(' trimming to coadd')\n coadd_wcs, coadd_pos, coadd_bnds, coadd_q = \\\n self._get_pos_and_bounds(self.obj_data, 0)\n in_bnds = coadd_bnds.contains_points(coadd_pos['zrow'], coadd_pos['zcol'])\n w_in_bnds, = np.where(in_bnds == True)\n assert w_in_bnds.size > 0,\"none found in coadd\"\n\n w_in_bnds = coadd_q[w_in_bnds]\n self.obj_data = self.obj_data[w_in_bnds]\n\n self._do_psf_setup()\n\n # box sizes are even\n half_box_size = self.obj_data['box_size']//2\n\n for file_id in range(nim):\n\n wcs, pos, bnds, q = self._get_pos_and_bounds(self.obj_data, file_id)\n\n # do the test\n in_bnds = bnds.contains_points(pos['zrow'], pos['zcol'])\n q_rc, = np.where(in_bnds == True)\n print(' second cut: %6d of %6d objects' % (len(q_rc),len(q)))\n\n # now make sure everything is there\n if self['check_in_first_image']:\n if file_id == 0 and len(self.obj_data['ra']) != len(q_rc):\n raise MEDSCreationError('Not all objects were found in first image for '\n 'MEDS making (which is the coadd/detection '\n 'image by convention).')\n # compose them\n q = q[q_rc]\n\n # fill in the object_data structure\n\n # note q_rc since pos was created using obj_data[q]\n qrow = pos['zrow'][q_rc]\n qcol = pos['zcol'][q_rc]\n\n icut = self.obj_data['ncutout'][q]\n self.obj_data['file_id'][q,icut] = file_id\n self.obj_data['orig_row'][q,icut] = qrow\n self.obj_data['orig_col'][q,icut] = qcol\n\n # this results in the object center being close to\n # the natural center (dim-1.)/2.\n ostart_row = qrow.astype('i4') - half_box_size[q] + 1\n ostart_col = qcol.astype('i4') - half_box_size[q] + 1\n crow = qrow - ostart_row\n ccol = qcol - ostart_col\n\n self.obj_data['orig_start_row'][q,icut] = ostart_row\n self.obj_data['orig_start_col'][q,icut] = ostart_col\n self.obj_data['cutout_row'][q,icut] = crow\n self.obj_data['cutout_col'][q,icut] = ccol\n\n # do jacobian, in original, not-offset coords\n # note q_rc since pos was created using self.obj_data[q]\n jacob = wcs.get_jacobian(\n x=pos['wcs_col'][q_rc],\n y=pos['wcs_row'][q_rc])\n\n # jacob is a tuple of arrays\n self.obj_data['dudcol'][q,icut] = jacob[0]\n self.obj_data['dudrow'][q,icut] = jacob[1]\n self.obj_data['dvdcol'][q,icut] = jacob[2]\n self.obj_data['dvdrow'][q,icut] = jacob[3]\n\n # increment\n self.obj_data['ncutout'][q] += 1\n\n w,=np.where(self.obj_data['ncutout'] > 0)\n print('%d/%d had ncut > 0' % (w.size, self.obj_data.size))\n #self.obj_data = self.obj_data[w]\n\n self.obj_data = self._make_resized_data(self.obj_data)\n print('setting number field as sequential')\n self.obj_data['number'] = 1+np.arange(self.obj_data.size)\n\n\n self._set_start_rows_and_pixel_count()\n\n if self['survey']=='cosmos':\n self._set_psf_layout_hst()\n else:\n self._set_psf_layout_psfex()","def set_default_parameters(self):\n super().set_default_parameters()\n if not \"region_size\" in vars(self):\n self.region_size = 0.08\n if not \"RGB_bands\" in vars(self):\n self.RGB_bands = [\"B4\",\"B3\",\"B2\"]\n if not \"split_RGB_images\" in vars(self):\n self.split_RGB_images = True\n # in PROCESSED dir we expect RGB. NDVI, BWNDVI\n self.num_files_per_point = 3"],"string":"[\n \"def _set_psf_layout_hst(self):\\n\\n print('setting psf layout for HST')\\n obj_data=self.obj_data\\n\\n total_psf_pixels = 0\\n psf_start_row = 0\\n\\n for iobj in range(obj_data.size):\\n if (iobj+1) % 100 == 0:\\n print(' %d/%d' % (iobj+1,obj_data.size))\\n\\n # note assuming same psf for all \\\"epochs\\\"\\n psf_im = self.psf_data.get_psf(iobj)\\n\\n psf_shape = psf_im.shape\\n psf_npix = psf_im.size\\n\\n cen = (np.array(psf_shape)-1.0)/2.0\\n\\n # we will expand the psfs\\n\\n for icut in range(obj_data['ncutout'][iobj]):\\n\\n obj_data['psf_row_size'][iobj,icut] = psf_shape[0]\\n obj_data['psf_col_size'][iobj,icut] = psf_shape[1]\\n obj_data['psf_cutout_row'][iobj,icut] = cen[0]\\n obj_data['psf_cutout_col'][iobj,icut] = cen[1]\\n obj_data['psf_start_row'][iobj,icut] = psf_start_row\\n\\n psf_start_row += psf_npix\\n total_psf_pixels += psf_npix\\n\\n self.total_psf_pixels = total_psf_pixels\",\n \"def generate_boxes(self, img):\\r\\n return [Box(left, top, img) for (left, top) in self.coords]\",\n \"def build_filler_images(self):\",\n \"def draw_boxes(self, im, boxes):\\n for bbox in boxes:\\n l = [int(x) for x in bbox[\\\"coords\\\"]]\\n l = self.scalebox(l)\\n icon = self.classes_to_icons[bbox[\\\"label\\\"]]\\n overlay_im_to_background(im, icon, l[0], l[1] - icon.shape[0] - 5)\\n cv2.rectangle(im,(l[0],l[1]),(l[2],l[3]),self.color,2)\",\n \"def makeImage(self):\\n\\n for row in range(self.height):\\n self.makeRow(row)\\n self.window.update() # display a row of pixels\",\n \"def _get_boxes(self, idx):\\n # Load Image\\n path = self.df.hsi_path.iloc[idx]\\n im = self._load_im(path)\\n\\n # Crop out box\\n r_box_im = self.df.width.iloc[idx] / im.shape[-1] # Ratio of RGB im box coords to load im width (e.g., r=10 for hsi)\\n box = np.array([self.df.ymin.iloc[idx], self.df.ymax.iloc[idx], self.df.xmin.iloc[idx], self.df.xmax.iloc[idx]])\\n box = np.around(box / r_box_im).astype(int)\\n\\n crop_im = im[:, box[0]:box[1]+1, box[2]:box[3]+1]\\n if np.any(np.array(crop_im.shape) == 0):\\n print('[WARNING] Loaded box has zero shape and is sketchily inflated. TODO: skip this box with ID', idx)\\n if box[0] == self.df.width.iloc[idx]/r_box_im: box[0] -= 1\\n if box[2] == self.df.height.iloc[idx]/r_box_im: box[2] -= 1\\n crop_im = im[:, box[0]:box[1]+1, box[2]:box[3]+1]\\n\\n target = {}\\n target[\\\"labels\\\"] = self.df.class_id.iloc[idx]\\n target[\\\"uid\\\"] = self.df.uid.iloc[idx]\\n \\n\\n return crop_im, target\",\n \"def _get_box_sizes(self, image_info, cat):\\n\\n\\n file_id=0\\n impath=image_info['image_path'][file_id].strip()\\n ext=image_info['image_ext'][file_id]\\n wcs_data = fitsio.read_header(impath, ext=ext)\\n wcs = eu.wcsutil.WCS(wcs_data)\\n\\n\\n jacob = wcs.get_jacobian(100,100)\\n dudcol, dudrow, dvdcol, dvdrow = jacob\\n\\n det = dvdrow*dudcol - dvdcol*dudrow\\n pixel_scale = np.sqrt(abs(det))\\n print('found pixel scale:',pixel_scale)\\n box_size = cat['box_size_arcsec']/pixel_scale\\n\\n # clip to range\\n box_size.clip(\\n min=self['min_box_size'],\\n max=self['max_box_size'],\\n out=box_size,\\n )\\n box_size = box_size.astype('i4')\\n\\n w,=np.where( ( (box_size % 2) != 0 ) )\\n if w.size > 0:\\n box_size[w] += 1\\n\\n return box_size\",\n \"def setBoxsize(length,width,height):\\n return length,width,height\",\n \"def draw_boxs(img,boxs,width=3,color=(0,0,255)):\\n box_img = copy.deepcopy(img)\\n for i in range(boxs.shape[0]):\\n # x1,y1,x2,y2=boxs[i]\\n x1 = boxs[i][0]\\n y1 = boxs[i][1]\\n x2 = boxs[i][2]\\n y2 = boxs[i][3]\\n p1 = (int(round(x1)),int(round(y1)))\\n p2 = (int(round(x2)),int(round(y2)))\\n cv2.rectangle(box_img, p1, p2, color, width)\\n\\n return box_img\",\n \"def setUp(self):\\r\\n center = [1,1]\\r\\n size = 1\\r\\n self.imageinfo = ImageInfo(center, size)\",\n \"def setUp(self):\\r\\n center = [1,1]\\r\\n size = 1\\r\\n self.imageinfo = ImageInfo(center, size)\",\n \"def setUp(self):\\r\\n center = [1,1]\\r\\n size = 1\\r\\n self.imageinfo = ImageInfo(center, size)\",\n \"def setUp(self):\\r\\n center = [1,1]\\r\\n size = 1\\r\\n self.imageinfo = ImageInfo(center, size)\",\n \"def setUp(self):\\r\\n center = [1,1]\\r\\n size = 1\\r\\n self.imageinfo = ImageInfo(center, size)\",\n \"def __init__(self, nb_sub_images, window_size, recovery, image_horiz_size):\\n self.nb_sub_images = nb_sub_images\\n self.window_size = window_size\\n self.recovery = recovery\\n self.image_horiz_size = image_horiz_size\",\n \"def _resize_bboxes(self, results):\\n img_shape = results['img_shape']\\n for key in results.get('bbox_fields', []):\\n bboxes = []\\n for box in results[key]:\\n tmp_box = np.array(box, dtype=np.float32)\\n tmp_box[0::2] *= results['scale_factor'][0]\\n tmp_box[1::2] *= results['scale_factor'][1]\\n if self.bbox_clip_border:\\n tmp_box[0::2] = np.clip(tmp_box[0::2], 0, img_shape[1])\\n tmp_box[1::2] = np.clip(tmp_box[1::2], 0, img_shape[0])\\n bboxes.append(tmp_box)\\n if len(results[key]) > 0:\\n results[key] = bboxes\",\n \"def _resize_bboxes(self, results):\\n for key in results.get('bbox_fields', []):\\n bboxes = results[key] * results['scale_factor']\\n if self.bbox_clip_border:\\n img_shape = results['img_shape']\\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])\\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])\\n results[key] = bboxes\",\n \"def _resize_bboxes(self, results):\\n for key in results.get('bbox_fields', []):\\n bboxes = results[key] * results['scale_factor']\\n if self.bbox_clip_border:\\n img_shape = results['img_shape']\\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])\\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])\\n results[key] = bboxes\",\n \"def set_box(self) -> None:\\n from pymol import cmd\\n\\n # Delete Box object in PyMOL\\n if \\\"box\\\" in cmd.get_names(\\\"selections\\\"):\\n cmd.delete(\\\"box\\\")\\n # Get dimensions of selected residues\\n selection = \\\"sele\\\"\\n if selection in cmd.get_names(\\\"selections\\\"):\\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(selection)\\n else:\\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(\\\"\\\")\\n \\n # Get center of each dimension (x, y, z)\\n self.x = (min_x + max_x) / 2\\n self.y = (min_y + max_y) / 2\\n self.z = (min_z + max_z) / 2\\n\\n # Set Box variables in interface\\n self.min_x.setValue(round(self.x - (min_x - self.padding.value()), 1))\\n self.max_x.setValue(round((max_x + self.padding.value()) - self.x, 1))\\n self.min_y.setValue(round(self.y - (min_y - self.padding.value()), 1))\\n self.max_y.setValue(round((max_y + self.padding.value()) - self.y, 1))\\n self.min_z.setValue(round(self.z - (min_z - self.padding.value()), 1))\\n self.max_z.setValue(round((max_z + self.padding.value()) - self.z, 1))\\n self.angle1.setValue(0)\\n self.angle2.setValue(0)\\n\\n # Setting background box values\\n self.min_x_set = self.min_x.value()\\n self.max_x_set = self.max_x.value()\\n self.min_y_set = self.min_y.value()\\n self.max_y_set = self.max_y.value()\\n self.min_z_set = self.min_z.value()\\n self.max_z_set = self.max_z.value()\\n self.angle1_set = self.angle1.value()\\n self.angle2_set = self.angle2.value()\\n self.padding_set = self.padding.value()\\n\\n # Draw box\\n self.draw_box()\\n\\n # Enable/Disable buttons\\n self.button_draw_box.setEnabled(False)\\n self.button_redraw_box.setEnabled(True)\\n self.min_x.setEnabled(True)\\n self.min_y.setEnabled(True)\\n self.min_z.setEnabled(True)\\n self.max_x.setEnabled(True)\\n self.max_y.setEnabled(True)\\n self.max_z.setEnabled(True)\\n self.angle1.setEnabled(True)\\n self.angle2.setEnabled(True)\",\n \"def analyzeImages(path, name_type, box1_size, box2_size, box3_size, box4_size, box5_size):\\n \\n folders = [f for f in sorted(glob.glob(path + \\\"/**\\\"))]\\n \\n for folder in folders: \\n \\n # to save this data frame in a csv file\\n \\n files = [f for f in sorted(glob.glob(folder + \\\"/**\\\" + \\\".jpg\\\"))]\\n \\n centroidsDf = pd.DataFrame(np.zeros([len(files), 11]),columns=[\\\"frame\\\", \\\"fly1_x\\\", \\\"fly1_y\\\", \\\"fly2_x\\\", \\\"fly2_y\\\", \\\"fly3_x\\\", \\\"fly3_y\\\", \\\"fly4_x\\\", \\\"fly4_y\\\", \\\"fly5_x\\\", \\\"fly5_y\\\"]);\\n headsDf = pd.DataFrame(np.zeros([len(files), 11]),columns=[\\\"frame\\\", \\\"fly1_x\\\", \\\"fly1_y\\\", \\\"fly2_x\\\", \\\"fly2_y\\\", \\\"fly3_x\\\", \\\"fly3_y\\\", \\\"fly4_x\\\", \\\"fly4_y\\\", \\\"fly5_x\\\", \\\"fly5_y\\\"]);\\n \\n img_array1 = []\\n img_array2 = []\\n img_array3 = []\\n img_array4 = []\\n img_array5 = []\\n\\n for file in files:\\n \\n print(file)\\n \\n centroidsDf[\\\"frame\\\"][files.index(file)] = files.index(file)+1\\n headsDf[\\\"frame\\\"][files.index(file)] = files.index(file)+1\\n \\n img = cv2.imread(file)\\n \\n ## FLY 1 ##\\n\\n box1 = img[box1_size[0]:box1_size[1], box1_size[2]:box1_size[3]]\\n \\n # image processing to get the centroid and head positions\\n x_centroid, y_centroid, x_head, y_head = findCentroid(box1, file) \\n \\n # add the centroid and head locations on the image \\n box1 = cv2.circle(box1, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\\n box1 = cv2.circle(box1, (x_head, y_head), 7, (0, 0, 255), -1)\\n img_array1.append(box1)\\n \\n # add the positions in the final data frame\\n centroidsDf[\\\"fly1_x\\\"][files.index(file)] = x_centroid\\n centroidsDf[\\\"fly1_y\\\"][files.index(file)] = y_centroid\\n \\n headsDf[\\\"fly1_x\\\"][files.index(file)] = x_head\\n headsDf[\\\"fly1_y\\\"][files.index(file)] = y_head\\n \\n ## FLY 2 ##\\n \\n box2 = img[box2_size[0]:box2_size[1], box2_size[2]:box2_size[3]]\\n \\n # image processing to get the centroid and head positions\\n x_centroid, y_centroid, x_head, y_head = findCentroid(box2, file)\\n \\n # add the centroid and head locations on the image \\n box2 = cv2.circle(box2, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\\n box2 = cv2.circle(box2, (x_head, y_head), 7, (0, 0, 255), -1)\\n img_array2.append(box2)\\n \\n # add the positions in the final data frame \\n centroidsDf[\\\"fly2_x\\\"][files.index(file)] = x_centroid\\n centroidsDf[\\\"fly2_y\\\"][files.index(file)] = y_centroid\\n \\n headsDf[\\\"fly2_x\\\"][files.index(file)] = x_head\\n headsDf[\\\"fly2_y\\\"][files.index(file)] = y_head\\n \\n ## FLY 3 ##\\n\\n box3 = img[box3_size[0]:box3_size[1], box3_size[2]:box3_size[3]]\\n \\n # image processing to get the centroid and head positions\\n x_centroid, y_centroid, x_head, y_head = findCentroid(box3, file)\\n \\n # add the centroid and head locations on the image \\n box3 = cv2.circle(box3, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\\n box3 = cv2.circle(box3, (x_head, y_head), 7, (0, 0, 255), -1)\\n img_array3.append(box3)\\n\\n # add the positions in the final data frame\\n centroidsDf[\\\"fly3_x\\\"][files.index(file)] = x_centroid\\n centroidsDf[\\\"fly3_y\\\"][files.index(file)] = y_centroid\\n \\n headsDf[\\\"fly3_x\\\"][files.index(file)] = x_head\\n headsDf[\\\"fly3_y\\\"][files.index(file)] = y_head\\n \\n ## FLY 4 ##\\n \\n box4 = img[box4_size[0]:box4_size[1], box4_size[2]:box4_size[3]]\\n \\n # image processing to get the centroid and head positions\\n x_centroid, y_centroid, x_head, y_head = findCentroid(box4, file)\\n \\n # add the centroid and head locations on the image \\n box4 = cv2.circle(box4, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\\n box4 = cv2.circle(box4, (x_head, y_head), 7, (0, 0, 255), -1)\\n img_array4.append(box4)\\n \\n # add the positions in the final data frame\\n centroidsDf[\\\"fly4_x\\\"][files.index(file)] = x_centroid\\n centroidsDf[\\\"fly4_y\\\"][files.index(file)] = y_centroid\\n \\n headsDf[\\\"fly4_x\\\"][files.index(file)] = x_head\\n headsDf[\\\"fly4_y\\\"][files.index(file)] = y_head\\n \\n ## FLY 5 ##\\n \\n # the fifth fly is not present in all the genetic strains \\n if (box5_size != []):\\n box5 = img[box5_size[0]:box5_size[1], box5_size[2]:box5_size[3]]\\n \\n # image processing to get the centroid and head positions\\n x_centroid, y_centroid, x_head, y_head = findCentroid(box5, file)\\n \\n # add the centroid and head locations on the image \\n box5 = cv2.circle(box5, (x_centroid, y_centroid), 7, (255, 0, 0), -1)\\n box5 = cv2.circle(box5, (x_head, y_head), 7, (0, 0, 255), -1)\\n img_array5.append(box5)\\n \\n # add the positions in the final data frame\\n centroidsDf[\\\"fly5_x\\\"][files.index(file)] = x_centroid\\n centroidsDf[\\\"fly5_y\\\"][files.index(file)] = y_centroid\\n \\n headsDf[\\\"fly5_x\\\"][files.index(file)] = x_head\\n headsDf[\\\"fly5_y\\\"][files.index(file)] = y_head\\n \\n # save the data frame in a .csv file, \\n # one for the centroids and one for the heads\\n #centroidsDf.to_csv(folder+\\\"/centroids.csv\\\", index = None, header=True)\\n #headsDf.to_csv(folder+\\\"/heads.csv\\\", index = None, header=True)\\n \\n \\n ## CREATE THE VIDEOS ##\\n \\n height, width, _ = box1.shape\\n size = (width,height)\\n out = cv2.VideoWriter(folder+name_type+'_1_' + str(folders.index(folder)+1)+ '.mp4',cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\\n for i in range(len(img_array1)):\\n out.write(img_array1[i])\\n out.release()\\n \\n height, width, _ = box2.shape\\n size = (width,height)\\n out = cv2.VideoWriter(folder+name_type+'_2_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\\n for i in range(len(img_array2)):\\n out.write(img_array2[i])\\n out.release()\\n \\n height, width, _ = box3.shape\\n size = (width,height)\\n out = cv2.VideoWriter(folder+name_type+'_3_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\\n for i in range(len(img_array3)):\\n out.write(img_array3[i])\\n out.release()\\n \\n height, width, _ = box4.shape\\n size = (width,height)\\n out = cv2.VideoWriter(folder+name_type+'_4_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\\n for i in range(len(img_array4)):\\n out.write(img_array4[i])\\n out.release()\\n \\n if (box5_size != []):\\n height, width, _ = box5.shape\\n size = (width,height)\\n out = cv2.VideoWriter(folder+name_type+'_5_' + str(folders.index(folder)+1)+ '.mp4' ,cv2.VideoWriter_fourcc(*'DIVX'), 1.5, size)\\n for i in range(len(img_array5)):\\n out.write(img_array5[i])\\n out.release()\",\n \"def _iter_images_rects(self):\\n image_x = self._margin\\n image_y = self._margin\\n total_width = self.width - 2 * self._margin\\n total_height = self.height - self._texts_height - 2 * self._margin\\n\\n if len(self._images) == 1:\\n image_width = total_width\\n image_height = total_height\\n elif 2 <= len(self._images) < 4:\\n if self.is_portrait:\\n image_width = total_width\\n image_height = (total_height - (len(self._images) - 1) * self._margin) // len(self._images)\\n else:\\n image_width = (total_width - (len(self._images) - 1) * self._margin) // len(self._images)\\n image_height = total_height\\n else:\\n image_width = (total_width - self._margin) // 2\\n image_height = (total_height - self._margin) // 2\\n\\n yield image_x, image_y, image_width, image_height\\n\\n if 2 <= len(self._images) < 4:\\n if self.is_portrait:\\n image_y += image_height + self._margin\\n else:\\n image_x += image_width + self._margin\\n yield image_x, image_y, image_width, image_height\\n\\n if 3 <= len(self._images) < 4:\\n if self.is_portrait:\\n image_y += image_height + self._margin\\n else:\\n image_x += image_width + self._margin\\n yield image_x, image_y, image_width, image_height\\n\\n if len(self._images) == 4:\\n image_x += image_width + self._margin\\n yield image_x, image_y, image_width, image_height\\n image_y += image_height + self._margin\\n image_x = self._margin\\n yield image_x, image_y, image_width, image_height\\n image_x += image_width + self._margin\\n yield image_x, image_y, image_width, image_height\",\n \"def _assign_sizes(self):\",\n \"def create_human_box(self, i):\\n self.box = self.detections[0, 0, i, 3:7] * np.array([self.w, self.h, self.w, self.h])\\n (self.startX, self.startY, self.endX, self.endY) = self.box.astype(\\\"int\\\")\",\n \"def __init__(self, path_image, path_imagefile, path_bndboxfile, transform):\\r\\n # -------------------- DATA ARGUMENT\\r\\n self.shape = 446\\r\\n self.hue = 0.1\\r\\n self.saturation = 1.5\\r\\n self.exposure = 1.5\\r\\n self.imagelist = []\\r\\n self.labellist = []\\r\\n self.transform = transform\\r\\n label_dir = os.listdir(path_bndboxfile)\\r\\n image_dir = os.listdir(path_imagefile)\\r\\n\\r\\n # read imagepath\\r\\n for file in image_dir:\\r\\n file_name = os.path.join(path_imagefile, file)\\r\\n with open(file_name) as f:\\r\\n lines = f.readlines()\\r\\n for line in lines:\\r\\n image_name = line.split()[0] + '.JPEG'\\r\\n image = os.path.join(path_image, image_name)\\r\\n self.imagelist.append(image)\\r\\n\\r\\n # read imagelabel, i.e, (name, xmin, xmax, ymin, ymax)\\r\\n for file in label_dir:\\r\\n if file.split('.')[1] == 'xml':\\r\\n file_name = os.path.join(path_bndboxfile, file)\\r\\n with open(file_name) as f:\\r\\n xml_tree = parse(f).documentElement\\r\\n objects = xml_tree.getElementsByTagName('object')\\r\\n for object in objects:\\r\\n label = []\\r\\n name = object.getElementsByTagName('name')[0]\\r\\n label.append(name.childNodes[0].data)\\r\\n bndbox = object.getElementsByTagName('bndbox')[0]\\r\\n for node in bndbox.childNodes:\\r\\n if node.nodeType == node.ELEMENT_NODE:\\r\\n label.append(node.childNodes[0].data)\\r\\n self.labellist.append(label)\\r\\n else:\\r\\n print('Expect files in xml format. but get {}'.format(file.split('.')[1]))\",\n \"def _images_and_boxes_preprocessing(self, imgs, boxes):\\r\\n # Image [0, 255] -> [0, 1].\\r\\n imgs = imgs.float()\\r\\n imgs = imgs / 255.0\\r\\n\\r\\n height, width = imgs.shape[2], imgs.shape[3]\\r\\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\\r\\n # range of [0, 1].\\r\\n boxes[:, [0, 2]] *= width\\r\\n boxes[:, [1, 3]] *= height\\r\\n boxes = transform.clip_boxes_to_image(boxes, height, width)\\r\\n\\r\\n if self._split == \\\"train\\\":\\r\\n # Train split\\r\\n imgs, boxes = transform.random_short_side_scale_jitter(\\r\\n imgs,\\r\\n min_size=self._jitter_min_scale,\\r\\n max_size=self._jitter_max_scale,\\r\\n boxes=boxes,\\r\\n )\\r\\n imgs, boxes = transform.random_crop(imgs, self._crop_size, boxes=boxes)\\r\\n\\r\\n # Random flip.\\r\\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\\r\\n elif self._split == \\\"val\\\":\\r\\n # Val split\\r\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\r\\n imgs, boxes = transform.random_short_side_scale_jitter(\\r\\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\\r\\n )\\r\\n\\r\\n # Apply center crop for val split\\r\\n imgs, boxes = transform.uniform_crop(\\r\\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\\r\\n )\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\r\\n elif self._split == \\\"test\\\":\\r\\n # Test split\\r\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\r\\n imgs, boxes = transform.random_short_side_scale_jitter(\\r\\n imgs, min_size=self._crop_size, max_size=self._crop_size, boxes=boxes\\r\\n )\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\r\\n else:\\r\\n raise NotImplementedError(\\\"{} split not supported yet!\\\".format(self._split))\\r\\n\\r\\n # Do color augmentation (after divided by 255.0).\\r\\n if self._split == \\\"train\\\" and self._use_color_augmentation:\\r\\n if not self._pca_jitter_only:\\r\\n imgs = transform.color_jitter(\\r\\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\\r\\n )\\r\\n\\r\\n imgs = transform.lighting_jitter(\\r\\n imgs,\\r\\n alphastd=0.1,\\r\\n eigval=np.array(self._pca_eigval).astype(np.float32),\\r\\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\\r\\n )\\r\\n\\r\\n # Normalize images by mean and std.\\r\\n imgs = transform.color_normalization(\\r\\n imgs,\\r\\n np.array(self._data_mean, dtype=np.float32),\\r\\n np.array(self._data_std, dtype=np.float32),\\r\\n )\\r\\n\\r\\n if self._use_bgr:\\r\\n # Convert image format from RGB to BGR.\\r\\n # Note that Kinetics pre-training uses RGB!\\r\\n imgs = imgs[:, [2, 1, 0], ...]\\r\\n\\r\\n boxes = transform.clip_boxes_to_image(boxes, self._crop_size, self._crop_size)\\r\\n\\r\\n return imgs, boxes\",\n \"def _resize_cbboxes(self, results):\\n img_shape = results['img_shape']\\n for key in results.get('cbbox_fields', []):\\n cbboxes = []\\n for cbox in results[key]:\\n tmp_cbox = np.array(cbox, dtype=np.float32)\\n new_tmp_cbox = []\\n for ccbox in tmp_cbox:\\n ccbox = np.array(ccbox, dtype=np.float32)\\n ccbox[0::2] *= results['scale_factor'][0]\\n ccbox[1::2] *= results['scale_factor'][1]\\n new_tmp_cbox.append(ccbox)\\n tmp_cbox = np.array(new_tmp_cbox, dtype=np.float32)\\n if self.bbox_clip_border:\\n tmp_cbox[:, 0::2] = np.clip(tmp_cbox[:, 0::2], 0, img_shape[1])\\n tmp_cbox[:, 1::2] = np.clip(tmp_cbox[:, 1::2], 0, img_shape[0])\\n cbboxes.append(tmp_cbox)\\n results[key] = cbboxes\",\n \"def drawBox (self, left, top, width, height, colour):\\r\\n w = self.bih_vals [bih_Width]\\r\\n h = self.bih_vals [bih_Height]\\r\\n\\r\\n cols = [left, left + width - 1]\\r\\n rows = [top, top + height - 1]\\r\\n \\r\\n x0 = max ((0,left))\\r\\n x1 = min ((cols[1]+1, w))\\r\\n y0 = max ((0,top))\\r\\n y1 = min ((rows [1]+1, h))\\r\\n\\r\\n # rows\\r\\n\\r\\n for r in rows:\\r\\n if r >= 0 and r < h:\\r\\n row = self.image [r]\\r\\n for x in range (x0, x1):\\r\\n row [x] = colour\\r\\n\\r\\n # columns\\r\\n \\r\\n for y in range (y0, y1):\\r\\n row = self.image [y]\\r\\n for c in cols:\\r\\n if c >= 0 and c < w :\\r\\n row [c] = colour\",\n \"def OnSize(self, event):\\r\\n\\r\\n for pos, item in self._items.items():\\r\\n widget, horizontalalignment, verticalalignment = item.widget, item.horizontalalignment, item.verticalalignment\\r\\n\\r\\n rect = self.GetFieldRect(pos)\\r\\n widgetpos = widget.GetPosition()\\r\\n widgetsize = widget.GetSize()\\r\\n\\r\\n rect = self.GetFieldRect(pos)\\r\\n\\r\\n if horizontalalignment == ESB_EXACT_FIT:\\r\\n if verticalalignment == ESB_EXACT_FIT:\\r\\n widget.SetSize((rect.width-2, rect.height-2))\\r\\n widget.SetPosition((rect.x-1, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\\r\\n if widgetsize[1] < rect.width - 1:\\r\\n diffs = (rect.height - widgetsize[1])/2\\r\\n widget.SetSize((rect.width-2, widgetsize[1]))\\r\\n widget.SetPosition((rect.x-1, rect.y+diffs))\\r\\n else:\\r\\n widget.SetSize((rect.width-2, widgetsize[1]))\\r\\n widget.SetPosition((rect.x-1, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_TOP:\\r\\n widget.SetSize((rect.width-2, widgetsize[1]))\\r\\n widget.SetPosition((rect.x-1, rect.y))\\r\\n elif verticalalignment == ESB_ALIGN_BOTTOM:\\r\\n widget.SetSize((rect.width-2, widgetsize[1]))\\r\\n widget.SetPosition((rect.x-1, rect.height-widgetsize[1]))\\r\\n\\r\\n elif horizontalalignment == ESB_ALIGN_LEFT:\\r\\n\\r\\n xpos = rect.x - 1\\r\\n if verticalalignment == ESB_EXACT_FIT:\\r\\n widget.SetSize((widgetsize[0], rect.height-2))\\r\\n widget.SetPosition((xpos, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\\r\\n if widgetsize[1] < rect.height - 1:\\r\\n diffs = (rect.height - widgetsize[1])/2\\r\\n widget.SetPosition((xpos, rect.y+diffs))\\r\\n else:\\r\\n widget.SetSize((widgetsize[0], rect.height-2))\\r\\n widget.SetPosition((xpos, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_TOP:\\r\\n widget.SetPosition((xpos, rect.y))\\r\\n elif verticalalignment == ESB_ALIGN_BOTTOM:\\r\\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\\r\\n\\r\\n elif horizontalalignment == ESB_ALIGN_RIGHT:\\r\\n\\r\\n xpos = rect.x + rect.width - widgetsize[0] - 1\\r\\n if verticalalignment == ESB_EXACT_FIT:\\r\\n widget.SetSize((widgetsize[0], rect.height-2))\\r\\n widget.SetPosition((xpos, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\\r\\n if widgetsize[1] < rect.height - 1:\\r\\n diffs = (rect.height - widgetsize[1])/2\\r\\n widget.SetPosition((xpos, rect.y+diffs))\\r\\n else:\\r\\n widget.SetSize((widgetsize[0], rect.height-2))\\r\\n widget.SetPosition((xpos, rect.y-1))\\r\\n elif verticalalignment == ESB_ALIGN_TOP:\\r\\n widget.SetPosition((xpos, rect.y))\\r\\n elif verticalalignment == ESB_ALIGN_BOTTOM:\\r\\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\\r\\n\\r\\n elif horizontalalignment == ESB_ALIGN_CENTER_HORIZONTAL:\\r\\n\\r\\n xpos = rect.x + (rect.width - widgetsize[0])/2 - 1\\r\\n if verticalalignment == ESB_EXACT_FIT:\\r\\n widget.SetSize((widgetsize[0], rect.height))\\r\\n widget.SetPosition((xpos, rect.y))\\r\\n elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:\\r\\n if widgetsize[1] < rect.height - 1:\\r\\n diffs = (rect.height - widgetsize[1])/2\\r\\n widget.SetPosition((xpos, rect.y+diffs))\\r\\n else:\\r\\n widget.SetSize((widgetsize[0], rect.height-1))\\r\\n widget.SetPosition((xpos, rect.y+1))\\r\\n elif verticalalignment == ESB_ALIGN_TOP:\\r\\n widget.SetPosition((xpos, rect.y))\\r\\n elif verticalalignment == ESB_ALIGN_BOTTOM:\\r\\n widget.SetPosition((xpos, rect.height-widgetsize[1]))\\r\\n\\r\\n if event is not None:\\r\\n event.Skip()\",\n \"def recreate_grid(self):\\n\\n self.print_numlist = arcade.SpriteList()\\n for row in range(ROW_COUNT):\\n for column in range(COLUMN_COUNT):\\n sprite = arcade.Sprite(\\n f\\\"Numbers/{self.grid[row][column]}.png\\\", scale=0.2\\n )\\n x = (MARGIN + WIDTH) * column + MARGIN + WIDTH // 2\\n y = (MARGIN + HEIGHT) * row + MARGIN + HEIGHT // 2\\n sprite.center_x = x\\n sprite.center_y = y\\n self.print_numlist.append(sprite)\\n # Check to see if all squares have been filled in\\n if 0 not in self.grid:\\n # if Cameron.Check_for_Completion(self.grid) == True:\\n self.done = True\",\n \"def _draw_boxes(self, image, boxes, classes, thickness=4):\\n for i in range(len(boxes)):\\n bot, left, top, right = boxes[i, ...]\\n class_id = int(classes[i]) - 1\\n color = self.COLOR_LIST[class_id]\\n cv2.rectangle(image, (left, top), (right, bot), color=color, thickness=thickness)\",\n \"def scale_boxes(boxes, image_shape):\\n height = image_shape[0]\\n width = image_shape[1]\\n image_dims = K.stack([height, width, height, width])\\n image_dims = K.reshape(image_dims, [1, 4])\\n boxes = boxes * image_dims\\n return boxes\",\n \"def place_images(self, final_list, points):\\n\\t\\tfor i in range(8): \\n # Please change this (8) into a class-level variable --KOH\\n\\t\\t\\timage_object = final_list[i]\\n#\\t\\tif type(image_object) == 'CorrectImage':\\n#\\t\\t\\t\\tself.correct = [i, points[i]]\\n\\t\\t\\timage = pygame.image.load(image_object.file_path)\\n # Why can't these be stored as a property of the class --KOH\\n\\t\\t\\timagerect = image.get_rect()\\n\\t\\t\\treimage = pygame.transform.scale(image, image_object.size)\\n\\t\\t\\tself.screen.blit(reimage, points[i])\",\n \"def _images_and_boxes_preprocessing(self, imgs, boxes, gt_boxes=None):\\n # Image [0, 255] -> [0, 1].\\n imgs = imgs.float()\\n imgs = imgs / 255.0\\n\\n height, width = imgs.shape[2], imgs.shape[3]\\n # The format of boxes is [x1, y1, x2, y2]. The input boxes are in the\\n # range of [0, 1].\\n # boxes[:, [0, 2]] *= width\\n # boxes[:, [1, 3]] *= height\\n boxes = transform.clip_boxes_to_image(boxes, height, width)\\n\\n if self._split == \\\"train\\\":\\n # Train split\\n imgs, boxes = transform.random_short_side_scale_jitter(\\n imgs,\\n min_size=self._jitter_min_scale,\\n max_size=self._jitter_max_scale,\\n boxes=boxes,\\n )\\n imgs, boxes = transform.random_crop(\\n imgs, self._crop_size, boxes=boxes\\n )\\n\\n # Random flip.\\n imgs, boxes = transform.horizontal_flip(0.5, imgs, boxes=boxes)\\n elif self._split == \\\"val\\\":\\n # Val split\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\n imgs, boxes = transform.random_short_side_scale_jitter(\\n imgs,\\n min_size=self._crop_size,\\n max_size=self._crop_size,\\n boxes=boxes,\\n )\\n\\n # Apply center crop for val split\\n imgs, boxes = transform.uniform_crop(\\n imgs, size=self._crop_size, spatial_idx=1, boxes=boxes\\n )\\n\\n if self._test_force_flip:\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\n elif self._split == \\\"test\\\":\\n # Test split\\n # Resize short side to crop_size. Non-local and STRG uses 256.\\n imgs, boxes = transform.random_short_side_scale_jitter(\\n imgs,\\n min_size=self._crop_size,\\n max_size=self._crop_size,\\n boxes=boxes,\\n )\\n\\n if self._test_force_flip:\\n imgs, boxes = transform.horizontal_flip(1, imgs, boxes=boxes)\\n else:\\n raise NotImplementedError(\\n \\\"{} split not supported yet!\\\".format(self._split)\\n )\\n\\n # Do color augmentation (after divided by 255.0).\\n if self._split == \\\"train\\\" and self._use_color_augmentation:\\n if not self._pca_jitter_only:\\n imgs = transform.color_jitter(\\n imgs,\\n img_brightness=0.4,\\n img_contrast=0.4,\\n img_saturation=0.4,\\n )\\n\\n imgs = transform.lighting_jitter(\\n imgs,\\n alphastd=0.1,\\n eigval=np.array(self._pca_eigval).astype(np.float32),\\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\\n )\\n\\n # Normalize images by mean and std.\\n imgs = transform.color_normalization(\\n imgs,\\n np.array(self._data_mean, dtype=np.float32),\\n np.array(self._data_std, dtype=np.float32),\\n )\\n\\n if not self._use_bgr:\\n # Convert image format from BGR to RGB.\\n # Note that Kinetics pre-training uses RGB!\\n imgs = imgs[:, [2, 1, 0], ...]\\n\\n boxes = transform.clip_boxes_to_image(\\n boxes, self._crop_size, self._crop_size\\n )\\n\\n return imgs, boxes\",\n \"def populate_images(self):\\n print \\\"Populating images info...\\\"\\n images = self.get_all_images()\\n for i in images:\\n\\n associated_snapshots = self.get_snapshots_of(i)\\n\\n self.spreadsheet[i.id] = dict(name=i.name, Name_tag=self.get_name_tag(i), id=i.id,\\n KEEP_tag=self.get_keep_tag(i), PROD_tag=self.is_production(i),\\n region=i.region.name,\\n created=i.creationDate,\\n associated_snapshots=associated_snapshots,\\n description=i.description)\",\n \"def stage_one(self, imgs, threshold, factor, minsize, nms_threshold):\\n\\n width = imgs.shape[-2]\\n height = imgs.shape[-1]\\n num_img = imgs.shape[0]\\n\\n # Compute valid scales\\n scales = []\\n cur_width = width\\n cur_height = height\\n cur_factor = 1\\n while cur_width >= 12 and cur_height >= 12:\\n if 12 / cur_factor >= minsize: # Ignore boxes that smaller than minsize\\n\\n w = cur_width\\n h = cur_height\\n scales.append((w, h, cur_factor))\\n\\n cur_factor *= factor\\n cur_width = math.ceil(cur_width * factor)\\n cur_height = math.ceil(cur_height * factor)\\n\\n # Get candidate boxesi ph\\n candidate_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\\n candidate_scores = torch.empty(0, device=self.device)\\n candidate_offsets = torch.empty(\\n 0, dtype=torch.float32, device=self.device)\\n all_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\\n for w, h, f in scales:\\n resize_img = torch.nn.functional.interpolate(\\n imgs, size=(w, h), mode='bilinear')\\n p_distribution, box_regs, _ = self.pnet(resize_img)\\n\\n candidate, scores, offsets, img_labels = self._generate_bboxes(\\n p_distribution, box_regs, f, threshold)\\n\\n candidate_boxes = torch.cat([candidate_boxes, candidate])\\n candidate_scores = torch.cat([candidate_scores, scores])\\n candidate_offsets = torch.cat([candidate_offsets, offsets])\\n all_img_labels = torch.cat([all_img_labels, img_labels])\\n\\n \\n if candidate_boxes.shape[0] != 0:\\n candidate_boxes = self._calibrate_box(\\n candidate_boxes, candidate_offsets)\\n candidate_boxes = self._convert_to_square(candidate_boxes)\\n candidate_boxes = self._refine_boxes(\\n candidate_boxes, width, height)\\n \\n final_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\\n final_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\\n for i in range(num_img):\\n mask = all_img_labels == i\\n keep = func.nms(candidate_boxes[mask].cpu().numpy(),\\n candidate_scores[mask].cpu().numpy(), nms_threshold)\\n final_boxes = torch.cat([final_boxes, candidate_boxes[mask][keep]])\\n final_img_labels = torch.cat([final_img_labels, all_img_labels[mask][keep]])\\n\\n return torch.cat([final_boxes, final_img_labels.unsqueeze(1 )], -1)\\n else:\\n return candidate_boxes\",\n \"def _images_and_boxes_preprocessing_cv2(self, imgs, boxes):\\r\\n\\r\\n height, width, _ = imgs[0].shape\\r\\n\\r\\n boxes[:, [0, 2]] *= width\\r\\n boxes[:, [1, 3]] *= height\\r\\n boxes = cv2_transform.clip_boxes_to_image(boxes, height, width)\\r\\n\\r\\n # `transform.py` is list of np.array. However, for AVA, we only have\\r\\n # one np.array.\\r\\n boxes = [boxes]\\r\\n # The image now is in HWC, BGR format.\\r\\n if self._split == \\\"train\\\": # \\\"train\\\"\\r\\n imgs, boxes = cv2_transform.random_short_side_scale_jitter_list(\\r\\n imgs,\\r\\n min_size=self._jitter_min_scale,\\r\\n max_size=self._jitter_max_scale,\\r\\n boxes=boxes,\\r\\n )\\r\\n imgs, boxes = cv2_transform.random_crop_list(\\r\\n imgs, self._crop_size, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n if self.random_horizontal_flip:\\r\\n # random flip\\r\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\r\\n 0.5, imgs, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n elif self._split == \\\"val\\\":\\r\\n # Short side to test_scale. Non-local and STRG uses 256.\\r\\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\\r\\n boxes = [\\r\\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\\r\\n ]\\r\\n imgs, boxes = cv2_transform.spatial_shift_crop_list(\\r\\n self._crop_size, imgs, 1, boxes=boxes\\r\\n )\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\r\\n 1, imgs, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n elif self._split == \\\"test\\\":\\r\\n # Short side to test_scale. Non-local and STRG uses 256.\\r\\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\\r\\n boxes = [\\r\\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\\r\\n ]\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\r\\n 1, imgs, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n else:\\r\\n raise NotImplementedError(\\\"Unsupported split mode {}\\\".format(self._split))\\r\\n\\r\\n # Convert image to CHW keeping BGR order.\\r\\n imgs = [cv2_transform.HWC2CHW(img) for img in imgs]\\r\\n\\r\\n # Image [0, 255] -> [0, 1].\\r\\n imgs = [img / 255.0 for img in imgs]\\r\\n\\r\\n imgs = [\\r\\n np.ascontiguousarray(\\r\\n # img.reshape((3, self._crop_size, self._crop_size))\\r\\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\\r\\n ).astype(np.float32)\\r\\n for img in imgs\\r\\n ]\\r\\n\\r\\n # Do color augmentation (after divided by 255.0).\\r\\n if self._split == \\\"train\\\" and self._use_color_augmentation:\\r\\n if not self._pca_jitter_only:\\r\\n imgs = cv2_transform.color_jitter_list(\\r\\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\\r\\n )\\r\\n\\r\\n imgs = cv2_transform.lighting_list(\\r\\n imgs,\\r\\n alphastd=0.1,\\r\\n eigval=np.array(self._pca_eigval).astype(np.float32),\\r\\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\\r\\n )\\r\\n\\r\\n # Normalize images by mean and std.\\r\\n imgs = [\\r\\n cv2_transform.color_normalization(\\r\\n img,\\r\\n np.array(self._data_mean, dtype=np.float32),\\r\\n np.array(self._data_std, dtype=np.float32),\\r\\n )\\r\\n for img in imgs\\r\\n ]\\r\\n\\r\\n # Concat list of images to single ndarray.\\r\\n imgs = np.concatenate([np.expand_dims(img, axis=1) for img in imgs], axis=1)\\r\\n\\r\\n if not self._use_bgr:\\r\\n # Convert image format from BGR to RGB.\\r\\n imgs = imgs[::-1, ...]\\r\\n\\r\\n imgs = np.ascontiguousarray(imgs)\\r\\n imgs = torch.from_numpy(imgs)\\r\\n boxes = cv2_transform.clip_boxes_to_image(\\r\\n boxes[0], imgs[0].shape[1], imgs[0].shape[2]\\r\\n )\\r\\n return imgs, boxes\",\n \"def __init__(self,jx,jy,img,geo,mbox=10,hist=False,zoomc=False,pfile=False):\\n \\n self.mbox = mbox # Box half-size\\n self.nbox = 2*mbox + 1 # Box size\\n # Adjust central pixel location to ensure box fits within full image\\n self.ix = int( np.median( [ mbox, jx, img.nx-mbox-1 ] ) )\\n self.iy = int( np.median( [ mbox, jy, img.ny-mbox-1 ] ) )\\n iymin = self.iy - mbox\\n iymax = self.iy + mbox\\n ixmin = self.ix - mbox\\n ixmax = self.ix + mbox\\n label = img.label # Copy information from full disk image\\n self.label = label\\n self.desc = img.desc[label]\\n self.img = img.images[label][iymin:iymax+1,ixmin:ixmax+1]\\n self.disp(zoomc)\\n if hist: self.hist(geo,pfile)\",\n \"def _images_and_boxes_preprocessing_cv2(self, imgs, boxes, gt_boxes=None, min_scale=None, crop_size=None, n_imgs=0):\\n\\n height, width, _ = imgs[0].shape\\n\\n # boxes[:, [0, 2]] *= width\\n # boxes[:, [1, 3]] *= height\\n boxes = cv2_transform.clip_boxes_to_image(boxes, height, width)\\n\\n # `transform.py` is list of np.array. However, for AVA, we only have\\n # one np.array.\\n boxes = [boxes]\\n\\n crop_size = crop_size if self.multigrid_enabled and crop_size is not None else self._crop_size\\n \\n if self._split != 'train':\\n assert gt_boxes is not None\\n gt_boxes = cv2_transform.clip_boxes_to_image(gt_boxes, height, width)\\n gt_boxes = [gt_boxes]\\n\\n # The image now is in HWC, BGR format.\\n if self._split == \\\"train\\\": # \\\"train\\\"\\n imgs, boxes = cv2_transform.random_short_side_scale_jitter_list(\\n imgs,\\n min_size=self._jitter_min_scale if not self.multigrid_enabled and min_scale is None else min_scale,\\n max_size=self._jitter_max_scale,\\n boxes=boxes,\\n )\\n imgs, boxes = cv2_transform.random_crop_list(\\n imgs, crop_size, order=\\\"HWC\\\", boxes=boxes, n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\\n )\\n if self.random_horizontal_flip:\\n # random flip\\n # if self.cfg.MODEL.USE_SPA_CONF and len(imgs[n_imgs].shape) != 3:\\n # for i in range(n_imgs, len(imgs) + 1):\\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\n 0.5, imgs, order=\\\"HWC\\\", boxes=boxes, \\n n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\\n )\\n # elif self._split == \\\"val\\\":\\n # # Short side to test_scale. Non-local and STRG uses 256.\\n # imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\\n # boxes, gt_boxes = cv2_transform.scale_boxes(\\n # self._crop_size, boxes[0], height, width, gt_boxes=gt_boxes[0]\\n # )\\n # boxes, gt_boxes = [boxes], [gt_boxes]\\n # imgs, boxes, gt_boxes = cv2_transform.spatial_shift_crop_list(\\n # self._crop_size, imgs, 1, boxes=boxes, gt_boxes=gt_boxes\\n # )\\n\\n # if self._test_force_flip:\\n # imgs, boxes = cv2_transform.horizontal_flip_list(\\n # 1, imgs, order=\\\"HWC\\\", boxes=boxes, gt_boxes=gt_boxes\\n # )\\n elif self._split == \\\"val\\\" or self._split == \\\"test\\\":\\n # Short side to test_scale. Non-local and STRG uses 256.\\n imgs = [cv2_transform.scale(crop_size, img) for img in imgs]\\n boxes, gt_boxes = cv2_transform.scale_boxes(\\n crop_size, boxes[0], height, width, gt_boxes=gt_boxes[0]\\n )\\n boxes, gt_boxes = [boxes], [gt_boxes]\\n\\n if self._test_force_flip:\\n # if self.cfg.MODEL.USE_SPA_CONF and len(imgs[n_imgs].shape) != 3:\\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\\n # imgs[n_imgs:] = [np.expand_dims(img, axis=-1) for img in imgs[n_imgs:]]\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\n 1, imgs, order=\\\"HWC\\\", boxes=boxes, gt_boxes=gt_boxes,\\n n_imgs=n_imgs, USE_SPA_CONF=self.cfg.MODEL.USE_SPA_CONF\\n )\\n else:\\n raise NotImplementedError(\\n \\\"Unsupported split mode {}\\\".format(self._split)\\n )\\n\\n # Convert image to CHW keeping BGR order.\\n if self.cfg.MODEL.USE_SPA_CONF:\\n try:\\n if len(imgs[n_imgs].shape) == 2:\\n imgs[n_imgs:] = [np.expand_dims(img, axis=-1) for img in imgs[n_imgs:]]\\n elif len(imgs[n_imgs].shape) > 3:\\n imgs[n_imgs:] = [np.expand_dims(img.squeeze(), axis=-1) for img in imgs[n_imgs:]]\\n except:\\n import pdb; pdb.set_trace()\\n \\n # for i in range(n_imgs, len(imgs) + 1):\\n # imgs[i] = np.expand_dims(imgs[i], axis=-1)\\n # try:\\n imgs = [cv2_transform.HWC2CHW(img) for img in imgs]\\n # except:\\n # print('imgs[n_imgs].shape:', imgs[n_imgs].shape)\\n # print('len(imgs):', len(imgs))\\n # print('n_imgs:', n_imgs)\\n # import pdb; pdb.set_trace()\\n\\n # Image [0, 255] -> [0, 1].\\n if self.cfg.MODEL.USE_SPA_CONF:\\n imgs[:n_imgs] = [img / 255.0 for img in imgs[:n_imgs]]\\n else: \\n imgs = [img / 255.0 for img in imgs]\\n\\n if self.cfg.MODEL.USE_SPA_CONF:\\n imgs[:n_imgs] = [\\n np.ascontiguousarray(\\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\\n ).astype(np.float32)\\n for img in imgs[:n_imgs]\\n ]\\n imgs[n_imgs:] = [\\n np.ascontiguousarray(\\n img.reshape((1, imgs[0].shape[1], imgs[0].shape[2]))\\n ).astype(np.float32)\\n for img in imgs[n_imgs:]\\n ]\\n else:\\n imgs = [\\n np.ascontiguousarray(\\n # img.reshape((3, self._crop_size, self._crop_size))\\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\\n ).astype(np.float32)\\n for img in imgs\\n ]\\n\\n # Do color augmentation (after divided by 255.0).\\n if self.cfg.MODEL.USE_SPA_CONF:\\n skeleton_imgs = imgs[n_imgs:]\\n imgs = imgs[:n_imgs]\\n if self._split == \\\"train\\\" and self._use_color_augmentation: # False\\n if not self._pca_jitter_only:\\n imgs = cv2_transform.color_jitter_list(\\n imgs,\\n img_brightness=0.4,\\n img_contrast=0.4,\\n img_saturation=0.4,\\n )\\n\\n imgs = cv2_transform.lighting_list(\\n imgs,\\n alphastd=0.1,\\n eigval=np.array(self._pca_eigval).astype(np.float32),\\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\\n )\\n\\n # Normalize images by mean and std.\\n imgs = [\\n cv2_transform.color_normalization(\\n img,\\n np.array(self._data_mean, dtype=np.float32),\\n np.array(self._data_std, dtype=np.float32),\\n )\\n for img in imgs\\n ]\\n\\n # Concat list of images to single ndarray.\\n imgs = np.concatenate(\\n [np.expand_dims(img, axis=1) for img in imgs], axis=1\\n )\\n\\n if not self._use_bgr:\\n # Convert image format from BGR to RGB.\\n imgs = imgs[::-1, ...]\\n\\n imgs = np.ascontiguousarray(imgs)\\n imgs = torch.from_numpy(imgs)\\n \\n if self.cfg.MODEL.USE_SPA_CONF:\\n skeleton_imgs = np.concatenate(\\n [np.expand_dims(img, axis=1) for img in skeleton_imgs], axis=1\\n )\\n skeleton_imgs = np.ascontiguousarray(skeleton_imgs)\\n skeleton_imgs = torch.from_numpy(skeleton_imgs)\\n\\n boxes = cv2_transform.clip_boxes_to_image(\\n boxes[0], imgs[0].shape[1], imgs[0].shape[2]\\n )\\n if gt_boxes is not None:\\n gt_boxes = cv2_transform.clip_boxes_to_image(\\n gt_boxes[0], imgs[0].shape[1], imgs[0].shape[2]\\n )\\n if self.cfg.MODEL.USE_SPA_CONF:\\n return (imgs, skeleton_imgs, boxes) if gt_boxes is None else (imgs, skeleton_imgs, boxes, gt_boxes)\\n else:\\n return (imgs, boxes) if gt_boxes is None else (imgs, boxes, gt_boxes)\",\n \"def set_figure_size(self):\\n lims, _ = self.set_lims()\\n size_fac = 50\\n paperSizeFac = 0.65\\n one_dec = 1.6\\n xdecs = np.log10(lims(1)) - np.log10(lims(0))\\n one_dec = one_dec * 4 / xdecs\\n ydecs = np.log10(lims[3]) - np.log10(lims[2])\\n paper_width = xdecs * one_dec\\n paper_height = (ydecs + 3) * one_dec\\n paper_height = min([paper_height, 9])\\n rectScreen = [0.5, 0.5, paper_width, paper_height] * size_fac\\n rectPaper = [1.0, 1.0, paper_width * paperSizeFac, paper_height * paperSizeFac]\\n\\n rectRho = [0.15, 0.15 + 2.3 / (ydecs + 3), 0.8, ydecs / (ydecs + 3) * 0.8]\\n rectPhi = [0.15, 0.15, 0.8, 2 / (ydecs + 3) * 0.8]\\n rects = {\\n \\\"Screen\\\": rectScreen,\\n \\\"Paper\\\": rectPaper,\\n \\\"Rho\\\": rectRho,\\n \\\"Phi\\\": rectPhi,\\n }\\n return rects\",\n \"def define_box_location(self):\\n self.contents['Box_ID'] = np.ones(self.numatom) * self.num_box\",\n \"def configure_grid(self):\\r\\n\\r\\n for r in range(3):\\r\\n self.rowconfigure(r, weight=1)\\r\\n for c in range(3):\\r\\n self.columnconfigure(c, weight=1)\",\n \"def create_prior_boxes(self):\\n # value of k for each feature map to create k^2 boxes for each feature map\\n feature_map_dims = {'conv4_3': 38, 'conv7': 19, 'conv8_2': 10, 'conv9_2': 5}\\n\\n # scale for boxes across different feature maps. boxes for inner feature maps\\n # are scaled much lower to detect small objects\\n obj_scales = {'conv4_3': 0.1, 'conv7': 0.21, 'conv8_2': 0.255, 'conv9_2': 0.30}\\n\\n # Defined aspect ratio calculated from mean of (w/h) across all bounding boxes\\n # from the dataset. The mean is 0.66 with deviation of 0.07. So aspect ratio is kept\\n # at 0.66 for all feature maps\\n aspect_ratios = {'conv4_3': [0.5], 'conv7': [0.55], 'conv8_2': [0.6], 'conv9_2': [.66]}\\n\\n fmaps = list(feature_map_dims.keys())\\n prior_boxes = []\\n for k, fmap in enumerate(fmaps):\\n # for each feature map, create k*k boxes\\n for i in range(feature_map_dims[fmap]):\\n for j in range(feature_map_dims[fmap]):\\n # calculate center coordinates of boxes\\n cx = (j + 0.5) / feature_map_dims[fmap]\\n cy = (i + 0.5) / feature_map_dims[fmap]\\n\\n # For each\\n for ratio in aspect_ratios[fmap]:\\n prior_boxes.append([cx, cy, obj_scales[fmap] * sqrt(ratio), obj_scales[fmap] / sqrt(ratio)])\\n\\n prior_boxes = torch.FloatTensor(prior_boxes).to(device) # (1930, 4)\\n prior_boxes.clamp_(0, 1) # (1930, 4)\\n\\n return prior_boxes\",\n \"def setup_image(self):\\n # Create the correct size image for the table\\n rows = self.table.count('\\\\n')\\n columns = self.table.split('\\\\n')[0].count('-') + self.table.split('\\\\n')[0].count('+')\\n self.img = Image.new('RGB', ((columns * 12) + 24, rows * 21 + 48), color=(54, 57, 63))\\n\\n # Initialize font and drawing object\\n self.font = ImageFont.truetype('../extra_files/cour.ttf', 20)\\n self.draw = ImageDraw.Draw(self.img)\\n\\n # Draw the table without markings\\n for x in range(5):\\n self.draw.text((12, 12), self.table, font=self.font, fill=(255, 255, 255))\",\n \"def boxes_postprocess(boxes, image_meta):\\n if 'scales' in image_meta:\\n boxes[:, [0, 2]] /= image_meta['scales'][1]\\n boxes[:, [1, 3]] /= image_meta['scales'][0]\\n\\n if 'padding' in image_meta:\\n boxes[:, [0, 2]] -= image_meta['padding'][2]\\n boxes[:, [1, 3]] -= image_meta['padding'][0]\\n\\n if 'crops' in image_meta:\\n boxes[:, [0, 2]] += image_meta['crops'][2]\\n boxes[:, [1, 3]] += image_meta['crops'][0]\\n\\n if 'flipped' in image_meta and image_meta['flipped']:\\n image_width = image_meta['drifted_size'][1] if 'drifted_size' in image_meta else \\\\\\n image_meta['orig_size'][1]\\n boxes_widths = boxes[:, 2] - boxes[:, 0] + 1.\\n boxes[:, 0] = image_width - 1 - boxes[:, 2]\\n boxes[:, 2] = boxes[:, 0] + boxes_widths - 1.\\n\\n if 'drifts' in image_meta:\\n boxes[:, [0, 2]] += image_meta['drifts'][1]\\n boxes[:, [1, 3]] += image_meta['drifts'][0]\\n\\n return boxes\",\n \"def draw_boxes(bboxes: [[int]], img: 'np.array', line_width: int=2) -> 'np.array':\\n for x, y, w, h in bboxes:\\n cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), line_width)\\n return img\",\n \"def __call__(self, results):\\n\\n if 'img_fields' in results:\\n assert results['img_fields'] == ['img'], \\\\\\n 'Only single img_fields is allowed'\\n img = results['img']\\n assert 'bbox_fields' in results\\n boxes = [results[key] for key in results['bbox_fields']]\\n boxes = np.concatenate(boxes, 0)\\n h, w, c = img.shape\\n while True:\\n mode = random.choice(self.sample_mode)\\n self.mode = mode\\n if mode == 1:\\n return results\\n\\n min_iou = mode\\n for i in range(50):\\n new_w = random.uniform(self.min_crop_size * w, w)\\n new_h = random.uniform(self.min_crop_size * h, h)\\n\\n # h / w in [0.5, 2]\\n if new_h / new_w < 0.5 or new_h / new_w > 2:\\n continue\\n\\n left = random.uniform(w - new_w)\\n top = random.uniform(h - new_h)\\n\\n patch = np.array(\\n (int(left), int(top), int(left + new_w), int(top + new_h)))\\n # Line or point crop is not allowed\\n if patch[2] == patch[0] or patch[3] == patch[1]:\\n continue\\n overlaps = bbox_overlaps(\\n patch.reshape(-1, 4), boxes.reshape(-1, 4)).reshape(-1)\\n if len(overlaps) > 0 and overlaps.min() < min_iou:\\n continue\\n\\n # center of boxes should inside the crop img\\n # only adjust boxes and instance masks when the gt is not empty\\n if len(overlaps) > 0:\\n # adjust boxes\\n def is_center_of_bboxes_in_patch(boxes, patch):\\n center = (boxes[:, :2] + boxes[:, 2:]) / 2\\n mask = ((center[:, 0] > patch[0]) *\\n (center[:, 1] > patch[1]) *\\n (center[:, 0] < patch[2]) *\\n (center[:, 1] < patch[3]))\\n return mask\\n\\n mask = is_center_of_bboxes_in_patch(boxes, patch)\\n if not mask.any():\\n continue\\n for key in results.get('bbox_fields', []):\\n boxes = results[key].copy()\\n mask = is_center_of_bboxes_in_patch(boxes, patch)\\n boxes = boxes[mask]\\n if self.bbox_clip_border:\\n boxes[:, 2:] = boxes[:, 2:].clip(max=patch[2:])\\n boxes[:, :2] = boxes[:, :2].clip(min=patch[:2])\\n boxes -= np.tile(patch[:2], 2)\\n\\n results[key] = boxes\\n # labels\\n label_key = self.bbox2label.get(key)\\n if label_key in results:\\n results[label_key] = results[label_key][mask]\\n\\n # mask fields\\n mask_key = self.bbox2mask.get(key)\\n if mask_key in results:\\n results[mask_key] = results[mask_key][\\n mask.nonzero()[0]].crop(patch)\\n # adjust the img no matter whether the gt is empty before crop\\n img = img[patch[1]:patch[3], patch[0]:patch[2]]\\n results['img'] = img\\n results['img_shape'] = img.shape\\n\\n # seg fields\\n for key in results.get('seg_fields', []):\\n results[key] = results[key][patch[1]:patch[3],\\n patch[0]:patch[2]]\\n return results\",\n \"def initialize_grid(self) -> None:\\n for i in range(self.grid_size[0]):\\n for j in range(self.grid_size[1]):\\n self.set(i, j, self.base_color)\",\n \"def fillingrid(self):\\n\\n if self.imagearray is None:\\n if self.gs.isfixed:\\n for n in range(0, self.numcols):\\n self.vspins[n].setValue(self.currentvalues[n])\\n elif self.gs.isperc:\\n for n in range(0, self.numcols):\\n self.fillinpercent(n)\\n else:\\n for n in range(0, self.numcols):\\n self.nsspins[n].setValue(self.currentnsigs[n])\\n else:\\n for n in range(0, self.numcols):\\n self.vspins[n].setValue(self.currentvalues[n])\\n self.nsspins[n].setValue(self.currentnsigs[n])\\n self.fillinpercent(n)\",\n \"def create_flowbox(self, flowbox, frame_list):\\n\\n for num_frame in frame_list:\\n grid = Gtk.Grid()\\n btn = self.new_thumbnail_button(num_frame)\\n\\n widget_cls_label = Gtk.Label()\\n widget_cls_label.set_text(\\\"?\\\")\\n widget_cls_label.set_size_request(20, 20)\\n widget_cls_label.connect(\\\"draw\\\", self.area_on_draw, {'frame': num_frame, 'widget_label': widget_cls_label})\\n # Add drawing area\\n grid.add(btn)\\n grid.attach_next_to(widget_cls_label, btn, Gtk.PositionType.BOTTOM, 1, 2)\\n\\n flowbox.add(grid)\\n self.flowbox_layout = flowbox\",\n \"def updateFootprintBbox(self):\\n # Pull out the image bounds of the parent Footprint\\n self.bb = self.fp.getBBox()\\n if not self.imbb.contains(self.bb):\\n raise ValueError(('Footprint bounding-box %s extends outside image bounding-box %s') %\\n (str(self.bb), str(self.imbb)))\\n self.W, self.H = self.bb.getWidth(), self.bb.getHeight()\\n self.x0, self.y0 = self.bb.getMinX(), self.bb.getMinY()\\n self.x1, self.y1 = self.bb.getMaxX(), self.bb.getMaxY()\",\n \"def boxer(imgfile, parttree, outstack, boxsize):\\n imgarray = mrc.read(imgfile)\\n boxedparticles = boxerMemory(imgarray, parttree, boxsize)\\n apImagicFile.writeImagic(boxedparticles, outstack)\\n return True\",\n \"def build_boxes(self):\\n for index in self.box_space.points:\\n if self.rank_of_box[index] == self.my_rank:\\n self.my_boxes.append(Box(self, index))\",\n \"def __build__(self,data_index=0):\\n \\n super(Image,self).__build__()\\n # -- How to read the image\\n self._build_properties = dict(\\n data_index = data_index,\\n header_exptime = \\\"EXPTIME\\\",\\n dataslice0=\\\"undefined\\\",\\n dataslice1=\\\"undefined\\\",\\n bkgdbox={\\\"bh\\\":100,\\\"bw\\\":100,\\\"fh\\\":3,\\\"fw\\\":3},\\n )\",\n \"def set_pic_size(self, im_name):\\n im_vals = np.genfromtxt(im_name, delimiter=self.delim)\\n self.pic_width = int(np.size(im_vals[0]) - 1) # the first column of ASCII image is row number\\n try: self.pic_height = int(np.size(im_vals[:,0])) \\n except IndexError: \\n self.pic_width = int(np.size(im_vals) - 1)\\n self.pic_height = 1\\n self.create_rect_mask()\\n return self.pic_width, self.pic_height\",\n \"def preprocessing(image_data, max_height, max_width):\\n img = image_data[\\\"image\\\"]\\n img = resize_image(img, max_height, max_width)\\n gt_boxes = image_data[\\\"objects\\\"][\\\"bbox\\\"]\\n gt_labels = image_data[\\\"objects\\\"][\\\"label\\\"]\\n return img, gt_boxes, gt_labels\",\n \"def setpopbox(ty,slist,scaledtime,rootpop,poptree):\\r\\n wadjust = \\\"\\\"\\r\\n for i in range(numpops-1):\\r\\n wadjust += \\\"00\\\"\\r\\n if(scaledtime != []):\\r\\n minx_popbox = textwide(wadjust+\\\"0.00 MYR\\\", tfactor)\\r\\n else:\\r\\n minx_popbox = textwide(wadjust+\\\"0.00 tu\\\", tfactor)\\r\\n minx_popbox /= gv[\\\"globalscale\\\"]\\r\\n if gv[\\\"localxscale\\\"] > 0:\\r\\n minx_popbox /= gv[\\\"localxscale\\\"]\\r\\n\\r\\n popxvals = []\\r\\n## if scaledpop == [] then no text is written on time split line and there is more width to work with\\r\\n for i in range(2*numpops - 1):\\r\\n## left side temporarily at zero, right side temporarily at upper confidence interval\\r\\n popxvals.append( [0,slist[4][4][i][1]])\\r\\n (width,c,popxvals, leftpoint,rightpoint) = centerbox(rootpop,0,popxvals[rootpop][1],poptree,popxvals)\\r\\n popxvals = popadjustx(popxvals,minx_popbox)\\r\\n popbox = []\\r\\n\\r\\n ## maxwide will be used to adjust the width as a scaler so the part furthest to the right is not too far out\\r\\n maxwide = 0\\r\\n for i in range(2*numpops-1):\\r\\n if maxwide < (popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1])):\\r\\n maxwide = (popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1]))\\r\\n maxwide = maxwide/(1.0-minx_popbox)\\r\\n\\r\\n if gv[\\\"localxscale\\\"] > 0:\\r\\n maxwide *= gv[\\\"localxscale\\\"]\\r\\n\\r\\n farright = 0\\r\\n confint = []\\r\\n for i in range(2*numpops-1):\\r\\n confint.append([])\\r\\n confint[i].append(minx_popbox + ((popxvals[i][1] - (slist[4][4][i][1]-slist[4][4][i][2]))/maxwide))\\r\\n confint[i].append(minx_popbox + ((popxvals[i][1] + (slist[4][4][i][3]-slist[4][4][i][1]))/maxwide))\\r\\n if confint[i][1] > farright:\\r\\n farright = confint[i][1]\\r\\n popbox.append([[],[]])\\r\\n popbox[i][0].append(minx_popbox + popxvals[i][0]/maxwide)\\r\\n popbox[i][1].append(minx_popbox + popxvals[i][1]/maxwide)\\r\\n if poptree[i][1] == -1:\\r\\n popbox[i][0].append(gv[\\\"lineINFy\\\"])\\r\\n else:\\r\\n popbox[i][0].append(ty[poptree[i][1]-1][0])\\r\\n if poptree[i][0] == 0:\\r\\n popbox[i][1].append(gv[\\\"line0y\\\"])\\r\\n else:\\r\\n popbox[i][1].append(ty[poptree[i][0]-1][0])\\r\\n return popbox,maxwide, confint, farright\",\n \"def plt_bboxes(img, classes, scores, bboxes, figsize=(10,10), linewidth=1.5):\\n fig = plt.figure(figsize=figsize)\\n plt.imshow(img)\\n height = img.shape[0]\\n width = img.shape[1]\\n colors = dict()\\n for i in range(classes.shape[0]):\\n cls_id = int(classes[i])\\n if cls_id >= 0:\\n score = scores[i]\\n if cls_id not in colors:\\n colors[cls_id] = (random.random(), random.random(), random.random())\\n ymin = int(bboxes[i, 0] * height)\\n xmin = int(bboxes[i, 1] * width)\\n ymax = int(bboxes[i, 2] * height)\\n xmax = int(bboxes[i, 3] * width)\\n# crop_img = img[xmin:(xmax - xmin),xmax:(ymax - ymin)]\\n# misc.imsave('1.jpg', crop_img)\\n rect = plt.Rectangle((xmin, ymin), xmax - xmin,\\n ymax - ymin, fill=False,\\n edgecolor=colors[cls_id],\\n linewidth=linewidth)\\n plt.gca().add_patch(rect)\\n class_name = CLASSES[cls_id]\\n plt.gca().text(xmin, ymin - 2,\\n '{:s} | {:.3f}'.format(class_name, score),\\n bbox=dict(facecolor=colors[cls_id], alpha=0.5),\\n fontsize=12, color='white')\\n plt.show()\",\n \"def __init__(self,phosphene_resolution=(50,50), size=(480,480), jitter=0.35, intensity_var=0.9, aperture=.66, sigma=0.8, custom_grid=None):\\n if custom_grid is None:\\n self.phosphene_resolution = phosphene_resolution\\n self.size = size\\n self.phosphene_spacing = np.divide(size,phosphene_resolution)\\n self.jitter = jitter\\n self.intensity_var = intensity_var\\n self.grid = self.create_regular_grid(self.phosphene_resolution,self.size,self.jitter,self.intensity_var)\\n self.aperture = np.round(aperture*self.phosphene_spacing[0]).astype(int) #relative aperture > dilation kernel size\\n else:\\n self.grid = custom_grid\\n self.aperture = aperture\\n self.sigma = sigma\\n self.dilation_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(self.aperture,self.aperture))\\n self.k_size = 11 #np.round(4*sigma+1).astype(int) # rule of thumb: choose k_size>3*sigma\",\n \"def sizes(options):\\n # import data\\n pixels = dict() # volumes are given in #pixels\\n snap_mask = \\\"/net/astrogate/export/astrodata/jgacon/filex/processing/\\\" \\\\\\n \\\"export/f8_h50_v100_objs_snap_%d.csv\\\"\\n snap_ids = np.arange(2,28+1)\\n z = snapid2z(snap_ids)\\n print z\\n\\n for id in snap_ids:\\n snap = snap_mask % (id - 1) # fix: snap number one too low in filename\\n pixels[id] = np.genfromtxt(snap)[1:-1,1] # row 2 contains volumes\\n # rm void & halo volumes\\n\\n # visualise\\n if \\\"err\\\" in options.keys():\\n nums = np.array([pixels[id].size for id in snap_ids])\\n avgs = np.array([np.mean(pixels[id]) for id in snap_ids])\\n mods = np.array([st.mode(pixels[id])[0][0] for id in snap_ids])\\n meds = np.array([np.median(pixels[id]) for id in snap_ids])\\n stds = np.array([np.std(pixels[id]) for id in snap_ids])\\n\\n print mods\\n print mods.shape\\n\\n plt.figure()\\n plt.title(\\\"Sizes of filaments as function of redshift\\\")\\n plt.xlabel(\\\"Redshift $z$\\\")\\n plt.xticks(snap_ids[::3], z[::3])\\n\\n plt.ylabel(\\\"Size in #pixels\\\")\\n\\n plt.errorbar(snap_ids, avgs, yerr=stds, label=\\\"Mean\\\")\\n plt.plot(snap_ids, mods, \\\"g\\\", label=\\\"Mode\\\")\\n plt.plot(snap_ids, meds, \\\"c\\\", label=\\\"Median\\\")\\n plt.legend(loc=\\\"best\\\")\\n\\n plt.twinx()\\n plt.ylabel(\\\"#Filaments\\\", color=\\\"r\\\")\\n plt.tick_params(\\\"y\\\", colors=\\\"r\\\")\\n\\n plt.plot(snap_ids, nums, \\\"r--\\\")\\n\\n plt.savefig(options[\\\"err\\\"])\\n\\n if \\\"dist\\\" in options.keys():\\n targets = np.array([5,10,15,20,25])\\n plt.figure()\\n plt.title(\\\"Volume distribution of filaments\\\")\\n plt.xlabel(\\\"Volume $V$ in #pixels\\\")\\n plt.ylabel(\\\"#Element with $V$ / Total #Elements\\\")\\n plt.xlim([0,1000])\\n for target in targets:\\n sns.kdeplot(pixels[target], label=\\\"$z$ = %f\\\" % snapid2z(target))\\n plt.legend(loc=\\\"best\\\")\\n plt.savefig(options[\\\"dist\\\"])\\n\\n if \\\"dist_inter\\\" in options.keys():\\n default = snap_ids[-1]\\n fig, ax = plt.subplots()\\n plt.subplots_adjust(bottom=0.25)\\n sns.kdeplot(pixels[int(default - 2)], ax=ax)\\n plt.xlim([0, 1000])\\n plt.ylim([0, 0.01])\\n plt.xlabel(\\\"Volume $V$ of filaments in #pixels\\\")\\n plt.ylabel(\\\"#Filaments with volume $V$ / Total #Filaments\\\")\\n\\n nums = np.array([pixels[id].size for id in snap_ids])\\n ax2 = ax.twinx()\\n ax2.set_ylabel(\\\"#Filaments\\\", color=\\\"r\\\", alpha=0.5)\\n ax2.tick_params(axis=\\\"y\\\", labelcolor=\\\"r\\\")\\n ax2_x = np.linspace(0, 1000, nums.size)\\n ax2.plot(ax2_x, nums, \\\"r--\\\", alpha=0.5)\\n point, = ax2.plot(ax2_x[default - 2], nums[default - 2], \\\"ro\\\", alpha=0.5)\\n\\n axcolor = 'lightgoldenrodyellow'\\n axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)\\n sid = Slider(axfreq, \\\"ID\\\", 2, 28, valinit=default, valstep=1)\\n ax.set_title(\\\"$z$ = %f\\\" % snapid2z(default))\\n\\n def update(val):\\n id = sid.val\\n\\n print id\\n #ax.clear()\\n ax.set_ydata()\\n ax.set_xdata()\\n ax.set_title(\\\"$z$ = %f\\\" % snapid2z(int(id)))\\n ax.set_xlim([0,1000])\\n ax.set_ylim([0, 0.01])\\n sns.kdeplot(pixels[int(id)], ax=ax)\\n point.set_xdata(ax2_x[int(id) - 2])\\n point.set_ydata(nums[int(id) - 2])\\n fig.canvas.draw_idle()\\n sid.on_changed(update)\\n\\n plt.show()\\n\\n\\n if \\\"hist\\\" in options.keys():\\n conc = None\\n for id, vols in pixels.iteritems():\\n data = np.empty((vols.size, 2))\\n data[:,0] = id\\n data[:,1] = vols\\n\\n if conc is None:\\n conc = data\\n else:\\n conc = np.vstack((conc, data))\\n\\n plt.figure()\\n plt.hist2d(conc[:,0], conc[:,1], bins=(snap_ids.size, 1000))\\n plt.ylim([100,400])\\n plt.savefig(options[\\\"hist\\\"])\",\n \"def create_image_caption_pairs(self):\",\n \"def _set_boxes(self, listOfBoxes):\\n self._boxes = listOfBoxes\",\n \"def generate_image_grid(sess, df, filenames,op, op2):\\n #x_points = np.arange(0, 1, 1.5).astype(np.float32)\\n #y_points = np.arange(0, 1, 1.5).astype(np.float32)\\n\\n nx, ny = 12, 1\\n #plt.subplot()\\n gs = gridspec.GridSpec(nx, ny, hspace=1, wspace=0.05)\\n # input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\\n #\\n # plt.imshow(np.array(df[0].tolist()).reshape(28, 28), cmap='gray')\\n # plt.show()\\n # x = sess.run(op, feed_dict={decoder_input: input_x[0].reshape(1,2)})\\n # img = np.array(x.tolist()).reshape(28, 28)\\n #\\n # plt.imshow(img, cmap='gray')\\n # plt.show()\\n\\n \\\"\\\"\\\" grid \\\"\\\"\\\"\\n input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\\n for i, g in enumerate(gs):\\n\\n x = sess.run(op, feed_dict={decoder_input: input_x[i].reshape(1,2)})\\n ax = plt.subplot(g)\\n img = np.array(x.tolist()).reshape(28, 28)\\n ax.imshow(img, cmap='gray')\\n ax.set_xticks([])\\n ax.set_yticks([])\\n #ax.set_aspect('auto')\\n ax.set_title(filenames[i])\\n plt.show()\\n\\n for i, g in enumerate(gs):\\n\\n ax = plt.subplot(g)\\n img = np.array(df[i].tolist()).reshape(28, 28)\\n ax.imshow(img, cmap='gray')\\n ax.set_xticks([])\\n ax.set_yticks([])\\n #ax.set_aspect('auto')\\n ax.set_title(filenames[i])\\n plt.show()\",\n \"def plt_bboxes(img, classes, scores, bboxes, figsize=(17.78,10), linewidth=1.5):\\n fig = plt.figure(figsize=figsize, frameon=False)\\n ax = fig.add_axes([0, 0, 1, 1])\\n ax.axis('off')\\n plt.imshow(img)\\n height = img.shape[0]\\n width = img.shape[1]\\n print (\\\"original height width\\\", height, width)\\n if (classes.shape[0] > 0):\\n print (\\\"This frame has class\\\")\\n for i in range(classes.shape[0]):\\n cls_id = int(classes[i])\\n if cls_id >= 0:\\n score = scores[i]\\n if cls_id not in colors:\\n colors[cls_id] = (random.random(), random.random(), random.random())\\n ymin = int(bboxes[i, 0] * height)\\n xmin = int(bboxes[i, 1] * width)\\n ymax = int(bboxes[i, 2] * height)\\n xmax = int(bboxes[i, 3] * width)\\n rect = plt.Rectangle((xmin, ymin), xmax - xmin,\\n ymax - ymin, fill=False,\\n edgecolor=colors[cls_id],\\n linewidth=linewidth)\\n plt.gca().add_patch(rect)\\n class_name = pascal_classes[cls_id]\\n plt.gca().text(xmin, ymin - 2,\\n '{:s} | {:.3f}'.format(class_name, score),\\n bbox=dict(facecolor=colors[cls_id], alpha=0.5),\\n fontsize=12, color='white')\\n fig.canvas.draw()\\n data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')\\n data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))\\n plt.close()\\n print(\\\"Processed data with shape, \\\", data.shape)\\n return data\",\n \"def draw_boxes(indexes, frame, all_boxes):\\n bbox = []\\n mid_points = []\\n\\n for i in indexes:\\n x = i[0]\\n box = all_boxes[x]\\n bbox.append(box)\\n mid_points.append(mid_point(frame, box))\\n x1, y1, w, h = box[0], box[1], box[2], box[3]\\n x2, y2 = x1+w, y1+h\\n\\n cv2.rectangle(frame, (x1,y1),(x2,y2),(255,0,0),2) \\n\\n return mid_points, bbox\",\n \"def __draw_boxes(self, img, bboxes, color=(128, 0, 0), thick=4):\\n\\n # Make a copy of the image\\n imcopy = np.copy(img)\\n # Iterate through the bounding boxes\\n for bbox in bboxes:\\n # Draw a rectangle given bbox coordinates\\n cv2.rectangle(imcopy, bbox[0], bbox[1], color, thick)\\n # Return the image copy with boxes drawn\\n return imcopy\",\n \"def setUp(self):\\n img_path = osp.join(osp.dirname(__file__), '../../data/gray.jpg')\\n self.results = {\\n 'img_path':\\n img_path,\\n 'img_shape': (300, 400),\\n 'instances': [{\\n 'bbox': [0, 0, 10, 20],\\n 'bbox_label': 1,\\n 'mask': [[0, 0, 0, 20, 10, 20, 10, 0]],\\n 'ignore_flag': 0\\n }, {\\n 'bbox': [10, 10, 110, 120],\\n 'bbox_label': 2,\\n 'mask': [[10, 10, 110, 10, 110, 120, 110, 10]],\\n 'ignore_flag': 0\\n }, {\\n 'bbox': [50, 50, 60, 80],\\n 'bbox_label': 2,\\n 'mask': [[50, 50, 60, 50, 60, 80, 50, 80]],\\n 'ignore_flag': 1\\n }]\\n }\",\n \"def make_grid_bbox(tensor, box, nrow=8, padding=2,\\n normalize=False, range=None, \\n scale_each=False, pad_value=0, draw_line=False):\\n\\n # make the mini-batch of images into a grid\\n # nmaps = tensor.size(0)\\n nmaps = len(box)\\n xmaps = min(nrow, nmaps)\\n ymaps = int(math.ceil(float(nmaps) / xmaps))\\n # height, width = int(tensor.size(2) + padding), int(tensor.size(3) + padding)\\n height, width = int(256 + padding), int(256 + padding)\\n tensor = torch.ones(())\\n grid = tensor.new_full((3, height * ymaps + padding, width * xmaps + padding), pad_value)\\n # # add the white image into the grid\\n # block = tensor.new_full((3, height - padding, width - padding), 9.0/13)\\n k = 0\\n for y in irange(ymaps):\\n for x in irange(xmaps):\\n if k >= nmaps:\\n break\\n # add the white image into the grid\\n block = tensor.new_full((3, height - padding, width - padding), 9.0/13)\\n # print(box[0].size())\\n # print(box[1].size())\\n # assert False\\n # num_curr_box = box[0][k].size(0)\\n num_curr_box = box[k][0].size(0)\\n for z in irange(num_curr_box):\\n # label = box[1][k][z].item()\\n try:\\n label = box[k][1][z].item()\\n except:\\n print(box)\\n print(k)\\n assert False\\n \\n if label != -1:\\n block = draw_box(block, box[k][0][z], label, draw_line)\\n # print(k, z)\\n else:\\n break\\n # copy to the grid\\n grid.narrow(1, y * height + padding, height - padding)\\\\\\n .narrow(2, x * width + padding, width - padding)\\\\\\n .copy_(block)\\n k = k + 1\\n return grid\",\n \"def _resize_bboxes(self, ori_bboxes, scale_factor):\\n bboxes = ori_bboxes * scale_factor\\n bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, self.img_shape[1])\\n bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, self.img_shape[0])\\n return bboxes\",\n \"def draw_boxes_info(image, current_data):\\n\\n font_position1 = (50, 600)\\n font_position2 = (50, 650)\\n font_scale = .4\\n font_thickness = 1\\n\\n locations = current_data[\\\"locations\\\"] #returns x1, y1, x2, y2\\n frame_num = \\\"Frame Number: \\\" + str(current_data[\\\"frame_num\\\"])\\n\\n for box in locations:\\n box_text = (\\\"Box locations are x1: {0}, y1: {1}, x2: {2}, y2: {3}\\\").format(box[1],box[3],box[0],box[2])\\n\\n cv2.rectangle(image, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 3)\\n cv2.putText(image, box_text, font_position1, cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255),\\n font_thickness, cv2.LINE_AA)\\n\\n cv2.putText(image, frame_num, font_position2, cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255),\\n font_thickness, cv2.LINE_AA)\\n\\n return image\",\n \"def display_precomputed_boxes(self, sample_index, all_boxes):\\n image_rois = [class_detections[sample_index]\\n for class_detections in all_boxes]\\n\\n image_rois_list = []\\n image_classes = []\\n for class_index, class_rois in enumerate(image_rois):\\n if len(class_rois) > 0:\\n classes = np.ones((class_rois.shape[0])) * class_index\\n image_rois_list.extend(class_rois)\\n image_classes.extend(classes)\\n image_rois_list = np.array(image_rois_list)\\n image_classes = np.array(image_classes)\\n\\n show_gt_boxes = False\\n self.display_detections(image_rois_list, image_classes, \\n self.data_loader.dataset.samples[sample_index])\",\n \"def plot_n_box(img_prepro):\\n print(img_prepro)\\n h, w= img_prepro.shape\\n boxes = pytesseract.image_to_boxes(img_prepro)\\n for b in boxes.splitlines():\\n b = b.split(' ')\\n img_prepro = cv2.rectangle(img_prepro, (int(b[1]), h - int(b[2])), (int(b[3]), h - int(b[4])), (0, 255, 0), 2)\\n cv2.imshow('img', img_prepro)\\n cv2.waitKey(0)\\n\\n return\",\n \"def setwinsize(self, rows, cols):\",\n \"def onet_process(self, image, boxes, height, width):\\n data = self.__padding(image, boxes, height, width)\\n return data\",\n \"def forward(self):\\n priors = []\\n for k, f in enumerate(self.feature_maps):\\n scale = self.image_size / self.strides[k]\\n # for i, j in product(range(f), repeat=2):\\n for i in range(f[0]):\\n for j in range(f[1]):\\n # print(i, j)\\n # unit center x,y\\n cx = (j + 0.5) / scale\\n cy = (i + 0.5) / scale\\n\\n # small sized square box\\n size = self.min_sizes[k]\\n h = w = size / self.image_size\\n priors.append([cx, cy, w, h])\\n\\n # big sized square box\\n size = sqrt(self.min_sizes[k] * self.max_sizes[k])\\n h = w = size / self.image_size\\n priors.append([cx, cy, w, h])\\n\\n # change h/w ratio of the small sized box\\n size = self.min_sizes[k]\\n h = w = size / self.image_size\\n for ratio in self.aspect_ratios[k]:\\n ratio = sqrt(ratio)\\n priors.append([cx, cy, w * ratio, h / ratio])\\n priors.append([cx, cy, w / ratio, h * ratio])\\n\\n priors = torch.Tensor(priors)\\n if self.clip:\\n priors.clamp_(max=1, min=0)\\n return priors\",\n \"def get_boxes():\\n boxes = []\\n\\n box_sizes = [256]\\n left_x_cords = [x for x in range(0,1280,12)]\\n top_y_cords = [y for y in range(360,720,12)]\\n\\n for box_size in box_sizes:\\n for x_cord in left_x_cords:\\n for y_cord in top_y_cords:\\n if box_size+x_cord < 1280 and box_size+y_cord < 720:\\n boxes.append([x_cord, y_cord, x_cord+box_size, y_cord+box_size])\\n\\n return boxes\",\n \"def __create_blank_page__(self):\\n with open(\\\"active_weather.basic.exp\\\"+str(self.box_count)+\\\".box\\\",\\\"w\\\") as f:\\n f.write(\\\"\\\")\\n\\n self.width = 2508\\n # self.height = 200\\n self.height = 4000\\n self.training_page = np.zeros((self.height,self.width),dtype=np.uint8)\\n self.training_page.fill(255)\\n\\n self.row_bitmaps = []\\n self.row_characters = []\\n\\n self.row_pointer = spacing\\n self.column_pointer = spacing\\n\\n\\n # self.__box_file_flush__()\\n self.box_file_entries = []\\n self.used_height = spacing\",\n \"def plot_image(image, boxes, class_dic, frame_n):\\n im = np.array(image)\\n print(im.shape)\\n height, width, _ = im.shape\\n\\n # Create figure and axes\\n # fig, ax = plt.subplots(1)\\n # # Display the image\\n # ax.imshow(im)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111, aspect='auto')\\n ax.set_axis_off()\\n fig.add_axes(ax)\\n ax.imshow(im)\\n # box[0] is x midpoint, box[2] is width\\n # box[1] is y midpoint, box[3] is height\\n\\n # Create a Rectangle potch\\n for box in boxes:\\n class_ = int(box[0])\\n confidence_ = box[1]\\n box = box[2:]\\n assert len(box) == 4, \\\"Got more values than in x, y, w, h, in a box!\\\"\\n upper_left_x = box[0] - box[2] / 2\\n upper_left_y = box[1] - box[3] / 2\\n rect = patches.Rectangle(\\n (upper_left_x * width, upper_left_y * height),\\n box[2] * width,\\n box[3] * height,\\n linewidth=1,\\n edgecolor=\\\"r\\\",\\n facecolor=\\\"none\\\",\\n )\\n\\n\\n label_bbox = class_dic[class_] + \\\":::\\\" + f\\\"{100 * confidence_:.2f}\\\" + \\\"%\\\"\\n plt.text(upper_left_x * width, upper_left_y * height - 10, label_bbox, size=10, rotation=0,\\n ha=\\\"left\\\", va=\\\"bottom\\\",\\n bbox=dict(boxstyle=\\\"square\\\",\\n ec=(1, 0, 0),\\n fc=(1, 0, 0),\\n )\\n )\\n \\n \\n # Add the patch to the Axes\\n ax.add_patch(rect)\\n if frame_n:\\n plt.savefig(str(frame_n) + '.png', dpi=200, bbox_inches=\\\"tight\\\", transparent=True, pad_inches=0)\\n else:\\n plt.show()\",\n \"def setUp(self):\\n self.single_box = [ScoredRect(Rect(0, 10, 0, 20), 0.0)]\\n\\n self.ground_truths = [ScoredRect(Rect(0, 10, 0, 10), 0.5),\\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\\n ScoredRect(Rect(-40, -30, -20, -10), 0.5),\\n ]\\n self.detections = [ScoredRect(Rect(0, 10, 0, 10), 0.5),\\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\\n ScoredRect(Rect(10, 20, 20, 30), 0.5),\\n ScoredRect(Rect(100, 110, 20, 30), 0.5),\\n ]\",\n \"def normalize_boxes(all_boxes, image_width, image_height):\\n new_boxes = []\\n for boxes_per_frame in all_boxes:\\n new_boxes_per_frame = []\\n for i, box in enumerate(boxes_per_frame):\\n left, top, right, bottom = box\\n new_boxes_per_frame.append((left / image_width, top / image_height, right / image_width, bottom / image_height))\\n new_boxes.append(new_boxes_per_frame)\\n\\n assert(len(new_boxes) == len(all_boxes))\\n for i, boxes_per_frame in enumerate(all_boxes):\\n assert(len(boxes_per_frame) == len(new_boxes[i]))\\n\\n\\n\\n return new_boxes\",\n \"def test_nominal_case(self):\\n\\n image_filename, boxes = list(annotation.read(self.filename))\\n self.assertEqual(image_filename, 'image.jpg')\\n self.assertEqual(len(boxes), 2)\\n width = 400\\n height = 300\\n b = boxes[0]\\n self.assertEqual(b.xmin, 10 / width)\\n self.assertEqual(b.ymin, 20 / height)\\n self.assertEqual(b.xmax, 30 / width)\\n self.assertEqual(b.ymax, 40 / height)\",\n \"def resize_spacing(img_sz,img_sp,factor):\\n img_sz_np = np.array(list(img_sz))\\n img_sp_np = np.array(list(img_sp))\\n new_sz_np = img_sz_np*factor\\n new_sp = img_sp_np*(img_sz_np-1)/(new_sz_np-1)\\n return tuple(list(new_sp))\",\n \"def __init__(self):\\n toplevel_create_image = mw.tkinter.Toplevel(mw.MainWindow, bg = \\\"#a1a1a1\\\")\\n \\\"\\\"\\\" top level window attributes\\\"\\\"\\\"\\n toplevel_create_image.title(\\\"create new image\\\")\\n toplevel_create_image.geometry(\\\"800x600+600+200\\\")\\n toplevel_create_image.resizable(width = False, height = False)\\n self. top_down = 60\\n\\n # UI\\n image_width_label = mw.tkinter.Label(toplevel_create_image, text = \\\"Width: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n image_width_label.grid(row = 0, column = 0, padx = 20, pady = 20)\\n image_height_label = mw.tkinter.Label(toplevel_create_image, text = \\\"Height: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n image_height_label.grid(row = 1, column = 0)\\n\\n # text box image size \\n image_width_text_box = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n bg = \\\"grey\\\", fg = \\\"white\\\")\\n image_width_text_box.grid(row = 0, column = 1, pady = 20)\\n\\n image_height_text_box = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n bg = \\\"grey\\\", fg = \\\"white\\\")\\n image_height_text_box.grid(row = 1, column = 1)\\n\\n # color mode\\n color_mode_combo_box = mw.tkinter.Label(toplevel_create_image, text = \\\"color mode: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n color_mode_combo_box.grid(row = 2, column = 0, padx = 20, pady = 20)\\n\\n # image_color_mode_text = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n # bg = \\\"grey\\\", fg = \\\"white\\\")\\n # image_color_mode_text.grid(row = 2, column = 1)\\n\\n color_mode_combo_box = ttk.Combobox(toplevel_create_image, values = [\\n \\\"RGB\\\",\\n \\\"RGBA\\\",\\n \\\"CYMA\\\"\\n ])\\n color_mode_combo_box.current(0)\\n color_mode_combo_box.grid(row = 2, column = 1)\\n\\n # background color\\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \\\"red: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n image_background_color_label.grid(row = 3, column = 0, padx = 30)\\n\\n image_background_color_text_red = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n bg = \\\"grey\\\", fg = \\\"white\\\")\\n image_background_color_text_red.grid(row = 3, column = 1)\\n# -----------------------------------------------------------------------------------------------------------\\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \\\"green: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n image_background_color_label.grid(row = 4, column = 0, padx = 30)\\n\\n image_background_color_text_green = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n bg = \\\"grey\\\", fg = \\\"white\\\")\\n image_background_color_text_green.grid(row = 4, column = 1)\\n\\n# ----------------------------------------------------------------------------------------------------------\\n image_background_color_label = mw.tkinter.Label(toplevel_create_image, text = \\\"blue: \\\",\\n font = (\\\"\\\", 15), bg = \\\"#a1a1a1\\\", fg = \\\"white\\\")\\n image_background_color_label.grid(row = 5, column = 0, padx = 30)\\n\\n image_background_color_text_blue = mw.tkinter.Text(toplevel_create_image, width = 20, height = 2,\\n bg = \\\"grey\\\", fg = \\\"white\\\")\\n image_background_color_text_blue.grid(row = 5, column = 1)\\n # create_new_image\\n def create_new_image():\\n new_image = Image.new(mode = (color_mode_combo_box.get()),\\n size = (int(image_width_text_box.get(\\\"1.0\\\", mw.tkinter.END)),\\n int(image_height_text_box.get(\\\"1.0\\\", mw.tkinter.END)) ),\\n color = ((int(image_background_color_text_red.get(\\\"1.0\\\", mw.tkinter.END))),\\n (int(image_background_color_text_green.get(\\\"1.0\\\", mw.tkinter.END))),\\n (int(image_background_color_text_blue.get(\\\"1.0\\\", mw.tkinter.END)))))\\n # get new image properties\\n the_width, the_height = new_image.size\\n # to-do clear the image\\n new_image_compatible = ImageTk.PhotoImage(new_image)\\n # load the image on the canvas \\n app.default_image_canvas.delete(\\\"all\\\")\\n # app.default_image_canvas = mw.tkinter.Canvas(toplevel_create_image, height = the_height, width = the_width)\\n app.default_image_canvas.create_image(0,0, image = new_image_compatible, anchor = mw.tkinter.NW)\\n # app.load_image_canvas.grid(row = 0, column = 1)\\n toplevel_create_image.destroy()\\n # to-do - correct error\\n app.default_image_canvas.configure(mw.MainWindow)\\n \\n\\n\\n # create_image_button\\n create_image_button = mw.tkinter.Button(toplevel_create_image, text = \\\"create image\\\",\\n bg = \\\"grey\\\", fg = \\\"white\\\", font = (\\\"times\\\", 13,\\\"bold\\\"),\\n command = create_new_image)\\n create_image_button.grid(row = 6, column = 0, padx = 40, pady = 20)\",\n \"def draw_boxes(self, image, boxes):\\n return draw_boxes(image, boxes, self.labels)\",\n \"def initrows(self):\\n #~ self.initrows2()\\n self.rows=[]\\n for yy in range(self.height):\\n row=[]\\n for xx in range(self.width):\\n if (xx,yy) in self.allsqs:\\n row.append(0)\\n #~ elif p in self.gatesqs:\\n #~ row.append(0)\\n else:\\n row.append(1)\\n self.rows.append(row)\",\n \"def rescale_box(box, img_size_orig, img_size_new):\\n orig_w, orig_h = img_size_orig\\n new_w, new_h = img_size_new\\n scale_x = new_w / orig_w\\n scale_y = new_h / orig_h\\n sx, sy, ex, ey = box\\n return [sx * scale_x, sy * scale_y, ex * scale_x, ey * scale_y]\",\n \"def __getitem__(self, index):\\n image_id = self.image_ids[index]\\n\\n filename = self.image_id_to_filename[image_id]\\n image_path = os.path.join(self.image_dir, filename)\\n\\n with open(image_path, 'rb') as f:\\n with PIL.Image.open(f) as image:\\n WW, HH = image.size\\n image = self.transform(image.convert('RGB'))\\n\\n H, W = self.image_size\\n objs, boxes, masks = [], [], []\\n\\n for object_data in self.image_id_to_objects[image_id]:\\n # objs.append(object_data['category_id'])\\n objs.append(int(object_data.find('name').get(\\\"id\\\")))\\n\\n bndbox = object_data.findall('bndbox')[0]\\n xmin = int(bndbox.find('xmin').text)\\n ymin = int(bndbox.find('ymin').text)\\n xmax = int(bndbox.find('xmax').text)\\n ymax = int(bndbox.find('ymax').text)\\n w = xmax - xmin\\n h = ymax - ymin\\n\\n boxes.append(torch.FloatTensor([xmin, ymin, xmax, ymax]))\\n\\n # This will give a numpy array of shape (HH, WW)\\n mask = torch.zeros(1, H, W)\\n # mask = seg_to_mask(object_data['segmentation'], WW, HH)\\n mask[:, round(ymin * H):max(round(ymin * H) + 1, round(ymax * H)),\\n round(xmin * W):max(round(xmin * W) + 1, round(xmax * W))] = 1\\n masks.append(mask)\\n # shuffle objs\\n O = len(objs)\\n rand_idx = list(range(O))\\n random.shuffle(rand_idx)\\n\\n objs = [objs[i] for i in rand_idx]\\n boxes = [boxes[i] for i in rand_idx]\\n masks = [masks[i] for i in rand_idx]\\n\\n objs = torch.LongTensor(objs)\\n boxes = torch.stack(boxes, dim=0)\\n masks = torch.stack(masks, dim=0)\\n\\n # print(image_path)\\n\\n return image, objs, boxes, masks\",\n \"def show_field(self, vehicles, type):\\n\\n # starting pixels x = 0, y = 0 on field image\\n start_x = 78\\n start_y = 45\\n\\n # block pixel width is slightly different per field size\\n if self.size == 6:\\n block_width = 72\\n elif self.size == 9:\\n block_width = 69\\n elif self.size == 12:\\n block_width = 68.5\\n\\n field = plt.imread(f\\\"data/RushHourImages/RushHour{self.size}.jpg\\\")\\n fig, ax = plt.subplots()\\n plt.imshow(field)\\n plt.axis('off')\\n\\n for vehicle in vehicles:\\n if vehicle.orientation == 'H':\\n x = start_x + (vehicle.x * block_width)\\n y = start_y + (vehicle.y * block_width)\\n if vehicle.length == 2:\\n car = plt.imread(f\\\"data/RushHourImages/Car{vehicle.id}.png\\\")\\n else:\\n car = plt.imread(f\\\"data/RushHourImages/Truck{vehicle.id}.png\\\")\\n\\n # truck: the image coordinate is his middle, which changes with the length of the car\\n x += 40\\n\\n if vehicle.orientation == 'V':\\n x = start_y + (vehicle.x * block_width)\\n y = start_x + (vehicle.y * block_width)\\n if vehicle.length == 2:\\n car = plt.imread(f\\\"data/RushHourImages/Car-rotated{vehicle.id}.png\\\")\\n else:\\n car = plt.imread(f\\\"data/RushHourImages/Truck-rotated{vehicle.id}.png\\\")\\n y += 40\\n\\n if self.size == 6:\\n imagebox = OffsetImage(car, zoom=0.6)\\n elif self.size == 9:\\n imagebox = OffsetImage(car, zoom=0.4)\\n elif self.size == 12:\\n imagebox = OffsetImage(car, zoom=0.3)\\n\\n imagebox.image.axes = ax\\n xy = (x, y)\\n ab = AnnotationBbox(imagebox, xy, frameon=False)\\n ax.add_artist(ab)\\n\\n if type == True:\\n plt.show(block=False)\\n plt.pause(0.001)\\n plt.close()\\n else:\\n plt.show()\",\n \"def proposal_boxes(self, fmap, im_sizes, image_offset, gt_boxes=None, gt_classes=None, gt_rels=None, train_anchor_inds=None, proposals=None):\\n assert proposals is not None\\n rois = filter_roi_proposals(proposals[:, 2:].data.contiguous(), proposals[:, 1].data.contiguous(), np.array([2000] * len(im_sizes)), nms_thresh=0.7, pre_nms_topn=12000 if self.training and self.mode == 'rpntrain' else 6000, post_nms_topn=2000 if self.training and self.mode == 'rpntrain' else 1000)\\n if self.training:\\n all_rois, labels, bbox_targets = proposal_assignments_det(rois, gt_boxes.data, gt_classes.data, image_offset, fg_thresh=0.5)\\n all_rois = torch.cat((all_rois, Variable(rois)), 0)\\n else:\\n all_rois = Variable(rois, volatile=True)\\n labels = None\\n bbox_targets = None\\n rpn_scores = None\\n rpn_box_deltas = None\\n rel_labels = None\\n return all_rois, labels, bbox_targets, rpn_scores, rpn_box_deltas, rel_labels\",\n \"def _to_image_coords(self, boxes, height, width):\\n box_coords = np.zeros_like(boxes)\\n box_coords[:, 0] = boxes[:, 0] * height\\n box_coords[:, 1] = boxes[:, 1] * width\\n box_coords[:, 2] = boxes[:, 2] * height\\n box_coords[:, 3] = boxes[:, 3] * width\\n \\n return box_coords\",\n \"def boxplots(self, groups, nrows, ncols, type):\\n fig, axs = plt.subplots(nrows=nrows, ncols=ncols, figsize=(6, 9.3), sharey=\\\"row\\\")\\n\\n fig.subplots_adjust(left=0.03, right=0.97, hspace=0.3, wspace=0.05)\\n\\n for ax, (effs, dat) in zip(axs, groups):\\n ax[0].boxplot(dat[\\\"perm\\\"])\\n ax[1].boxplot(dat[\\\"t_test\\\"])\\n ax[0].set_ylabel(\\\"Errors\\\")\\n if type == \\\"es\\\":\\n ax[0].set_title(f\\\"Effect size = {effs}, Test = Perm\\\")\\n ax[1].set_title(f\\\"Effect size = {effs}, Test = t-test\\\")\\n elif type == \\\"samp2\\\":\\n ax[0].set_title(f\\\"Sample size = {effs}, Test = Perm\\\")\\n ax[1].set_title(f\\\"Sample size = {effs}, Test = t-test\\\")\\n\\n\\n plt.tight_layout()\\n #plt.show()\",\n \"def draw_bboxes_withindex(img,boxes, uids):\\n source = Image.fromarray(img)\\n draw = ImageDraw.Draw(source)\\n w2,h2 = (img.shape[0],img.shape[1])\\n \\n font = ImageFont.truetype('/usr/share/fonts/truetype/freefont/FreeSerif.ttf', 40)\\n #font = ImageFont.truetype('arial.ttf', 24)\\n\\n\\n idx = 0\\n\\n for b in boxes:\\n xmin,ymin,xmax,ymax = b\\n \\n for j in range(3):\\n draw.rectangle(((xmin+j, ymin+j), (xmax+j, ymax+j)), outline=\\\"red\\\")\\n draw.text((xmin+20, ymin+70), str(uids[idx]), font = font)\\n idx +=1\\n return source\",\n \"def load_boxes(self, data):\\r\\n\\r\\n # worldbox represents the total map area\\r\\n self.worldbox = self.Box((0, 0), (len(data[0]) * self.cellwidth, len(data) * self.cellwidth))\\r\\n\\r\\n # create a box corresponding to each character/cell in the map file\\r\\n tl_x = 0\\r\\n tl_y = 0\\r\\n for row in data:\\r\\n for cell in row:\\r\\n if cell == \\\".\\\":\\r\\n self.wallboxes += [self.Box((tl_x, tl_y), (tl_x + self.cellwidth, tl_y + self.cellwidth))]\\r\\n elif cell == \\\"x\\\":\\r\\n self.targetboxes += [self.Box((tl_x, tl_y), (tl_x + self.cellwidth, tl_y + self.cellwidth))]\\r\\n tl_x += self.cellwidth\\r\\n tl_x = 0\\r\\n tl_y += self.cellwidth\",\n \"def layout_graphics(self):\\n # Graphics layout object to place viewboxes in\\n self.g_layout = pg.GraphicsLayoutWidget(border=(80, 80, 80))\\n self.g_layout.setCursor(QtCore.Qt.CrossCursor)\\n\\n # Viewboxes for images\\n # aspect locked so that pixels are square\\n # y inverted so that (0,0) is top left as in Thorlabs software\\n options = {\\\"lockAspect\\\":True, \\\"invertY\\\":True}\\n self.vb_image = self.g_layout.addViewBox(row=0, col=0, rowspan=2, **options)\\n self.vb_zoom = self.g_layout.addViewBox(row=0, col=2, **options)\\n self.vb_residuals = self.g_layout.addViewBox(row=1, col=2, **options)\\n\\n # Link zoom and residual views\\n self.vb_zoom.setXLink(self.vb_residuals)\\n self.vb_zoom.setYLink(self.vb_residuals)\\n\\n # Viewboxes for slice data\\n # Both boxes have mouse disabled - range is fixed so we don't want to\\n # scale them accidentally\\n # Y box has y inverted to match the main image\\n # Y box has x inverted so that zero pixel value is far from the image\\n options = {\\\"enableMouse\\\":False, \\\"enableMenu\\\": False}\\n self.vb_x = self.g_layout.addViewBox(row=2, col=0, **options)\\n self.vb_y = self.g_layout.addViewBox(row=0, col=1, rowspan=2,\\n invertX=True, invertY=True, **options)\\n\\n # Link the slice axes to the main image so that when we zoom/pan the\\n # main image, our slices zoom/pan also\\n self.vb_x.setXLink(self.vb_image)\\n self.vb_y.setYLink(self.vb_image)\\n\\n # Disable autoscaling and fix range to maximum pixel intensity\\n self.vb_x.setRange(yRange=(0,255))\\n self.vb_y.setRange(xRange=(0,255))\\n self.vb_x.disableAutoRange(axis=self.vb_x.YAxis)\\n self.vb_y.disableAutoRange(axis=self.vb_y.XAxis)\\n\\n # Background color must not be black so that we can see where images\\n # start/end\\n color = pg.mkColor(40,40,40)\\n self.vb_image.setBackgroundColor(color)\\n self.vb_zoom.setBackgroundColor(color)\\n self.vb_residuals.setBackgroundColor(color)\\n self.vb_x.setBackgroundColor(color)\\n self.vb_y.setBackgroundColor(color)\\n self.g_layout.setBackground(color)\\n\\n self.vb_image.addItem(self.image)\\n self.vb_image.addItem(self.fit_v_line)\\n self.vb_image.addItem(self.fit_h_line)\\n self.vb_image.addItem(self.mark_v_line)\\n self.vb_image.addItem(self.mark_h_line)\\n # self.vb_image.addItem(self.cursor_text)\\n self.vb_image.addItem(self.cursor_delta)\\n self.vb_image.addItem(self.beam_delta)\\n self.vb_image.addItem(self.history_plot)\\n # Figure out how to overlay properly?\\n # self.vb_image.addItem(self.x_slice)\\n # self.vb_image.addItem(self.x_fit)\\n # self.vb_image.addItem(self.y_slice)\\n # self.vb_image.addItem(self.y_fit)\\n self.vb_zoom.addItem(self.zoom)\\n self.vb_zoom.addItem(self.fit_maj_line)\\n self.vb_zoom.addItem(self.fit_min_line)\\n self.vb_zoom.addItem(self.zoom_text)\\n self.vb_residuals.addItem(self.residuals)\\n self.vb_residuals.addItem(self.residuals_text)\\n self.vb_x.addItem(self.x_slice)\\n self.vb_x.addItem(self.x_fit)\\n self.vb_x.addItem(self.cursor_v)\\n self.vb_y.addItem(self.y_slice)\\n self.vb_y.addItem(self.y_fit)\\n self.vb_y.addItem(self.cursor_h)\\n\\n self.res_legend.setParentItem(self.vb_residuals)\\n self.cursor_text.setParentItem(self.vb_image)\\n\\n self.vb_image.setRange(QtCore.QRectF(0, 0, 1280, 1024))\\n self.vb_zoom.setRange(QtCore.QRectF(0, 0, 50, 50))\\n self.vb_residuals.setRange(QtCore.QRectF(0, 0, 50, 50))\\n\\n #\\n # Size hints below here\\n #\\n self.g_layout.ci.layout.setColumnStretchFactor(0, 4)\\n self.g_layout.ci.layout.setColumnStretchFactor(1, 1)\\n self.g_layout.ci.layout.setColumnStretchFactor(2, 2)\\n self.g_layout.ci.layout.setRowStretchFactor(0, 2)\\n self.g_layout.ci.layout.setRowStretchFactor(1, 2)\\n self.g_layout.ci.layout.setRowStretchFactor(2, 1)\\n\\n self.vb_x.setMinimumHeight(50)\\n self.vb_y.setMinimumWidth(50)\\n self.vb_x.setMaximumHeight(100)\\n self.vb_y.setMaximumWidth(100)\\n self.vb_image.setMinimumSize(640, 512)\\n self.vb_zoom.setMinimumSize(320, 320)\\n self.vb_residuals.setMinimumSize(320, 320)\\n\\n self.g_layout.setMinimumSize(1100,562)\",\n \"def plantGrid(name, minimum, maximum, spacing):\\n name = sys.argv[1]\\n minimum = sys.argv[2]\\n maximum = sys.argv[3]\\n minimum = int(minimum)\\n maximum = int(maximum)\\n #convert to flux\\n min1 = conversion(minimum)\\n max1 = conversion(maximum)\\n min1 = int(min1)\\n max1 = int(max1)\\n #brightness = [random.uniform(min1, max1) for _ in xrange(len(position))]\\n #print brightness\\n spacing = sys.argv[4]\\n spacing = float(spacing)\\n print len(data1)\\n #create the position array for x values\\n x = np.arange(6, len(data1), spacing)\\n #create the position array for y values\\n y = np.arange(6, len(data1), spacing)\\n x2 = np.arange(6, len(data1), spacing)\\n y2 = np.flipud(y)\\n \\n #combine both arrays to form a grid\\n position = np.column_stack((x,y))\\n position2 = np.column_stack((x2,y2))\\n \\n #combine both lines of grid to one array\\n position = np.concatenate((position, position2), axis = 0)\\n \\n #create a random brightness array between the min and max values\\n brightness = np.array([random.uniform(min1, max1) for _ in range(0,len(position))])\\n \\n #add to image file and subtract\\n fakestars.addtofits(name, out_file, psf, position, brightness, coordsys, verbose)\\n fakestars.addtofits(name, outfile2, psf, position, brightness, coordsys, verbose)\\n imarith.imsubtract(out_file, outfile2, differenceFile, clobber=True)\",\n \"def prepare_map(self):\\n for y, row in enumerate(self.contents):\\n for x, tile in enumerate(row):\\n bm = self.get_tile(tile)\\n self.image[\\n y * TILE_SIZE : (y + 1) * TILE_SIZE,\\n x * TILE_SIZE : (x + 1) * TILE_SIZE,\\n ] = bm\",\n \"def scale_box(box, img_size):\\n xscale = img_size[0] / FLAGS.size\\n yscale = img_size[1] / FLAGS.size\\n x0, y0, x1, y1 = box\\n return [\\n float(x0) * xscale,\\n float(y0) * yscale,\\n float(x1) * xscale,\\n float(y1) * yscale,\\n ]\",\n \"def initialize(self, frame):\\n self.grid_size = 5\\n\\n Label(frame, text=\\\"Grid Size:\\\").grid(row=0)\\n\\n self.e1 = Scale(frame, from_=self.grid_size, to=25, orient=HORIZONTAL)\\n self.e1.grid(row=0, column=1)\\n\\n return self.e1\",\n \"def make(self) -> None:\\n\\n # arbitrarily selecting the first image from the list, index 0\\n with Image.open(self.image_list[0]) as first_frame_image_in_list:\\n\\n # Find the width and height of the first image of the list.\\n # Assuming all the images have same size.\\n frame_image_width, frame_image_height = first_frame_image_in_list.size\\n\\n # scale is the ratio of collage_image_width and product of\\n # images_per_row_in_collage with frame_image_width.\\n\\n # The scale will always lie between 0 and 1, which implies that\\n # the images are always going to get downsized.\\n scale = (self.collage_image_width) / (\\n self.images_per_row_in_collage * frame_image_width\\n )\\n\\n # Calculating the scaled height and width for the frame image.\\n scaled_frame_image_width = ceil(frame_image_width * scale)\\n scaled_frame_image_height = ceil(frame_image_height * scale)\\n\\n # Divide the number of images by images_per_row_in_collage. The later\\n # was calculated by taking the square root of total number of images.\\n number_of_rows = ceil(self.number_of_images / self.images_per_row_in_collage)\\n\\n # Multiplying the height of one downsized image with number of rows.\\n # Height of 1 downsized image is product of scale and frame_image_height\\n # Total height is number of rows times the height of one downsized image.\\n self.collage_image_height = ceil(scale * frame_image_height * number_of_rows)\\n\\n # Create an image of passed collage_image_width and calculated collage_image_height.\\n # The downsized images will be pasted on this new base image.\\n # The image is 0,0,0 RGB(black).\\n collage_image = Image.new(\\n \\\"RGB\\\", (self.collage_image_width, self.collage_image_height)\\n )\\n\\n # keep track of the x and y coordinates of the resized frame images\\n i, j = (0, 0)\\n\\n # iterate the frames and paste them on their position on the collage_image\\n for count, frame_path in enumerate(self.image_list):\\n\\n # Set the x coordinate to zero if we are on the first column\\n # If self.images_per_row_in_collage is 4\\n # then 0,4,8 and so on should have their x coordinate as 0\\n if (count % self.images_per_row_in_collage) == 0:\\n i = 0\\n\\n # open the frame image, must open it to resize it using the thumbnail method\\n frame = Image.open(frame_path)\\n\\n # scale the opened frame images\\n frame.thumbnail(\\n (scaled_frame_image_width, scaled_frame_image_height), Image.ANTIALIAS\\n )\\n\\n # set the value of x to that of i's value.\\n # i is set to 0 if we are on the first column.\\n x = i\\n\\n # It ensures that y coordinate stays the same for any given row.\\n # The floor of a real number is the largest integer that is less\\n # than or equal to the number. floor division is used because of\\n # the zero based indexing, the floor of the division stays same\\n # for an entier row as the decimal values are negled by the floor.\\n # for the first row the result of floor division is always zero and\\n # the product of 0 with scaled_frame_image_height is also zero, they\\n # y coordinate for the first row is 0.\\n # For the second row the result of floor division is one and the prodcut\\n # with scaled_frame_image_height ensures that the y coordinate is\\n # scaled_frame_image_height below the first row.\\n y = (j // self.images_per_row_in_collage) * scaled_frame_image_height\\n\\n # paste the frame image on the newly created base image(base image is black)\\n collage_image.paste(frame, (x, y))\\n frame.close()\\n\\n # increase the x coordinate by scaled_frame_image_width\\n # to get the x coordinate of the next frame. unless the next image\\n # will be on the very first column this will be the x coordinate.\\n i = i + scaled_frame_image_width\\n\\n # increase the value of j by 1, this is to calculate the y coordinate of\\n # next image. The increased number will be floor divided by images_per_row_in_collage\\n # therefore the y coordinate stays the same for any given row.\\n j += 1\\n\\n # save the base image with all the scaled frame images embeded on it.\\n collage_image.save(self.output_path)\\n collage_image.close()\",\n \"def _build_meds_layout(self):\\n\\n\\n nim = self.image_info.size\\n nobj = self.obj_data.size\\n\\n trim_to_coadd = self.get('trim_to_coadd',False)\\n if trim_to_coadd:\\n print(' trimming to coadd')\\n coadd_wcs, coadd_pos, coadd_bnds, coadd_q = \\\\\\n self._get_pos_and_bounds(self.obj_data, 0)\\n in_bnds = coadd_bnds.contains_points(coadd_pos['zrow'], coadd_pos['zcol'])\\n w_in_bnds, = np.where(in_bnds == True)\\n assert w_in_bnds.size > 0,\\\"none found in coadd\\\"\\n\\n w_in_bnds = coadd_q[w_in_bnds]\\n self.obj_data = self.obj_data[w_in_bnds]\\n\\n self._do_psf_setup()\\n\\n # box sizes are even\\n half_box_size = self.obj_data['box_size']//2\\n\\n for file_id in range(nim):\\n\\n wcs, pos, bnds, q = self._get_pos_and_bounds(self.obj_data, file_id)\\n\\n # do the test\\n in_bnds = bnds.contains_points(pos['zrow'], pos['zcol'])\\n q_rc, = np.where(in_bnds == True)\\n print(' second cut: %6d of %6d objects' % (len(q_rc),len(q)))\\n\\n # now make sure everything is there\\n if self['check_in_first_image']:\\n if file_id == 0 and len(self.obj_data['ra']) != len(q_rc):\\n raise MEDSCreationError('Not all objects were found in first image for '\\n 'MEDS making (which is the coadd/detection '\\n 'image by convention).')\\n # compose them\\n q = q[q_rc]\\n\\n # fill in the object_data structure\\n\\n # note q_rc since pos was created using obj_data[q]\\n qrow = pos['zrow'][q_rc]\\n qcol = pos['zcol'][q_rc]\\n\\n icut = self.obj_data['ncutout'][q]\\n self.obj_data['file_id'][q,icut] = file_id\\n self.obj_data['orig_row'][q,icut] = qrow\\n self.obj_data['orig_col'][q,icut] = qcol\\n\\n # this results in the object center being close to\\n # the natural center (dim-1.)/2.\\n ostart_row = qrow.astype('i4') - half_box_size[q] + 1\\n ostart_col = qcol.astype('i4') - half_box_size[q] + 1\\n crow = qrow - ostart_row\\n ccol = qcol - ostart_col\\n\\n self.obj_data['orig_start_row'][q,icut] = ostart_row\\n self.obj_data['orig_start_col'][q,icut] = ostart_col\\n self.obj_data['cutout_row'][q,icut] = crow\\n self.obj_data['cutout_col'][q,icut] = ccol\\n\\n # do jacobian, in original, not-offset coords\\n # note q_rc since pos was created using self.obj_data[q]\\n jacob = wcs.get_jacobian(\\n x=pos['wcs_col'][q_rc],\\n y=pos['wcs_row'][q_rc])\\n\\n # jacob is a tuple of arrays\\n self.obj_data['dudcol'][q,icut] = jacob[0]\\n self.obj_data['dudrow'][q,icut] = jacob[1]\\n self.obj_data['dvdcol'][q,icut] = jacob[2]\\n self.obj_data['dvdrow'][q,icut] = jacob[3]\\n\\n # increment\\n self.obj_data['ncutout'][q] += 1\\n\\n w,=np.where(self.obj_data['ncutout'] > 0)\\n print('%d/%d had ncut > 0' % (w.size, self.obj_data.size))\\n #self.obj_data = self.obj_data[w]\\n\\n self.obj_data = self._make_resized_data(self.obj_data)\\n print('setting number field as sequential')\\n self.obj_data['number'] = 1+np.arange(self.obj_data.size)\\n\\n\\n self._set_start_rows_and_pixel_count()\\n\\n if self['survey']=='cosmos':\\n self._set_psf_layout_hst()\\n else:\\n self._set_psf_layout_psfex()\",\n \"def set_default_parameters(self):\\n super().set_default_parameters()\\n if not \\\"region_size\\\" in vars(self):\\n self.region_size = 0.08\\n if not \\\"RGB_bands\\\" in vars(self):\\n self.RGB_bands = [\\\"B4\\\",\\\"B3\\\",\\\"B2\\\"]\\n if not \\\"split_RGB_images\\\" in vars(self):\\n self.split_RGB_images = True\\n # in PROCESSED dir we expect RGB. NDVI, BWNDVI\\n self.num_files_per_point = 3\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62900573","0.6085298","0.6009164","0.58949316","0.58541226","0.58446145","0.5767578","0.5712032","0.5706543","0.5674811","0.5674811","0.5674811","0.5674811","0.5674811","0.5668548","0.5650026","0.5615289","0.5615289","0.5593645","0.55755764","0.55713177","0.55709535","0.5566756","0.5561757","0.55550766","0.55439216","0.55324256","0.5499715","0.5493037","0.5491024","0.5488773","0.54860556","0.5479351","0.5477189","0.54661876","0.54654974","0.5462513","0.5436562","0.54347384","0.5429081","0.54147685","0.5409667","0.54019666","0.5395863","0.5394675","0.5392269","0.5371903","0.53668004","0.53408337","0.53349805","0.533052","0.53242874","0.52984256","0.529094","0.5273975","0.5269214","0.5264517","0.5261543","0.5260264","0.5256314","0.52466404","0.52401096","0.52370954","0.52364236","0.52281755","0.52137214","0.52120256","0.5209313","0.52089477","0.5208163","0.5206278","0.52018976","0.51996654","0.51974803","0.5184914","0.51843166","0.51824045","0.5175214","0.517447","0.51738864","0.517314","0.51640254","0.5162107","0.51584274","0.5151213","0.51493704","0.5145289","0.5140283","0.51401466","0.51368606","0.5136106","0.51344085","0.51342916","0.5132771","0.5125228","0.5124148","0.512393","0.512312","0.5120537","0.51197904"],"string":"[\n \"0.62900573\",\n \"0.6085298\",\n \"0.6009164\",\n \"0.58949316\",\n \"0.58541226\",\n \"0.58446145\",\n \"0.5767578\",\n \"0.5712032\",\n \"0.5706543\",\n \"0.5674811\",\n \"0.5674811\",\n \"0.5674811\",\n \"0.5674811\",\n \"0.5674811\",\n \"0.5668548\",\n \"0.5650026\",\n \"0.5615289\",\n \"0.5615289\",\n \"0.5593645\",\n \"0.55755764\",\n \"0.55713177\",\n \"0.55709535\",\n \"0.5566756\",\n \"0.5561757\",\n \"0.55550766\",\n \"0.55439216\",\n \"0.55324256\",\n \"0.5499715\",\n \"0.5493037\",\n \"0.5491024\",\n \"0.5488773\",\n \"0.54860556\",\n \"0.5479351\",\n \"0.5477189\",\n \"0.54661876\",\n \"0.54654974\",\n \"0.5462513\",\n \"0.5436562\",\n \"0.54347384\",\n \"0.5429081\",\n \"0.54147685\",\n \"0.5409667\",\n \"0.54019666\",\n \"0.5395863\",\n \"0.5394675\",\n \"0.5392269\",\n \"0.5371903\",\n \"0.53668004\",\n \"0.53408337\",\n \"0.53349805\",\n \"0.533052\",\n \"0.53242874\",\n \"0.52984256\",\n \"0.529094\",\n \"0.5273975\",\n \"0.5269214\",\n \"0.5264517\",\n \"0.5261543\",\n \"0.5260264\",\n \"0.5256314\",\n \"0.52466404\",\n \"0.52401096\",\n \"0.52370954\",\n \"0.52364236\",\n \"0.52281755\",\n \"0.52137214\",\n \"0.52120256\",\n \"0.5209313\",\n \"0.52089477\",\n \"0.5208163\",\n \"0.5206278\",\n \"0.52018976\",\n \"0.51996654\",\n \"0.51974803\",\n \"0.5184914\",\n \"0.51843166\",\n \"0.51824045\",\n \"0.5175214\",\n \"0.517447\",\n \"0.51738864\",\n \"0.517314\",\n \"0.51640254\",\n \"0.5162107\",\n \"0.51584274\",\n \"0.5151213\",\n \"0.51493704\",\n \"0.5145289\",\n \"0.5140283\",\n \"0.51401466\",\n \"0.51368606\",\n \"0.5136106\",\n \"0.51344085\",\n \"0.51342916\",\n \"0.5132771\",\n \"0.5125228\",\n \"0.5124148\",\n \"0.512393\",\n \"0.512312\",\n \"0.5120537\",\n \"0.51197904\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6761654"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":197,"cells":{"query":{"kind":"string","value":"read the cosmos catalog"},"document":{"kind":"string","value":"def _read_catalog(self, catname):\n print('loading catalog:',catname)\n with fitsio.FITS(catname,lower=True) as fits:\n #cat = fits[1][100000:110000]\n if 'object_data' in fits:\n print('reading from MEDS object data')\n ext='object_data'\n else:\n ext=1\n cat = fits[ext][:]\n\n # one cut here based on if we matched to the galsim cat\n w, = np.where(\n #(cat['mu_class'] < 3)\n #&\n #(cat['mask']==0)\n #&\n (cat['gscosmos_index'] >= 0)\n )\n print('initial cuts %d/%d %g%%' % (w.size,cat.size,w.size/cat.size*100))\n\n cat = cat[w]\n return cat"},"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 read_catalog(catalog):\n with open(catalog, \"r\") as f:\n header = f.readline()\n if header.startswith('#EventID | Time | Latitude | Longitude | Depth/km'):\n catalog = _read_iris(f)\n elif header.startswith('time, latitude, longitude, depth, depthUnits, magnitude'):\n catalog = _read_sod(f)\n else:\n sys.exit(\"Unknown catalog format\")\n return catalog","def getCatalogs():","def getCatalog(unique_name):","def read_catalog():\n categories = session.query(Category).all()\n items = session.query(CatalogItem).order_by(CatalogItem.id.desc())\n quantity = items.count()\n return categories, items, quantity","def catalog(self) -> str:\n return pulumi.get(self, \"catalog\")","def get_catalog():\n return jsonify(getCatalog())","def sample():\n write_drive_catalog_file(\"j:\\\\\", \"SANSA2_1G\", r\"c:\\SANSA2_1G.txt\")\n write_drive_catalog_file(\"k:\\\\\", \"8GB\", r\"c:\\8GB.txt\")\n write_master_catalog_file([r\"c:\\SANSA2_1G.txt\", r\"c:\\8GB.txt\"], r\"c:\\Master_Catalog.txt\")\n entries = read_catalog_file_entries(r\"c:\\Master_Catalog.txt\")\n for entry in entries:\n println(entry_to_line(entry))","def testCosmologyCatalog(self):\n dbObj = myTestGals(database=self.dbName)\n cat = cosmologicalGalaxyCatalog(dbObj)\n cat.write_catalog(self.catName)","def _get_catalog_object(self):\n return self.cluster.catalogd.service.read_debug_webpage(\n \"catalog_object?object_type=TABLE&object_name=functional.alltypes\")","def get_catalog(self) -> Dict[str, str]:\n return self.catalog","def load_catalog(self):\n self.catalog = pd.read_csv(self.catalog_path, \n index_col=0, parse_dates=True)\n self.unique_years = self.catalog.index.year.unique()\n return","def loadData(catalog):\n return controller.loadData(catalog)","def loadData(catalog):\n return controller.loadData(catalog)","def test_api_ucs_get_catalog(self):\n api_data = request(\"get\", \"/sys\")\n self.assertEqual(api_data['status'], 200,\n 'Incorrect HTTP return code, expected 200, got:' + str(api_data['status']))\n total_elements = 0\n for elementTypes in api_data[\"json\"]:\n for element in api_data[\"json\"][str(elementTypes)]:\n api_data_c = request(\"get\", \"/catalog\",\n query={\"identifier\": element[\"relative_path\"].strip(\"/\")})\n self.assertEqual(api_data_c['status'], 200,\n 'Incorrect HTTP return code, expected 200, got:' +\n str(api_data_c['status']))\n total_elements += 1\n self.assertGreater(total_elements, 0, \"Zero catalog elements found\")\n # TO DO: deeper check on the catalog data","def read_catalogs():\n if not StateHolder.config_parsed:\n config = YamlUtils.read(file=StateHolder.catalog_config_file, doc=Doc.CATALOGS_CONFIG)\n\n if not type(config) is dict:\n config['default'] = {}\n StateHolder.config = dict(config)\n StateHolder.config_parsed = True","def loadData(catalog):\r\n controller.loadData(catalog)","def readDataFromCosmosDB(self):\n self.cosmosdb.updateCollectionThroughput(\n self.config.get_database_name(), self.config.get_hash_table(), self.config.get_scaleup_cosmos(),\n self.config.get_key(),\n self.config.get_cosmos_account())\n\n # read all the data from cosmos DB with encrypted fields and store in a data frame\n df = spark.read.format(\"com.microsoft.azure.cosmosdb.spark\").options(\n **self.config.get_hash_readconfig()).load()\n\n # iterate over the dataframe and decrypt and replace all fields except the cosmos db system fields strating\n # with \"_\" and the key --> id field since its hashed not encrypted and also not the partition field\n df = df.repartition(160).cache()\n dec_udf = udf(decrypt)\n\n for columns in df.columns:\n if columns.startswith('_') or columns.startswith('id') or columns.startswith('partition'):\n print('not to be encrypted field: ' + columns)\n else:\n print('to be encrypted field: ' + columns)\n df = df.withColumn(columns, dec_udf(df[columns]))\n print(\"succesfully decrypted the fields in spark df data frame\")\n\n # Register the DataFrame as a SQL temporary view\n df = df.repartition(1).cache()\n # df.persist(StorageLevel.DISK_ONLY_2)\n df.createOrReplaceTempView(\"customer\")\n spark.sql(\"CACHE TABLE customer\").collect()\n\n print(\"succesfully read \" + str(df.count()) +\n \" records from CosmosDB and saved in spark df data frame\")\n self.cosmosdb.updateCollectionThroughput(\n self.config.get_database_name(), self.config.get_hash_table(), self.config.get_scaledown_cosmos(),\n self.config.get_key(),\n self.config.get_cosmos_account())\n\n return df","def loadData(catalog):\n controller.loadData(catalog)","def loadData(catalog):\n controller.loadData(catalog)","def loadData(catalog):\n controller.loadData(catalog)","def loadData(catalog):\n controller.loadData(catalog)","def loadData(catalog):\n controller.loadData(catalog)","def get_catalog(self) -> Catalog:\n params: Dict[str, Any] = self._status.get_status_info()\n\n response = self._client.open_api_do(\n \"GET\", \"labels/catalogs\", self.dataset_id, params=params\n ).json()\n return Catalog.loads(response[\"catalog\"])","def print_catalog(self):\n # first download the json for the catalog\n self.download_json()\n\n # open the saved json file and load the json\n with self.file.open(\"r\") as catalog_file:\n pages = json.load(catalog_file)\n\n # the catalog json is just a list of pages\n # so we begin by iterating through the pages\n for page_num in range(len(pages)):\n # get each page\n page = pages[page_num]\n\n # get the threads on each page\n threads = page[\"threads\"]\n\n # print the page heading\n print(\"*** PAGE \", page_num + 1, \"***\")\n\n # iterate through the threads on each page\n for thread_num in range(len(threads)):\n # get each thread\n thread = threads[thread_num]\n\n # print the thread number\n num = thread[\"no\"]\n print(\"---\", \"Thread:\", num, \"---\")\n\n # not all threads have a subject or comment\n try:\n subject = thread[\"sub\"]\n comment = thread[\"com\"]\n\n print(\"Sub:\", subject)\n print(\"Comment:\", comment)\n except KeyError:\n print(\"N/A\")","def read_combined_star_catalog(params,log):\n\n if path.isfile(params['catalog_file']) == False:\n\n return np.zeros(1)\n\n hdulist = fits.open(params['catalog_file'])\n\n data = hdulist[1].data\n\n header = hdulist[0].header\n\n star_catalog = Table(data)\n\n data = hdulist[2].data\n\n image_trios = Table(data)\n\n log.info('Read data from combined colour star catalog')\n\n return star_catalog, image_trios, header","def list_detail_catalog(self, catalog_name):\n # list catalog\n self._list_catalog(catalog_name)\n # detail catalog\n self._details_catalog(catalog_name)","def load_data(catalog):\n controller.load_data(catalog)","def initCatalog():\n return controller.initCatalog()","def initCatalog():\n return controller.initCatalog()","def initCatalog():\n return controller.initCatalog()","def initCatalog():\n return controller.initCatalog()","def initCatalog():\n return controller.initCatalog()","def checkCatalogs():\n url = CHECKBASE % 'catalogs'\n catalogs = []\n try:\n fh = getURLHandle(url)\n #fh = urllib2.urlopen(url)\n data = fh.read()\n dom = minidom.parseString(data)\n fh.close()\n catalog_elements = dom.getElementsByTagName('Catalog')\n for catel in catalog_elements:\n if catel.firstChild is None:\n continue\n catalog = catel.firstChild.data.strip()\n if len(catalog):\n catalogs.append(str(catalog))\n except:\n raise Exception,\"Could not open %s to search for list of catalogs\" % url\n return catalogs","def initCatalog():\n catalog = model.newCatalog()\n return catalog","def initCatalog():\n catalog = model.newCatalog()\n return catalog","def initCatalog():\n catalog = model.newCatalog()\n return catalog","def list(logger, client):\n logger.info('Retrieving Cloudify License')\n license = client.license.list()\n print_data(LICENSE_COLUMN, license, 'Cloudify License')","async def get_catalog(self, board_id):\n\n route = f'{board_id}/catalog'\n\n data = await self.interact(route)\n\n value = Asset(data)\n\n return value","def get_catalog(self):\n\n rep = req.get_json(self.CATALOG)\n repo_list = rep[\"repositories\"]\n\n for repo in repo_list:\n self.list.append(Repository(repo))\n\n return self.list","def test_catalog_opds(self):\n client = Client()\n response = client.get('/catalog.atom/')\n print 'status code for catalog in opds', response.status_code\n self.failUnlessEqual(response.status_code, 200)","def loadData(catalog):\n loadArtworks(catalog)\n loadArtists(catalog)","def init_catalog():\n return controller.init_catalog()","def get_catalog(self, command):\n return self._catalogs.get(str(command))","def loadData(catalog):\n loadArtists(catalog)\n loadArtworks(catalog)","def loadData(catalog):\n loadArtists(catalog)\n loadArtworks(catalog)","def test_get_catalogue(self):\n s1 = System()\n self.assertEqual(len(s1.get_catalogue()), 0)","def loadData(catalog):\n\n loadArtwork(catalog)\n loadArtists(catalog)","def catalog(self) -> TNSCatalog:\n if not self.__catalog:\n self.__catalog = TNSCatalog.from_web(cache=True)\n return self.__catalog\n else:\n self.__catalog.refresh()\n return self.__catalog","def dcos_aws() -> None:","def print_catalog(self):\n for book in self.books.keys():\n print(book)","def print_catalog(self):\n for book in self.books.keys():\n print(book)","def show_catalogue(self):\n\n data = cur.execute(\"\"\"SELECT productid, productname, unitcost, stock, location \n FROM catalogue WHERE vendorname = ?\"\"\", (self.vendorname,)).fetchall()\n print(tabulate(data, headers=[\"Product ID\", \"Name\", \"Unit Cost\", \"Stock\", \"Location\"]))","def test_getDigitalObjects(self):\n cases = [\n (self.test_eac + 'NE00001.xml', 0),\n (self.test_eac + 'NE00100.xml', 1),\n (self.test_eac + 'NE01101.xml', 15),\n (self.test_eac + 'NE01400.xml', 1),\n ]\n for case in cases:\n source, expected = case\n doc = EacCpf.EacCpf(source, 'http://www.example.com/metadata.xml', 'http://www.example.com/presentation.html')\n self.assertNotEqual(doc, None)\n result = doc.getDigitalObjects()\n self.assertNotEqual(result, None)\n self.assertEqual(len(result), expected)","def catalogs(env):\n envs = environments()\n check_env(env, envs)\n\n if app.config['ENABLE_CATALOG']:\n nodenames = []\n catalog_list = []\n query = AndOperator()\n\n if env != '*':\n query.add(EqualsOperator(\"catalog_environment\", env))\n\n query.add(NullOperator(\"catalog_timestamp\", False))\n\n order_by_str = '[{\"field\": \"certname\", \"order\": \"asc\"}]'\n nodes = get_or_abort(puppetdb.nodes,\n query=query,\n with_status=False,\n order_by=order_by_str)\n nodes, temp = tee(nodes)\n\n for node in temp:\n nodenames.append(node.name)\n\n for node in nodes:\n table_row = {\n 'name': node.name,\n 'catalog_timestamp': node.catalog_timestamp\n }\n\n if len(nodenames) > 1:\n form = CatalogForm()\n\n form.compare.data = node.name\n form.against.choices = [(x, x) for x in nodenames\n if x != node.name]\n table_row['form'] = form\n else:\n table_row['form'] = None\n\n catalog_list.append(table_row)\n\n return render_template(\n 'catalogs.html',\n nodes=catalog_list,\n envs=envs,\n current_env=env)\n else:\n log.warn('Access to catalog interface disabled by administrator')\n abort(403)","def retrieve_catalog(self, catalog_hash):\n return self.repository.retrieve_catalog(catalog_hash)","def read_all():\n # Create the list of CIs from our data\n ci = db.session.query(CI).order_by(CI.id).all()\n app.logger.debug(pformat(ci))\n # Serialize the data for the response\n ci_schema = CISchema(many=True)\n data = ci_schema.dump(ci)\n return data","def get_items_for_catalog(catalog_id):\n pass","def get(self):\n return GenericGet().get_catalogs()","def get_scnlist_con2ard(self):\n logger.debug(\"Creating Database Engine and Session.\")\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\n ses = session_sqlalc()\n\n logger.debug(\"Perform query to find scenes which need downloading.\")\n query_result = ses.query(EDDSentinel1ASF).filter(EDDSentinel1ASF.Downloaded == True,\n EDDSentinel1ASF.ARDProduct == False,\n EDDSentinel1ASF.Invalid == False).order_by(\n EDDSentinel1ASF.Acquisition_Date.asc()).all()\n\n scns2ard = list()\n if query_result is not None:\n for record in query_result:\n scns2ard.append(record.PID)\n ses.close()\n logger.debug(\"Closed the database session.\")\n return scns2ard","def get_catalog(self, user_id, tenant_id, metadata=None):\n raise exception.NotImplemented() # pragma: no cover","def read(self, path):\n client = self.connect(VAULT_TOKEN)\n return client.read(path)","def read_data(term):\n course_url = '/admweb/!SWKSECX.main?term='+ term + '&title=&course=&crn=&coll=&dept=&subj='\n connection = httplib.HTTPSConnection('courses.rice.edu', 443)\n connection.connect()\n connection.request(\n 'GET',\n course_url\n )\n courses_xml = connection.getresponse()\n return courses_xml","def final_catalogs(self, filename=None, catalog_cols=None):\n\n final_catalog = vstack([cluster_info['catalog'] for cluster_info in self._catalog_dictionary.values()])\n\n # If we request to keep only certain columns in our output\n if catalog_cols is not None:\n final_catalog.keep_columns(catalog_cols)\n\n if filename is None:\n return final_catalog\n else:\n if filename.endswith('.cat'):\n final_catalog.write(filename, format='ascii', overwrite=True)\n else:\n final_catalog.write(filename, overwrite=True)","def getcatalogs():\n \n # default path for the gthumb catalogs of the logged in user\n gpath = os.environ['HOME'] + \"/.local/share/gthumb/catalogs\"\n\n cats = [] \n cat_list = [] \n try:\n # dir_list has all files and directories in path\n # directories are WITHOUT ending '/'\n dir_list = os.listdir(gpath)\n except:\n # path may not be a directory or permission error\n print \"ERROR: in getcatalogs, gpath:\", gpath\n return []\n \n # get only the directories \n for line in dir_list:\n file = gpath + \"/\" + line\n #print file \n if os.path.isdir(file):\n cats.append(file)\n else: \n # not a directory; ignore \n #print \"not a directory:\", file \n pass\n\n # now get each catalog file from each directory\n for cat in cats:\n try:\n # dir_list has all files and directories in path\n # any directory is WITHOUT ending '/'\n dir_list = os.listdir(cat)\n except:\n # path may not be a directory or permission error\n print \"ERROR: in getcatalogs, cat:\", cat\n return []\n \n for line in dir_list:\n file = cat + \"/\" + line\n #print os.path.splitext(file)[1][1:]\n # append file only if it has catalog extension\n if os.path.splitext(file)[1][1:] == \"catalog\":\n cat_list.append(file)\n \n cat_list.sort() \n\n if random_mode:\n random.shuffle(cat_list)\n \n return cat_list","async def getCollectionDetail(self, slug=None):\n payload = {}\n \n if slug:\n payload[\"slug\"] = slug\n \n\n # Parameter validation\n schema = CatalogValidator.getCollectionDetail()\n schema.dump(schema.load(payload))\n \n\n url_with_params = await create_url_with_params(self._conf.domain, f\"/service/platform/catalog/v1.0/company/{self._conf.companyId}/application/{self.applicationId}/collections/{slug}/\", \"\"\"{\"required\":[{\"in\":\"path\",\"name\":\"company_id\",\"description\":\"A `company_id` is a unique identifier for a particular seller account.\",\"schema\":{\"type\":\"string\"},\"required\":true},{\"in\":\"path\",\"name\":\"application_id\",\"description\":\"A `application_id` is a unique identifier for a particular sale channel.\",\"schema\":{\"type\":\"string\"},\"required\":true},{\"in\":\"path\",\"name\":\"slug\",\"description\":\"A `slug` is a human readable, URL friendly unique identifier of an object. Pass the `slug` of the collection which you want to retrieve.\",\"schema\":{\"type\":\"string\"},\"required\":true}],\"optional\":[],\"query\":[],\"headers\":[],\"path\":[{\"in\":\"path\",\"name\":\"company_id\",\"description\":\"A `company_id` is a unique identifier for a particular seller account.\",\"schema\":{\"type\":\"string\"},\"required\":true},{\"in\":\"path\",\"name\":\"application_id\",\"description\":\"A `application_id` is a unique identifier for a particular sale channel.\",\"schema\":{\"type\":\"string\"},\"required\":true},{\"in\":\"path\",\"name\":\"slug\",\"description\":\"A `slug` is a human readable, URL friendly unique identifier of an object. Pass the `slug` of the collection which you want to retrieve.\",\"schema\":{\"type\":\"string\"},\"required\":true}]}\"\"\", slug=slug)\n query_string = await create_query_string(slug=slug)\n headers = {\n \"Authorization\": \"Bearer \" + await self._conf.getAccessToken()\n }\n for h in self._conf.extraHeaders:\n headers.update(h)\n exclude_headers = []\n for key, val in headers.items():\n if not key.startswith(\"x-fp-\"):\n exclude_headers.append(key)\n return await AiohttpHelper().aiohttp_request(\"GET\", url_with_params, headers=get_headers_with_signature(self._conf.domain, \"get\", await create_url_without_domain(f\"/service/platform/catalog/v1.0/company/{self._conf.companyId}/application/{self.applicationId}/collections/{slug}/\", slug=slug), query_string, headers, \"\", exclude_headers=exclude_headers), data=\"\")","def catalog():\n session['target'] = \"/\"\n sqlsession = SQLSESSION()\n items = sqlsession.query(Item, Category)\\\n .join(Category).order_by(Item.create_date).limit(10)\n categories = sqlsession.query(Category).all()\n return render_template(\"catalog.html\",\n items=items,\n categories=categories,\n item_title=\"Latest Items\")","def loadData(catalog):\n loadVideos(catalog)\n loadCategories(catalog)","def getUserCatalogOnFilespace(fs_id):\n result = None\n session = Queries.createSession()\n try:\n result = session.execute(sqlalchemy.select([Catalog])\n .where(Catalog.fs_id == fs_id)\n .order_by(asc(Catalog.id))\n ).fetchone()\n except sqlalchemy.exc.ArgumentError:\n print 'SQLAlchemy ERROR: Invalid or conflicting function argument is supplied'\n except sqlalchemy.exc.CompileError:\n print 'SQLAlchemy ERROR: Error occurs during SQL compilation'\n finally:\n session.close()\n return result","def loadData(catalog):\n loadArtworks(catalog)\n loadArtists(catalog)\n loadAdquires(catalog)\n loadNacionalities(catalog)\n load2DArtworks(catalog)\n loadArtistMediumsTags(catalog)\n loadDptments(catalog)\n catalog['artists'] = sortArtists(catalog, 3)\n fillArtistMediums(catalog)\n fillMostUsedMediums(catalog)\n catalog['artists_tags'] = sortArtistTags(catalog, 3)\n sort_dptments(catalog)","def getConc(fileID, spc):\r\n\r\n dataKey = rmn.fstinf(fileID, nomvar=spc, ip1=ip1)['key']\r\n dataRec = rmn.fstluk(dataKey)\r\n concData = dataRec['d']\r\n return concData, dataKey, dataRec","def catalog_get(self, args):\n headers = DEFAULT_HEADERS.copy()\n headers.update(args.headers)\n\n if args.output_format == \"json\":\n headers[\"accept\"] = \"application/json\"\n elif args.output_format == \"json-stream\":\n headers[\"accept\"] = \"application/x-json-stream\"\n elif args.output_format == \"csv\":\n headers[\"accept\"] = \"text/csv\"\n else:\n raise UsageException(\"Unsupported output format: %s\" % args.output_format)\n\n catalog = self.server.connect_ermrest(args.id)\n try:\n if args.output_file:\n catalog.getAsFile(args.path,\n destfilename=args.output_file,\n headers=headers,\n delete_if_empty=args.auto_delete)\n else:\n pp(catalog.get(args.path, headers=headers).json())\n except HTTPError as e:\n if e.response.status_code == requests.codes.not_found:\n raise ResourceException('Catalog not found', e)\n except:\n if args.output_file and os.path.isfile(args.output_file):\n logging.info(\"Deleting empty file: %s\" % args.output_file)\n os.remove(args.output_file)\n raise","def build_catalog_info(self, catalog_info):\n cat = SourceFactory.build_catalog(**catalog_info)\n catalog_info['catalog'] = cat\n # catalog_info['catalog_table'] =\n # Table.read(catalog_info['catalog_file'])\n catalog_info['catalog_table'] = cat.table\n catalog_info['roi_model'] =\\\n SourceFactory.make_fermipy_roi_model_from_catalogs([cat])\n catalog_info['srcmdl_name'] =\\\n self._name_factory.srcmdl_xml(sourcekey=catalog_info['catalog_name'])\n return CatalogInfo(**catalog_info)","def test_get_hyperflex_app_catalog_list(self):\n pass","def init():\n catalog = model.newCatalog()\n return catalog","def read_nonsidereal_catalog(filename):\n catalog_table = ascii.read(filename, comment='#')\n\n # Check to see whether the position is in x,y or ra,dec\n pixelflag = False\n try:\n if 'position_pixels' in catalog_table.meta['comments'][0:4]:\n pixelflag = True\n except:\n pass\n\n # If present, check whether the velocity entries are pix/sec\n # or arcsec/sec.\n pixelvelflag = False\n try:\n if 'velocity_pixels' in catalog_table.meta['comments'][0:4]:\n pixelvelflag = True\n except:\n pass\n return catalog_table, pixelflag, pixelvelflag","def read_all(self):\r\n pass","def check_catalogs():\n for config in StateHolder.config:\n conf = StateHolder.config[config]\n if type(conf) is not dict:\n continue\n if conf.get(\"repositoryType\", \"file\") is \"file\":\n FileUtils.make_empty_file_with_empty_dict(directory=StateHolder.home_dir,\n file=conf.get('file', 'poco-catalog.yml'))","def query_object_catalogs(self, position, catalogs=__ALL_STRING, row_limit=DEFAULT_ROW_LIMIT,\n get_query_payload=False, cache=True, verbose=False):\n return self.query_region_catalogs(position=position,\n radius=self.__ZERO_ARCMIN_STRING,\n catalogs=catalogs,\n row_limit=row_limit,\n get_query_payload=get_query_payload,\n cache=cache,\n verbose=verbose)","def read_category_items():\n items = session.query(CatalogItem).order_by(CatalogItem.id.desc())\n return items","def getCatalog(self, version=None, level=None, cubeInfo=True):\n print('WaPOR API: Loading catalog WaPOR.v{v}_l{lv}...'.format(\n v=version, lv=level))\n self.isAPITokenSet()\n\n isFound = False\n\n # if isinstance(version, int) and isinstance(level, int):\n # print('| int')\n # if 0 < version < 3 and 0 < level < 4:\n # print('| range')\n if version == self.version and level == self.level:\n # print('| equal')\n if self.catalog is not None:\n # print('| not None')\n isFound = True\n\n if isFound:\n df = self.catalog\n\n print('WaPOR API: Loading catalog WaPOR.v{v}_l{lv} found.'.format(\n v=version, lv=level))\n else:\n df = self._query_catalog(version, level)\n\n print('WaPOR API: Loading catalog WaPOR.v{v}_l{lv} loaded.'.format(\n v=version, lv=level))\n\n if cubeInfo:\n cubes_measure = []\n cubes_dimension = []\n for cube_code in df['code'].values:\n cubes_measure.append(self._query_cubeMeasures(cube_code))\n cubes_dimension.append(self._query_cubeDimensions(cube_code))\n df['measure'] = cubes_measure\n df['dimension'] = cubes_dimension\n\n self.catalog = df\n return self.catalog","def _extract_catalog(self, data):\n interface = 'public'\n catalog = data['token']['catalog']\n service_map = {}\n for service in catalog:\n service_endpoint = None\n for endpoint in service['endpoints']:\n if endpoint['interface'] == interface:\n service_endpoint = endpoint['url']\n break\n if service_endpoint:\n service_map[service['type']] = service_endpoint\n LOG.debug('Service catalog: %s' % service_map)\n return service_map","def __init__(self, catalog_path):\n self.catalog_path = catalog_path\n self.load_catalog()\n return","def getting_info(self, cloud_path):\n\t\telog(\"getting info on {}\".format(cloud_path))","def get_infores_catalog(self):\n return self._infores_catalog","def initCatalog():\n t = \"SINGLE_LINKED\"\n catalog = model.newCatalog(t)\n return catalog","def read(self):","def read(self, path: Path, oracle: Oracle) -> MagicCollection:\n with path.open(\"rt\", encoding=\"utf-8\") as csv_file:\n reader = csv.DictReader(csv_file)\n card_counts = counts.aggregate_card_counts(reader, oracle)\n return MagicCollection(oracle=oracle, counts=card_counts)","def read_meta(self):\n meta = cPickle.load(open('../sugar_analysis_data/META-CABALLO2.pkl'))\n self.meta_sn_name_list = []\n self.meta_zcmb = []\n self.meta_x0 =[]\n self.meta_x0_err = []\n self.meta_x1 =[]\n self.meta_x1_err = []\n self.meta_c = []\n self.meta_c_err = []\n self.meta_mb = []\n self.meta_mb_err = []\n self.meta_cov_x0_x1 = [] \n self.meta_cov_x0_c = []\n self.meta_cov_x1_c = []\n self.meta_cov_mb_x1 = []\n self.meta_cov_mb_c = [] \n self.meta_zhl = []\n self.meta_zhl_err = []\n self.meta_idr = []\n for meta_sn_name in meta.keys(): \n \n if meta[meta_sn_name]['idr.subset'] != 'bad' and meta[meta_sn_name]['idr.subset'] != 'auxiliary':\n \n self.meta_sn_name_list.append(meta_sn_name)\n self.meta_zhl_err.append(meta[meta_sn_name]['host.zhelio.err'])\n self.meta_zhl.append(meta[meta_sn_name]['host.zhelio'])\n self.meta_zcmb.append(meta[meta_sn_name]['host.zcmb'])\n self.meta_x0.append(meta[meta_sn_name]['salt2.X0'])\n self.meta_x0_err.append(meta[meta_sn_name]['salt2.X0.err'])\n self.meta_x1.append(meta[meta_sn_name]['salt2.X1'])\n self.meta_x1_err.append(meta[meta_sn_name]['salt2.X1.err'])\n self.meta_c.append(meta[meta_sn_name]['salt2.Color'])\n self.meta_c_err.append(meta[meta_sn_name]['salt2.Color.err'])\n self.meta_mb.append(meta[meta_sn_name]['salt2.RestFrameMag_0_B'])\n self.meta_mb_err.append(meta[meta_sn_name]['salt2.RestFrameMag_0_B.err'])\n self.meta_cov_x0_x1.append(meta[meta_sn_name]['salt2.CovX0X1'])\n self.meta_cov_x0_c.append(meta[meta_sn_name]['salt2.CovColorX0'])\n self.meta_cov_x1_c.append(meta[meta_sn_name]['salt2.CovColorX1'])\n self.meta_cov_mb_x1.append(meta[meta_sn_name]['salt2.CovRestFrameMag_0_BX1'])\n self.meta_cov_mb_c.append(meta[meta_sn_name]['salt2.CovColorRestFrameMag_0_B'])\n self.meta_idr.append(meta[meta_sn_name]['idr.subset'])\n \n self.meta_idr = np.array(self.meta_idr)\n self.meta_zcmb = np.array(self.meta_zcmb)\n self.meta_zhl = np.array(self.meta_zhl)\n self.meta_zhl_err = np.array(self.meta_zhl_err)\n self.meta_x0 = np.array(self.meta_x0)\n self.meta_x0_err = np.array(self.meta_x0_err)\n self.meta_x1 = np.array(self.meta_x1)\n self.meta_x1_err = np.array(self.meta_x1_err) \n self.meta_c = np.array(self.meta_c)\n self.meta_c_err = np.array(self.meta_c_err)\n self.meta_mb = np.array(self.meta_mb)\n self.meta_mb_err = np.array(self.meta_mb_err)\n self.meta_cov_x0_x1 = np.array(self.meta_cov_x0_x1)\n self.meta_cov_x0_c = np.array(self.meta_cov_x0_c)\n self.meta_cov_x1_c = np.array(self.meta_cov_x1_c)\n self.meta_cov_mb_x1 = np.array(self.meta_cov_mb_x1)\n self.meta_cov_mb_c = np.array(self.meta_cov_mb_c)","def s3_read_data(self):\n\n self.k.open()\n self.k.read()","def read():\n # TODO","def read_catalog(catalogfile):\n\t#dictionary to store the url and key\n\tglobal books\n\tglobal default_books\n\tglobal default_titles\n\tglobal count_books\n\t#list to store the titles\n\tglobal titles\n\t#counter for dictionary key\n\ti = 0\n\ttry:\n\t#open file\n\t\twith open(catalogfile,'r') as catalog:\n\t\t\t#read and strip lines\n\t\t\tfor lines in catalog.readlines():\n\t\t\t\tlines_stripped = lines.strip()\n\t\t\t\t#split the lines by using the tag http\n\t\t\t\tvalues = lines_stripped.split(\",http://\")\n\t\t\t\t#if values is not empty and has length 2 and title and url is not empty\n\t\t\t\tif values != [''] and len(values) == 2 and values[0] != \"\" and values[1] != \"\":\n\t\t\t\t\t#add title to the list\n\t\t\t\t\ttitles.append(values[0])\n\t\t\t\t\t#add url to the dictionary\n\t\t\t\t\tbooks[i] = \"http://\" + values[1]\n\t\t\t\t\t#increase counter\n\t\t\t\t\ti += 1\n\t\t#get count of book\n\t\tcount_books = len(books)\n\n\t\t#if no books was read - terminate program\n\t\tif (count_books == 0):\n\t\t\tprint(\"File is not readable. Using default values.\")\n\t\t\t#use default values\n\t\t\tbooks = default_books\n\t\t\ttitles = default_titles\n\t\t\tcount_books = len(books)\n\t#if error in reading file - terminate\n\texcept:\n\t\tprint(\"Exception occured while reading file. Using default values\")\n\t\t#use default values\n\t\tbooks = default_books\n\t\ttitles = default_titles\n\t\tcount_books = len(books)\n\twhile True:\n\t#read all the books\n\t\tall_data = list()\n\t\tb_count = range(0,count_books)\n\t\t#for each book in the dictionary - read data\n\t\tfor book_num in b_count:\n\t\t#print(titles)\n\t\t\tcontents = read_book(books[book_num],book_num)\n\t\t\t# add contents to a list\n\t\t\tall_data.append(contents)\n\t\t#if all the URL are not readable\n\t\tempty_data = list()\n\t\tfor x in range(0,count_books):\n\t\t\tempty_data.append([])\n\n\t\tif all_data == empty_data:\n\t\t\t#use default values\n\t\t\tprint(\"No contents were read. Using default values.\")\n\t\t\tbooks = default_books\n\t\t\ttitles = default_titles\n\t\t\tcount_books = len(books)\n\t\t\tcontinue\n\t\t#create a dictionary of words in the data\n\t\tfor values in range(0,count_books):\n\t\t\tupdate_words(all_data[values],values)\n\t\t#ask user for search term\n\t\tprompt_user()\n\t\tbreak","def fake_catalog(tenant, token):\n catalog_gen = servicecatalog.ServiceCatalogGenerator(token, tenant)\n catalog = catalog_gen.generate_full_catalog()['access']\n return access.AccessInfoV2(**catalog)","def print_catalog(self, catalog_filter=[]):\n keys = sorted(self.catalog.keys())\n if len(catalog_filter) > 0: # pylint: disable=len-as-condition\n valid = []\n for key in keys:\n for f in catalog_filter:\n if len(self.catalog[key][f]) > 0: # pylint: disable=len-as-condition\n valid.append(key)\n keys = valid\n for key in keys:\n print(f\"Pnum: {self.catalog[key]['pnum']}\")\n print(f\"Edition: {self.catalog[key]['edition']}\")\n print(f\"Metadata: {len(self.catalog[key]['metadata']) > 0}\")\n print(f\"Transliteration: {len(self.catalog[key]['transliteration']) > 0}\")\n print(f\"Normalization: {len(self.catalog[key]['normalization']) > 0}\")\n print(f\"Translation: {len(self.catalog[key]['translation']) > 0}\")\n print()","def get_cart_contents(db):","def get_scnlist_datacube(self, loaded=False):\n logger.debug(\"Creating Database Engine and Session.\")\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\n ses = session_sqlalc()\n\n logger.debug(\"Perform query to find scenes which need converting to ARD.\")\n query_result = ses.query(EDDSentinel1ASF).filter(EDDSentinel1ASF.ARDProduct == True,\n EDDSentinel1ASF.DCLoaded == loaded).order_by(\n EDDSentinel1ASF.Acquisition_Date.asc()).all()\n scns2dcload = list()\n if query_result is not None:\n for record in query_result:\n scns2dcload.append(record.PID)\n ses.close()\n logger.debug(\"Closed the database session.\")\n return scns2dcload","def loadSourceCatalog(self, filename):\n sourceCat = afwTable.SourceCatalog.readFits(filename)\n aliasMap = sourceCat.schema.getAliasMap()\n aliasMap.set(\"slot_ApFlux\", \"base_PsfFlux\")\n instFluxKey = sourceCat.schema[\"slot_ApFlux_instFlux\"].asKey()\n instFluxErrKey = sourceCat.schema[\"slot_ApFlux_instFluxErr\"].asKey()\n\n # print(\"schema=\", sourceCat.schema)\n\n # Source x,y positions are ~ (500,1500) x (500,1500)\n centroidKey = sourceCat.table.getCentroidSlot().getMeasKey()\n for src in sourceCat:\n adjCentroid = src.get(centroidKey) - lsst.geom.Extent2D(500, 500)\n src.set(centroidKey, adjCentroid)\n src.set(instFluxKey, 1000)\n src.set(instFluxErrKey, 1)\n\n # Set catalog coord\n for src in sourceCat:\n src.updateCoord(self.wcs)\n return sourceCat","def load_spitzer_catalog(): # pragma: no cover\n\n path = get_path('spitzer_example_catalog.xml', location='remote')\n table = Table.read(path)\n\n return table","def do_ascii(catalog):\n task_str = catalog.get_current_task_str()\n\n\n # Howerton Catalog\n datafile = os.path.join(catalog.get_current_task_repo(), 'ASCII',\n 'vizier_J_MNRAS_441_1186_table1 J_MNRAS_441_1186_table3_20200403.csv')\n data = read(datafile, format='csv')\n for rrow in pbar(data, task_str):\n row = dict((x, str(rrow[x])) for x in rrow.columns)\n# if any(x in row['Notes'].lower() for x in ['artifact']):\n# continue\n# ctypes = row['Type'].split('/')\n# nonsne = False\n# for ct in ctypes:\n# if ct.replace('?', '') in catalog.nonsnetypes:\n# nonsne = True\n# else:\n# nonsne = False\n# break\n# if nonsne:\n# continue\n name, source = catalog.new_entry(\n row['CRTS'],\n srcname='CRTS',\n bibcode='2014MNRAS.441.1186D')\n# if row['IAU des.'] != '--':\n# catalog.entries[name].add_quantity(SUPERNOVA.ALIAS,\n# row['IAU des.'], source)\n# for ct in ctypes:\n# catalog.entries[name].add_quantity(SUPERNOVA.CLAIMED_TYPE, ct,\n# source)\n# catalog.entries[name].add_quantity(SUPERNOVA.DISCOVERER,\n# row['Discoverer'], source)\n# date = row['Discovery'].split('/')\n# date = '/'.join([date[-1].zfill(2), date[0].zfill(2), date[1]])\n# catalog.entries[name].add_quantity(SUPERNOVA.DISCOVER_DATE, date,\n# source)\n catalog.entries[name].add_quantity(CATACLYSMIC.VISUAL_MAG, row['Vmax'],\n source)\n catalog.entries[name].add_quantity(CATACLYSMIC.RA, row['RAJ2000'], source)\n catalog.entries[name].add_quantity(CATACLYSMIC.DEC, row['DEJ2000'], source)\n catalog.journal_entries()\n\n # Howerton Catalog","def get_data_from_storage(data_file):\n print(f\"{CR}Yipes, I don't know how to pull data from dvc yet{C0}\")","def _read_data(self):"],"string":"[\n \"def read_catalog(catalog):\\n with open(catalog, \\\"r\\\") as f:\\n header = f.readline()\\n if header.startswith('#EventID | Time | Latitude | Longitude | Depth/km'):\\n catalog = _read_iris(f)\\n elif header.startswith('time, latitude, longitude, depth, depthUnits, magnitude'):\\n catalog = _read_sod(f)\\n else:\\n sys.exit(\\\"Unknown catalog format\\\")\\n return catalog\",\n \"def getCatalogs():\",\n \"def getCatalog(unique_name):\",\n \"def read_catalog():\\n categories = session.query(Category).all()\\n items = session.query(CatalogItem).order_by(CatalogItem.id.desc())\\n quantity = items.count()\\n return categories, items, quantity\",\n \"def catalog(self) -> str:\\n return pulumi.get(self, \\\"catalog\\\")\",\n \"def get_catalog():\\n return jsonify(getCatalog())\",\n \"def sample():\\n write_drive_catalog_file(\\\"j:\\\\\\\\\\\", \\\"SANSA2_1G\\\", r\\\"c:\\\\SANSA2_1G.txt\\\")\\n write_drive_catalog_file(\\\"k:\\\\\\\\\\\", \\\"8GB\\\", r\\\"c:\\\\8GB.txt\\\")\\n write_master_catalog_file([r\\\"c:\\\\SANSA2_1G.txt\\\", r\\\"c:\\\\8GB.txt\\\"], r\\\"c:\\\\Master_Catalog.txt\\\")\\n entries = read_catalog_file_entries(r\\\"c:\\\\Master_Catalog.txt\\\")\\n for entry in entries:\\n println(entry_to_line(entry))\",\n \"def testCosmologyCatalog(self):\\n dbObj = myTestGals(database=self.dbName)\\n cat = cosmologicalGalaxyCatalog(dbObj)\\n cat.write_catalog(self.catName)\",\n \"def _get_catalog_object(self):\\n return self.cluster.catalogd.service.read_debug_webpage(\\n \\\"catalog_object?object_type=TABLE&object_name=functional.alltypes\\\")\",\n \"def get_catalog(self) -> Dict[str, str]:\\n return self.catalog\",\n \"def load_catalog(self):\\n self.catalog = pd.read_csv(self.catalog_path, \\n index_col=0, parse_dates=True)\\n self.unique_years = self.catalog.index.year.unique()\\n return\",\n \"def loadData(catalog):\\n return controller.loadData(catalog)\",\n \"def loadData(catalog):\\n return controller.loadData(catalog)\",\n \"def test_api_ucs_get_catalog(self):\\n api_data = request(\\\"get\\\", \\\"/sys\\\")\\n self.assertEqual(api_data['status'], 200,\\n 'Incorrect HTTP return code, expected 200, got:' + str(api_data['status']))\\n total_elements = 0\\n for elementTypes in api_data[\\\"json\\\"]:\\n for element in api_data[\\\"json\\\"][str(elementTypes)]:\\n api_data_c = request(\\\"get\\\", \\\"/catalog\\\",\\n query={\\\"identifier\\\": element[\\\"relative_path\\\"].strip(\\\"/\\\")})\\n self.assertEqual(api_data_c['status'], 200,\\n 'Incorrect HTTP return code, expected 200, got:' +\\n str(api_data_c['status']))\\n total_elements += 1\\n self.assertGreater(total_elements, 0, \\\"Zero catalog elements found\\\")\\n # TO DO: deeper check on the catalog data\",\n \"def read_catalogs():\\n if not StateHolder.config_parsed:\\n config = YamlUtils.read(file=StateHolder.catalog_config_file, doc=Doc.CATALOGS_CONFIG)\\n\\n if not type(config) is dict:\\n config['default'] = {}\\n StateHolder.config = dict(config)\\n StateHolder.config_parsed = True\",\n \"def loadData(catalog):\\r\\n controller.loadData(catalog)\",\n \"def readDataFromCosmosDB(self):\\n self.cosmosdb.updateCollectionThroughput(\\n self.config.get_database_name(), self.config.get_hash_table(), self.config.get_scaleup_cosmos(),\\n self.config.get_key(),\\n self.config.get_cosmos_account())\\n\\n # read all the data from cosmos DB with encrypted fields and store in a data frame\\n df = spark.read.format(\\\"com.microsoft.azure.cosmosdb.spark\\\").options(\\n **self.config.get_hash_readconfig()).load()\\n\\n # iterate over the dataframe and decrypt and replace all fields except the cosmos db system fields strating\\n # with \\\"_\\\" and the key --> id field since its hashed not encrypted and also not the partition field\\n df = df.repartition(160).cache()\\n dec_udf = udf(decrypt)\\n\\n for columns in df.columns:\\n if columns.startswith('_') or columns.startswith('id') or columns.startswith('partition'):\\n print('not to be encrypted field: ' + columns)\\n else:\\n print('to be encrypted field: ' + columns)\\n df = df.withColumn(columns, dec_udf(df[columns]))\\n print(\\\"succesfully decrypted the fields in spark df data frame\\\")\\n\\n # Register the DataFrame as a SQL temporary view\\n df = df.repartition(1).cache()\\n # df.persist(StorageLevel.DISK_ONLY_2)\\n df.createOrReplaceTempView(\\\"customer\\\")\\n spark.sql(\\\"CACHE TABLE customer\\\").collect()\\n\\n print(\\\"succesfully read \\\" + str(df.count()) +\\n \\\" records from CosmosDB and saved in spark df data frame\\\")\\n self.cosmosdb.updateCollectionThroughput(\\n self.config.get_database_name(), self.config.get_hash_table(), self.config.get_scaledown_cosmos(),\\n self.config.get_key(),\\n self.config.get_cosmos_account())\\n\\n return df\",\n \"def loadData(catalog):\\n controller.loadData(catalog)\",\n \"def loadData(catalog):\\n controller.loadData(catalog)\",\n \"def loadData(catalog):\\n controller.loadData(catalog)\",\n \"def loadData(catalog):\\n controller.loadData(catalog)\",\n \"def loadData(catalog):\\n controller.loadData(catalog)\",\n \"def get_catalog(self) -> Catalog:\\n params: Dict[str, Any] = self._status.get_status_info()\\n\\n response = self._client.open_api_do(\\n \\\"GET\\\", \\\"labels/catalogs\\\", self.dataset_id, params=params\\n ).json()\\n return Catalog.loads(response[\\\"catalog\\\"])\",\n \"def print_catalog(self):\\n # first download the json for the catalog\\n self.download_json()\\n\\n # open the saved json file and load the json\\n with self.file.open(\\\"r\\\") as catalog_file:\\n pages = json.load(catalog_file)\\n\\n # the catalog json is just a list of pages\\n # so we begin by iterating through the pages\\n for page_num in range(len(pages)):\\n # get each page\\n page = pages[page_num]\\n\\n # get the threads on each page\\n threads = page[\\\"threads\\\"]\\n\\n # print the page heading\\n print(\\\"*** PAGE \\\", page_num + 1, \\\"***\\\")\\n\\n # iterate through the threads on each page\\n for thread_num in range(len(threads)):\\n # get each thread\\n thread = threads[thread_num]\\n\\n # print the thread number\\n num = thread[\\\"no\\\"]\\n print(\\\"---\\\", \\\"Thread:\\\", num, \\\"---\\\")\\n\\n # not all threads have a subject or comment\\n try:\\n subject = thread[\\\"sub\\\"]\\n comment = thread[\\\"com\\\"]\\n\\n print(\\\"Sub:\\\", subject)\\n print(\\\"Comment:\\\", comment)\\n except KeyError:\\n print(\\\"N/A\\\")\",\n \"def read_combined_star_catalog(params,log):\\n\\n if path.isfile(params['catalog_file']) == False:\\n\\n return np.zeros(1)\\n\\n hdulist = fits.open(params['catalog_file'])\\n\\n data = hdulist[1].data\\n\\n header = hdulist[0].header\\n\\n star_catalog = Table(data)\\n\\n data = hdulist[2].data\\n\\n image_trios = Table(data)\\n\\n log.info('Read data from combined colour star catalog')\\n\\n return star_catalog, image_trios, header\",\n \"def list_detail_catalog(self, catalog_name):\\n # list catalog\\n self._list_catalog(catalog_name)\\n # detail catalog\\n self._details_catalog(catalog_name)\",\n \"def load_data(catalog):\\n controller.load_data(catalog)\",\n \"def initCatalog():\\n return controller.initCatalog()\",\n \"def initCatalog():\\n return controller.initCatalog()\",\n \"def initCatalog():\\n return controller.initCatalog()\",\n \"def initCatalog():\\n return controller.initCatalog()\",\n \"def initCatalog():\\n return controller.initCatalog()\",\n \"def checkCatalogs():\\n url = CHECKBASE % 'catalogs'\\n catalogs = []\\n try:\\n fh = getURLHandle(url)\\n #fh = urllib2.urlopen(url)\\n data = fh.read()\\n dom = minidom.parseString(data)\\n fh.close()\\n catalog_elements = dom.getElementsByTagName('Catalog')\\n for catel in catalog_elements:\\n if catel.firstChild is None:\\n continue\\n catalog = catel.firstChild.data.strip()\\n if len(catalog):\\n catalogs.append(str(catalog))\\n except:\\n raise Exception,\\\"Could not open %s to search for list of catalogs\\\" % url\\n return catalogs\",\n \"def initCatalog():\\n catalog = model.newCatalog()\\n return catalog\",\n \"def initCatalog():\\n catalog = model.newCatalog()\\n return catalog\",\n \"def initCatalog():\\n catalog = model.newCatalog()\\n return catalog\",\n \"def list(logger, client):\\n logger.info('Retrieving Cloudify License')\\n license = client.license.list()\\n print_data(LICENSE_COLUMN, license, 'Cloudify License')\",\n \"async def get_catalog(self, board_id):\\n\\n route = f'{board_id}/catalog'\\n\\n data = await self.interact(route)\\n\\n value = Asset(data)\\n\\n return value\",\n \"def get_catalog(self):\\n\\n rep = req.get_json(self.CATALOG)\\n repo_list = rep[\\\"repositories\\\"]\\n\\n for repo in repo_list:\\n self.list.append(Repository(repo))\\n\\n return self.list\",\n \"def test_catalog_opds(self):\\n client = Client()\\n response = client.get('/catalog.atom/')\\n print 'status code for catalog in opds', response.status_code\\n self.failUnlessEqual(response.status_code, 200)\",\n \"def loadData(catalog):\\n loadArtworks(catalog)\\n loadArtists(catalog)\",\n \"def init_catalog():\\n return controller.init_catalog()\",\n \"def get_catalog(self, command):\\n return self._catalogs.get(str(command))\",\n \"def loadData(catalog):\\n loadArtists(catalog)\\n loadArtworks(catalog)\",\n \"def loadData(catalog):\\n loadArtists(catalog)\\n loadArtworks(catalog)\",\n \"def test_get_catalogue(self):\\n s1 = System()\\n self.assertEqual(len(s1.get_catalogue()), 0)\",\n \"def loadData(catalog):\\n\\n loadArtwork(catalog)\\n loadArtists(catalog)\",\n \"def catalog(self) -> TNSCatalog:\\n if not self.__catalog:\\n self.__catalog = TNSCatalog.from_web(cache=True)\\n return self.__catalog\\n else:\\n self.__catalog.refresh()\\n return self.__catalog\",\n \"def dcos_aws() -> None:\",\n \"def print_catalog(self):\\n for book in self.books.keys():\\n print(book)\",\n \"def print_catalog(self):\\n for book in self.books.keys():\\n print(book)\",\n \"def show_catalogue(self):\\n\\n data = cur.execute(\\\"\\\"\\\"SELECT productid, productname, unitcost, stock, location \\n FROM catalogue WHERE vendorname = ?\\\"\\\"\\\", (self.vendorname,)).fetchall()\\n print(tabulate(data, headers=[\\\"Product ID\\\", \\\"Name\\\", \\\"Unit Cost\\\", \\\"Stock\\\", \\\"Location\\\"]))\",\n \"def test_getDigitalObjects(self):\\n cases = [\\n (self.test_eac + 'NE00001.xml', 0),\\n (self.test_eac + 'NE00100.xml', 1),\\n (self.test_eac + 'NE01101.xml', 15),\\n (self.test_eac + 'NE01400.xml', 1),\\n ]\\n for case in cases:\\n source, expected = case\\n doc = EacCpf.EacCpf(source, 'http://www.example.com/metadata.xml', 'http://www.example.com/presentation.html')\\n self.assertNotEqual(doc, None)\\n result = doc.getDigitalObjects()\\n self.assertNotEqual(result, None)\\n self.assertEqual(len(result), expected)\",\n \"def catalogs(env):\\n envs = environments()\\n check_env(env, envs)\\n\\n if app.config['ENABLE_CATALOG']:\\n nodenames = []\\n catalog_list = []\\n query = AndOperator()\\n\\n if env != '*':\\n query.add(EqualsOperator(\\\"catalog_environment\\\", env))\\n\\n query.add(NullOperator(\\\"catalog_timestamp\\\", False))\\n\\n order_by_str = '[{\\\"field\\\": \\\"certname\\\", \\\"order\\\": \\\"asc\\\"}]'\\n nodes = get_or_abort(puppetdb.nodes,\\n query=query,\\n with_status=False,\\n order_by=order_by_str)\\n nodes, temp = tee(nodes)\\n\\n for node in temp:\\n nodenames.append(node.name)\\n\\n for node in nodes:\\n table_row = {\\n 'name': node.name,\\n 'catalog_timestamp': node.catalog_timestamp\\n }\\n\\n if len(nodenames) > 1:\\n form = CatalogForm()\\n\\n form.compare.data = node.name\\n form.against.choices = [(x, x) for x in nodenames\\n if x != node.name]\\n table_row['form'] = form\\n else:\\n table_row['form'] = None\\n\\n catalog_list.append(table_row)\\n\\n return render_template(\\n 'catalogs.html',\\n nodes=catalog_list,\\n envs=envs,\\n current_env=env)\\n else:\\n log.warn('Access to catalog interface disabled by administrator')\\n abort(403)\",\n \"def retrieve_catalog(self, catalog_hash):\\n return self.repository.retrieve_catalog(catalog_hash)\",\n \"def read_all():\\n # Create the list of CIs from our data\\n ci = db.session.query(CI).order_by(CI.id).all()\\n app.logger.debug(pformat(ci))\\n # Serialize the data for the response\\n ci_schema = CISchema(many=True)\\n data = ci_schema.dump(ci)\\n return data\",\n \"def get_items_for_catalog(catalog_id):\\n pass\",\n \"def get(self):\\n return GenericGet().get_catalogs()\",\n \"def get_scnlist_con2ard(self):\\n logger.debug(\\\"Creating Database Engine and Session.\\\")\\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\\n ses = session_sqlalc()\\n\\n logger.debug(\\\"Perform query to find scenes which need downloading.\\\")\\n query_result = ses.query(EDDSentinel1ASF).filter(EDDSentinel1ASF.Downloaded == True,\\n EDDSentinel1ASF.ARDProduct == False,\\n EDDSentinel1ASF.Invalid == False).order_by(\\n EDDSentinel1ASF.Acquisition_Date.asc()).all()\\n\\n scns2ard = list()\\n if query_result is not None:\\n for record in query_result:\\n scns2ard.append(record.PID)\\n ses.close()\\n logger.debug(\\\"Closed the database session.\\\")\\n return scns2ard\",\n \"def get_catalog(self, user_id, tenant_id, metadata=None):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"def read(self, path):\\n client = self.connect(VAULT_TOKEN)\\n return client.read(path)\",\n \"def read_data(term):\\n course_url = '/admweb/!SWKSECX.main?term='+ term + '&title=&course=&crn=&coll=&dept=&subj='\\n connection = httplib.HTTPSConnection('courses.rice.edu', 443)\\n connection.connect()\\n connection.request(\\n 'GET',\\n course_url\\n )\\n courses_xml = connection.getresponse()\\n return courses_xml\",\n \"def final_catalogs(self, filename=None, catalog_cols=None):\\n\\n final_catalog = vstack([cluster_info['catalog'] for cluster_info in self._catalog_dictionary.values()])\\n\\n # If we request to keep only certain columns in our output\\n if catalog_cols is not None:\\n final_catalog.keep_columns(catalog_cols)\\n\\n if filename is None:\\n return final_catalog\\n else:\\n if filename.endswith('.cat'):\\n final_catalog.write(filename, format='ascii', overwrite=True)\\n else:\\n final_catalog.write(filename, overwrite=True)\",\n \"def getcatalogs():\\n \\n # default path for the gthumb catalogs of the logged in user\\n gpath = os.environ['HOME'] + \\\"/.local/share/gthumb/catalogs\\\"\\n\\n cats = [] \\n cat_list = [] \\n try:\\n # dir_list has all files and directories in path\\n # directories are WITHOUT ending '/'\\n dir_list = os.listdir(gpath)\\n except:\\n # path may not be a directory or permission error\\n print \\\"ERROR: in getcatalogs, gpath:\\\", gpath\\n return []\\n \\n # get only the directories \\n for line in dir_list:\\n file = gpath + \\\"/\\\" + line\\n #print file \\n if os.path.isdir(file):\\n cats.append(file)\\n else: \\n # not a directory; ignore \\n #print \\\"not a directory:\\\", file \\n pass\\n\\n # now get each catalog file from each directory\\n for cat in cats:\\n try:\\n # dir_list has all files and directories in path\\n # any directory is WITHOUT ending '/'\\n dir_list = os.listdir(cat)\\n except:\\n # path may not be a directory or permission error\\n print \\\"ERROR: in getcatalogs, cat:\\\", cat\\n return []\\n \\n for line in dir_list:\\n file = cat + \\\"/\\\" + line\\n #print os.path.splitext(file)[1][1:]\\n # append file only if it has catalog extension\\n if os.path.splitext(file)[1][1:] == \\\"catalog\\\":\\n cat_list.append(file)\\n \\n cat_list.sort() \\n\\n if random_mode:\\n random.shuffle(cat_list)\\n \\n return cat_list\",\n \"async def getCollectionDetail(self, slug=None):\\n payload = {}\\n \\n if slug:\\n payload[\\\"slug\\\"] = slug\\n \\n\\n # Parameter validation\\n schema = CatalogValidator.getCollectionDetail()\\n schema.dump(schema.load(payload))\\n \\n\\n url_with_params = await create_url_with_params(self._conf.domain, f\\\"/service/platform/catalog/v1.0/company/{self._conf.companyId}/application/{self.applicationId}/collections/{slug}/\\\", \\\"\\\"\\\"{\\\"required\\\":[{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"company_id\\\",\\\"description\\\":\\\"A `company_id` is a unique identifier for a particular seller account.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true},{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"application_id\\\",\\\"description\\\":\\\"A `application_id` is a unique identifier for a particular sale channel.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true},{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"slug\\\",\\\"description\\\":\\\"A `slug` is a human readable, URL friendly unique identifier of an object. Pass the `slug` of the collection which you want to retrieve.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true}],\\\"optional\\\":[],\\\"query\\\":[],\\\"headers\\\":[],\\\"path\\\":[{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"company_id\\\",\\\"description\\\":\\\"A `company_id` is a unique identifier for a particular seller account.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true},{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"application_id\\\",\\\"description\\\":\\\"A `application_id` is a unique identifier for a particular sale channel.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true},{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"slug\\\",\\\"description\\\":\\\"A `slug` is a human readable, URL friendly unique identifier of an object. Pass the `slug` of the collection which you want to retrieve.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true}]}\\\"\\\"\\\", slug=slug)\\n query_string = await create_query_string(slug=slug)\\n headers = {\\n \\\"Authorization\\\": \\\"Bearer \\\" + await self._conf.getAccessToken()\\n }\\n for h in self._conf.extraHeaders:\\n headers.update(h)\\n exclude_headers = []\\n for key, val in headers.items():\\n if not key.startswith(\\\"x-fp-\\\"):\\n exclude_headers.append(key)\\n return await AiohttpHelper().aiohttp_request(\\\"GET\\\", url_with_params, headers=get_headers_with_signature(self._conf.domain, \\\"get\\\", await create_url_without_domain(f\\\"/service/platform/catalog/v1.0/company/{self._conf.companyId}/application/{self.applicationId}/collections/{slug}/\\\", slug=slug), query_string, headers, \\\"\\\", exclude_headers=exclude_headers), data=\\\"\\\")\",\n \"def catalog():\\n session['target'] = \\\"/\\\"\\n sqlsession = SQLSESSION()\\n items = sqlsession.query(Item, Category)\\\\\\n .join(Category).order_by(Item.create_date).limit(10)\\n categories = sqlsession.query(Category).all()\\n return render_template(\\\"catalog.html\\\",\\n items=items,\\n categories=categories,\\n item_title=\\\"Latest Items\\\")\",\n \"def loadData(catalog):\\n loadVideos(catalog)\\n loadCategories(catalog)\",\n \"def getUserCatalogOnFilespace(fs_id):\\n result = None\\n session = Queries.createSession()\\n try:\\n result = session.execute(sqlalchemy.select([Catalog])\\n .where(Catalog.fs_id == fs_id)\\n .order_by(asc(Catalog.id))\\n ).fetchone()\\n except sqlalchemy.exc.ArgumentError:\\n print 'SQLAlchemy ERROR: Invalid or conflicting function argument is supplied'\\n except sqlalchemy.exc.CompileError:\\n print 'SQLAlchemy ERROR: Error occurs during SQL compilation'\\n finally:\\n session.close()\\n return result\",\n \"def loadData(catalog):\\n loadArtworks(catalog)\\n loadArtists(catalog)\\n loadAdquires(catalog)\\n loadNacionalities(catalog)\\n load2DArtworks(catalog)\\n loadArtistMediumsTags(catalog)\\n loadDptments(catalog)\\n catalog['artists'] = sortArtists(catalog, 3)\\n fillArtistMediums(catalog)\\n fillMostUsedMediums(catalog)\\n catalog['artists_tags'] = sortArtistTags(catalog, 3)\\n sort_dptments(catalog)\",\n \"def getConc(fileID, spc):\\r\\n\\r\\n dataKey = rmn.fstinf(fileID, nomvar=spc, ip1=ip1)['key']\\r\\n dataRec = rmn.fstluk(dataKey)\\r\\n concData = dataRec['d']\\r\\n return concData, dataKey, dataRec\",\n \"def catalog_get(self, args):\\n headers = DEFAULT_HEADERS.copy()\\n headers.update(args.headers)\\n\\n if args.output_format == \\\"json\\\":\\n headers[\\\"accept\\\"] = \\\"application/json\\\"\\n elif args.output_format == \\\"json-stream\\\":\\n headers[\\\"accept\\\"] = \\\"application/x-json-stream\\\"\\n elif args.output_format == \\\"csv\\\":\\n headers[\\\"accept\\\"] = \\\"text/csv\\\"\\n else:\\n raise UsageException(\\\"Unsupported output format: %s\\\" % args.output_format)\\n\\n catalog = self.server.connect_ermrest(args.id)\\n try:\\n if args.output_file:\\n catalog.getAsFile(args.path,\\n destfilename=args.output_file,\\n headers=headers,\\n delete_if_empty=args.auto_delete)\\n else:\\n pp(catalog.get(args.path, headers=headers).json())\\n except HTTPError as e:\\n if e.response.status_code == requests.codes.not_found:\\n raise ResourceException('Catalog not found', e)\\n except:\\n if args.output_file and os.path.isfile(args.output_file):\\n logging.info(\\\"Deleting empty file: %s\\\" % args.output_file)\\n os.remove(args.output_file)\\n raise\",\n \"def build_catalog_info(self, catalog_info):\\n cat = SourceFactory.build_catalog(**catalog_info)\\n catalog_info['catalog'] = cat\\n # catalog_info['catalog_table'] =\\n # Table.read(catalog_info['catalog_file'])\\n catalog_info['catalog_table'] = cat.table\\n catalog_info['roi_model'] =\\\\\\n SourceFactory.make_fermipy_roi_model_from_catalogs([cat])\\n catalog_info['srcmdl_name'] =\\\\\\n self._name_factory.srcmdl_xml(sourcekey=catalog_info['catalog_name'])\\n return CatalogInfo(**catalog_info)\",\n \"def test_get_hyperflex_app_catalog_list(self):\\n pass\",\n \"def init():\\n catalog = model.newCatalog()\\n return catalog\",\n \"def read_nonsidereal_catalog(filename):\\n catalog_table = ascii.read(filename, comment='#')\\n\\n # Check to see whether the position is in x,y or ra,dec\\n pixelflag = False\\n try:\\n if 'position_pixels' in catalog_table.meta['comments'][0:4]:\\n pixelflag = True\\n except:\\n pass\\n\\n # If present, check whether the velocity entries are pix/sec\\n # or arcsec/sec.\\n pixelvelflag = False\\n try:\\n if 'velocity_pixels' in catalog_table.meta['comments'][0:4]:\\n pixelvelflag = True\\n except:\\n pass\\n return catalog_table, pixelflag, pixelvelflag\",\n \"def read_all(self):\\r\\n pass\",\n \"def check_catalogs():\\n for config in StateHolder.config:\\n conf = StateHolder.config[config]\\n if type(conf) is not dict:\\n continue\\n if conf.get(\\\"repositoryType\\\", \\\"file\\\") is \\\"file\\\":\\n FileUtils.make_empty_file_with_empty_dict(directory=StateHolder.home_dir,\\n file=conf.get('file', 'poco-catalog.yml'))\",\n \"def query_object_catalogs(self, position, catalogs=__ALL_STRING, row_limit=DEFAULT_ROW_LIMIT,\\n get_query_payload=False, cache=True, verbose=False):\\n return self.query_region_catalogs(position=position,\\n radius=self.__ZERO_ARCMIN_STRING,\\n catalogs=catalogs,\\n row_limit=row_limit,\\n get_query_payload=get_query_payload,\\n cache=cache,\\n verbose=verbose)\",\n \"def read_category_items():\\n items = session.query(CatalogItem).order_by(CatalogItem.id.desc())\\n return items\",\n \"def getCatalog(self, version=None, level=None, cubeInfo=True):\\n print('WaPOR API: Loading catalog WaPOR.v{v}_l{lv}...'.format(\\n v=version, lv=level))\\n self.isAPITokenSet()\\n\\n isFound = False\\n\\n # if isinstance(version, int) and isinstance(level, int):\\n # print('| int')\\n # if 0 < version < 3 and 0 < level < 4:\\n # print('| range')\\n if version == self.version and level == self.level:\\n # print('| equal')\\n if self.catalog is not None:\\n # print('| not None')\\n isFound = True\\n\\n if isFound:\\n df = self.catalog\\n\\n print('WaPOR API: Loading catalog WaPOR.v{v}_l{lv} found.'.format(\\n v=version, lv=level))\\n else:\\n df = self._query_catalog(version, level)\\n\\n print('WaPOR API: Loading catalog WaPOR.v{v}_l{lv} loaded.'.format(\\n v=version, lv=level))\\n\\n if cubeInfo:\\n cubes_measure = []\\n cubes_dimension = []\\n for cube_code in df['code'].values:\\n cubes_measure.append(self._query_cubeMeasures(cube_code))\\n cubes_dimension.append(self._query_cubeDimensions(cube_code))\\n df['measure'] = cubes_measure\\n df['dimension'] = cubes_dimension\\n\\n self.catalog = df\\n return self.catalog\",\n \"def _extract_catalog(self, data):\\n interface = 'public'\\n catalog = data['token']['catalog']\\n service_map = {}\\n for service in catalog:\\n service_endpoint = None\\n for endpoint in service['endpoints']:\\n if endpoint['interface'] == interface:\\n service_endpoint = endpoint['url']\\n break\\n if service_endpoint:\\n service_map[service['type']] = service_endpoint\\n LOG.debug('Service catalog: %s' % service_map)\\n return service_map\",\n \"def __init__(self, catalog_path):\\n self.catalog_path = catalog_path\\n self.load_catalog()\\n return\",\n \"def getting_info(self, cloud_path):\\n\\t\\telog(\\\"getting info on {}\\\".format(cloud_path))\",\n \"def get_infores_catalog(self):\\n return self._infores_catalog\",\n \"def initCatalog():\\n t = \\\"SINGLE_LINKED\\\"\\n catalog = model.newCatalog(t)\\n return catalog\",\n \"def read(self):\",\n \"def read(self, path: Path, oracle: Oracle) -> MagicCollection:\\n with path.open(\\\"rt\\\", encoding=\\\"utf-8\\\") as csv_file:\\n reader = csv.DictReader(csv_file)\\n card_counts = counts.aggregate_card_counts(reader, oracle)\\n return MagicCollection(oracle=oracle, counts=card_counts)\",\n \"def read_meta(self):\\n meta = cPickle.load(open('../sugar_analysis_data/META-CABALLO2.pkl'))\\n self.meta_sn_name_list = []\\n self.meta_zcmb = []\\n self.meta_x0 =[]\\n self.meta_x0_err = []\\n self.meta_x1 =[]\\n self.meta_x1_err = []\\n self.meta_c = []\\n self.meta_c_err = []\\n self.meta_mb = []\\n self.meta_mb_err = []\\n self.meta_cov_x0_x1 = [] \\n self.meta_cov_x0_c = []\\n self.meta_cov_x1_c = []\\n self.meta_cov_mb_x1 = []\\n self.meta_cov_mb_c = [] \\n self.meta_zhl = []\\n self.meta_zhl_err = []\\n self.meta_idr = []\\n for meta_sn_name in meta.keys(): \\n \\n if meta[meta_sn_name]['idr.subset'] != 'bad' and meta[meta_sn_name]['idr.subset'] != 'auxiliary':\\n \\n self.meta_sn_name_list.append(meta_sn_name)\\n self.meta_zhl_err.append(meta[meta_sn_name]['host.zhelio.err'])\\n self.meta_zhl.append(meta[meta_sn_name]['host.zhelio'])\\n self.meta_zcmb.append(meta[meta_sn_name]['host.zcmb'])\\n self.meta_x0.append(meta[meta_sn_name]['salt2.X0'])\\n self.meta_x0_err.append(meta[meta_sn_name]['salt2.X0.err'])\\n self.meta_x1.append(meta[meta_sn_name]['salt2.X1'])\\n self.meta_x1_err.append(meta[meta_sn_name]['salt2.X1.err'])\\n self.meta_c.append(meta[meta_sn_name]['salt2.Color'])\\n self.meta_c_err.append(meta[meta_sn_name]['salt2.Color.err'])\\n self.meta_mb.append(meta[meta_sn_name]['salt2.RestFrameMag_0_B'])\\n self.meta_mb_err.append(meta[meta_sn_name]['salt2.RestFrameMag_0_B.err'])\\n self.meta_cov_x0_x1.append(meta[meta_sn_name]['salt2.CovX0X1'])\\n self.meta_cov_x0_c.append(meta[meta_sn_name]['salt2.CovColorX0'])\\n self.meta_cov_x1_c.append(meta[meta_sn_name]['salt2.CovColorX1'])\\n self.meta_cov_mb_x1.append(meta[meta_sn_name]['salt2.CovRestFrameMag_0_BX1'])\\n self.meta_cov_mb_c.append(meta[meta_sn_name]['salt2.CovColorRestFrameMag_0_B'])\\n self.meta_idr.append(meta[meta_sn_name]['idr.subset'])\\n \\n self.meta_idr = np.array(self.meta_idr)\\n self.meta_zcmb = np.array(self.meta_zcmb)\\n self.meta_zhl = np.array(self.meta_zhl)\\n self.meta_zhl_err = np.array(self.meta_zhl_err)\\n self.meta_x0 = np.array(self.meta_x0)\\n self.meta_x0_err = np.array(self.meta_x0_err)\\n self.meta_x1 = np.array(self.meta_x1)\\n self.meta_x1_err = np.array(self.meta_x1_err) \\n self.meta_c = np.array(self.meta_c)\\n self.meta_c_err = np.array(self.meta_c_err)\\n self.meta_mb = np.array(self.meta_mb)\\n self.meta_mb_err = np.array(self.meta_mb_err)\\n self.meta_cov_x0_x1 = np.array(self.meta_cov_x0_x1)\\n self.meta_cov_x0_c = np.array(self.meta_cov_x0_c)\\n self.meta_cov_x1_c = np.array(self.meta_cov_x1_c)\\n self.meta_cov_mb_x1 = np.array(self.meta_cov_mb_x1)\\n self.meta_cov_mb_c = np.array(self.meta_cov_mb_c)\",\n \"def s3_read_data(self):\\n\\n self.k.open()\\n self.k.read()\",\n \"def read():\\n # TODO\",\n \"def read_catalog(catalogfile):\\n\\t#dictionary to store the url and key\\n\\tglobal books\\n\\tglobal default_books\\n\\tglobal default_titles\\n\\tglobal count_books\\n\\t#list to store the titles\\n\\tglobal titles\\n\\t#counter for dictionary key\\n\\ti = 0\\n\\ttry:\\n\\t#open file\\n\\t\\twith open(catalogfile,'r') as catalog:\\n\\t\\t\\t#read and strip lines\\n\\t\\t\\tfor lines in catalog.readlines():\\n\\t\\t\\t\\tlines_stripped = lines.strip()\\n\\t\\t\\t\\t#split the lines by using the tag http\\n\\t\\t\\t\\tvalues = lines_stripped.split(\\\",http://\\\")\\n\\t\\t\\t\\t#if values is not empty and has length 2 and title and url is not empty\\n\\t\\t\\t\\tif values != [''] and len(values) == 2 and values[0] != \\\"\\\" and values[1] != \\\"\\\":\\n\\t\\t\\t\\t\\t#add title to the list\\n\\t\\t\\t\\t\\ttitles.append(values[0])\\n\\t\\t\\t\\t\\t#add url to the dictionary\\n\\t\\t\\t\\t\\tbooks[i] = \\\"http://\\\" + values[1]\\n\\t\\t\\t\\t\\t#increase counter\\n\\t\\t\\t\\t\\ti += 1\\n\\t\\t#get count of book\\n\\t\\tcount_books = len(books)\\n\\n\\t\\t#if no books was read - terminate program\\n\\t\\tif (count_books == 0):\\n\\t\\t\\tprint(\\\"File is not readable. Using default values.\\\")\\n\\t\\t\\t#use default values\\n\\t\\t\\tbooks = default_books\\n\\t\\t\\ttitles = default_titles\\n\\t\\t\\tcount_books = len(books)\\n\\t#if error in reading file - terminate\\n\\texcept:\\n\\t\\tprint(\\\"Exception occured while reading file. Using default values\\\")\\n\\t\\t#use default values\\n\\t\\tbooks = default_books\\n\\t\\ttitles = default_titles\\n\\t\\tcount_books = len(books)\\n\\twhile True:\\n\\t#read all the books\\n\\t\\tall_data = list()\\n\\t\\tb_count = range(0,count_books)\\n\\t\\t#for each book in the dictionary - read data\\n\\t\\tfor book_num in b_count:\\n\\t\\t#print(titles)\\n\\t\\t\\tcontents = read_book(books[book_num],book_num)\\n\\t\\t\\t# add contents to a list\\n\\t\\t\\tall_data.append(contents)\\n\\t\\t#if all the URL are not readable\\n\\t\\tempty_data = list()\\n\\t\\tfor x in range(0,count_books):\\n\\t\\t\\tempty_data.append([])\\n\\n\\t\\tif all_data == empty_data:\\n\\t\\t\\t#use default values\\n\\t\\t\\tprint(\\\"No contents were read. Using default values.\\\")\\n\\t\\t\\tbooks = default_books\\n\\t\\t\\ttitles = default_titles\\n\\t\\t\\tcount_books = len(books)\\n\\t\\t\\tcontinue\\n\\t\\t#create a dictionary of words in the data\\n\\t\\tfor values in range(0,count_books):\\n\\t\\t\\tupdate_words(all_data[values],values)\\n\\t\\t#ask user for search term\\n\\t\\tprompt_user()\\n\\t\\tbreak\",\n \"def fake_catalog(tenant, token):\\n catalog_gen = servicecatalog.ServiceCatalogGenerator(token, tenant)\\n catalog = catalog_gen.generate_full_catalog()['access']\\n return access.AccessInfoV2(**catalog)\",\n \"def print_catalog(self, catalog_filter=[]):\\n keys = sorted(self.catalog.keys())\\n if len(catalog_filter) > 0: # pylint: disable=len-as-condition\\n valid = []\\n for key in keys:\\n for f in catalog_filter:\\n if len(self.catalog[key][f]) > 0: # pylint: disable=len-as-condition\\n valid.append(key)\\n keys = valid\\n for key in keys:\\n print(f\\\"Pnum: {self.catalog[key]['pnum']}\\\")\\n print(f\\\"Edition: {self.catalog[key]['edition']}\\\")\\n print(f\\\"Metadata: {len(self.catalog[key]['metadata']) > 0}\\\")\\n print(f\\\"Transliteration: {len(self.catalog[key]['transliteration']) > 0}\\\")\\n print(f\\\"Normalization: {len(self.catalog[key]['normalization']) > 0}\\\")\\n print(f\\\"Translation: {len(self.catalog[key]['translation']) > 0}\\\")\\n print()\",\n \"def get_cart_contents(db):\",\n \"def get_scnlist_datacube(self, loaded=False):\\n logger.debug(\\\"Creating Database Engine and Session.\\\")\\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\\n ses = session_sqlalc()\\n\\n logger.debug(\\\"Perform query to find scenes which need converting to ARD.\\\")\\n query_result = ses.query(EDDSentinel1ASF).filter(EDDSentinel1ASF.ARDProduct == True,\\n EDDSentinel1ASF.DCLoaded == loaded).order_by(\\n EDDSentinel1ASF.Acquisition_Date.asc()).all()\\n scns2dcload = list()\\n if query_result is not None:\\n for record in query_result:\\n scns2dcload.append(record.PID)\\n ses.close()\\n logger.debug(\\\"Closed the database session.\\\")\\n return scns2dcload\",\n \"def loadSourceCatalog(self, filename):\\n sourceCat = afwTable.SourceCatalog.readFits(filename)\\n aliasMap = sourceCat.schema.getAliasMap()\\n aliasMap.set(\\\"slot_ApFlux\\\", \\\"base_PsfFlux\\\")\\n instFluxKey = sourceCat.schema[\\\"slot_ApFlux_instFlux\\\"].asKey()\\n instFluxErrKey = sourceCat.schema[\\\"slot_ApFlux_instFluxErr\\\"].asKey()\\n\\n # print(\\\"schema=\\\", sourceCat.schema)\\n\\n # Source x,y positions are ~ (500,1500) x (500,1500)\\n centroidKey = sourceCat.table.getCentroidSlot().getMeasKey()\\n for src in sourceCat:\\n adjCentroid = src.get(centroidKey) - lsst.geom.Extent2D(500, 500)\\n src.set(centroidKey, adjCentroid)\\n src.set(instFluxKey, 1000)\\n src.set(instFluxErrKey, 1)\\n\\n # Set catalog coord\\n for src in sourceCat:\\n src.updateCoord(self.wcs)\\n return sourceCat\",\n \"def load_spitzer_catalog(): # pragma: no cover\\n\\n path = get_path('spitzer_example_catalog.xml', location='remote')\\n table = Table.read(path)\\n\\n return table\",\n \"def do_ascii(catalog):\\n task_str = catalog.get_current_task_str()\\n\\n\\n # Howerton Catalog\\n datafile = os.path.join(catalog.get_current_task_repo(), 'ASCII',\\n 'vizier_J_MNRAS_441_1186_table1 J_MNRAS_441_1186_table3_20200403.csv')\\n data = read(datafile, format='csv')\\n for rrow in pbar(data, task_str):\\n row = dict((x, str(rrow[x])) for x in rrow.columns)\\n# if any(x in row['Notes'].lower() for x in ['artifact']):\\n# continue\\n# ctypes = row['Type'].split('/')\\n# nonsne = False\\n# for ct in ctypes:\\n# if ct.replace('?', '') in catalog.nonsnetypes:\\n# nonsne = True\\n# else:\\n# nonsne = False\\n# break\\n# if nonsne:\\n# continue\\n name, source = catalog.new_entry(\\n row['CRTS'],\\n srcname='CRTS',\\n bibcode='2014MNRAS.441.1186D')\\n# if row['IAU des.'] != '--':\\n# catalog.entries[name].add_quantity(SUPERNOVA.ALIAS,\\n# row['IAU des.'], source)\\n# for ct in ctypes:\\n# catalog.entries[name].add_quantity(SUPERNOVA.CLAIMED_TYPE, ct,\\n# source)\\n# catalog.entries[name].add_quantity(SUPERNOVA.DISCOVERER,\\n# row['Discoverer'], source)\\n# date = row['Discovery'].split('/')\\n# date = '/'.join([date[-1].zfill(2), date[0].zfill(2), date[1]])\\n# catalog.entries[name].add_quantity(SUPERNOVA.DISCOVER_DATE, date,\\n# source)\\n catalog.entries[name].add_quantity(CATACLYSMIC.VISUAL_MAG, row['Vmax'],\\n source)\\n catalog.entries[name].add_quantity(CATACLYSMIC.RA, row['RAJ2000'], source)\\n catalog.entries[name].add_quantity(CATACLYSMIC.DEC, row['DEJ2000'], source)\\n catalog.journal_entries()\\n\\n # Howerton Catalog\",\n \"def get_data_from_storage(data_file):\\n print(f\\\"{CR}Yipes, I don't know how to pull data from dvc yet{C0}\\\")\",\n \"def _read_data(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69564354","0.63602346","0.6289939","0.6274737","0.6120884","0.60243875","0.5962401","0.59330785","0.5929398","0.59037805","0.5888229","0.58801526","0.58801526","0.587579","0.586561","0.582441","0.582154","0.57935977","0.57935977","0.57935977","0.57935977","0.57935977","0.5749884","0.5731499","0.5704847","0.5690862","0.5621293","0.5611027","0.5611027","0.5611027","0.5611027","0.5611027","0.55949634","0.5548831","0.5548831","0.5548831","0.55485344","0.55387056","0.5530069","0.54957","0.5495501","0.54836243","0.5478288","0.5468943","0.5468943","0.5455843","0.54533356","0.54413396","0.54113495","0.53944564","0.53944564","0.53887814","0.5357043","0.5351722","0.53232026","0.5321776","0.5314509","0.5288348","0.52870494","0.5286469","0.52845746","0.5282257","0.52753425","0.52727574","0.5256187","0.5253637","0.5252118","0.52322114","0.5211968","0.5211652","0.521025","0.5209808","0.52049756","0.5204262","0.52028525","0.51889217","0.51863503","0.5179233","0.51778716","0.517136","0.5157558","0.5154618","0.51533186","0.5151255","0.5146149","0.5143206","0.51393056","0.51295197","0.51288337","0.512875","0.51263404","0.51123536","0.5098167","0.50966096","0.5085958","0.5068772","0.505841","0.5050331","0.5046148","0.50458694"],"string":"[\n \"0.69564354\",\n \"0.63602346\",\n \"0.6289939\",\n \"0.6274737\",\n \"0.6120884\",\n \"0.60243875\",\n \"0.5962401\",\n \"0.59330785\",\n \"0.5929398\",\n \"0.59037805\",\n \"0.5888229\",\n \"0.58801526\",\n \"0.58801526\",\n \"0.587579\",\n \"0.586561\",\n \"0.582441\",\n \"0.582154\",\n \"0.57935977\",\n \"0.57935977\",\n \"0.57935977\",\n \"0.57935977\",\n \"0.57935977\",\n \"0.5749884\",\n \"0.5731499\",\n \"0.5704847\",\n \"0.5690862\",\n \"0.5621293\",\n \"0.5611027\",\n \"0.5611027\",\n \"0.5611027\",\n \"0.5611027\",\n \"0.5611027\",\n \"0.55949634\",\n \"0.5548831\",\n \"0.5548831\",\n \"0.5548831\",\n \"0.55485344\",\n \"0.55387056\",\n \"0.5530069\",\n \"0.54957\",\n \"0.5495501\",\n \"0.54836243\",\n \"0.5478288\",\n \"0.5468943\",\n \"0.5468943\",\n \"0.5455843\",\n \"0.54533356\",\n \"0.54413396\",\n \"0.54113495\",\n \"0.53944564\",\n \"0.53944564\",\n \"0.53887814\",\n \"0.5357043\",\n \"0.5351722\",\n \"0.53232026\",\n \"0.5321776\",\n \"0.5314509\",\n \"0.5288348\",\n \"0.52870494\",\n \"0.5286469\",\n \"0.52845746\",\n \"0.5282257\",\n \"0.52753425\",\n \"0.52727574\",\n \"0.5256187\",\n \"0.5253637\",\n \"0.5252118\",\n \"0.52322114\",\n \"0.5211968\",\n \"0.5211652\",\n \"0.521025\",\n \"0.5209808\",\n \"0.52049756\",\n \"0.5204262\",\n \"0.52028525\",\n \"0.51889217\",\n \"0.51863503\",\n \"0.5179233\",\n \"0.51778716\",\n \"0.517136\",\n \"0.5157558\",\n \"0.5154618\",\n \"0.51533186\",\n \"0.5151255\",\n \"0.5146149\",\n \"0.5143206\",\n \"0.51393056\",\n \"0.51295197\",\n \"0.51288337\",\n \"0.512875\",\n \"0.51263404\",\n \"0.51123536\",\n \"0.5098167\",\n \"0.50966096\",\n \"0.5085958\",\n \"0.5068772\",\n \"0.505841\",\n \"0.5050331\",\n \"0.5046148\",\n \"0.50458694\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67307436"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":198,"cells":{"query":{"kind":"string","value":"add fields from the cat some will not be in the odata but some will. When copy is True We will copy over the ones that are in both, in some cases"},"document":{"kind":"string","value":"def _add_cat_fields(self, odata, copy=True):\n # these are required fileds from get_meds_output_dtype\n # that we have put into the input catalog\n always_copy=[\n 'id',\n 'ra',\n 'dec',\n ]\n cat = self.cat_orig\n\n add_dt = []\n for d in cat.dtype.descr:\n n = d[0]\n if n not in odata.dtype.names:\n add_dt.append(d)\n\n obj_data = eu.numpy_util.add_fields(\n odata,\n add_dt,\n )\n\n if copy:\n for n in always_copy:\n obj_data[n] = cat[n]\n\n for d in add_dt:\n n = d[0]\n if n in always_copy:\n continue\n\n # don't clobber things that should be left at\n # their default values\n if n not in odata.dtype.names:\n obj_data[n] = cat[n]\n\n\n return obj_data"},"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 copyAttributes(self, other, add_nxpars=False):\n import copy\n \n self.setTitle(other.getTitle())\n self.setDataSetType(other.getDataSetType())\n self.setAllAxisLabels(other.getAllAxisLabels())\n self.setAllAxisUnits(other.getAllAxisUnits())\n self.setYLabel(other.getYLabel())\n self.setYUnits(other.getYUnits())\n if len(self.attr_list.keys()) == 0:\n self.attr_list = copy.copy(other.attr_list)\n else:\n self.attr_list.instrument = copy.copy(other.attr_list.instrument)\n self.attr_list.sample = copy.copy(other.attr_list.sample)\n\n if add_nxpars:\n nxpar_keys = [item[0] for item in self.attr_list.iteritems() \\\n if isinstance(item[1], NxParameter)]\n\n for nxpar_key in nxpar_keys:\n self.attr_list[nxpar_key] += other.attr_list[nxpar_key]\n else:\n # Do nothing\n pass\n \n keys_to_get = [other_key for other_key in other.attr_list \\\n if other_key not in self.attr_list]\n \n for key_to_get in keys_to_get:\n self.attr_list[key_to_get] = \\\n copy.copy(other.attr_list[key_to_get])","def new_data(first: dict, second: dict, changeables: tuple):\n for name, field in first.items():\n if name not in changeables:\n second[name] = field","def union(self, other: Catalog) -> Catalog:\n cat = self.copy()\n oth_cp = other.copy()\n\n for k in oth_cp.keys():\n for ver_id, version in oth_cp[k].versions.items():\n cat[k][ver_id] = version\n return cat","def __add__(self, other):\n return self.__class__(\n {\n name:\n self.__getattribute__(name) + other.__getattribute__(name)\n for name in self._fields\n }\n )","def merge(self, new_store):\n if new_store.name and len(new_store.name) > 0:\n self.name = new_store.name\n if new_store.address and len(new_store.address) > 0:\n self.address = new_store.address\n if new_store.city and len(new_store.city) > 0:\n self.city = new_store.city\n if new_store.state and len(new_store.state) > 0:\n self.state = new_store.state\n if new_store.zip and new_store.zip > 0:\n self.zipcode = new_store.zip\n if new_store.phone and new_store.phone > 0:\n self.phone = new_store.phone","def _copy(self, *, new_instance:bool=False, new_alias:bool=False,\n _context:dict=None, _deep_copy:bool=True, **kwargs):\n self_id = id(self)\n if _context is None:\n _context = {}\n elif self_id in _context:\n return _context[self_id] # I've already been copied\n\n\n existing_items = {k:getattr(self, k) for k in self._nb_attrs}\n #It's a copy so shouldn't have the same uuid\n existing_items.pop('uuid', None)\n existing_items.update(kwargs)\n\n if new_instance:\n existing_items['_ref'] = self\n elif not ('_ref' in kwargs and kwargs['_ref']) and self._ref:\n existing_items['_ref'] = self._ref._copy(_context=_context)\n\n if new_alias:\n existing_items['_alias'] = True\n\n new_obj = type(self)(**existing_items)\n\n _context[self_id] = new_obj\n\n if _deep_copy:\n for obj in self:\n new_obj._add(obj._copy(new_alias=new_alias, _context=_context))\n\n return new_obj","def test_copy_2(dset_full):\n dset_new = copy.deepcopy(dset_full)\n\n # Test internal references in the dataset\n assert id(dset_new.site_pos.other) == id(dset_new.sat_pos)\n assert id(dset_new.site_delta.ref_pos) == id(dset_new.site_pos)\n assert id(dset_new.site_posvel.other) == id(dset_new.sat_posvel)\n assert id(dset_new.site_posvel_delta.ref_pos) == id(dset_new.site_posvel)\n\n assert id(dset_new.group.site_pos.other) == id(dset_new.group.sat_pos)\n assert id(dset_new.group.site_delta.ref_pos) == id(dset_new.group.site_pos)\n assert id(dset_new.group.site_posvel.other) == id(dset_new.group.sat_posvel)\n assert id(dset_new.group.site_posvel_delta.ref_pos) == id(dset_new.group.site_posvel)\n\n # Verify that new dataset have different references than original object\n for field_name, field in dset_full._fields.items():\n assert id(field.data) != id(dset_new._fields[field_name].data)\n try:\n for group_field_name, group_field in field.data._fields.items():\n assert id(group_field.data) != id(dset_new._fields[field_name].data._fields[group_field_name].data)\n except AttributeError:\n # Field is not a group\n pass","def copy_attrs(data_orig, data_new):\n\n if isinstance(data_orig, Dataset):\n\n # Variables\n for v in data_orig.data_vars:\n field = data_orig[v]\n for attr, val in field.attrs.items():\n data_new[v].attrs[attr] = val\n\n # Coordinates\n for c in data_orig.coords:\n coord = data_orig.coords[c]\n for attr, val in coord.attrs.items():\n if c in data_new.coords:\n data_new.coords[c].attrs[attr] = val\n\n # Metadata\n for attr, val in data_orig.attrs.items():\n data_new.attrs[attr] = val\n\n elif isinstance(data_orig, DataArray):\n\n # Variable Metadata\n for att, val in data_orig.attrs.items():\n data_new.attrs[att] = val\n\n # Coordinates\n for c in data_orig.coords:\n coord = data_orig.coords[c]\n for attr, val in coord.attrs.items():\n if c in data_new.coords:\n data_new.coords[c].attrs[attr] = val\n\n else:\n raise ValueError(\"Couldn't handle type %r\" % type(data_orig))\n\n return data_new","def test_copy_features(self):\n fc = self.read_feature()\n other = FeatureCollection(features=fc.features,\n otherProperties=fc.otherProperties)\n assert len(other.features) == 1\n feature = other.features[0]\n\n self.check_feature(feature)","def _merge_attributes(self, workout):\n keys = self.__table__.columns.keys()\n for key in keys:\n if key in [\"id\",\n \"external_id\",\n \"is_duplicate_with\",\n \"manual_check_required_with\",\n ]:\n continue\n elif getattr(self, key) == None:\n # copy attribute if empty; else keep existing \n setattr(self, key, getattr(workout, key))","def _merge_two(self, obj1, obj2):\r\n for uniq_ident in obj2.keys():\r\n if (uniq_ident not in obj1) \\\r\n or (obj1[uniq_ident]['modified'] \\\r\n < obj2[uniq_ident]['modified']):\r\n obj1[uniq_ident] = obj2[uniq_ident]\r\n\r\n return obj1 # self._dict_to_list(obj1)\r","def copyBooks(self):\n skipMods = set(('Morrowind.esm',self.fileInfo.name))\n for id,(record,modName) in (self.srcBooks.items() + self.altBooks.items()):\n if modName not in skipMods:\n self.setRecord(copy.copy(record))","def append_ipma_metadata(orig: dict, dest: dict):\n for key in [key for key in orig.keys() if key != 'data']:\n dest[key] = orig[key]","def copy_fields(self, model):\n fields = super(HistoricalRecords, self).copy_fields(model)\n for name, field in self.additional_fields.items():\n assert name not in fields\n assert hasattr(self, 'get_%s_value' % name)\n fields[name] = field\n return fields","def combine_data(self, object, additional_data):\n for k, v in additional_data.items():\n if isinstance(v, list):\n object[k] = object.get(k, []) + v\n else:\n object[k] = v\n for instance in object.get(\"instances\", []):\n if instance.get(\"sub_container\", {}).get(\"top_container\", {}).get(\"_resolved\"):\n del instance[\"sub_container\"][\"top_container\"][\"_resolved\"]\n object = super(ArchivalObjectMerger, self).combine_data(object, additional_data)\n return combine_references(object)","def _copy_metadata_deep(value, old_value):\n if value is None or old_value is None or value is old_value: return\n\n if isinstance(value, dict):\n for k, v in value.iteritems():\n _copy_metadata_deep(v, old_value[k])\n elif isinstance(value, list):\n for v, old_v in zip(value, old_value):\n _copy_metadata_deep(v, old_v)\n else:\n try:\n value.__dict__.update(old_value.__dict__)\n except AttributeError:\n pass","def __add__(self, other):\n\n if isinstance(other, type(self)):\n # always create new fields, since otherwise c = a - b changes a as well!\n p = fields(self)\n p.elec[:] = self.elec + other.elec\n p.magn[:] = self.magn + other.magn\n return p\n else:\n raise DataError(\"Type error: cannot add %s to %s\" % (type(other), type(self)))","def copy_attributes(var1, var2):\n for each in var1.ncattrs():\n if each != \"_FillValue\":\n setattr(var2, each, getattr(var1, each))","def _copy_from_doc(doc):\n d = {\"has_props\": [], \"origins\": []}\n # Complex function to grab the keys and put them in the root doc\n # if the item is a list, it makes one doc per item with those corresponding keys\n for doc_key in summary_fields:\n sub_doc = doc.get(doc_key, None)\n if isinstance(sub_doc, list) and len(sub_doc) > 0:\n d[\"has_props\"].append(doc_key)\n d[doc_key] = []\n for sub_item in sub_doc:\n temp_doc = {\n copy_key: sub_item[copy_key]\n for copy_key in summary_fields[doc_key]\n if copy_key in sub_item\n }\n d[doc_key].append(temp_doc)\n elif isinstance(sub_doc, dict):\n d[\"has_props\"].append(doc_key)\n if sub_doc.get(\"origins\", None):\n d[\"origins\"].extend(sub_doc[\"origins\"])\n d.update(\n {\n copy_key: sub_doc[copy_key]\n for copy_key in summary_fields[doc_key]\n if copy_key in sub_doc\n }\n )\n return d","def merge_contextual(self, other):\n # TODO: This is currently dependent on our data model? Make more robust to schema changes\n # Currently we assume all lists at Compound level, with 1 further potential nested level of lists\n for k in self.keys():\n # print('key: %s' % k)\n for item in self[k]:\n # print('item: %s' % item)\n for other_item in other.get(k, []):\n # Skip text properties (don't merge names, labels, roles)\n if isinstance(other_item, six.text_type):\n continue\n for otherk in other_item.keys():\n if isinstance(other_item[otherk], list):\n if len(other_item[otherk]) > 0 and len(item[otherk]) > 0:\n other_nested_item = other_item[otherk][0]\n for othernestedk in other_nested_item.keys():\n for nested_item in item[otherk]:\n if not nested_item[othernestedk]:\n nested_item[othernestedk] = other_nested_item[othernestedk]\n elif not item[otherk]:\n item[otherk] = other_item[otherk]\n log.debug('Result: %s' % self.serialize())\n return self","def mergeWith(self, others):","def combine_data(self, object, additional_data):\n object[\"ancestors\"] = additional_data[\"ancestors\"] if self.cartographer_client else []\n object[\"position\"] = additional_data.get(\"order\", 0) if additional_data else 0\n object = super(ResourceMerger, self).combine_data(object, additional_data)\n return combine_references(object)","def append(dest, field, value):\n if isinstance(dest[field], list):\n dest[field].append(value)\n else:\n dest[field] = [dest[field], value]","def merge(self, obj):\n pass","def test__ActivityParty__copy_with__1():\n old_party_id = 'plain'\n old_size = 6\n old_max = 12\n new_party_id = 'asia'\n new_size = 1\n new_max = 8\n \n field = ActivityParty(\n party_id = old_party_id,\n size = old_size,\n max_ = old_max,\n )\n copy = field.copy_with(\n party_id = new_party_id,\n size = new_size,\n max_ = new_max,\n )\n _assert_fields_set(copy)\n vampytest.assert_is_not(field, copy)\n \n vampytest.assert_eq(copy.id, new_party_id)\n vampytest.assert_eq(copy.size, new_size)\n vampytest.assert_eq(copy.max, new_max)","def copy(self):","def _copy_from_doc(doc):\n\n d = {\"has_props\": []}\n\n # Function to grab the keys and put them in the root doc\n for doc_key in summary_fields:\n sub_doc = doc.get(doc_key, None)\n if isinstance(sub_doc, list) and len(sub_doc) > 0:\n d[\"has_props\"].append(doc_key)\n for copy_key in summary_fields[doc_key]:\n d[copy_key] = dict()\n for sub_item in sub_doc:\n # In cases where multiple docs have the same properties,\n # they must differ by method\n if copy_key in sub_item and \"method\" in sub_item:\n d[copy_key][sub_item[\"method\"]] = sub_item[copy_key]\n\n elif isinstance(sub_doc, dict):\n d[\"has_props\"].append(doc_key)\n d.update(\n {\n copy_key: sub_doc[copy_key]\n for copy_key in summary_fields[doc_key]\n if copy_key in sub_doc\n }\n )\n\n return d","def get_added_dicts(a, b):\n tmp = copy.deepcopy(a)\n for key, val in b.iteritems():\n if key not in tmp:\n tmp[key] = val\n return tmp","def copy_attributes(ncin, ncout,exclude=None, include=None):\n att_dict = odict()\n for attribute_name in ncin.ncattrs():\n if include is not None and attribute_name not in include:\n continue #if include is defined, and this attribute is not there\n if exclude is not None and attribute_name in exclude:\n continue #if exclude is defined, and this attribute is there\n att_dict[attribute_name] = ncin.getncattr(attribute_name)\n ncout.setncatts(att_dict)","def fusionne(self, new):\n if new == self:\n raise ValueError(\"une catégorie ne peut être fusionnée avec elle même\")\n self.alters_data = True\n if not isinstance(new, type(self)):\n raise TypeError(\"pas la même classe d'objet\")\n if self.type != new.type:\n raise TypeError(\"pas le même type de catégorie, %s est %s alors que %s est %s\" % (\n self.nom, self.type, new.nom, new.type))\n nb_change = Echeance.objects.filter(cat=self).update(cat=new)\n nb_change += Ope.objects.filter(cat=self).update(cat=new)\n self.delete()\n return nb_change","def merge_fields(d, new):\n if not new:\n return\n\n for k, v in new.iteritems():\n if k not in d:\n d[k] = v\n elif isinstance(v, list) and isinstance(d[k], list):\n d[k].extend(v)\n elif isinstance(v, dict) and isinstance(d[k], dict):\n d[k].update(v)\n else:\n d[k] = v","def _handle_load_unknown(self, data, original):\n for key, val in original.items():\n if key not in self.fields:\n data[key] = val\n return data","def __duplicate_o2o_fields(self, duplicate):\n for f in self._meta.related_objects:\n if f.one_to_one:\n if any(\n [\n f.name in self._clone_o2o_fields\n and f not in self._meta.concrete_fields,\n self._clone_excluded_o2o_fields\n and f.name not in self._clone_excluded_o2o_fields\n and f not in self._meta.concrete_fields,\n ]\n ):\n rel_object = getattr(self, f.name, None)\n if rel_object:\n new_rel_object = CloneMixin._create_copy_of_instance(\n rel_object,\n force=True,\n sub_clone=True,\n )\n setattr(new_rel_object, f.remote_field.name, duplicate)\n new_rel_object.save()\n\n return duplicate","def updated_object(self):\n o = deepcopy(self.object)\n o[\"name\"] += \"-copy\"\n return o","def test_merge_aggregate_traditional(self):\n mdict = copy.deepcopy(self.dict1)\n mdict[\"A\"] = \"b\"\n ret = dictupdate.merge_overwrite(copy.deepcopy(self.dict1), {\"A\": \"b\"})\n self.assertEqual(mdict, ret)","def conditional_copy(self, other, key, altkey=None):\n if hasattr(self, key):\n possible = getattr(self, key)\n if possible:\n usekey = {True: altkey, False: key}[altkey is not None]\n if hasattr(other, usekey):\n exists = getattr(other, usekey)\n if exists:\n return\n if isinstance(possible, list):\n setattr(other, usekey, [deepcopy(i) for i in possible])\n else:\n setattr(other, usekey, deepcopy(possible))","def copy_attrs(varin,varout):\n for attr_name in varin.ncattrs():\n varout.setncattr(attr_name,varin.getncattr(attr_name))","def test_dict_merge_immutable():\n x1 = {'one': 1, 'two': 2}\n x1_cop = x1.copy()\n ir.dict_merge(x1, {'three': 3, 'two': None})\n assert x1 == x1_cop\n ir.dict_merge({'ten': 10, 'one': '1'}, x1)\n assert x1 == x1_cop","def copy(self):\n new = self.__class__(integration=None, data=None)\n for attribute, value in self.__dict__.items():\n if attribute in self.referenced_attributes:\n setattr(new, attribute, value)\n elif hasattr(value, 'copy'):\n setattr(new, attribute, value.copy())\n else:\n setattr(new, attribute, deepcopy(value))\n return new","def __add__(self, other):\n self.__dict__.update(other)\n return self","def _copy_catalog(self):\n\n # load the IOL into an astropy table\n # the table is in iol.catalog\n self.iol = axeiol.InputObjectList(self.in_sex)\n\n # check for an empty table\n if len(self.iol.catalog) < 1:\n _log.info(\"Empty catalog found\\n\")\n return None\n\n # create a new GOL that's a copy of the input list\n self.gol = deepcopy(self.iol.catalog) # just make a copy","def merge_schema(self, schema):\n super(CategoricalAttributeSchema, self).merge_schema(schema)\n self.categories.update(schema.categories)","def concat(self, other):\n self.add_rules(other.cliques)\n self.prop_names.update(other.prop_names)","def _merge(self, other: dict):\n self._storage = dict_merge(self._storage, other)","def __listunion(self, c1, c2):\n s1 = {}\n for delta in c1:\n s1[delta] = 1\n\n\tc = c1[:]\n\tfor delta in c2:\n if not s1.has_key(delta):\n\t\tc.append(delta)\n\n\treturn c","def __duplicate_m2o_fields(self, duplicate):\n fields = set()\n\n for f in self._meta.concrete_fields:\n if f.many_to_one:\n if any(\n [\n f.name in self._clone_m2o_or_o2m_fields,\n self._clone_excluded_m2o_or_o2m_fields\n and f.name not in self._clone_excluded_m2o_or_o2m_fields,\n ]\n ):\n fields.add(f)\n\n # Clone many to one fields\n for field in fields:\n item = getattr(self, field.name)\n try:\n item_clone = item.make_clone()\n except IntegrityError:\n item_clone = item.make_clone(sub_clone=True)\n\n setattr(duplicate, field.name, item_clone)\n\n return duplicate","def merge(self, object_class):\n other_oc = self.schema.get_object_class(object_class)\n self.required_attrs |= other_oc.required_attrs\n self.allowed_attrs |= other_oc.allowed_attrs","def copyCommonFields(self):\n self.fetchDataToForm(self.selected_row, self.selected_column, fields = \"Recent\")","def add_dict(dest, src):\n for key in src.keys():\n if key in dest.keys():\n dest[key] += src[key]\n else:\n dest[key] = src[key]","def test_copy_attributes(self):\n\n v = Vector({ 'x': 3 }, { 'y': True })\n n = v.copy()\n\n self.assertEqual(v.attributes, n.attributes)\n\n v.attributes['y'] = False\n self.assertFalse(v.attributes['y'])\n self.assertTrue(n.attributes['y'])\n v.attributes['y'] = True","def mergeMetadata(self, obj, dom): \n self.update_semantics = 'merge'\n # create a metadata dict that has all the values from obj, overridden\n # by the current dom values.\n metadata = self.getModuleMetadata(obj, {})\n metadata.update(self.getMetadata(dom, METADATA_MAPPING))\n for oerdc_name, cnx_name in METADATA_MAPPING.items():\n if cnx_name in ['keywords',]:\n old_value = getattr(obj, cnx_name)\n if old_value:\n current_value = list(metadata.get(cnx_name, []))\n current_value.extend(old_value)\n metadata[cnx_name] = current_value\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 self.updateRoles(obj, dom)\n obj.reindexObject(idxs=metadata.keys())","def test_deepcopy(self):\n t = Compose([Enumerate([2, \"asfa\", \"ipsi\"]), OneHotEncode(3)], \"categorical\")\n t.transform([2])\n copy.deepcopy(t)","def _merge(acc: Dict[str, str], cur: Any) -> Dict[str, str]:\n parsed = _parse_feature(cur)\n acc[\"timestamp\"] = parsed[\"timestamp\"]\n acc[\"lat\"] = parsed[\"lat\"]\n acc[\"lon\"] = parsed[\"lon\"]\n key = parsed[\"property\"]\n val = parsed[\"value\"]\n\n acc[key] = val\n\n return acc","def copy(self):\n return self.update({})","def _handle_dump_unknown(self, data, original):\n for key, val in original.items():\n if key not in self.fields:\n data[key] = val\n return data","def add_tags(self, tags):\n cp = self.copy()\n cp.tags = cp.tags.union(set(tags))\n return cp","def copy_nc_attrs(src, dest):\n with xarray.open_dataset(src) as s:\n attrs = s.attrs\n # Write empty root dataset with attributes\n ds = xarray.Dataset(attrs=attrs)\n ds.to_netcdf(dest, mode=\"a\")","def copy_oids(fc, fld_name):\n oid_fld = arcpy.Describe(fc).OIDFieldName\n arcpy.AddField_management(fc, fld_name, 'LONG')\n arcpy.CalculateField_management(\n fc, fld_name, '!{}!'.format(oid_fld), 'PYTHON_9.3')","def add_data(self, in_data):\n old_data = {}\n for field in self.fields:\n # ToDo - might be a better way to determine the fieldname\n if field in in_data:\n if field in self.data:\n old_data = dict(self.data)\n self.data = {}\n\n self.data[field] = in_data[field]\n self.data['usUnits'] = in_data['usUnits']\n self.data['dateTime'] = in_data['dateTime']\n return old_data","def copy(self):\n new = self.__class__()\n do_not_copy_by_ref = {\"alleles\", \"strains\", \"base_cobra_model\", \"notes\",\n \"annotation\"}\n for attr in self.__dict__:\n if attr not in do_not_copy_by_ref:\n new.__dict__[attr] = self.__dict__[attr]\n new.notes = deepcopy(self.notes)\n new.annotation = deepcopy(self.annotation)\n\n new.alleles = DictList()\n do_not_copy_by_ref = {\"_strains\", \"_model\"}\n for allele in self.alleles:\n new_allele = allele.__class__()\n for attr, value in iteritems(allele.__dict__):\n if attr not in do_not_copy_by_ref:\n new_allele.__dict__[attr] = copy(\n value) if attr == \"formula\" else value\n new_allele._model = new\n new.alleles.append(new_allele)\n\n new.strains = DictList()\n do_not_copy_by_ref = {\"_model\", \"_alleles\", \"_base_cobra_model\"}\n for strain in self.strains:\n new_strain = strain.__class__()\n for attr, value in iteritems(strain.__dict__):\n if attr not in do_not_copy_by_ref:\n new_strain.__dict__[attr] = copy(value)\n new_strain._model = new\n new.strains.append(new_strain)\n # update awareness\n for allele, stoic in iteritems(strain._alleles):\n new_allele = new.alleles.get_by_id(allele.id)\n new_strain._alleles[new_allele] = stoic\n new_allele._strain.add(new_strain)\n # it doesn't make sense to retain the context of a copied model so\n # assign a new empty context\n new._contexts = list()","def __add__(self, other):\r\n # Make a defaultdict of defaultdicts, the latter of which returns\r\n # None when an key is not present\r\n merged_data = defaultdict(lambda: defaultdict(lambda: None))\r\n\r\n # We will keep track of all unique sample_ids and metadata headers\r\n # we have seen as we go\r\n all_sample_ids = set()\r\n all_headers = set()\r\n\r\n # add all values from self into the merged_data structure\r\n for sample_id, data in self._metadata.iteritems():\r\n all_sample_ids.add(sample_id)\r\n for header, value in data.iteritems():\r\n all_headers.add(header)\r\n merged_data[sample_id][header] = value\r\n\r\n # then add all data from other\r\n for sample_id, data in other._metadata.iteritems():\r\n all_sample_ids.add(sample_id)\r\n for header, value in data.iteritems():\r\n all_headers.add(header)\r\n # if the two mapping files have identical sample_ids and\r\n # metadata columns but have DIFFERENT values, raise a value\r\n # error\r\n if merged_data[sample_id][header] is not None and \\\r\n merged_data[sample_id][header] != value:\r\n raise ValueError(\"Different values provided for %s for \"\r\n \"sample %s in different mapping files.\"\r\n % (header, sample_id))\r\n else:\r\n merged_data[sample_id][header] = value\r\n\r\n # Now, convert what we have seen into a normal dict\r\n normal_dict = {}\r\n for sample_id in all_sample_ids:\r\n if sample_id not in normal_dict:\r\n normal_dict[sample_id] = {}\r\n\r\n for header in all_headers:\r\n normal_dict[sample_id][header] = \\\r\n merged_data[sample_id][header]\r\n\r\n # and create a MetadataMap object from it; concatenate comments\r\n return self.__class__(normal_dict, self.Comments + other.Comments)","def deepcopy(self, **datas):\n new_obj = self.__class__(**datas)\n new_obj.save()\n\n return new_obj","def _copy_kwargs(self, **kwargs):\n ns = self.__dict__\n for attr, kw in {'_engine': 'engine', '_format': 'format'}.items():\n assert kw not in kwargs\n if attr in ns:\n kwargs[kw] = ns[attr]\n return super()._copy_kwargs(**kwargs)","def copy(self):\n new = super().copy()\n new.drip_cal_config = deepcopy(self.drip_cal_config)\n new.drip_config = deepcopy(self.drip_config)\n new.pipecal_config = deepcopy(self.pipecal_config)\n return new","def difference(self, other: Catalog) -> Catalog:\n cat1 = self.copy()\n cat2 = other.copy()\n\n new_cat = Catalog()\n for a_cat1, a_cat_2 in [(cat1, cat2), (cat2, cat1)]:\n for k in a_cat1.keys():\n for ver_id, version in a_cat1[k].versions.items():\n if k not in a_cat_2 or ver_id not in a_cat_2[k]:\n new_cat[k][ver_id] = version\n return new_cat","def add_metadata_properties(self, sentence, result):\r\n for property in sentence.properties:\r\n if property.property_metadata.is_category:\r\n result[property.name] = property.value","def _modified_copy(cls, copy, is_offset: bool, mod_mapping: dict):\n\n for attribute, value in mod_mapping.items():\n\n path = attribute.split(\"__\")\n\n if len(path) == 1:\n # Non-nested attribute change\n cls._set_stuff(is_offset, copy, attribute, value)\n\n else:\n # Nested attribute change, e.g. circle__position__x=4\n *nested_attr_chain, attribute = path\n obj = copy\n for nested_attr in nested_attr_chain:\n obj = getattr(obj, nested_attr)\n cls._set_stuff(is_offset, obj, attribute, value)\n\n return copy","def osl_fill_from(self, other):\n #TODO: What about inherited properties?\n for p in self._osl.properties:\n conditional_copy(other, self, p[0])\n return self","def __add__(self, other):\n merged_profile = super().__add__(other)\n\n # struct specific property merging\n merged_profile.row_has_null_count = \\\n self.row_has_null_count + other.row_has_null_count\n merged_profile.row_is_null_count = \\\n self.row_is_null_count + other.row_is_null_count\n merged_profile.hashed_row_dict.update(self.hashed_row_dict)\n merged_profile.hashed_row_dict.update(other.hashed_row_dict)\n\n self_to_other_idx = self._get_and_validate_schema_mapping(self._col_name_to_idx,\n other._col_name_to_idx)\n\n # merge profiles\n for idx in range(len(self._profile)):\n other_idx = self_to_other_idx[idx]\n merged_profile._profile.append(self._profile[idx] +\n other._profile[other_idx])\n\n # schemas are asserted to be identical\n merged_profile._col_name_to_idx = copy.deepcopy(self._col_name_to_idx)\n\n # merge correlation\n if (self.options.correlation.is_enabled\n and other.options.correlation.is_enabled):\n merged_profile.correlation_matrix = self._merge_correlation(other)\n\n # recompute chi2 if needed\n if self.options.chi2_homogeneity.is_enabled and \\\n other.options.chi2_homogeneity.is_enabled:\n\n chi2_mat1 = self.chi2_matrix\n chi2_mat2 = other.chi2_matrix\n n1 = self.total_samples - self.row_is_null_count\n n2 = other.total_samples - other.row_is_null_count\n if n1 == 0:\n merged_profile.chi2_matrix = chi2_mat2\n elif n2 == 0:\n merged_profile.chi2_matrix = chi2_mat1\n elif chi2_mat1 is None or chi2_mat2 is None:\n merged_profile.chi2_matrix = None\n else:\n merged_profile.chi2_matrix = merged_profile._update_chi2()\n\n return merged_profile","def merge(self, other):\n log.debug('Merging: %s and %s' % (self.serialize(), other.serialize()))\n for k in self.keys():\n for new_item in other[k]:\n if new_item not in self[k]:\n self[k].append(new_item)\n log.debug('Result: %s' % self.serialize())\n return self","def test__ApplicationCommandOptionMetadataNested__copy_with__1():\n old_options = [\n ApplicationCommandOption('nue', 'nue', ApplicationCommandOptionType.string),\n ApplicationCommandOption('seija', 'seija', ApplicationCommandOptionType.integer),\n ]\n \n new_options = [\n ApplicationCommandOption('aya', 'ayaya', ApplicationCommandOptionType.float),\n ApplicationCommandOption('momiji', 'awoo', ApplicationCommandOptionType.user),\n ]\n \n option_metadata = ApplicationCommandOptionMetadataNested(\n options = old_options,\n )\n \n copy = option_metadata.copy_with(\n options = new_options,\n )\n \n _asert_fields_set(copy)\n vampytest.assert_is_not(option_metadata, copy)\n \n vampytest.assert_eq(copy.options, tuple(new_options))","def copy_properties(self, from_metadata, clear_properties=False):\n if (clear_properties):\n self.clear_properties()\n\n for key, value in from_metadata.properties.items():\n self.properties[key] = copy.deepcopy(value)","def add_other_meta_data(self, other: _MetaData) -> None:\n\n for key in other._meta_data_dict.keys():\n self.add_data(key, other._meta_data_dict[key])","def CopyData(self, p_int, vtkDataSetAttributes, p_int_1, vtkDataSetAttributes_1, p_int_2):\n ...","def test_merge_overwrite_traditional(self):\n mdict = copy.deepcopy(self.dict1)\n mdict[\"A\"] = \"b\"\n ret = dictupdate.merge_overwrite(copy.deepcopy(self.dict1), {\"A\": \"b\"})\n self.assertEqual(mdict, ret)","def varcopy(self, vars):","def merge(self, new_attributes):\n for k, v in new_attributes.items():\n setattr(self, k, v)","def testCopyCollection(self):\n copy = self.node.copy_collection()\n\n self.assertEqual(\n self.node.type,\n copy.type\n )\n\n self.assertEqual(\n self.node.desc,\n copy.desc\n )\n\n self.assertEqual(\n self.node.input_desc,\n copy.input_desc\n )\n\n self.assertEqual(\n self.node.viewing_desc,\n copy.viewing_desc\n )\n\n self.assertEqual(\n self.node.all_children,\n copy.all_children\n )","def copy():\n copy2(per, per_old)","def merge_object(self, obj):\n for key, value in obj.lines.items():\n if key not in self.lines:\n self.lines[key] = value\n self.lines[key] = self.lines[key] + value","def flatten_others(self, obj, many, **kwargs):\r\n for k, v in obj['others'].items():\r\n obj[k] = v\r\n obj.pop('others')\r\n return obj","def combine(self, other) -> None:\n assert self.id_ == other.id_\n assert self.type_ == other.type_\n self.count += other.count","def test_addingnewattributes(self):\n b1 = BaseModel()\n b1.name = \"Holberton\"\n b1.my_number = 89\n dictionary = b1.to_dict()\n self.assertEqual('name' in dictionary, True)\n self.assertEqual('my_number' in dictionary, True)\n b2 = BaseModel()\n dictionary2 = b2.to_dict()\n self.assertEqual('name' in dictionary2, False)\n self.assertEqual('my_number' in dictionary2, False)","def test__ActivityParty__copy_with__0():\n party_id = 'plain'\n size = 6\n max_ = 12\n \n field = ActivityParty(\n party_id = party_id,\n size = size,\n max_ = max_,\n )\n copy = field.copy_with()\n _assert_fields_set(copy)\n vampytest.assert_is_not(field, copy)\n \n vampytest.assert_eq(field, copy)","def test_copy(dset):\n dset_new = copy.deepcopy(dset)\n\n for field_name, field in dset._fields.items():\n print(f\"Testing {field_name}\")\n try:\n if field.data.dtype.type is np.str_:\n assert np.char.equal(field.data, dset_new._fields[field_name].data).all()\n else:\n assert np.equal(field.data, dset_new._fields[field_name].data).all()\n except AttributeError:\n for group_field_name, group_field in field.data._fields.items():\n if group_field.data.dtype.type is np.str_:\n assert np.char.equal(\n group_field.data, dset_new._fields[field_name].data._fields[group_field_name].data\n ).all()\n else:\n assert np.equal(\n group_field.data, dset_new._fields[field_name].data._fields[group_field_name].data\n ).all()","def copy_doclist(doclist, no_copy = []):\n\n\tcl = []\n\n\t# main doc\n\tc = Document(fielddata = doclist[0].fields.copy())\n\n\t# clear no_copy fields\n\tfor f in no_copy:\n\t\tif c.fields.has_key(f):\n\t\t\tc.fields[f] = None\n\n\tc.name = None\n\tc.save(1)\n\tcl.append(c)\n\n\t# new parent name\n\tparent = c.name\n\n\t# children\n\tfor d in doclist[1:]:\n\t\tc = Document(fielddata = d.fields.copy())\n\t\tc.name = None\n\n\t\t# clear no_copy fields\n\t\tfor f in no_copy:\n\t\t\tif c.fields.has_key(f):\n\t\t\t\tc.fields[f] = None\n\n\t\tc.parent = parent\n\t\tc.save(1)\n\t\tcl.append(c)\n\n\treturn cl","def test_copy(self):\n\n # Copy the 'orig' data pipe to the 'new' data pipe.\n pipes.copy('orig', 'new')\n\n # Test that the new data pipe exists.\n self.assert_('new' in ds)\n\n # Test that the new data pipe has the object 'x' and that its value is 1.\n self.assertEqual(ds['new'].x, 1)\n\n # Change the value of x.\n ds['new'].x = 2\n\n # Test that the two values are different.\n self.assert_(ds['orig'].x != ds['new'].x)\n\n # Test that the new data pipe has the object 'mol[0].res[0].spin[0].num' and that its value is 1.\n self.assertEqual(ds['new'].mol[0].res[0].spin[0].num, 1)\n\n # Change the spin system number.\n ds['new'].mol[0].res[0].spin[0].num = 2\n\n # Test that the original spin system number hasn't changed.\n self.assertEqual(ds['orig'].mol[0].res[0].spin[0].num, 1)","def merge(target, source):\n for key, value in source.items():\n if key not in target:\n target[key] = value\n elif type(target[key]) is dict:\n if key in self.OVERRIDE_ON_EXTENDS:\n target[key].update(value)\n else:\n merge(target[key], value)\n elif type(target[key]) is list:\n target[key] += value\n return target","def copy(self, rhs):\n\n\t\tself.name = rhs.name\n\t\tself.file = rhs.file\n\n\t\tfor rem in rhs.remark:\n\t\t\tself.addRemark(rem)\n\n\t\tself.bk_tot = rhs.bk_tot\n\t\tself.fa_rep = rhs.fa_rep\n\t\tself.fa_atr = rhs.fa_atr","def _copy_data_from(self, original):\n raise NotImplementedError()","def concatenate_data():","def __duplicate_o2m_fields(self, duplicate):\n fields = set()\n\n for f in self._meta.related_objects:\n if f.one_to_many:\n if any(\n [\n f.get_accessor_name() in self._clone_m2o_or_o2m_fields,\n self._clone_excluded_m2o_or_o2m_fields\n and f.get_accessor_name()\n not in self._clone_excluded_m2o_or_o2m_fields,\n ]\n ):\n fields.add(f)\n\n # Clone one to many fields\n for field in fields:\n for item in getattr(self, field.get_accessor_name()).all():\n try:\n item.make_clone(attrs={field.remote_field.name: duplicate})\n except IntegrityError:\n item.make_clone(\n attrs={field.remote_field.name: duplicate}, sub_clone=True\n )\n\n return duplicate","def test__ActivityParty__copy():\n party_id = 'plain'\n size = 6\n max_ = 12\n \n field = ActivityParty(\n party_id = party_id,\n size = size,\n max_ = max_,\n )\n copy = field.copy()\n _assert_fields_set(copy)\n vampytest.assert_is_not(field, copy)\n \n vampytest.assert_eq(field, copy)","def add_shallow_copy_of(self, child_to_add, merged=False):\n\n new_child = self.add_child(child_to_add.text)\n\n if merged:\n new_child.instances.append({\n 'hostname': child_to_add.host.hostname,\n 'comments': child_to_add.comments,\n 'tags': child_to_add.tags})\n new_child.comments.update(child_to_add.comments)\n new_child.tags.update(child_to_add.tags)\n new_child.order_weight = child_to_add.order_weight\n\n return new_child","def copy(self):\n return super().copy()","def copy(self):\n copied = super().copy()\n copied.anonymize()\n return copied","def transfer_missing_elements(target_dict, source_dict, transfer_type=None):\r\n\r\n if transfer_type is None:\r\n transfer_type = source_dict.get(\"_transfer_type_\", \"recursive\")\r\n\r\n for key_, val_ in source_dict.items():\r\n # print(key_,isinstance(val_, dict), val_)\r\n if isinstance(val_, dict):\r\n if key_ not in target_dict:\r\n target_dict[key_] = EasyDict()\r\n if transfer_type is None:\r\n transfer_type = val_.get(\"_transfer_type_\", \"recursive\")\r\n # print(\"*********** \",transfer_type)\r\n\r\n if transfer_type == \"recursive\":\r\n transfer_missing_elements(target_dict[key_], val_, transfer_type)\r\n elif transfer_type == \"update\":\r\n target_dict[key_].update(val_)\r\n elif transfer_type == \"overwrite\":\r\n target_dict[key_] = copy.deepcopy(source_dict[key_])\r\n # target_dict[key_] = val_\r\n\r\n elif key_ not in target_dict:\r\n target_dict[key_] = copy.deepcopy(source_dict[key_])\r\n # target_dict[key_] = val_\r\n # else :\r\n # target_dict[key_] = val_\r\n # target_dict[key_] = copy.deepcopy(source_dict[key_])\r\n\r\n\r\n # if isinstance(source_dict[key_],list) and isinstance(source_dict[key_][0],dict):\r\n # if key_ not in target_dict:\r\n # target_dict[key_] = []\r\n # for src_ in source_dict[key_]:\r\n # if not isinstance(src_,dict):\r\n # continue\r\n # match = False\r\n # for tar_ in target_dict[key_]:\r\n # # TODO make a list of bool with ID keys loaded from odb and check if any(matches):\r\n # if key_matches(\"pth_full\", src_, tar_) or key_matches(\"pth_alias\", src_, tar_) :\r\n # match = True\r\n # if not match:\r\n # temp = EasyDict()\r\n # target_dict[key_].append(temp)\r\n # transfer_missing_elements(temp, src_)\r","def mergeWith(self, newFL):\n srcMods = self.srcMods\n for levls, newLevls in ((self.levcs,newFL.levcs),(self.levis,newFL.levis)):\n for listId, newLevl in newLevls.items():\n if listId not in srcMods: \n srcMods[listId] = [newFL.fileInfo.name]\n levl = levls[listId] = copy.deepcopy(newLevl)\n self.records.append(levl)\n else:\n srcMods[listId].append(newFL.fileInfo.name)\n levls[listId].mergeWith(newLevl)","def add(self, other):\n\n def merge_dicts(d1, d2):\n \"\"\"\n Merge two dictionaries\n\n param d1: dictionary changed in place to have combined values\n type d1: dictionary(key -> set)\n param d2: dictioanry to be merged\n type d2: dictionary(key -> set)\n \"\"\"\n for key,value in d2.items():\n if key not in d1:\n d1[key] = value\n else:\n d1[key] |= value\n \n self.num_documents += other.num_documents\n self.num_expressions += other.num_expressions\n self.global_expressions += other.global_expressions\n self.expressions_with_e += other.expressions_with_e\n self.num_keywords += other.num_keywords\n merge_dicts(self.missing_tags, other.missing_tags)\n merge_dicts(self.problem_files, other.problem_files)","def extend(self, other_rollout):\n\n assert not self.is_terminal()\n assert all(k in other_rollout.fields for k in self.fields)\n for k, v in other_rollout.data.items():\n self.data[k].extend(v)\n self.last_r = other_rollout.last_r"],"string":"[\n \"def copyAttributes(self, other, add_nxpars=False):\\n import copy\\n \\n self.setTitle(other.getTitle())\\n self.setDataSetType(other.getDataSetType())\\n self.setAllAxisLabels(other.getAllAxisLabels())\\n self.setAllAxisUnits(other.getAllAxisUnits())\\n self.setYLabel(other.getYLabel())\\n self.setYUnits(other.getYUnits())\\n if len(self.attr_list.keys()) == 0:\\n self.attr_list = copy.copy(other.attr_list)\\n else:\\n self.attr_list.instrument = copy.copy(other.attr_list.instrument)\\n self.attr_list.sample = copy.copy(other.attr_list.sample)\\n\\n if add_nxpars:\\n nxpar_keys = [item[0] for item in self.attr_list.iteritems() \\\\\\n if isinstance(item[1], NxParameter)]\\n\\n for nxpar_key in nxpar_keys:\\n self.attr_list[nxpar_key] += other.attr_list[nxpar_key]\\n else:\\n # Do nothing\\n pass\\n \\n keys_to_get = [other_key for other_key in other.attr_list \\\\\\n if other_key not in self.attr_list]\\n \\n for key_to_get in keys_to_get:\\n self.attr_list[key_to_get] = \\\\\\n copy.copy(other.attr_list[key_to_get])\",\n \"def new_data(first: dict, second: dict, changeables: tuple):\\n for name, field in first.items():\\n if name not in changeables:\\n second[name] = field\",\n \"def union(self, other: Catalog) -> Catalog:\\n cat = self.copy()\\n oth_cp = other.copy()\\n\\n for k in oth_cp.keys():\\n for ver_id, version in oth_cp[k].versions.items():\\n cat[k][ver_id] = version\\n return cat\",\n \"def __add__(self, other):\\n return self.__class__(\\n {\\n name:\\n self.__getattribute__(name) + other.__getattribute__(name)\\n for name in self._fields\\n }\\n )\",\n \"def merge(self, new_store):\\n if new_store.name and len(new_store.name) > 0:\\n self.name = new_store.name\\n if new_store.address and len(new_store.address) > 0:\\n self.address = new_store.address\\n if new_store.city and len(new_store.city) > 0:\\n self.city = new_store.city\\n if new_store.state and len(new_store.state) > 0:\\n self.state = new_store.state\\n if new_store.zip and new_store.zip > 0:\\n self.zipcode = new_store.zip\\n if new_store.phone and new_store.phone > 0:\\n self.phone = new_store.phone\",\n \"def _copy(self, *, new_instance:bool=False, new_alias:bool=False,\\n _context:dict=None, _deep_copy:bool=True, **kwargs):\\n self_id = id(self)\\n if _context is None:\\n _context = {}\\n elif self_id in _context:\\n return _context[self_id] # I've already been copied\\n\\n\\n existing_items = {k:getattr(self, k) for k in self._nb_attrs}\\n #It's a copy so shouldn't have the same uuid\\n existing_items.pop('uuid', None)\\n existing_items.update(kwargs)\\n\\n if new_instance:\\n existing_items['_ref'] = self\\n elif not ('_ref' in kwargs and kwargs['_ref']) and self._ref:\\n existing_items['_ref'] = self._ref._copy(_context=_context)\\n\\n if new_alias:\\n existing_items['_alias'] = True\\n\\n new_obj = type(self)(**existing_items)\\n\\n _context[self_id] = new_obj\\n\\n if _deep_copy:\\n for obj in self:\\n new_obj._add(obj._copy(new_alias=new_alias, _context=_context))\\n\\n return new_obj\",\n \"def test_copy_2(dset_full):\\n dset_new = copy.deepcopy(dset_full)\\n\\n # Test internal references in the dataset\\n assert id(dset_new.site_pos.other) == id(dset_new.sat_pos)\\n assert id(dset_new.site_delta.ref_pos) == id(dset_new.site_pos)\\n assert id(dset_new.site_posvel.other) == id(dset_new.sat_posvel)\\n assert id(dset_new.site_posvel_delta.ref_pos) == id(dset_new.site_posvel)\\n\\n assert id(dset_new.group.site_pos.other) == id(dset_new.group.sat_pos)\\n assert id(dset_new.group.site_delta.ref_pos) == id(dset_new.group.site_pos)\\n assert id(dset_new.group.site_posvel.other) == id(dset_new.group.sat_posvel)\\n assert id(dset_new.group.site_posvel_delta.ref_pos) == id(dset_new.group.site_posvel)\\n\\n # Verify that new dataset have different references than original object\\n for field_name, field in dset_full._fields.items():\\n assert id(field.data) != id(dset_new._fields[field_name].data)\\n try:\\n for group_field_name, group_field in field.data._fields.items():\\n assert id(group_field.data) != id(dset_new._fields[field_name].data._fields[group_field_name].data)\\n except AttributeError:\\n # Field is not a group\\n pass\",\n \"def copy_attrs(data_orig, data_new):\\n\\n if isinstance(data_orig, Dataset):\\n\\n # Variables\\n for v in data_orig.data_vars:\\n field = data_orig[v]\\n for attr, val in field.attrs.items():\\n data_new[v].attrs[attr] = val\\n\\n # Coordinates\\n for c in data_orig.coords:\\n coord = data_orig.coords[c]\\n for attr, val in coord.attrs.items():\\n if c in data_new.coords:\\n data_new.coords[c].attrs[attr] = val\\n\\n # Metadata\\n for attr, val in data_orig.attrs.items():\\n data_new.attrs[attr] = val\\n\\n elif isinstance(data_orig, DataArray):\\n\\n # Variable Metadata\\n for att, val in data_orig.attrs.items():\\n data_new.attrs[att] = val\\n\\n # Coordinates\\n for c in data_orig.coords:\\n coord = data_orig.coords[c]\\n for attr, val in coord.attrs.items():\\n if c in data_new.coords:\\n data_new.coords[c].attrs[attr] = val\\n\\n else:\\n raise ValueError(\\\"Couldn't handle type %r\\\" % type(data_orig))\\n\\n return data_new\",\n \"def test_copy_features(self):\\n fc = self.read_feature()\\n other = FeatureCollection(features=fc.features,\\n otherProperties=fc.otherProperties)\\n assert len(other.features) == 1\\n feature = other.features[0]\\n\\n self.check_feature(feature)\",\n \"def _merge_attributes(self, workout):\\n keys = self.__table__.columns.keys()\\n for key in keys:\\n if key in [\\\"id\\\",\\n \\\"external_id\\\",\\n \\\"is_duplicate_with\\\",\\n \\\"manual_check_required_with\\\",\\n ]:\\n continue\\n elif getattr(self, key) == None:\\n # copy attribute if empty; else keep existing \\n setattr(self, key, getattr(workout, key))\",\n \"def _merge_two(self, obj1, obj2):\\r\\n for uniq_ident in obj2.keys():\\r\\n if (uniq_ident not in obj1) \\\\\\r\\n or (obj1[uniq_ident]['modified'] \\\\\\r\\n < obj2[uniq_ident]['modified']):\\r\\n obj1[uniq_ident] = obj2[uniq_ident]\\r\\n\\r\\n return obj1 # self._dict_to_list(obj1)\\r\",\n \"def copyBooks(self):\\n skipMods = set(('Morrowind.esm',self.fileInfo.name))\\n for id,(record,modName) in (self.srcBooks.items() + self.altBooks.items()):\\n if modName not in skipMods:\\n self.setRecord(copy.copy(record))\",\n \"def append_ipma_metadata(orig: dict, dest: dict):\\n for key in [key for key in orig.keys() if key != 'data']:\\n dest[key] = orig[key]\",\n \"def copy_fields(self, model):\\n fields = super(HistoricalRecords, self).copy_fields(model)\\n for name, field in self.additional_fields.items():\\n assert name not in fields\\n assert hasattr(self, 'get_%s_value' % name)\\n fields[name] = field\\n return fields\",\n \"def combine_data(self, object, additional_data):\\n for k, v in additional_data.items():\\n if isinstance(v, list):\\n object[k] = object.get(k, []) + v\\n else:\\n object[k] = v\\n for instance in object.get(\\\"instances\\\", []):\\n if instance.get(\\\"sub_container\\\", {}).get(\\\"top_container\\\", {}).get(\\\"_resolved\\\"):\\n del instance[\\\"sub_container\\\"][\\\"top_container\\\"][\\\"_resolved\\\"]\\n object = super(ArchivalObjectMerger, self).combine_data(object, additional_data)\\n return combine_references(object)\",\n \"def _copy_metadata_deep(value, old_value):\\n if value is None or old_value is None or value is old_value: return\\n\\n if isinstance(value, dict):\\n for k, v in value.iteritems():\\n _copy_metadata_deep(v, old_value[k])\\n elif isinstance(value, list):\\n for v, old_v in zip(value, old_value):\\n _copy_metadata_deep(v, old_v)\\n else:\\n try:\\n value.__dict__.update(old_value.__dict__)\\n except AttributeError:\\n pass\",\n \"def __add__(self, other):\\n\\n if isinstance(other, type(self)):\\n # always create new fields, since otherwise c = a - b changes a as well!\\n p = fields(self)\\n p.elec[:] = self.elec + other.elec\\n p.magn[:] = self.magn + other.magn\\n return p\\n else:\\n raise DataError(\\\"Type error: cannot add %s to %s\\\" % (type(other), type(self)))\",\n \"def copy_attributes(var1, var2):\\n for each in var1.ncattrs():\\n if each != \\\"_FillValue\\\":\\n setattr(var2, each, getattr(var1, each))\",\n \"def _copy_from_doc(doc):\\n d = {\\\"has_props\\\": [], \\\"origins\\\": []}\\n # Complex function to grab the keys and put them in the root doc\\n # if the item is a list, it makes one doc per item with those corresponding keys\\n for doc_key in summary_fields:\\n sub_doc = doc.get(doc_key, None)\\n if isinstance(sub_doc, list) and len(sub_doc) > 0:\\n d[\\\"has_props\\\"].append(doc_key)\\n d[doc_key] = []\\n for sub_item in sub_doc:\\n temp_doc = {\\n copy_key: sub_item[copy_key]\\n for copy_key in summary_fields[doc_key]\\n if copy_key in sub_item\\n }\\n d[doc_key].append(temp_doc)\\n elif isinstance(sub_doc, dict):\\n d[\\\"has_props\\\"].append(doc_key)\\n if sub_doc.get(\\\"origins\\\", None):\\n d[\\\"origins\\\"].extend(sub_doc[\\\"origins\\\"])\\n d.update(\\n {\\n copy_key: sub_doc[copy_key]\\n for copy_key in summary_fields[doc_key]\\n if copy_key in sub_doc\\n }\\n )\\n return d\",\n \"def merge_contextual(self, other):\\n # TODO: This is currently dependent on our data model? Make more robust to schema changes\\n # Currently we assume all lists at Compound level, with 1 further potential nested level of lists\\n for k in self.keys():\\n # print('key: %s' % k)\\n for item in self[k]:\\n # print('item: %s' % item)\\n for other_item in other.get(k, []):\\n # Skip text properties (don't merge names, labels, roles)\\n if isinstance(other_item, six.text_type):\\n continue\\n for otherk in other_item.keys():\\n if isinstance(other_item[otherk], list):\\n if len(other_item[otherk]) > 0 and len(item[otherk]) > 0:\\n other_nested_item = other_item[otherk][0]\\n for othernestedk in other_nested_item.keys():\\n for nested_item in item[otherk]:\\n if not nested_item[othernestedk]:\\n nested_item[othernestedk] = other_nested_item[othernestedk]\\n elif not item[otherk]:\\n item[otherk] = other_item[otherk]\\n log.debug('Result: %s' % self.serialize())\\n return self\",\n \"def mergeWith(self, others):\",\n \"def combine_data(self, object, additional_data):\\n object[\\\"ancestors\\\"] = additional_data[\\\"ancestors\\\"] if self.cartographer_client else []\\n object[\\\"position\\\"] = additional_data.get(\\\"order\\\", 0) if additional_data else 0\\n object = super(ResourceMerger, self).combine_data(object, additional_data)\\n return combine_references(object)\",\n \"def append(dest, field, value):\\n if isinstance(dest[field], list):\\n dest[field].append(value)\\n else:\\n dest[field] = [dest[field], value]\",\n \"def merge(self, obj):\\n pass\",\n \"def test__ActivityParty__copy_with__1():\\n old_party_id = 'plain'\\n old_size = 6\\n old_max = 12\\n new_party_id = 'asia'\\n new_size = 1\\n new_max = 8\\n \\n field = ActivityParty(\\n party_id = old_party_id,\\n size = old_size,\\n max_ = old_max,\\n )\\n copy = field.copy_with(\\n party_id = new_party_id,\\n size = new_size,\\n max_ = new_max,\\n )\\n _assert_fields_set(copy)\\n vampytest.assert_is_not(field, copy)\\n \\n vampytest.assert_eq(copy.id, new_party_id)\\n vampytest.assert_eq(copy.size, new_size)\\n vampytest.assert_eq(copy.max, new_max)\",\n \"def copy(self):\",\n \"def _copy_from_doc(doc):\\n\\n d = {\\\"has_props\\\": []}\\n\\n # Function to grab the keys and put them in the root doc\\n for doc_key in summary_fields:\\n sub_doc = doc.get(doc_key, None)\\n if isinstance(sub_doc, list) and len(sub_doc) > 0:\\n d[\\\"has_props\\\"].append(doc_key)\\n for copy_key in summary_fields[doc_key]:\\n d[copy_key] = dict()\\n for sub_item in sub_doc:\\n # In cases where multiple docs have the same properties,\\n # they must differ by method\\n if copy_key in sub_item and \\\"method\\\" in sub_item:\\n d[copy_key][sub_item[\\\"method\\\"]] = sub_item[copy_key]\\n\\n elif isinstance(sub_doc, dict):\\n d[\\\"has_props\\\"].append(doc_key)\\n d.update(\\n {\\n copy_key: sub_doc[copy_key]\\n for copy_key in summary_fields[doc_key]\\n if copy_key in sub_doc\\n }\\n )\\n\\n return d\",\n \"def get_added_dicts(a, b):\\n tmp = copy.deepcopy(a)\\n for key, val in b.iteritems():\\n if key not in tmp:\\n tmp[key] = val\\n return tmp\",\n \"def copy_attributes(ncin, ncout,exclude=None, include=None):\\n att_dict = odict()\\n for attribute_name in ncin.ncattrs():\\n if include is not None and attribute_name not in include:\\n continue #if include is defined, and this attribute is not there\\n if exclude is not None and attribute_name in exclude:\\n continue #if exclude is defined, and this attribute is there\\n att_dict[attribute_name] = ncin.getncattr(attribute_name)\\n ncout.setncatts(att_dict)\",\n \"def fusionne(self, new):\\n if new == self:\\n raise ValueError(\\\"une catégorie ne peut être fusionnée avec elle même\\\")\\n self.alters_data = True\\n if not isinstance(new, type(self)):\\n raise TypeError(\\\"pas la même classe d'objet\\\")\\n if self.type != new.type:\\n raise TypeError(\\\"pas le même type de catégorie, %s est %s alors que %s est %s\\\" % (\\n self.nom, self.type, new.nom, new.type))\\n nb_change = Echeance.objects.filter(cat=self).update(cat=new)\\n nb_change += Ope.objects.filter(cat=self).update(cat=new)\\n self.delete()\\n return nb_change\",\n \"def merge_fields(d, new):\\n if not new:\\n return\\n\\n for k, v in new.iteritems():\\n if k not in d:\\n d[k] = v\\n elif isinstance(v, list) and isinstance(d[k], list):\\n d[k].extend(v)\\n elif isinstance(v, dict) and isinstance(d[k], dict):\\n d[k].update(v)\\n else:\\n d[k] = v\",\n \"def _handle_load_unknown(self, data, original):\\n for key, val in original.items():\\n if key not in self.fields:\\n data[key] = val\\n return data\",\n \"def __duplicate_o2o_fields(self, duplicate):\\n for f in self._meta.related_objects:\\n if f.one_to_one:\\n if any(\\n [\\n f.name in self._clone_o2o_fields\\n and f not in self._meta.concrete_fields,\\n self._clone_excluded_o2o_fields\\n and f.name not in self._clone_excluded_o2o_fields\\n and f not in self._meta.concrete_fields,\\n ]\\n ):\\n rel_object = getattr(self, f.name, None)\\n if rel_object:\\n new_rel_object = CloneMixin._create_copy_of_instance(\\n rel_object,\\n force=True,\\n sub_clone=True,\\n )\\n setattr(new_rel_object, f.remote_field.name, duplicate)\\n new_rel_object.save()\\n\\n return duplicate\",\n \"def updated_object(self):\\n o = deepcopy(self.object)\\n o[\\\"name\\\"] += \\\"-copy\\\"\\n return o\",\n \"def test_merge_aggregate_traditional(self):\\n mdict = copy.deepcopy(self.dict1)\\n mdict[\\\"A\\\"] = \\\"b\\\"\\n ret = dictupdate.merge_overwrite(copy.deepcopy(self.dict1), {\\\"A\\\": \\\"b\\\"})\\n self.assertEqual(mdict, ret)\",\n \"def conditional_copy(self, other, key, altkey=None):\\n if hasattr(self, key):\\n possible = getattr(self, key)\\n if possible:\\n usekey = {True: altkey, False: key}[altkey is not None]\\n if hasattr(other, usekey):\\n exists = getattr(other, usekey)\\n if exists:\\n return\\n if isinstance(possible, list):\\n setattr(other, usekey, [deepcopy(i) for i in possible])\\n else:\\n setattr(other, usekey, deepcopy(possible))\",\n \"def copy_attrs(varin,varout):\\n for attr_name in varin.ncattrs():\\n varout.setncattr(attr_name,varin.getncattr(attr_name))\",\n \"def test_dict_merge_immutable():\\n x1 = {'one': 1, 'two': 2}\\n x1_cop = x1.copy()\\n ir.dict_merge(x1, {'three': 3, 'two': None})\\n assert x1 == x1_cop\\n ir.dict_merge({'ten': 10, 'one': '1'}, x1)\\n assert x1 == x1_cop\",\n \"def copy(self):\\n new = self.__class__(integration=None, data=None)\\n for attribute, value in self.__dict__.items():\\n if attribute in self.referenced_attributes:\\n setattr(new, attribute, value)\\n elif hasattr(value, 'copy'):\\n setattr(new, attribute, value.copy())\\n else:\\n setattr(new, attribute, deepcopy(value))\\n return new\",\n \"def __add__(self, other):\\n self.__dict__.update(other)\\n return self\",\n \"def _copy_catalog(self):\\n\\n # load the IOL into an astropy table\\n # the table is in iol.catalog\\n self.iol = axeiol.InputObjectList(self.in_sex)\\n\\n # check for an empty table\\n if len(self.iol.catalog) < 1:\\n _log.info(\\\"Empty catalog found\\\\n\\\")\\n return None\\n\\n # create a new GOL that's a copy of the input list\\n self.gol = deepcopy(self.iol.catalog) # just make a copy\",\n \"def merge_schema(self, schema):\\n super(CategoricalAttributeSchema, self).merge_schema(schema)\\n self.categories.update(schema.categories)\",\n \"def concat(self, other):\\n self.add_rules(other.cliques)\\n self.prop_names.update(other.prop_names)\",\n \"def _merge(self, other: dict):\\n self._storage = dict_merge(self._storage, other)\",\n \"def __listunion(self, c1, c2):\\n s1 = {}\\n for delta in c1:\\n s1[delta] = 1\\n\\n\\tc = c1[:]\\n\\tfor delta in c2:\\n if not s1.has_key(delta):\\n\\t\\tc.append(delta)\\n\\n\\treturn c\",\n \"def __duplicate_m2o_fields(self, duplicate):\\n fields = set()\\n\\n for f in self._meta.concrete_fields:\\n if f.many_to_one:\\n if any(\\n [\\n f.name in self._clone_m2o_or_o2m_fields,\\n self._clone_excluded_m2o_or_o2m_fields\\n and f.name not in self._clone_excluded_m2o_or_o2m_fields,\\n ]\\n ):\\n fields.add(f)\\n\\n # Clone many to one fields\\n for field in fields:\\n item = getattr(self, field.name)\\n try:\\n item_clone = item.make_clone()\\n except IntegrityError:\\n item_clone = item.make_clone(sub_clone=True)\\n\\n setattr(duplicate, field.name, item_clone)\\n\\n return duplicate\",\n \"def merge(self, object_class):\\n other_oc = self.schema.get_object_class(object_class)\\n self.required_attrs |= other_oc.required_attrs\\n self.allowed_attrs |= other_oc.allowed_attrs\",\n \"def copyCommonFields(self):\\n self.fetchDataToForm(self.selected_row, self.selected_column, fields = \\\"Recent\\\")\",\n \"def add_dict(dest, src):\\n for key in src.keys():\\n if key in dest.keys():\\n dest[key] += src[key]\\n else:\\n dest[key] = src[key]\",\n \"def test_copy_attributes(self):\\n\\n v = Vector({ 'x': 3 }, { 'y': True })\\n n = v.copy()\\n\\n self.assertEqual(v.attributes, n.attributes)\\n\\n v.attributes['y'] = False\\n self.assertFalse(v.attributes['y'])\\n self.assertTrue(n.attributes['y'])\\n v.attributes['y'] = True\",\n \"def mergeMetadata(self, obj, dom): \\n self.update_semantics = 'merge'\\n # create a metadata dict that has all the values from obj, overridden\\n # by the current dom values.\\n metadata = self.getModuleMetadata(obj, {})\\n metadata.update(self.getMetadata(dom, METADATA_MAPPING))\\n for oerdc_name, cnx_name in METADATA_MAPPING.items():\\n if cnx_name in ['keywords',]:\\n old_value = getattr(obj, cnx_name)\\n if old_value:\\n current_value = list(metadata.get(cnx_name, []))\\n current_value.extend(old_value)\\n metadata[cnx_name] = current_value\\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 self.updateRoles(obj, dom)\\n obj.reindexObject(idxs=metadata.keys())\",\n \"def test_deepcopy(self):\\n t = Compose([Enumerate([2, \\\"asfa\\\", \\\"ipsi\\\"]), OneHotEncode(3)], \\\"categorical\\\")\\n t.transform([2])\\n copy.deepcopy(t)\",\n \"def _merge(acc: Dict[str, str], cur: Any) -> Dict[str, str]:\\n parsed = _parse_feature(cur)\\n acc[\\\"timestamp\\\"] = parsed[\\\"timestamp\\\"]\\n acc[\\\"lat\\\"] = parsed[\\\"lat\\\"]\\n acc[\\\"lon\\\"] = parsed[\\\"lon\\\"]\\n key = parsed[\\\"property\\\"]\\n val = parsed[\\\"value\\\"]\\n\\n acc[key] = val\\n\\n return acc\",\n \"def copy(self):\\n return self.update({})\",\n \"def _handle_dump_unknown(self, data, original):\\n for key, val in original.items():\\n if key not in self.fields:\\n data[key] = val\\n return data\",\n \"def add_tags(self, tags):\\n cp = self.copy()\\n cp.tags = cp.tags.union(set(tags))\\n return cp\",\n \"def copy_nc_attrs(src, dest):\\n with xarray.open_dataset(src) as s:\\n attrs = s.attrs\\n # Write empty root dataset with attributes\\n ds = xarray.Dataset(attrs=attrs)\\n ds.to_netcdf(dest, mode=\\\"a\\\")\",\n \"def copy_oids(fc, fld_name):\\n oid_fld = arcpy.Describe(fc).OIDFieldName\\n arcpy.AddField_management(fc, fld_name, 'LONG')\\n arcpy.CalculateField_management(\\n fc, fld_name, '!{}!'.format(oid_fld), 'PYTHON_9.3')\",\n \"def add_data(self, in_data):\\n old_data = {}\\n for field in self.fields:\\n # ToDo - might be a better way to determine the fieldname\\n if field in in_data:\\n if field in self.data:\\n old_data = dict(self.data)\\n self.data = {}\\n\\n self.data[field] = in_data[field]\\n self.data['usUnits'] = in_data['usUnits']\\n self.data['dateTime'] = in_data['dateTime']\\n return old_data\",\n \"def copy(self):\\n new = self.__class__()\\n do_not_copy_by_ref = {\\\"alleles\\\", \\\"strains\\\", \\\"base_cobra_model\\\", \\\"notes\\\",\\n \\\"annotation\\\"}\\n for attr in self.__dict__:\\n if attr not in do_not_copy_by_ref:\\n new.__dict__[attr] = self.__dict__[attr]\\n new.notes = deepcopy(self.notes)\\n new.annotation = deepcopy(self.annotation)\\n\\n new.alleles = DictList()\\n do_not_copy_by_ref = {\\\"_strains\\\", \\\"_model\\\"}\\n for allele in self.alleles:\\n new_allele = allele.__class__()\\n for attr, value in iteritems(allele.__dict__):\\n if attr not in do_not_copy_by_ref:\\n new_allele.__dict__[attr] = copy(\\n value) if attr == \\\"formula\\\" else value\\n new_allele._model = new\\n new.alleles.append(new_allele)\\n\\n new.strains = DictList()\\n do_not_copy_by_ref = {\\\"_model\\\", \\\"_alleles\\\", \\\"_base_cobra_model\\\"}\\n for strain in self.strains:\\n new_strain = strain.__class__()\\n for attr, value in iteritems(strain.__dict__):\\n if attr not in do_not_copy_by_ref:\\n new_strain.__dict__[attr] = copy(value)\\n new_strain._model = new\\n new.strains.append(new_strain)\\n # update awareness\\n for allele, stoic in iteritems(strain._alleles):\\n new_allele = new.alleles.get_by_id(allele.id)\\n new_strain._alleles[new_allele] = stoic\\n new_allele._strain.add(new_strain)\\n # it doesn't make sense to retain the context of a copied model so\\n # assign a new empty context\\n new._contexts = list()\",\n \"def __add__(self, other):\\r\\n # Make a defaultdict of defaultdicts, the latter of which returns\\r\\n # None when an key is not present\\r\\n merged_data = defaultdict(lambda: defaultdict(lambda: None))\\r\\n\\r\\n # We will keep track of all unique sample_ids and metadata headers\\r\\n # we have seen as we go\\r\\n all_sample_ids = set()\\r\\n all_headers = set()\\r\\n\\r\\n # add all values from self into the merged_data structure\\r\\n for sample_id, data in self._metadata.iteritems():\\r\\n all_sample_ids.add(sample_id)\\r\\n for header, value in data.iteritems():\\r\\n all_headers.add(header)\\r\\n merged_data[sample_id][header] = value\\r\\n\\r\\n # then add all data from other\\r\\n for sample_id, data in other._metadata.iteritems():\\r\\n all_sample_ids.add(sample_id)\\r\\n for header, value in data.iteritems():\\r\\n all_headers.add(header)\\r\\n # if the two mapping files have identical sample_ids and\\r\\n # metadata columns but have DIFFERENT values, raise a value\\r\\n # error\\r\\n if merged_data[sample_id][header] is not None and \\\\\\r\\n merged_data[sample_id][header] != value:\\r\\n raise ValueError(\\\"Different values provided for %s for \\\"\\r\\n \\\"sample %s in different mapping files.\\\"\\r\\n % (header, sample_id))\\r\\n else:\\r\\n merged_data[sample_id][header] = value\\r\\n\\r\\n # Now, convert what we have seen into a normal dict\\r\\n normal_dict = {}\\r\\n for sample_id in all_sample_ids:\\r\\n if sample_id not in normal_dict:\\r\\n normal_dict[sample_id] = {}\\r\\n\\r\\n for header in all_headers:\\r\\n normal_dict[sample_id][header] = \\\\\\r\\n merged_data[sample_id][header]\\r\\n\\r\\n # and create a MetadataMap object from it; concatenate comments\\r\\n return self.__class__(normal_dict, self.Comments + other.Comments)\",\n \"def deepcopy(self, **datas):\\n new_obj = self.__class__(**datas)\\n new_obj.save()\\n\\n return new_obj\",\n \"def _copy_kwargs(self, **kwargs):\\n ns = self.__dict__\\n for attr, kw in {'_engine': 'engine', '_format': 'format'}.items():\\n assert kw not in kwargs\\n if attr in ns:\\n kwargs[kw] = ns[attr]\\n return super()._copy_kwargs(**kwargs)\",\n \"def copy(self):\\n new = super().copy()\\n new.drip_cal_config = deepcopy(self.drip_cal_config)\\n new.drip_config = deepcopy(self.drip_config)\\n new.pipecal_config = deepcopy(self.pipecal_config)\\n return new\",\n \"def difference(self, other: Catalog) -> Catalog:\\n cat1 = self.copy()\\n cat2 = other.copy()\\n\\n new_cat = Catalog()\\n for a_cat1, a_cat_2 in [(cat1, cat2), (cat2, cat1)]:\\n for k in a_cat1.keys():\\n for ver_id, version in a_cat1[k].versions.items():\\n if k not in a_cat_2 or ver_id not in a_cat_2[k]:\\n new_cat[k][ver_id] = version\\n return new_cat\",\n \"def add_metadata_properties(self, sentence, result):\\r\\n for property in sentence.properties:\\r\\n if property.property_metadata.is_category:\\r\\n result[property.name] = property.value\",\n \"def _modified_copy(cls, copy, is_offset: bool, mod_mapping: dict):\\n\\n for attribute, value in mod_mapping.items():\\n\\n path = attribute.split(\\\"__\\\")\\n\\n if len(path) == 1:\\n # Non-nested attribute change\\n cls._set_stuff(is_offset, copy, attribute, value)\\n\\n else:\\n # Nested attribute change, e.g. circle__position__x=4\\n *nested_attr_chain, attribute = path\\n obj = copy\\n for nested_attr in nested_attr_chain:\\n obj = getattr(obj, nested_attr)\\n cls._set_stuff(is_offset, obj, attribute, value)\\n\\n return copy\",\n \"def osl_fill_from(self, other):\\n #TODO: What about inherited properties?\\n for p in self._osl.properties:\\n conditional_copy(other, self, p[0])\\n return self\",\n \"def __add__(self, other):\\n merged_profile = super().__add__(other)\\n\\n # struct specific property merging\\n merged_profile.row_has_null_count = \\\\\\n self.row_has_null_count + other.row_has_null_count\\n merged_profile.row_is_null_count = \\\\\\n self.row_is_null_count + other.row_is_null_count\\n merged_profile.hashed_row_dict.update(self.hashed_row_dict)\\n merged_profile.hashed_row_dict.update(other.hashed_row_dict)\\n\\n self_to_other_idx = self._get_and_validate_schema_mapping(self._col_name_to_idx,\\n other._col_name_to_idx)\\n\\n # merge profiles\\n for idx in range(len(self._profile)):\\n other_idx = self_to_other_idx[idx]\\n merged_profile._profile.append(self._profile[idx] +\\n other._profile[other_idx])\\n\\n # schemas are asserted to be identical\\n merged_profile._col_name_to_idx = copy.deepcopy(self._col_name_to_idx)\\n\\n # merge correlation\\n if (self.options.correlation.is_enabled\\n and other.options.correlation.is_enabled):\\n merged_profile.correlation_matrix = self._merge_correlation(other)\\n\\n # recompute chi2 if needed\\n if self.options.chi2_homogeneity.is_enabled and \\\\\\n other.options.chi2_homogeneity.is_enabled:\\n\\n chi2_mat1 = self.chi2_matrix\\n chi2_mat2 = other.chi2_matrix\\n n1 = self.total_samples - self.row_is_null_count\\n n2 = other.total_samples - other.row_is_null_count\\n if n1 == 0:\\n merged_profile.chi2_matrix = chi2_mat2\\n elif n2 == 0:\\n merged_profile.chi2_matrix = chi2_mat1\\n elif chi2_mat1 is None or chi2_mat2 is None:\\n merged_profile.chi2_matrix = None\\n else:\\n merged_profile.chi2_matrix = merged_profile._update_chi2()\\n\\n return merged_profile\",\n \"def merge(self, other):\\n log.debug('Merging: %s and %s' % (self.serialize(), other.serialize()))\\n for k in self.keys():\\n for new_item in other[k]:\\n if new_item not in self[k]:\\n self[k].append(new_item)\\n log.debug('Result: %s' % self.serialize())\\n return self\",\n \"def test__ApplicationCommandOptionMetadataNested__copy_with__1():\\n old_options = [\\n ApplicationCommandOption('nue', 'nue', ApplicationCommandOptionType.string),\\n ApplicationCommandOption('seija', 'seija', ApplicationCommandOptionType.integer),\\n ]\\n \\n new_options = [\\n ApplicationCommandOption('aya', 'ayaya', ApplicationCommandOptionType.float),\\n ApplicationCommandOption('momiji', 'awoo', ApplicationCommandOptionType.user),\\n ]\\n \\n option_metadata = ApplicationCommandOptionMetadataNested(\\n options = old_options,\\n )\\n \\n copy = option_metadata.copy_with(\\n options = new_options,\\n )\\n \\n _asert_fields_set(copy)\\n vampytest.assert_is_not(option_metadata, copy)\\n \\n vampytest.assert_eq(copy.options, tuple(new_options))\",\n \"def copy_properties(self, from_metadata, clear_properties=False):\\n if (clear_properties):\\n self.clear_properties()\\n\\n for key, value in from_metadata.properties.items():\\n self.properties[key] = copy.deepcopy(value)\",\n \"def add_other_meta_data(self, other: _MetaData) -> None:\\n\\n for key in other._meta_data_dict.keys():\\n self.add_data(key, other._meta_data_dict[key])\",\n \"def CopyData(self, p_int, vtkDataSetAttributes, p_int_1, vtkDataSetAttributes_1, p_int_2):\\n ...\",\n \"def test_merge_overwrite_traditional(self):\\n mdict = copy.deepcopy(self.dict1)\\n mdict[\\\"A\\\"] = \\\"b\\\"\\n ret = dictupdate.merge_overwrite(copy.deepcopy(self.dict1), {\\\"A\\\": \\\"b\\\"})\\n self.assertEqual(mdict, ret)\",\n \"def varcopy(self, vars):\",\n \"def merge(self, new_attributes):\\n for k, v in new_attributes.items():\\n setattr(self, k, v)\",\n \"def testCopyCollection(self):\\n copy = self.node.copy_collection()\\n\\n self.assertEqual(\\n self.node.type,\\n copy.type\\n )\\n\\n self.assertEqual(\\n self.node.desc,\\n copy.desc\\n )\\n\\n self.assertEqual(\\n self.node.input_desc,\\n copy.input_desc\\n )\\n\\n self.assertEqual(\\n self.node.viewing_desc,\\n copy.viewing_desc\\n )\\n\\n self.assertEqual(\\n self.node.all_children,\\n copy.all_children\\n )\",\n \"def copy():\\n copy2(per, per_old)\",\n \"def merge_object(self, obj):\\n for key, value in obj.lines.items():\\n if key not in self.lines:\\n self.lines[key] = value\\n self.lines[key] = self.lines[key] + value\",\n \"def flatten_others(self, obj, many, **kwargs):\\r\\n for k, v in obj['others'].items():\\r\\n obj[k] = v\\r\\n obj.pop('others')\\r\\n return obj\",\n \"def combine(self, other) -> None:\\n assert self.id_ == other.id_\\n assert self.type_ == other.type_\\n self.count += other.count\",\n \"def test_addingnewattributes(self):\\n b1 = BaseModel()\\n b1.name = \\\"Holberton\\\"\\n b1.my_number = 89\\n dictionary = b1.to_dict()\\n self.assertEqual('name' in dictionary, True)\\n self.assertEqual('my_number' in dictionary, True)\\n b2 = BaseModel()\\n dictionary2 = b2.to_dict()\\n self.assertEqual('name' in dictionary2, False)\\n self.assertEqual('my_number' in dictionary2, False)\",\n \"def test__ActivityParty__copy_with__0():\\n party_id = 'plain'\\n size = 6\\n max_ = 12\\n \\n field = ActivityParty(\\n party_id = party_id,\\n size = size,\\n max_ = max_,\\n )\\n copy = field.copy_with()\\n _assert_fields_set(copy)\\n vampytest.assert_is_not(field, copy)\\n \\n vampytest.assert_eq(field, copy)\",\n \"def test_copy(dset):\\n dset_new = copy.deepcopy(dset)\\n\\n for field_name, field in dset._fields.items():\\n print(f\\\"Testing {field_name}\\\")\\n try:\\n if field.data.dtype.type is np.str_:\\n assert np.char.equal(field.data, dset_new._fields[field_name].data).all()\\n else:\\n assert np.equal(field.data, dset_new._fields[field_name].data).all()\\n except AttributeError:\\n for group_field_name, group_field in field.data._fields.items():\\n if group_field.data.dtype.type is np.str_:\\n assert np.char.equal(\\n group_field.data, dset_new._fields[field_name].data._fields[group_field_name].data\\n ).all()\\n else:\\n assert np.equal(\\n group_field.data, dset_new._fields[field_name].data._fields[group_field_name].data\\n ).all()\",\n \"def copy_doclist(doclist, no_copy = []):\\n\\n\\tcl = []\\n\\n\\t# main doc\\n\\tc = Document(fielddata = doclist[0].fields.copy())\\n\\n\\t# clear no_copy fields\\n\\tfor f in no_copy:\\n\\t\\tif c.fields.has_key(f):\\n\\t\\t\\tc.fields[f] = None\\n\\n\\tc.name = None\\n\\tc.save(1)\\n\\tcl.append(c)\\n\\n\\t# new parent name\\n\\tparent = c.name\\n\\n\\t# children\\n\\tfor d in doclist[1:]:\\n\\t\\tc = Document(fielddata = d.fields.copy())\\n\\t\\tc.name = None\\n\\n\\t\\t# clear no_copy fields\\n\\t\\tfor f in no_copy:\\n\\t\\t\\tif c.fields.has_key(f):\\n\\t\\t\\t\\tc.fields[f] = None\\n\\n\\t\\tc.parent = parent\\n\\t\\tc.save(1)\\n\\t\\tcl.append(c)\\n\\n\\treturn cl\",\n \"def test_copy(self):\\n\\n # Copy the 'orig' data pipe to the 'new' data pipe.\\n pipes.copy('orig', 'new')\\n\\n # Test that the new data pipe exists.\\n self.assert_('new' in ds)\\n\\n # Test that the new data pipe has the object 'x' and that its value is 1.\\n self.assertEqual(ds['new'].x, 1)\\n\\n # Change the value of x.\\n ds['new'].x = 2\\n\\n # Test that the two values are different.\\n self.assert_(ds['orig'].x != ds['new'].x)\\n\\n # Test that the new data pipe has the object 'mol[0].res[0].spin[0].num' and that its value is 1.\\n self.assertEqual(ds['new'].mol[0].res[0].spin[0].num, 1)\\n\\n # Change the spin system number.\\n ds['new'].mol[0].res[0].spin[0].num = 2\\n\\n # Test that the original spin system number hasn't changed.\\n self.assertEqual(ds['orig'].mol[0].res[0].spin[0].num, 1)\",\n \"def merge(target, source):\\n for key, value in source.items():\\n if key not in target:\\n target[key] = value\\n elif type(target[key]) is dict:\\n if key in self.OVERRIDE_ON_EXTENDS:\\n target[key].update(value)\\n else:\\n merge(target[key], value)\\n elif type(target[key]) is list:\\n target[key] += value\\n return target\",\n \"def copy(self, rhs):\\n\\n\\t\\tself.name = rhs.name\\n\\t\\tself.file = rhs.file\\n\\n\\t\\tfor rem in rhs.remark:\\n\\t\\t\\tself.addRemark(rem)\\n\\n\\t\\tself.bk_tot = rhs.bk_tot\\n\\t\\tself.fa_rep = rhs.fa_rep\\n\\t\\tself.fa_atr = rhs.fa_atr\",\n \"def _copy_data_from(self, original):\\n raise NotImplementedError()\",\n \"def concatenate_data():\",\n \"def __duplicate_o2m_fields(self, duplicate):\\n fields = set()\\n\\n for f in self._meta.related_objects:\\n if f.one_to_many:\\n if any(\\n [\\n f.get_accessor_name() in self._clone_m2o_or_o2m_fields,\\n self._clone_excluded_m2o_or_o2m_fields\\n and f.get_accessor_name()\\n not in self._clone_excluded_m2o_or_o2m_fields,\\n ]\\n ):\\n fields.add(f)\\n\\n # Clone one to many fields\\n for field in fields:\\n for item in getattr(self, field.get_accessor_name()).all():\\n try:\\n item.make_clone(attrs={field.remote_field.name: duplicate})\\n except IntegrityError:\\n item.make_clone(\\n attrs={field.remote_field.name: duplicate}, sub_clone=True\\n )\\n\\n return duplicate\",\n \"def test__ActivityParty__copy():\\n party_id = 'plain'\\n size = 6\\n max_ = 12\\n \\n field = ActivityParty(\\n party_id = party_id,\\n size = size,\\n max_ = max_,\\n )\\n copy = field.copy()\\n _assert_fields_set(copy)\\n vampytest.assert_is_not(field, copy)\\n \\n vampytest.assert_eq(field, copy)\",\n \"def add_shallow_copy_of(self, child_to_add, merged=False):\\n\\n new_child = self.add_child(child_to_add.text)\\n\\n if merged:\\n new_child.instances.append({\\n 'hostname': child_to_add.host.hostname,\\n 'comments': child_to_add.comments,\\n 'tags': child_to_add.tags})\\n new_child.comments.update(child_to_add.comments)\\n new_child.tags.update(child_to_add.tags)\\n new_child.order_weight = child_to_add.order_weight\\n\\n return new_child\",\n \"def copy(self):\\n return super().copy()\",\n \"def copy(self):\\n copied = super().copy()\\n copied.anonymize()\\n return copied\",\n \"def transfer_missing_elements(target_dict, source_dict, transfer_type=None):\\r\\n\\r\\n if transfer_type is None:\\r\\n transfer_type = source_dict.get(\\\"_transfer_type_\\\", \\\"recursive\\\")\\r\\n\\r\\n for key_, val_ in source_dict.items():\\r\\n # print(key_,isinstance(val_, dict), val_)\\r\\n if isinstance(val_, dict):\\r\\n if key_ not in target_dict:\\r\\n target_dict[key_] = EasyDict()\\r\\n if transfer_type is None:\\r\\n transfer_type = val_.get(\\\"_transfer_type_\\\", \\\"recursive\\\")\\r\\n # print(\\\"*********** \\\",transfer_type)\\r\\n\\r\\n if transfer_type == \\\"recursive\\\":\\r\\n transfer_missing_elements(target_dict[key_], val_, transfer_type)\\r\\n elif transfer_type == \\\"update\\\":\\r\\n target_dict[key_].update(val_)\\r\\n elif transfer_type == \\\"overwrite\\\":\\r\\n target_dict[key_] = copy.deepcopy(source_dict[key_])\\r\\n # target_dict[key_] = val_\\r\\n\\r\\n elif key_ not in target_dict:\\r\\n target_dict[key_] = copy.deepcopy(source_dict[key_])\\r\\n # target_dict[key_] = val_\\r\\n # else :\\r\\n # target_dict[key_] = val_\\r\\n # target_dict[key_] = copy.deepcopy(source_dict[key_])\\r\\n\\r\\n\\r\\n # if isinstance(source_dict[key_],list) and isinstance(source_dict[key_][0],dict):\\r\\n # if key_ not in target_dict:\\r\\n # target_dict[key_] = []\\r\\n # for src_ in source_dict[key_]:\\r\\n # if not isinstance(src_,dict):\\r\\n # continue\\r\\n # match = False\\r\\n # for tar_ in target_dict[key_]:\\r\\n # # TODO make a list of bool with ID keys loaded from odb and check if any(matches):\\r\\n # if key_matches(\\\"pth_full\\\", src_, tar_) or key_matches(\\\"pth_alias\\\", src_, tar_) :\\r\\n # match = True\\r\\n # if not match:\\r\\n # temp = EasyDict()\\r\\n # target_dict[key_].append(temp)\\r\\n # transfer_missing_elements(temp, src_)\\r\",\n \"def mergeWith(self, newFL):\\n srcMods = self.srcMods\\n for levls, newLevls in ((self.levcs,newFL.levcs),(self.levis,newFL.levis)):\\n for listId, newLevl in newLevls.items():\\n if listId not in srcMods: \\n srcMods[listId] = [newFL.fileInfo.name]\\n levl = levls[listId] = copy.deepcopy(newLevl)\\n self.records.append(levl)\\n else:\\n srcMods[listId].append(newFL.fileInfo.name)\\n levls[listId].mergeWith(newLevl)\",\n \"def add(self, other):\\n\\n def merge_dicts(d1, d2):\\n \\\"\\\"\\\"\\n Merge two dictionaries\\n\\n param d1: dictionary changed in place to have combined values\\n type d1: dictionary(key -> set)\\n param d2: dictioanry to be merged\\n type d2: dictionary(key -> set)\\n \\\"\\\"\\\"\\n for key,value in d2.items():\\n if key not in d1:\\n d1[key] = value\\n else:\\n d1[key] |= value\\n \\n self.num_documents += other.num_documents\\n self.num_expressions += other.num_expressions\\n self.global_expressions += other.global_expressions\\n self.expressions_with_e += other.expressions_with_e\\n self.num_keywords += other.num_keywords\\n merge_dicts(self.missing_tags, other.missing_tags)\\n merge_dicts(self.problem_files, other.problem_files)\",\n \"def extend(self, other_rollout):\\n\\n assert not self.is_terminal()\\n assert all(k in other_rollout.fields for k in self.fields)\\n for k, v in other_rollout.data.items():\\n self.data[k].extend(v)\\n self.last_r = other_rollout.last_r\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60299045","0.5626615","0.55989486","0.55208635","0.54832995","0.54745245","0.5468035","0.54594445","0.5416989","0.54133993","0.53944564","0.5360663","0.5277778","0.5271018","0.52541333","0.5244835","0.5185914","0.518226","0.5180149","0.51750094","0.5171218","0.5156771","0.5155819","0.51528907","0.5145961","0.5141367","0.51112574","0.51023513","0.50964636","0.5067921","0.5064287","0.505925","0.5057087","0.5055498","0.50506383","0.50484616","0.5046127","0.5044431","0.50399566","0.50249225","0.5022714","0.5017102","0.5014292","0.50117606","0.5003421","0.50026613","0.49966183","0.49893728","0.49813414","0.49805868","0.49730048","0.4970015","0.49678364","0.49635708","0.4960009","0.4958939","0.49501386","0.49419808","0.49388835","0.49311534","0.49293113","0.4928486","0.49264878","0.49242815","0.4921829","0.49175835","0.49108863","0.48965535","0.4896271","0.4890504","0.48883256","0.4886281","0.4872201","0.48690856","0.4867692","0.48665535","0.48660877","0.4858043","0.48436648","0.48419997","0.4839987","0.48382923","0.48313022","0.48279047","0.48185426","0.48178884","0.4813285","0.48069173","0.48068625","0.4805273","0.4800627","0.47968727","0.47960165","0.47928083","0.47907597","0.47903785","0.4789817","0.47898117","0.4788695","0.47845078"],"string":"[\n \"0.60299045\",\n \"0.5626615\",\n \"0.55989486\",\n \"0.55208635\",\n \"0.54832995\",\n \"0.54745245\",\n \"0.5468035\",\n \"0.54594445\",\n \"0.5416989\",\n \"0.54133993\",\n \"0.53944564\",\n \"0.5360663\",\n \"0.5277778\",\n \"0.5271018\",\n \"0.52541333\",\n \"0.5244835\",\n \"0.5185914\",\n \"0.518226\",\n \"0.5180149\",\n \"0.51750094\",\n \"0.5171218\",\n \"0.5156771\",\n \"0.5155819\",\n \"0.51528907\",\n \"0.5145961\",\n \"0.5141367\",\n \"0.51112574\",\n \"0.51023513\",\n \"0.50964636\",\n \"0.5067921\",\n \"0.5064287\",\n \"0.505925\",\n \"0.5057087\",\n \"0.5055498\",\n \"0.50506383\",\n \"0.50484616\",\n \"0.5046127\",\n \"0.5044431\",\n \"0.50399566\",\n \"0.50249225\",\n \"0.5022714\",\n \"0.5017102\",\n \"0.5014292\",\n \"0.50117606\",\n \"0.5003421\",\n \"0.50026613\",\n \"0.49966183\",\n \"0.49893728\",\n \"0.49813414\",\n \"0.49805868\",\n \"0.49730048\",\n \"0.4970015\",\n \"0.49678364\",\n \"0.49635708\",\n \"0.4960009\",\n \"0.4958939\",\n \"0.49501386\",\n \"0.49419808\",\n \"0.49388835\",\n \"0.49311534\",\n \"0.49293113\",\n \"0.4928486\",\n \"0.49264878\",\n \"0.49242815\",\n \"0.4921829\",\n \"0.49175835\",\n \"0.49108863\",\n \"0.48965535\",\n \"0.4896271\",\n \"0.4890504\",\n \"0.48883256\",\n \"0.4886281\",\n \"0.4872201\",\n \"0.48690856\",\n \"0.4867692\",\n \"0.48665535\",\n \"0.48660877\",\n \"0.4858043\",\n \"0.48436648\",\n \"0.48419997\",\n \"0.4839987\",\n \"0.48382923\",\n \"0.48313022\",\n \"0.48279047\",\n \"0.48185426\",\n \"0.48178884\",\n \"0.4813285\",\n \"0.48069173\",\n \"0.48068625\",\n \"0.4805273\",\n \"0.4800627\",\n \"0.47968727\",\n \"0.47960165\",\n \"0.47928083\",\n \"0.47907597\",\n \"0.47903785\",\n \"0.4789817\",\n \"0.47898117\",\n \"0.4788695\",\n \"0.47845078\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7400884"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":199,"cells":{"query":{"kind":"string","value":"make a new struct with ncutoutsizedarrays based on the actual maximum ncutout"},"document":{"kind":"string","value":"def _make_resized_data(self, odata):\n\n\n nmax = odata['file_id'].shape[1]\n new_nmax = odata['ncutout'].max()\n if new_nmax < 2:\n new_nmax = 2\n temp_obj_data = odata\n\n nobj = temp_obj_data.size\n\n new_data = meds.util.get_meds_output_struct(\n nobj,\n new_nmax,\n extra_fields=self._get_fields(new_nmax),\n )\n new_data = self._add_cat_fields(new_data, copy=False)\n\n for name in new_data.dtype.names:\n if name in temp_obj_data.dtype.names:\n\n shape = new_data[name].shape\n lshape = len(shape)\n\n if lshape > 1 and shape[1] == new_nmax:\n new_data[name][:,:] = temp_obj_data[name][:,0:new_nmax]\n else:\n new_data[name][:] = temp_obj_data[name][:]\n\n del temp_obj_data\n\n return new_data"},"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_maxcut_data_model():\n n = 5\n V = np.arange(0, n, 1)\n E = [(0, 1, 3.0), (1, 2, 2.0), (2, 3, 2.0), (3, 4, 3.0), (4, 0, 1.0), (0, 3, 3.0)]\n\n G = nx.Graph()\n G.add_nodes_from(V)\n G.add_weighted_edges_from(E)\n return G","def expanding_max_nb(a, minp=1):\n out = np.empty_like(a, dtype=np.float_)\n for col in range(a.shape[1]):\n out[:, col] = expanding_max_1d_nb(a[:, col], minp=minp)\n return out","def max_noutput_items(self) -> \"int\":\n return _beamforming_swig.phasedarray_sptr_max_noutput_items(self)","def get_bins(size, n, max_value):\n bin_lims = get_bin_lims(n, max_value)\n return sort_by_rows(np.array(list(itertools.product(bin_lims, repeat=size))))","def arrayManipulation_shortpeak(n, queries):\n a_s = []\n b_s = []\n k_s = []\n\n for i, row in enumerate(queries):\n a_s.append(row[0])\n b_s.append(row[1])\n k_s.append(row[2])\n\n # breakpoint()\n x = a_s + b_s\n all_indices = list(set(x))\n all_indices.sort()\n short_arr = [0] * len(all_indices)\n\n # mapping index of n-long array to index of shorter array\n index_lookup = {}\n for j, el in enumerate(all_indices):\n index_lookup[el] = j\n\n # breakpoint()\n for m in range(len(a_s)):\n short_arr[index_lookup[a_s[m]]] += k_s[m]\n short_arr[index_lookup[b_s[m]]] -= k_s[m]\n\n maxval = 0\n cumsum = 0\n for i, el in enumerate(short_arr):\n cumsum += el\n maxval = max(maxval, cumsum)\n\n print(f'{maxval: <15,d}: Max value')\n arr_size = short_arr.__sizeof__() / 1000000\n total = ((a_s.__sizeof__() / 1000000)\n + b_s.__sizeof__() / 1000000\n + k_s.__sizeof__() / 1000000\n + queries.__sizeof__() / 1000000\n + index_lookup.__sizeof__() / 1000000\n + short_arr.__sizeof__() / 1000000)\n print(f'{total: <15.2f}: All objects size(MB)')\n print(f'{arr_size: <15.2f}: Array size(MB)')\n return maxval, arr_size","def process_lim(pool_lim, area):\n\n pool_nolim = [] # No limitation\n pool_lim_n = [] # N limitation\n pool_lim_p = [] # P limitation\n # Colimitation driven by N (When the realized NPP allocation is smaller\n # thant the potential due to N but the other element is also limitant)\n pool_colim_n = []\n # Colimitation driven by P (When the realized NPP allocation is smaller\n # than the potential due to P but the other element is also limitant\n pool_colim_p = []\n # Real Colimitation = K <= 1D-6 (K is difference between P and N realized NPP allocation)\n pool_colim_np = []\n\n ndays = pool_lim.shape[1]\n npls = pool_lim.shape[0]\n\n for pls in range(npls):\n if area[pls]:\n no_lim = (pool_lim[pls, :] == 0).sum() / ndays * area[pls]\n lim_n = (np.count_nonzero(\n pool_lim[pls, :] == 1) / ndays) * area[pls]\n lim_p = (np.count_nonzero(\n pool_lim[pls, :] == 2) / ndays) * area[pls]\n colim_n = (np.count_nonzero(\n pool_lim[pls, :] == 4) / ndays) * area[pls]\n colim_p = (np.count_nonzero(\n pool_lim[pls, :] == 5) / ndays) * area[pls]\n colim_np = (np.count_nonzero(\n pool_lim[pls, :] == 6) / ndays) * area[pls]\n\n pool_nolim.append(no_lim)\n pool_lim_n.append(lim_n)\n pool_lim_p.append(lim_p)\n pool_colim_n.append(colim_n)\n pool_colim_p.append(colim_p)\n pool_colim_np.append(colim_np)\n\n return (np.sum(pool_nolim),\n np.sum(pool_lim_n),\n np.sum(pool_lim_p),\n np.sum(pool_colim_n),\n np.sum(pool_colim_p),\n np.sum(pool_colim_np))","def max_pooling(img):\n result_img = img.copy()\n heignt, width, _ = result_img.shape\n for h in range(0, heignt, 8):\n for w in range(0, width, 8):\n result_img[h:h+8, w:w+8, 0] = np.max(result_img[h:h+8, w:w+8, 0])\n result_img[h:h+8, w:w+8, 1] = np.max(result_img[h:h+8, w:w+8, 1])\n result_img[h:h+8, w:w+8, 2] = np.max(result_img[h:h+8, w:w+8, 2])\n result_img[(heignt//8)*8:heignt, :, :] = 0\n result_img[:, (width//8)*8:width, :] = 0\n return result_img","def create_array( n ):","def max_noutput_items(self):\n return _spacegrant_swig.invert_bit_sptr_max_noutput_items(self)","def expanding_max_1d_nb(a, minp=1):\n out = np.empty_like(a, dtype=np.float_)\n maxv = a[0]\n cnt = 0\n for i in range(a.shape[0]):\n if np.isnan(maxv) or a[i] > maxv:\n maxv = a[i]\n if ~np.isnan(a[i]):\n cnt += 1\n if cnt < minp:\n out[i] = np.nan\n else:\n out[i] = maxv\n return out","def max_noutput_items(self) -> \"int\":\n return _beamforming_swig.randomsampler_sptr_max_noutput_items(self)","def cut(self, max_lenght):\n self.V_estimates = self.V_estimates[:max_lenght]\n super().cut(max_lenght)","def get_max_combination(total_cuts):\n max_pieces = 0\n for i in range(total_cuts):\n result = i * (total_cuts - i)\n if result > max_pieces:\n max_pieces = result\n print(max_pieces)","def _get_max_sampled_bandit(self)->Bandit:\n estimates = []\n for bandit in self.bandits:\n Qth = np.random.normal(loc =self.mu[bandit.id], scale = self.var[bandit.id])\n f_hat = self.mu[bandit.id]#computing moving_average here \n estimates.append(max(Qth, f_hat))\n return self.bandits[np.argmax(estimates)]","def set_max_noutput_items(self, m: \"int\") -> \"void\":\n return _beamforming_swig.phasedarray_sptr_set_max_noutput_items(self, m)","def __init__(self, maxlen, dtype):\n self._start_index = np.int64(0)\n self._len = np.int64(0)\n self._maxlen = np.array(maxlen)\n initial_len = 10 if np.isinf(self._maxlen) else self._maxlen\n self._buffer = np.zeros(shape=(initial_len,), dtype=dtype)","def _get_optimal_threshold(arr, num_bins=1001, num_quantized_bins=255):\n if not isinstance(arr, np.ndarray):\n raise TypeError('get_optimal_threshold only supports input type of np.ndarray,'\n ' while received type=%s' % (str(type(arr))))\n min_val = np.min(arr)\n max_val = np.max(arr)\n th = max(abs(min_val), abs(max_val))\n\n hist, hist_edges = np.histogram(arr, bins=num_bins, range=(-th, th))\n zero_bin_idx = num_bins // 2\n num_half_quantized_bins = num_quantized_bins // 2\n assert np.allclose(hist_edges[zero_bin_idx] + hist_edges[zero_bin_idx + 1],\n 0, rtol=1e-5, atol=1e-7)\n\n thresholds = np.zeros(num_bins // 2 + 1 - num_quantized_bins // 2)\n divergence = np.zeros_like(thresholds)\n quantized_bins = np.zeros(num_quantized_bins, dtype=np.int32)\n # i means the number of bins on half axis excluding the zero bin.\n for i in range(num_quantized_bins // 2,\n num_bins // 2 + 1):\n p_bin_idx_start = zero_bin_idx - i\n p_bin_idx_stop = zero_bin_idx + i + 1\n thresholds[i - num_half_quantized_bins] = hist_edges[p_bin_idx_stop]\n sliced_nd_hist = hist[p_bin_idx_start:p_bin_idx_stop]\n\n # generate reference distribution p\n p = sliced_nd_hist.copy()\n assert p.size % 2 == 1\n assert p.size >= num_quantized_bins\n # put left outlier count in p[0]\n left_outlier_count = np.sum(hist[0:p_bin_idx_start])\n p[0] += left_outlier_count\n # put right outlier count in p[-1]\n right_outlier_count = np.sum(hist[p_bin_idx_stop:])\n p[-1] += right_outlier_count\n # is_nonzeros[k] indicates whether hist[k] is nonzero\n is_nonzeros = (sliced_nd_hist != 0).astype(np.int32)\n\n # calculate how many bins should be merged to generate quantized distribution q\n num_merged_bins = p.size // num_quantized_bins\n # merge hist into num_quantized_bins bins\n for j in range(num_quantized_bins):\n start = j * num_merged_bins\n stop = start + num_merged_bins\n quantized_bins[j] = sliced_nd_hist[start:stop].sum()\n quantized_bins[-1] += sliced_nd_hist[num_quantized_bins * num_merged_bins:].sum()\n # expand quantized_bins into p.size bins\n q = np.zeros(p.size, dtype=np.float32)\n for j in range(num_quantized_bins):\n start = j * num_merged_bins\n if j == num_quantized_bins - 1:\n stop = -1\n else:\n stop = start + num_merged_bins\n norm = is_nonzeros[start:stop].sum()\n if norm != 0:\n q[start:stop] = float(quantized_bins[j]) / float(norm)\n q[sliced_nd_hist == 0] = 0\n p = _smooth_distribution(p)\n # There is a chance that q is an invalid probability distribution.\n try:\n q = _smooth_distribution(q)\n except ValueError:\n divergence[i - num_half_quantized_bins] = float(\"inf\")\n else:\n divergence[i - num_half_quantized_bins] = stats.entropy(p, q)\n quantized_bins[:] = 0\n\n min_divergence_idx = np.argmin(divergence)\n min_divergence = divergence[min_divergence_idx]\n opt_th = thresholds[min_divergence_idx]\n return min_val, max_val, min_divergence, opt_th","def max_noutput_items(self):\n return _spacegrant_swig.general_burster_2_sptr_max_noutput_items(self)","def test_compute_c_max_output():\n # build\n T = np.array([600, 500])\n E_ion = np.array([20, 10])\n E_atom = np.array([30, 40])\n angles_ion = np.array([60, 60])\n angles_atom = np.array([60, 60])\n ion_flux = np.array([1e21, 1e20])\n atom_flux = np.array([2e21, 2e20])\n\n # run\n output = divHretention.compute_c_max(\n T, E_ion, E_atom, angles_ion, angles_atom,\n ion_flux, atom_flux, full_export=True)\n\n # test\n assert len(output) == 3\n\n # run\n output = divHretention.compute_c_max(\n T, E_ion, E_atom, angles_ion, angles_atom,\n ion_flux, atom_flux, full_export=False)\n\n # test\n assert len(output) == 2","def max_cut(g):\n # Write your code here.\n return []","def max_pool2d(input, kernel_size, stride=1, padding=0, ceil_mode=False):\n return _pool('MAX', utils._pair, **locals())","def max_pool3d(input, kernel_size, stride=1, padding=0, ceil_mode=False):\n return _pool('MAX', utils._triple, **locals())","def create_new_targets(window, data):\n new_data = np.apply_along_axis(lambda x: np.bincount(x).argmax(), axis=1, arr=(rolling_window(data.astype(int), 0, window)))\n\n return new_data","def maxpool(input, filter_h, filter_w, stride_h, stride_w, padding, name):\n with tf.name_scope(name):\n mp = tf.nn.max_pool(input, ksize=[1, filter_h, filter_w, 1], strides=[1, stride_h, stride_w, 1],\n padding=padding)\n # print(name + \" : \", str(mp.shape))\n return mp","def _get_max_estimated_bandit(self)->Bandit:\n # print(\"mus - \", self.mu)\n # print(\"actions - \", np.argmax(self.mu))\n unique, counts = np.unique(self.mu, return_counts=True)\n lens = counts[np.argmax(unique)] \n if lens>1: # if two actions have same argmax\n # then return arbitrarily from those max ones\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\n return np.random.choice(maxs)\n # otherwise return the max one\n return self.bandits[np.argmax(self.mu)]","def max_noutput_items(self):\n return _add_vector_swig.add_vector_2_cpp_sptr_max_noutput_items(self)","def max_pool1d(input, kernel_size, stride=1, padding=0, ceil_mode=False):\n return _pool('MAX', utils._single, **locals())","def _resize(self, maxval):\n assert maxval >= self._N\n temp = [None for i in range(maxval)] # (Item[]) new [maxval] # Item[]\n q_len = len(self._q)\n for i in range(self._N):\n temp[i] = self._q[(self._first + i) % q_len]\n self._q = temp\n self._first = 0\n self._last = self._N","def create_split_bounds(N, train_pct):\n train_len = int(round(train_pct * N))\n if ((N - train_len) % 2) != 0:\n train_len += 1\n\n # NOTE: We're assume the dev and test set are equal in length.\n test_len = dev_len = int((N - train_len) / 2)\n\n assert \"Not all data points are being used. Check create_split_bounds()\", \\\n (train_len + test_len + dev_len) == N\n\n return train_len, dev_len, test_len","def non_max_suppression(inputs, n_classes, max_output_size, iou_threshold, confidence_threshold):\n batch = tf.unstack(inputs)\n boxes_dicts = []\n\n for boxes in batch:\n boxes = tf.boolean_mask(boxes, boxes[:, 4] > confidence_threshold)\n classes = tf.argmax(boxes[:, 5:], axis=-1)\n classes = tf.expand_dims(tf.cast(classes, tf.float32), axis=-1)\n boxes = tf.concat([boxes[:, :5], classes], axis=-1)\n\n boxes_dict = dict()\n for cls in range(n_classes):\n mask = tf.equal(boxes[:, 5], cls)\n mask_shape = mask.get_shape()\n if mask_shape.ndims != 0:\n class_boxes = tf.boolean_mask(boxes, mask)\n boxes_coords, boxes_conf_scores, _ = tf.split(class_boxes, [4, 1, -1], axis=-1)\n boxes_conf_scores = tf.reshape(boxes_conf_scores, [-1])\n indices = tf.image.non_max_suppression(boxes_coords,\n boxes_conf_scores,\n max_output_size,\n iou_threshold)\n class_boxes = tf.gather(class_boxes, indices)\n boxes_dict[cls] = class_boxes[:, :5]\n\n boxes_dicts.append(boxes_dict)\n return boxes_dicts","def adaptive_max_pool3d(input, output_size):\n args = utils._get_adaptive_pool_args(\n input.size()[-3:], utils._triple(output_size))\n return _pool('MAX', utils._triple, input, **args)","def pick_largest(self, cut_off):\r\n for i in range(self.dimension):\r\n m = self.masked[int(self.rank_yx(self.rank[i])[0]) # locating the corresponding mark array\r\n ,int(self.rank_yx(self.rank[i])[1])]\r\n if m * self.image_data[i] == self.image_data[i]:\r\n if self.image_data[i] <= cut_off:\r\n print(\"Surveying completed\")\r\n return -1,-1 # returns -1,-1 if scan is completed\r\n else:\r\n return self.image_data[i], np.array(self.rank[i])","def __len__(self):\n return max(self.A_size, self.B50_size, self.B100_size, self.B150_size)","def slice_sample_bounded_max(N, burn, logdist, xx, widths, step_out, max_attempts, bounds):\n xx = copy.deepcopy(xx)\n D = len(xx)\n samples = []\n if (not isinstance(widths, list)) or len(widths) == 1:\n widths = np.ones(D) * widths\n\n log_Px = logdist(xx)\n\n for ii in range(N + burn):\n log_uprime = np.log(random.random()) + log_Px\n for dd in random.sample(range(D), D):\n x_l = copy.deepcopy(xx)\n x_r = copy.deepcopy(xx)\n xprime = copy.deepcopy(xx)\n\n # Create a horizontal interval (x_l, x_r) enclosing xx\n rr = random.random()\n x_l[dd] = max(xx[dd] - rr*widths[dd], bounds[dd][0])\n x_r[dd] = min(xx[dd] + (1-rr)*widths[dd], bounds[dd][1])\n\n if step_out:\n while logdist(x_l) > log_uprime and x_l[dd] > bounds[dd][0]:\n\n x_l[dd] = max(x_l[dd] - widths[dd], bounds[dd][0])\n while logdist(x_r) > log_uprime and x_r[dd] < bounds[dd][1]:\n x_r[dd] = min(x_r[dd] + widths[dd], bounds[dd][1])\n\n # Propose xprimes and shrink interval until good one found\n zz = 0\n num_attempts = 0\n while True:\n zz += 1\n # print(x_l)\n xprime[dd] = random.random()*(x_r[dd] - x_l[dd]) + x_l[dd]\n \n log_Px = logdist(xx)\n if log_Px > log_uprime:\n xx[dd] = xprime[dd]\n break\n else:\n # Shrink in\n num_attempts += 1\n if num_attempts >= max_attempts:\n # print('Failed to find something')\n break\n elif xprime[dd] > xx[dd]:\n x_r[dd] = xprime[dd]\n elif xprime[dd] < xx[dd]:\n x_l[dd] = xprime[dd]\n else:\n raise Exception('Slice sampling failed to find an acceptable point')\n # Record samples\n if ii >= burn:\n samples.append(copy.deepcopy(xx))\n return samples","def max_noutput_items(self) -> \"int\":\n return _beamforming_swig.beamformer_sptr_max_noutput_items(self)","def max_noutput_items(self):\n return _TestA_swig.my_qpsk_demod_cb_sptr_max_noutput_items(self)","def max_pool(inputs):\n return tf.layers.max_pooling2d(\n inputs,\n pool_size=[2, 2],\n strides=[2, 2],\n padding='same',\n )","def set_max_noutput_items(self, m):\n return _spacegrant_swig.general_burster_2_sptr_set_max_noutput_items(self, m)","def create_max_pool(x):\n return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')","def max_noutput_items(self):\n return _TestA_swig.cleanslate_sptr_max_noutput_items(self)","def over_classification_filter(self, in_metadata, max_classes=30):\n print('size before:', len(in_metadata))\n out_metadata = {}\n for img_id, img_dict in in_metadata.iteritems():\n if img_dict['n_labels'] <= max_classes:\n out_metadata[img_id] = img_dict\n\n print('size after:', len(out_metadata))\n return out_metadata","def set_max_noutput_items(self, m):\n return _spacegrant_swig.invert_bit_sptr_set_max_noutput_items(self, m)","def set_max_noutput_items(self, m):\n return _add_vector_swig.add_vector_2_cpp_sptr_set_max_noutput_items(self, m)","def build_convpool_max(input_vars, nb_classes, imsize=32, n_colors=3, n_timewin=3):\n convnets = []\n w_init = None\n # Build 7 parallel CNNs with shared weights\n for i in range(n_timewin):\n if i == 0:\n convnet, w_init = build_cnn(input_vars[i], imsize=imsize, n_colors=n_colors)\n else:\n convnet, _ = build_cnn(input_vars[i], w_init=w_init, imsize=imsize, n_colors=n_colors)\n convnets.append(convnet)\n # convpooling using Max pooling over frames\n convpool = ElemwiseMergeLayer(convnets, theano.tensor.maximum)\n # A fully-connected layer of 512 units with 50% dropout on its inputs:\n convpool = DenseLayer(lasagne.layers.dropout(convpool, p=.5),\n num_units=512, nonlinearity=lasagne.nonlinearities.rectify)\n # And, finally, the output layer with 50% dropout on its inputs:\n convpool = lasagne.layers.DenseLayer(lasagne.layers.dropout(convpool, p=.5),\n num_units=nb_classes, nonlinearity=lasagne.nonlinearities.softmax)\n return convpool","def max_pool(inputs, window_shape, strides=None, padding=\"VALID\"):\n y = pool(inputs, -jnp.inf, lax.max, window_shape, strides, padding)\n return y","def __cut_arrays(data_array, maximum_time, arrays_to_cut):\n\n try:\n begin_time = data_array[arrays_to_cut[0]][0][0]\n end_time = data_array[arrays_to_cut[0]][0][-1]\n delta_time = (\n data_array[arrays_to_cut[0]][0][1]\n - data_array[arrays_to_cut[0]][0][0]\n )\n total_time = end_time - begin_time\n if total_time > maximum_time:\n over_time = total_time - maximum_time\n array_elm_to_drop = int(over_time / delta_time)\n for arrays in arrays_to_cut:\n data_array[arrays][0] = data_array[arrays][0][\n array_elm_to_drop:\n ]\n data_array[arrays][1] = data_array[arrays][1][\n array_elm_to_drop:\n ]\n except:\n pass","def _infer_dimension_(spectrum, n_samples, n_features):\n n_spectrum = len(spectrum)\n ll = np.empty(n_spectrum)\n for rank in range(n_spectrum):\n ll[rank] = _assess_dimension_(spectrum, rank, n_samples, n_features)\n return ll.argmax()","def look_for_biggest_structure(game, chunk, imgs, hmap, nmax, type_):\n for n in range(nmax,0,-1):\n i = 0\n m = parameters.MAX_VILLAGE_WIDTH * n / parameters.MAX_VILLAGE_SIZE\n while i < parameters.VILLAGE_TRY:\n chunkpos = np.random.randint(0,parameters.S,2)\n cx,cy = chunkpos\n h = np.sum(hmap[cx:cx+m,cy:cy+m]) / (m*m)\n if h > parameters.VILLAGE_LEVEL:\n force_build_structure(game, imgs, chunk, chunkpos, n, type_)\n return n\n i += 1\n return 0","def _max_pool(x):\n return tf.nn.max_pool(value=x,\n ksize=[1, 2, 2, 1],\n strides=[1, 2, 2, 1],\n padding='SAME')","def max_noutput_items(self) -> \"int\":\n return _beamforming_swig.doaesprit_sptr_max_noutput_items(self)","def filter_halo_pnum(data, Ncut=1000):\n npart = np.array(data['np'][0])\n ind =np.where(npart > Ncut)[0]\n print(\"# of halos:\",len(ind))\n return ind","def max_noutput_items(self):\n return _spacegrant_swig.NRZI_sptr_max_noutput_items(self)","def margin_sampling(predictions, number):\n maxes = []\n maxesBis = []\n tmp = []\n for i in range(0, predictions.shape[0]):\n maxes.append(np.max(predictions[i]))\n tmp.append(np.delete(predictions[i], np.where(predictions[i] == np.max(predictions[i]))[0]))\n maxesBis.append(np.max(tmp[i]))\n\n val = np.array(maxes) - np.array(maxesBis)\n\n return __get_min_indexes(val, number)","def cutout(a):\n x = np.arange(a.shape[0])\n c = a.shape[0] / 2\n\n if len(a.shape) == 2:\n x = x.reshape(-1, 1)\n y = x.reshape(1, -1)\n zero = ((x-c)**2 + (y-c)**2) < c**2\n elif len(a.shape) == 3:\n x = x.reshape(-1, 1, 1)\n y = x.reshape(1, -1, 1)\n z = x.reshape(1, -1, 1)\n zero = ((x-c)**2 + (y-c)**2 + (z-c)**2) < c**2\n else:\n raise ValueError(\"Cutout array must have dimension 2 or 3!\")\n a *= zero\n return a","def __init__(self, maxSize=3):\r\n try:\r\n if maxSize % 2 == 1 and maxSize >= 3:\r\n self._maxSize = maxSize\r\n else:\r\n raise ValueError(\"maxSize must be an odd integer >= 3\")\r\n except ValueError:\r\n raise\r\n self._data = np.ndarray(0)","def get_arraymax_section_data(key_list, max_size=1300000000):\n result_list = []\n data_key_list = DATA_BLOCK_SPEC.keys()\n for key in key_list:\n if key in data_key_list:\n result_list.append(max_size)\n else:\n result_list.append(0)\n return np.array(result_list)","def cov_seg_max(n, L):\n n_seg = 1\n while int(n) > n_seg:\n n_seg += 1\n return int(L/n_seg) # Samples within one segment ","def get_num_bins(train_input: np.array, max_splits: int) -> List[int]:\n num_bins = [2 for _ in train_input[0]]\n max_bins = [len(set(column)) for column in train_input.T]\n entropies = [ExamDropExtractor.__entropy(np.expand_dims(column, axis = 1), 2) for column in train_input.T]\n options = PriorityQueue()\n\n for i, data in enumerate(train_input.T):\n if max_bins[i] > 2:\n data = np.expand_dims(data, axis = 1)\n new_entropy = ExamDropExtractor.__entropy(data, 3)\n options.put((-(new_entropy - entropies[i]), i))\n\n for _ in range(max_splits):\n if options.empty():\n break\n\n entropy, i = options.get()\n num_bins[i] = num_bins[i] + 1\n entropies[i] = entropies[i] - entropy\n if num_bins[i] != max_bins[i]:\n data = np.expand_dims(train_input[:, i], axis = 1)\n new_entropy = ExamDropExtractor.__entropy(data, num_bins[i] + 1)\n options.put((-(new_entropy - entropies[i]), i))\n\n return num_bins","def max_noutput_items(self):\n return _spacegrant_swig.DeNRZI_sptr_max_noutput_items(self)","def __reduce__(self):\n return ImageNetDownsample, (self.cutout,)","def rolling_max_nb(a, window, minp=None):\n out = np.empty_like(a, dtype=np.float_)\n for col in range(a.shape[1]):\n out[:, col] = rolling_max_1d_nb(a[:, col], window, minp=minp)\n return out","def max_noutput_items(self):\n return _spacegrant_swig.G3RUH_descramble_sptr_max_noutput_items(self)","def set_max_noutput_items(self, *args, **kwargs):\n return _TestA_swig.my_qpsk_demod_cb_sptr_set_max_noutput_items(self, *args, **kwargs)","def __init__(self, size=(2, 2), **kwargs):\n super(MaxUnpooling2D, self).__init__(**kwargs)\n self.size = size","def min_noutput_items(self) -> \"int\":\n return _beamforming_swig.phasedarray_sptr_min_noutput_items(self)","def max_noutput_items(self):\n return _spacegrant_swig.binary_sink_sptr_max_noutput_items(self)","def set_max_noutput_items(self, m):\n return _spacegrant_swig.binary_sink_sptr_set_max_noutput_items(self, m)","def _get_max_sampled_bandit(self)->Bandit:\n estimates = []\n for bandit in self.bandits:\n estimates.append(np.random.normal(loc =self.mu[bandit.id], scale = self.var[bandit.id]))\n return self.bandits[np.argmax(estimates)]","def post_processing(conf_thresh, nms_thresh, output):\n # anchors = [12, 16, 19, 36, 40, 28, 36, 75, 76, 55, 72, 146, 142, 110, 192, 243, 459, 401]\n # num_anchors = 9\n # anchor_masks = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]\n # strides = [8, 16, 32]\n # anchor_step = len(anchors) // num_anchors\n\n # [batch, num, 1, 4]\n box_array = output[0]\n # [batch, num, num_classes]\n confs = output[1]\n\n if type(box_array).__name__ != \"ndarray\":\n box_array = box_array.cpu().detach().numpy()\n confs = confs.cpu().detach().numpy()\n\n num_classes = confs.shape[2]\n\n # [batch, num, 4]\n box_array = box_array[:, :, 0]\n\n # [batch, num, num_classes] --> [batch, num]\n max_conf = np.max(confs, axis=2)\n max_id = np.argmax(confs, axis=2)\n\n bboxes_batch = []\n for batch in range(box_array.shape[0]):\n\n argwhere = max_conf[batch] > conf_thresh\n l_box_array = box_array[batch, argwhere, :]\n l_max_conf = max_conf[batch, argwhere]\n l_max_id = max_id[batch, argwhere]\n\n bboxes = []\n # nms for each class\n for cls_id in range(num_classes):\n\n cls_argwhere = l_max_id == cls_id\n ll_box_array = l_box_array[cls_argwhere, :]\n ll_max_conf = l_max_conf[cls_argwhere]\n ll_max_id = l_max_id[cls_argwhere]\n\n keep = nms_cpu(ll_box_array, ll_max_conf, nms_thresh)\n\n if keep.size > 0:\n ll_box_array = ll_box_array[keep, :]\n ll_max_conf = ll_max_conf[keep]\n ll_max_id = ll_max_id[keep]\n\n for box in range(ll_box_array.shape[0]):\n bboxes.append(\n [\n ll_box_array[box, 0],\n ll_box_array[box, 1],\n ll_box_array[box, 2],\n ll_box_array[box, 3],\n ll_max_conf[box],\n ll_max_conf[box],\n ll_max_id[box],\n ]\n )\n\n bboxes_batch.append(bboxes)\n\n return bboxes_batch","def nanmax_nb(a):\n out = np.empty(a.shape[1], dtype=np.float_)\n for col in range(a.shape[1]):\n out[col] = np.nanmax(a[:, col])\n return out","def nmax2t(cls, n_max: int, oversampling: float = 10.) -> np.ndarray:\n critical_res = 4 * SHT.nmax2nside(n_max) - 1\n return np.linspace(-1, 1, np.ceil(oversampling * critical_res).astype(int))","def __init__(self, max_n):\n self._max_n = max_n\n self.__pq = [0] * (max_n + 1)\n self.__qp = [-1] * (max_n + 1)\n self.__keys = [None] * (max_n + 1)\n self.__n = 0","def adaptive_max_pool2d(input, output_size):\n args = utils._get_adaptive_pool_args(\n input.size()[-2:], utils._pair(output_size))\n return _pool('MAX', utils._pair, input, **args)","def set_max_noutput_items(self, m: \"int\") -> \"void\":\n return _beamforming_swig.randomsampler_sptr_set_max_noutput_items(self, m)","def max_pool_2x2(x):\n#{{{\n return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],\n strides=[1, 2, 2, 1], padding='SAME')","def contraction_max_algos():\n return cutensor.contractionMaxAlgos()","def max_output_buffer(self, i):\n return _spacegrant_swig.general_burster_2_sptr_max_output_buffer(self, i)","def __init__(self):\n self.counts = [0] * 10\n self.values = [0] * 10\n self.softmaxvalues = [0] * 10\n self.t = 0.3","def compute(self, node, input_vals):\r\n #start = time.time()\r\n\r\n #assert len(input_vals) == 1\r\n strides = node.const_attr[1]\r\n ksize = node.const_attr[0]\r\n ish = list(input_vals[0].shape)\r\n input = input_vals[0]\r\n output = np.zeros([ish[0],(ish[1]-ksize[1])//strides[1]+1,(ish[2]-ksize[2])//strides[2]+1,ish[3]])\r\n osh = output.shape\r\n #print(osh)\r\n for i in range(osh[1]):\r\n for j in range(osh[2]):\r\n output[:,i,j,:] = np.amax(input[:,i*strides[1]:(i+1)*strides[1],j*strides[1]:(j+1)*strides[1],:],axis=(1,2))\r\n #end = time.time() \r\n #print(\"max_pool\") \r\n #print(end - start) \r\n return output\r\n \r\n #assert False\r","def test_max_N_too_small(self):\n\t\t\n\t\t\n\t\tparams = DEFAULT_PARAMS.copy()\n\t\tparams[MAX_N] = DEFAULT_MAX_EVALS+1\n\t\t\n\t\titerator = self.watcher.make_layer_iterator(model=self.model, params=params)\n\t\tfor ww_layer in iterator:\n\t\t\tif ww_layer.N > params[MAX_N]:\n\t\t\t\tself.assertTrue(ww_layer.skipped)\n\t\t\n\t\tdetails = self.watcher.describe(max_N=DEFAULT_MAX_EVALS+1)\n\t\tprint(details[['N','M']])\n\t\tself.assertEqual(10,len(details))\n\n\t\treturn","def constraints_max_offer_per_cust(n_row, n_col):\n constraints = np.identity(n_row * n_col)\n return constraints","def non_maximum_suppression(prediction, iou_threshold=0.45, score_threshold=0.25):\n\n # num_classes = len(names)\n max_wh = 4096\n max_det = 300\n max_nms = 30000\n output = [torch.zeros((0, 6), device=prediction.device)] * prediction.shape[0]\n\n for xi, x in enumerate(prediction):\n x = x[x[..., 4] > score_threshold]\n\n # If none remain process next image\n if not x.shape[0]:\n continue\n\n # Compute conf\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\n\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\n box = x[:, :4]\n\n conf, j = x[:, 5:].max(1, keepdim=True)\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > score_threshold]\n\n # Filter by class\n # if classes is not None:\n # x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)]\n\n # Check shape\n n = x.shape[0] # number of boxes\n if not n: # no boxes\n continue\n elif n > max_nms: # excess boxes\n # sort by confidence\n x = x[x[:, 4].argsort(descending=True)[:max_nms]]\n\n # Batched NMS\n c = x[:, 5:6] * max_wh # classes\n # boxes (offset by class), scores\n boxes, scores = x[:, :4] + c, x[:, 4]\n i = nms(boxes, scores, iou_threshold) # NMS\n if i.shape[0] > max_det: # limit detections\n i = i[:max_det]\n\n output[xi] = x[i]\n\n return output","def max_noutput_items(self):\n return _spacegrant_swig.hdlc_deframer_sptr_max_noutput_items(self)","def set_max_noutput_items(self, m):\n return _spacegrant_swig.NRZI_sptr_set_max_noutput_items(self, m)","def set_max_noutput_items(self, m):\n return _spacegrant_swig.DeNRZI_sptr_set_max_noutput_items(self, m)","def set_max_noutput_items(self, m):\n return _spacegrant_swig.G3RUH_descramble_sptr_set_max_noutput_items(self, m)","def MaxHks(N): \n return np.log2(N-1)/2","def __init__(self, max_len, max_num):\n self.a = {}\n self.a[0] = [[]]\n self.a[1] = [[1]]\n\n self.max_len = max_len\n self.max_num = max_num","def nms(boxes, scores, overlap=0.5, top_k=200):\n\n keep = torch.Tensor(scores.size(0)).fill_(0).long()\n if boxes.numel() == 0:\n return keep\n x1 = boxes[:, 0]\n y1 = boxes[:, 1]\n x2 = boxes[:, 2]\n y2 = boxes[:, 3]\n area = torch.mul(x2 - x1, y2 - y1)\n v, idx = scores.sort(0) # sort in ascending order\n # I = I[v >= 0.01]\n idx = idx[-top_k:] # indices of the top-k largest vals\n xx1 = boxes.new()\n yy1 = boxes.new()\n xx2 = boxes.new()\n yy2 = boxes.new()\n w = boxes.new()\n h = boxes.new()\n\n # keep = torch.Tensor()\n count = 0\n while idx.numel() > 0:\n i = idx[-1] # index of current largest val\n # keep.append(i)\n keep[count] = i\n count += 1\n if idx.size(0) == 1:\n break\n idx = idx[:-1] # remove kept element from view\n # load bboxes of next highest vals\n torch.index_select(x1, 0, idx, out=xx1)\n torch.index_select(y1, 0, idx, out=yy1)\n torch.index_select(x2, 0, idx, out=xx2)\n torch.index_select(y2, 0, idx, out=yy2)\n # store element-wise max with next highest score\n xx1 = torch.clamp(xx1, min=x1[i])\n yy1 = torch.clamp(yy1, min=y1[i])\n xx2 = torch.clamp(xx2, max=x2[i])\n yy2 = torch.clamp(yy2, max=y2[i])\n w.resize_as_(xx2)\n h.resize_as_(yy2)\n w = xx2 - xx1\n h = yy2 - yy1\n # check sizes of xx1 and xx2.. after each iteration\n w = torch.clamp(w, min=0.0)\n h = torch.clamp(h, min=0.0)\n inter = w*h\n # IoU = i / (area(a) + area(b) - i)\n rem_areas = torch.index_select(area, 0, idx) # load remaining areas)\n union = (rem_areas - inter) + area[i]\n IoU = inter/union # store result in iou\n # keep only elements with an IoU <= overlap\n idx = idx[IoU.le(overlap)]\n return keep, count","def set_max_noutput_items(self, *args, **kwargs):\n return _TestA_swig.cleanslate_sptr_set_max_noutput_items(self, *args, **kwargs)","def hard_nms(box_scores, iou_threshold, top_k=-1, candidate_size=10):\n # TOP_K was originally -1, to keep all faces, but trying to filter\n # CANDIDATE_SIZE was originally 200, trying to limit # of faces\n scores = box_scores[:, -1]\n boxes = box_scores[:, :-1]\n picked = []\n indexes = np.argsort(scores)\n indexes = indexes[-candidate_size:]\n while len(indexes) > 0:\n current = indexes[-1]\n picked.append(current)\n if 0 < top_k == len(picked) or len(indexes) == 1:\n break\n current_box = boxes[current, :]\n\n indexes = indexes[:-1]\n rest_boxes = boxes[indexes, :]\n iou = iou_of(\n rest_boxes,\n np.expand_dims(current_box, axis=0),\n )\n indexes = indexes[iou <= iou_threshold]\n \n # additional method of discrimination, only the boxes\n # with the largest areas are selected\n new_boxes = box_scores[picked, :]\n areas = []\n for box in new_boxes:\n left_top = np.asarray([box[0], box[1]])\n right_bottom = np.asarray([box[2], box[3]])\n area = area_of(left_top, right_bottom)\n areas.append(area)\n areas = np.asarray(areas)\n biggest = np.argsort(areas)\n last_index = len(biggest) - 1\n middle = max(len(biggest)// 2, 1)\n size = min(middle, candidate_size / 2)\n \n final_boxes = []\n for i in range(size):\n final_boxes.append(new_boxes[biggest[last_index-i]])\n final_boxes = np.asarray(final_boxes)\n \n return final_boxes\n #return box_scores[picked, :]","def max_output_buffer(self, i: \"int\") -> \"long\":\n return _beamforming_swig.phasedarray_sptr_max_output_buffer(self, i)","def set_max_noutput_items(self, m):\n return _spacegrant_swig.hdlc_deframer_sptr_set_max_noutput_items(self, m)","def set_max_noutput_items(self, m: \"int\") -> \"void\":\n return _beamforming_swig.beamformer_sptr_set_max_noutput_items(self, m)","def max_level(data: np.ndarray) -> int:\n shape = data.shape[1:] # exclude channel dimension\n return min(shape).bit_length() - 1","def n_largest_channels(summed, n=6):\r\n\r\n rows, columns = summed.shape\r\n\r\n # n has to be smaller than the number of rows\r\n assert n <= rows\r\n\r\n n_out_of_m = np.zeros(summed.shape)\r\n\r\n for col in range(columns):\r\n column = summed[:, col]\r\n indices = np.argsort(column)[:-n]\r\n tmp = column\r\n tmp[indices] = 0\r\n n_out_of_m[:, col] = tmp\r\n\r\n return n_out_of_m","def __init__(self, max_num_of_rounds_to_retain=100, num_of_last_check_rounds_consider=2):\n self.data = list()\n self.max_num_of_rounds_to_retain = max_num_of_rounds_to_retain\n self.num_of_last_check_rounds_consider = num_of_last_check_rounds_consider","def nms(boxes, scores, overlap=0.5, top_k=200):\n\n keep = scores.new(scores.size(0)).zero_().long()\n if boxes.numel() == 0:\n return keep\n x1 = boxes[:, 0]\n y1 = boxes[:, 1]\n x2 = boxes[:, 2]\n y2 = boxes[:, 3]\n area = torch.mul(x2 - x1, y2 - y1)\n v, idx = scores.sort(0) # sort in ascending order\n # I = I[v >= 0.01]\n idx = idx[-top_k:] # indices of the top-k largest vals\n xx1 = boxes.new()\n yy1 = boxes.new()\n xx2 = boxes.new()\n yy2 = boxes.new()\n w = boxes.new()\n h = boxes.new()\n\n # keep = torch.Tensor()\n count = 0\n while idx.numel() > 0:\n i = idx[-1] # index of current largest val\n # keep.append(i)\n keep[count] = i\n count += 1\n if idx.size(0) == 1:\n break\n idx = idx[:-1] # remove kept element from view\n # load bboxes of next highest vals\n torch.index_select(x1, 0, idx, out=xx1)\n torch.index_select(y1, 0, idx, out=yy1)\n torch.index_select(x2, 0, idx, out=xx2)\n torch.index_select(y2, 0, idx, out=yy2)\n # store element-wise max with next highest score\n xx1 = torch.clamp(xx1, min=x1[i])\n yy1 = torch.clamp(yy1, min=y1[i])\n xx2 = torch.clamp(xx2, max=x2[i])\n yy2 = torch.clamp(yy2, max=y2[i])\n w.resize_as_(xx2)\n h.resize_as_(yy2)\n w = xx2 - xx1\n h = yy2 - yy1\n # check sizes of xx1 and xx2.. after each iteration\n w = torch.clamp(w, min=0.0)\n h = torch.clamp(h, min=0.0)\n inter = w*h\n # IoU = i / (area(a) + area(b) - i)\n rem_areas = torch.index_select(area, 0, idx) # load remaining areas)\n union = (rem_areas - inter) + area[i]\n IoU = inter/union # store result in iou\n # keep only elements with an IoU <= overlap\n idx = idx[IoU.le(overlap)]\n return keep, count","def max_output_buffer(self, i):\n return _add_vector_swig.add_vector_2_cpp_sptr_max_output_buffer(self, i)","def set_max_noutput_items(self, m):\n return _spacegrant_swig.hdlc_framer_sptr_set_max_noutput_items(self, m)"],"string":"[\n \"def get_maxcut_data_model():\\n n = 5\\n V = np.arange(0, n, 1)\\n E = [(0, 1, 3.0), (1, 2, 2.0), (2, 3, 2.0), (3, 4, 3.0), (4, 0, 1.0), (0, 3, 3.0)]\\n\\n G = nx.Graph()\\n G.add_nodes_from(V)\\n G.add_weighted_edges_from(E)\\n return G\",\n \"def expanding_max_nb(a, minp=1):\\n out = np.empty_like(a, dtype=np.float_)\\n for col in range(a.shape[1]):\\n out[:, col] = expanding_max_1d_nb(a[:, col], minp=minp)\\n return out\",\n \"def max_noutput_items(self) -> \\\"int\\\":\\n return _beamforming_swig.phasedarray_sptr_max_noutput_items(self)\",\n \"def get_bins(size, n, max_value):\\n bin_lims = get_bin_lims(n, max_value)\\n return sort_by_rows(np.array(list(itertools.product(bin_lims, repeat=size))))\",\n \"def arrayManipulation_shortpeak(n, queries):\\n a_s = []\\n b_s = []\\n k_s = []\\n\\n for i, row in enumerate(queries):\\n a_s.append(row[0])\\n b_s.append(row[1])\\n k_s.append(row[2])\\n\\n # breakpoint()\\n x = a_s + b_s\\n all_indices = list(set(x))\\n all_indices.sort()\\n short_arr = [0] * len(all_indices)\\n\\n # mapping index of n-long array to index of shorter array\\n index_lookup = {}\\n for j, el in enumerate(all_indices):\\n index_lookup[el] = j\\n\\n # breakpoint()\\n for m in range(len(a_s)):\\n short_arr[index_lookup[a_s[m]]] += k_s[m]\\n short_arr[index_lookup[b_s[m]]] -= k_s[m]\\n\\n maxval = 0\\n cumsum = 0\\n for i, el in enumerate(short_arr):\\n cumsum += el\\n maxval = max(maxval, cumsum)\\n\\n print(f'{maxval: <15,d}: Max value')\\n arr_size = short_arr.__sizeof__() / 1000000\\n total = ((a_s.__sizeof__() / 1000000)\\n + b_s.__sizeof__() / 1000000\\n + k_s.__sizeof__() / 1000000\\n + queries.__sizeof__() / 1000000\\n + index_lookup.__sizeof__() / 1000000\\n + short_arr.__sizeof__() / 1000000)\\n print(f'{total: <15.2f}: All objects size(MB)')\\n print(f'{arr_size: <15.2f}: Array size(MB)')\\n return maxval, arr_size\",\n \"def process_lim(pool_lim, area):\\n\\n pool_nolim = [] # No limitation\\n pool_lim_n = [] # N limitation\\n pool_lim_p = [] # P limitation\\n # Colimitation driven by N (When the realized NPP allocation is smaller\\n # thant the potential due to N but the other element is also limitant)\\n pool_colim_n = []\\n # Colimitation driven by P (When the realized NPP allocation is smaller\\n # than the potential due to P but the other element is also limitant\\n pool_colim_p = []\\n # Real Colimitation = K <= 1D-6 (K is difference between P and N realized NPP allocation)\\n pool_colim_np = []\\n\\n ndays = pool_lim.shape[1]\\n npls = pool_lim.shape[0]\\n\\n for pls in range(npls):\\n if area[pls]:\\n no_lim = (pool_lim[pls, :] == 0).sum() / ndays * area[pls]\\n lim_n = (np.count_nonzero(\\n pool_lim[pls, :] == 1) / ndays) * area[pls]\\n lim_p = (np.count_nonzero(\\n pool_lim[pls, :] == 2) / ndays) * area[pls]\\n colim_n = (np.count_nonzero(\\n pool_lim[pls, :] == 4) / ndays) * area[pls]\\n colim_p = (np.count_nonzero(\\n pool_lim[pls, :] == 5) / ndays) * area[pls]\\n colim_np = (np.count_nonzero(\\n pool_lim[pls, :] == 6) / ndays) * area[pls]\\n\\n pool_nolim.append(no_lim)\\n pool_lim_n.append(lim_n)\\n pool_lim_p.append(lim_p)\\n pool_colim_n.append(colim_n)\\n pool_colim_p.append(colim_p)\\n pool_colim_np.append(colim_np)\\n\\n return (np.sum(pool_nolim),\\n np.sum(pool_lim_n),\\n np.sum(pool_lim_p),\\n np.sum(pool_colim_n),\\n np.sum(pool_colim_p),\\n np.sum(pool_colim_np))\",\n \"def max_pooling(img):\\n result_img = img.copy()\\n heignt, width, _ = result_img.shape\\n for h in range(0, heignt, 8):\\n for w in range(0, width, 8):\\n result_img[h:h+8, w:w+8, 0] = np.max(result_img[h:h+8, w:w+8, 0])\\n result_img[h:h+8, w:w+8, 1] = np.max(result_img[h:h+8, w:w+8, 1])\\n result_img[h:h+8, w:w+8, 2] = np.max(result_img[h:h+8, w:w+8, 2])\\n result_img[(heignt//8)*8:heignt, :, :] = 0\\n result_img[:, (width//8)*8:width, :] = 0\\n return result_img\",\n \"def create_array( n ):\",\n \"def max_noutput_items(self):\\n return _spacegrant_swig.invert_bit_sptr_max_noutput_items(self)\",\n \"def expanding_max_1d_nb(a, minp=1):\\n out = np.empty_like(a, dtype=np.float_)\\n maxv = a[0]\\n cnt = 0\\n for i in range(a.shape[0]):\\n if np.isnan(maxv) or a[i] > maxv:\\n maxv = a[i]\\n if ~np.isnan(a[i]):\\n cnt += 1\\n if cnt < minp:\\n out[i] = np.nan\\n else:\\n out[i] = maxv\\n return out\",\n \"def max_noutput_items(self) -> \\\"int\\\":\\n return _beamforming_swig.randomsampler_sptr_max_noutput_items(self)\",\n \"def cut(self, max_lenght):\\n self.V_estimates = self.V_estimates[:max_lenght]\\n super().cut(max_lenght)\",\n \"def get_max_combination(total_cuts):\\n max_pieces = 0\\n for i in range(total_cuts):\\n result = i * (total_cuts - i)\\n if result > max_pieces:\\n max_pieces = result\\n print(max_pieces)\",\n \"def _get_max_sampled_bandit(self)->Bandit:\\n estimates = []\\n for bandit in self.bandits:\\n Qth = np.random.normal(loc =self.mu[bandit.id], scale = self.var[bandit.id])\\n f_hat = self.mu[bandit.id]#computing moving_average here \\n estimates.append(max(Qth, f_hat))\\n return self.bandits[np.argmax(estimates)]\",\n \"def set_max_noutput_items(self, m: \\\"int\\\") -> \\\"void\\\":\\n return _beamforming_swig.phasedarray_sptr_set_max_noutput_items(self, m)\",\n \"def __init__(self, maxlen, dtype):\\n self._start_index = np.int64(0)\\n self._len = np.int64(0)\\n self._maxlen = np.array(maxlen)\\n initial_len = 10 if np.isinf(self._maxlen) else self._maxlen\\n self._buffer = np.zeros(shape=(initial_len,), dtype=dtype)\",\n \"def _get_optimal_threshold(arr, num_bins=1001, num_quantized_bins=255):\\n if not isinstance(arr, np.ndarray):\\n raise TypeError('get_optimal_threshold only supports input type of np.ndarray,'\\n ' while received type=%s' % (str(type(arr))))\\n min_val = np.min(arr)\\n max_val = np.max(arr)\\n th = max(abs(min_val), abs(max_val))\\n\\n hist, hist_edges = np.histogram(arr, bins=num_bins, range=(-th, th))\\n zero_bin_idx = num_bins // 2\\n num_half_quantized_bins = num_quantized_bins // 2\\n assert np.allclose(hist_edges[zero_bin_idx] + hist_edges[zero_bin_idx + 1],\\n 0, rtol=1e-5, atol=1e-7)\\n\\n thresholds = np.zeros(num_bins // 2 + 1 - num_quantized_bins // 2)\\n divergence = np.zeros_like(thresholds)\\n quantized_bins = np.zeros(num_quantized_bins, dtype=np.int32)\\n # i means the number of bins on half axis excluding the zero bin.\\n for i in range(num_quantized_bins // 2,\\n num_bins // 2 + 1):\\n p_bin_idx_start = zero_bin_idx - i\\n p_bin_idx_stop = zero_bin_idx + i + 1\\n thresholds[i - num_half_quantized_bins] = hist_edges[p_bin_idx_stop]\\n sliced_nd_hist = hist[p_bin_idx_start:p_bin_idx_stop]\\n\\n # generate reference distribution p\\n p = sliced_nd_hist.copy()\\n assert p.size % 2 == 1\\n assert p.size >= num_quantized_bins\\n # put left outlier count in p[0]\\n left_outlier_count = np.sum(hist[0:p_bin_idx_start])\\n p[0] += left_outlier_count\\n # put right outlier count in p[-1]\\n right_outlier_count = np.sum(hist[p_bin_idx_stop:])\\n p[-1] += right_outlier_count\\n # is_nonzeros[k] indicates whether hist[k] is nonzero\\n is_nonzeros = (sliced_nd_hist != 0).astype(np.int32)\\n\\n # calculate how many bins should be merged to generate quantized distribution q\\n num_merged_bins = p.size // num_quantized_bins\\n # merge hist into num_quantized_bins bins\\n for j in range(num_quantized_bins):\\n start = j * num_merged_bins\\n stop = start + num_merged_bins\\n quantized_bins[j] = sliced_nd_hist[start:stop].sum()\\n quantized_bins[-1] += sliced_nd_hist[num_quantized_bins * num_merged_bins:].sum()\\n # expand quantized_bins into p.size bins\\n q = np.zeros(p.size, dtype=np.float32)\\n for j in range(num_quantized_bins):\\n start = j * num_merged_bins\\n if j == num_quantized_bins - 1:\\n stop = -1\\n else:\\n stop = start + num_merged_bins\\n norm = is_nonzeros[start:stop].sum()\\n if norm != 0:\\n q[start:stop] = float(quantized_bins[j]) / float(norm)\\n q[sliced_nd_hist == 0] = 0\\n p = _smooth_distribution(p)\\n # There is a chance that q is an invalid probability distribution.\\n try:\\n q = _smooth_distribution(q)\\n except ValueError:\\n divergence[i - num_half_quantized_bins] = float(\\\"inf\\\")\\n else:\\n divergence[i - num_half_quantized_bins] = stats.entropy(p, q)\\n quantized_bins[:] = 0\\n\\n min_divergence_idx = np.argmin(divergence)\\n min_divergence = divergence[min_divergence_idx]\\n opt_th = thresholds[min_divergence_idx]\\n return min_val, max_val, min_divergence, opt_th\",\n \"def max_noutput_items(self):\\n return _spacegrant_swig.general_burster_2_sptr_max_noutput_items(self)\",\n \"def test_compute_c_max_output():\\n # build\\n T = np.array([600, 500])\\n E_ion = np.array([20, 10])\\n E_atom = np.array([30, 40])\\n angles_ion = np.array([60, 60])\\n angles_atom = np.array([60, 60])\\n ion_flux = np.array([1e21, 1e20])\\n atom_flux = np.array([2e21, 2e20])\\n\\n # run\\n output = divHretention.compute_c_max(\\n T, E_ion, E_atom, angles_ion, angles_atom,\\n ion_flux, atom_flux, full_export=True)\\n\\n # test\\n assert len(output) == 3\\n\\n # run\\n output = divHretention.compute_c_max(\\n T, E_ion, E_atom, angles_ion, angles_atom,\\n ion_flux, atom_flux, full_export=False)\\n\\n # test\\n assert len(output) == 2\",\n \"def max_cut(g):\\n # Write your code here.\\n return []\",\n \"def max_pool2d(input, kernel_size, stride=1, padding=0, ceil_mode=False):\\n return _pool('MAX', utils._pair, **locals())\",\n \"def max_pool3d(input, kernel_size, stride=1, padding=0, ceil_mode=False):\\n return _pool('MAX', utils._triple, **locals())\",\n \"def create_new_targets(window, data):\\n new_data = np.apply_along_axis(lambda x: np.bincount(x).argmax(), axis=1, arr=(rolling_window(data.astype(int), 0, window)))\\n\\n return new_data\",\n \"def maxpool(input, filter_h, filter_w, stride_h, stride_w, padding, name):\\n with tf.name_scope(name):\\n mp = tf.nn.max_pool(input, ksize=[1, filter_h, filter_w, 1], strides=[1, stride_h, stride_w, 1],\\n padding=padding)\\n # print(name + \\\" : \\\", str(mp.shape))\\n return mp\",\n \"def _get_max_estimated_bandit(self)->Bandit:\\n # print(\\\"mus - \\\", self.mu)\\n # print(\\\"actions - \\\", np.argmax(self.mu))\\n unique, counts = np.unique(self.mu, return_counts=True)\\n lens = counts[np.argmax(unique)] \\n if lens>1: # if two actions have same argmax\\n # then return arbitrarily from those max ones\\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\\n return np.random.choice(maxs)\\n # otherwise return the max one\\n return self.bandits[np.argmax(self.mu)]\",\n \"def max_noutput_items(self):\\n return _add_vector_swig.add_vector_2_cpp_sptr_max_noutput_items(self)\",\n \"def max_pool1d(input, kernel_size, stride=1, padding=0, ceil_mode=False):\\n return _pool('MAX', utils._single, **locals())\",\n \"def _resize(self, maxval):\\n assert maxval >= self._N\\n temp = [None for i in range(maxval)] # (Item[]) new [maxval] # Item[]\\n q_len = len(self._q)\\n for i in range(self._N):\\n temp[i] = self._q[(self._first + i) % q_len]\\n self._q = temp\\n self._first = 0\\n self._last = self._N\",\n \"def create_split_bounds(N, train_pct):\\n train_len = int(round(train_pct * N))\\n if ((N - train_len) % 2) != 0:\\n train_len += 1\\n\\n # NOTE: We're assume the dev and test set are equal in length.\\n test_len = dev_len = int((N - train_len) / 2)\\n\\n assert \\\"Not all data points are being used. Check create_split_bounds()\\\", \\\\\\n (train_len + test_len + dev_len) == N\\n\\n return train_len, dev_len, test_len\",\n \"def non_max_suppression(inputs, n_classes, max_output_size, iou_threshold, confidence_threshold):\\n batch = tf.unstack(inputs)\\n boxes_dicts = []\\n\\n for boxes in batch:\\n boxes = tf.boolean_mask(boxes, boxes[:, 4] > confidence_threshold)\\n classes = tf.argmax(boxes[:, 5:], axis=-1)\\n classes = tf.expand_dims(tf.cast(classes, tf.float32), axis=-1)\\n boxes = tf.concat([boxes[:, :5], classes], axis=-1)\\n\\n boxes_dict = dict()\\n for cls in range(n_classes):\\n mask = tf.equal(boxes[:, 5], cls)\\n mask_shape = mask.get_shape()\\n if mask_shape.ndims != 0:\\n class_boxes = tf.boolean_mask(boxes, mask)\\n boxes_coords, boxes_conf_scores, _ = tf.split(class_boxes, [4, 1, -1], axis=-1)\\n boxes_conf_scores = tf.reshape(boxes_conf_scores, [-1])\\n indices = tf.image.non_max_suppression(boxes_coords,\\n boxes_conf_scores,\\n max_output_size,\\n iou_threshold)\\n class_boxes = tf.gather(class_boxes, indices)\\n boxes_dict[cls] = class_boxes[:, :5]\\n\\n boxes_dicts.append(boxes_dict)\\n return boxes_dicts\",\n \"def adaptive_max_pool3d(input, output_size):\\n args = utils._get_adaptive_pool_args(\\n input.size()[-3:], utils._triple(output_size))\\n return _pool('MAX', utils._triple, input, **args)\",\n \"def pick_largest(self, cut_off):\\r\\n for i in range(self.dimension):\\r\\n m = self.masked[int(self.rank_yx(self.rank[i])[0]) # locating the corresponding mark array\\r\\n ,int(self.rank_yx(self.rank[i])[1])]\\r\\n if m * self.image_data[i] == self.image_data[i]:\\r\\n if self.image_data[i] <= cut_off:\\r\\n print(\\\"Surveying completed\\\")\\r\\n return -1,-1 # returns -1,-1 if scan is completed\\r\\n else:\\r\\n return self.image_data[i], np.array(self.rank[i])\",\n \"def __len__(self):\\n return max(self.A_size, self.B50_size, self.B100_size, self.B150_size)\",\n \"def slice_sample_bounded_max(N, burn, logdist, xx, widths, step_out, max_attempts, bounds):\\n xx = copy.deepcopy(xx)\\n D = len(xx)\\n samples = []\\n if (not isinstance(widths, list)) or len(widths) == 1:\\n widths = np.ones(D) * widths\\n\\n log_Px = logdist(xx)\\n\\n for ii in range(N + burn):\\n log_uprime = np.log(random.random()) + log_Px\\n for dd in random.sample(range(D), D):\\n x_l = copy.deepcopy(xx)\\n x_r = copy.deepcopy(xx)\\n xprime = copy.deepcopy(xx)\\n\\n # Create a horizontal interval (x_l, x_r) enclosing xx\\n rr = random.random()\\n x_l[dd] = max(xx[dd] - rr*widths[dd], bounds[dd][0])\\n x_r[dd] = min(xx[dd] + (1-rr)*widths[dd], bounds[dd][1])\\n\\n if step_out:\\n while logdist(x_l) > log_uprime and x_l[dd] > bounds[dd][0]:\\n\\n x_l[dd] = max(x_l[dd] - widths[dd], bounds[dd][0])\\n while logdist(x_r) > log_uprime and x_r[dd] < bounds[dd][1]:\\n x_r[dd] = min(x_r[dd] + widths[dd], bounds[dd][1])\\n\\n # Propose xprimes and shrink interval until good one found\\n zz = 0\\n num_attempts = 0\\n while True:\\n zz += 1\\n # print(x_l)\\n xprime[dd] = random.random()*(x_r[dd] - x_l[dd]) + x_l[dd]\\n \\n log_Px = logdist(xx)\\n if log_Px > log_uprime:\\n xx[dd] = xprime[dd]\\n break\\n else:\\n # Shrink in\\n num_attempts += 1\\n if num_attempts >= max_attempts:\\n # print('Failed to find something')\\n break\\n elif xprime[dd] > xx[dd]:\\n x_r[dd] = xprime[dd]\\n elif xprime[dd] < xx[dd]:\\n x_l[dd] = xprime[dd]\\n else:\\n raise Exception('Slice sampling failed to find an acceptable point')\\n # Record samples\\n if ii >= burn:\\n samples.append(copy.deepcopy(xx))\\n return samples\",\n \"def max_noutput_items(self) -> \\\"int\\\":\\n return _beamforming_swig.beamformer_sptr_max_noutput_items(self)\",\n \"def max_noutput_items(self):\\n return _TestA_swig.my_qpsk_demod_cb_sptr_max_noutput_items(self)\",\n \"def max_pool(inputs):\\n return tf.layers.max_pooling2d(\\n inputs,\\n pool_size=[2, 2],\\n strides=[2, 2],\\n padding='same',\\n )\",\n \"def set_max_noutput_items(self, m):\\n return _spacegrant_swig.general_burster_2_sptr_set_max_noutput_items(self, m)\",\n \"def create_max_pool(x):\\n return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')\",\n \"def max_noutput_items(self):\\n return _TestA_swig.cleanslate_sptr_max_noutput_items(self)\",\n \"def over_classification_filter(self, in_metadata, max_classes=30):\\n print('size before:', len(in_metadata))\\n out_metadata = {}\\n for img_id, img_dict in in_metadata.iteritems():\\n if img_dict['n_labels'] <= max_classes:\\n out_metadata[img_id] = img_dict\\n\\n print('size after:', len(out_metadata))\\n return out_metadata\",\n \"def set_max_noutput_items(self, m):\\n return _spacegrant_swig.invert_bit_sptr_set_max_noutput_items(self, m)\",\n \"def set_max_noutput_items(self, m):\\n return _add_vector_swig.add_vector_2_cpp_sptr_set_max_noutput_items(self, m)\",\n \"def build_convpool_max(input_vars, nb_classes, imsize=32, n_colors=3, n_timewin=3):\\n convnets = []\\n w_init = None\\n # Build 7 parallel CNNs with shared weights\\n for i in range(n_timewin):\\n if i == 0:\\n convnet, w_init = build_cnn(input_vars[i], imsize=imsize, n_colors=n_colors)\\n else:\\n convnet, _ = build_cnn(input_vars[i], w_init=w_init, imsize=imsize, n_colors=n_colors)\\n convnets.append(convnet)\\n # convpooling using Max pooling over frames\\n convpool = ElemwiseMergeLayer(convnets, theano.tensor.maximum)\\n # A fully-connected layer of 512 units with 50% dropout on its inputs:\\n convpool = DenseLayer(lasagne.layers.dropout(convpool, p=.5),\\n num_units=512, nonlinearity=lasagne.nonlinearities.rectify)\\n # And, finally, the output layer with 50% dropout on its inputs:\\n convpool = lasagne.layers.DenseLayer(lasagne.layers.dropout(convpool, p=.5),\\n num_units=nb_classes, nonlinearity=lasagne.nonlinearities.softmax)\\n return convpool\",\n \"def max_pool(inputs, window_shape, strides=None, padding=\\\"VALID\\\"):\\n y = pool(inputs, -jnp.inf, lax.max, window_shape, strides, padding)\\n return y\",\n \"def __cut_arrays(data_array, maximum_time, arrays_to_cut):\\n\\n try:\\n begin_time = data_array[arrays_to_cut[0]][0][0]\\n end_time = data_array[arrays_to_cut[0]][0][-1]\\n delta_time = (\\n data_array[arrays_to_cut[0]][0][1]\\n - data_array[arrays_to_cut[0]][0][0]\\n )\\n total_time = end_time - begin_time\\n if total_time > maximum_time:\\n over_time = total_time - maximum_time\\n array_elm_to_drop = int(over_time / delta_time)\\n for arrays in arrays_to_cut:\\n data_array[arrays][0] = data_array[arrays][0][\\n array_elm_to_drop:\\n ]\\n data_array[arrays][1] = data_array[arrays][1][\\n array_elm_to_drop:\\n ]\\n except:\\n pass\",\n \"def _infer_dimension_(spectrum, n_samples, n_features):\\n n_spectrum = len(spectrum)\\n ll = np.empty(n_spectrum)\\n for rank in range(n_spectrum):\\n ll[rank] = _assess_dimension_(spectrum, rank, n_samples, n_features)\\n return ll.argmax()\",\n \"def look_for_biggest_structure(game, chunk, imgs, hmap, nmax, type_):\\n for n in range(nmax,0,-1):\\n i = 0\\n m = parameters.MAX_VILLAGE_WIDTH * n / parameters.MAX_VILLAGE_SIZE\\n while i < parameters.VILLAGE_TRY:\\n chunkpos = np.random.randint(0,parameters.S,2)\\n cx,cy = chunkpos\\n h = np.sum(hmap[cx:cx+m,cy:cy+m]) / (m*m)\\n if h > parameters.VILLAGE_LEVEL:\\n force_build_structure(game, imgs, chunk, chunkpos, n, type_)\\n return n\\n i += 1\\n return 0\",\n \"def _max_pool(x):\\n return tf.nn.max_pool(value=x,\\n ksize=[1, 2, 2, 1],\\n strides=[1, 2, 2, 1],\\n padding='SAME')\",\n \"def max_noutput_items(self) -> \\\"int\\\":\\n return _beamforming_swig.doaesprit_sptr_max_noutput_items(self)\",\n \"def filter_halo_pnum(data, Ncut=1000):\\n npart = np.array(data['np'][0])\\n ind =np.where(npart > Ncut)[0]\\n print(\\\"# of halos:\\\",len(ind))\\n return ind\",\n \"def max_noutput_items(self):\\n return _spacegrant_swig.NRZI_sptr_max_noutput_items(self)\",\n \"def margin_sampling(predictions, number):\\n maxes = []\\n maxesBis = []\\n tmp = []\\n for i in range(0, predictions.shape[0]):\\n maxes.append(np.max(predictions[i]))\\n tmp.append(np.delete(predictions[i], np.where(predictions[i] == np.max(predictions[i]))[0]))\\n maxesBis.append(np.max(tmp[i]))\\n\\n val = np.array(maxes) - np.array(maxesBis)\\n\\n return __get_min_indexes(val, number)\",\n \"def cutout(a):\\n x = np.arange(a.shape[0])\\n c = a.shape[0] / 2\\n\\n if len(a.shape) == 2:\\n x = x.reshape(-1, 1)\\n y = x.reshape(1, -1)\\n zero = ((x-c)**2 + (y-c)**2) < c**2\\n elif len(a.shape) == 3:\\n x = x.reshape(-1, 1, 1)\\n y = x.reshape(1, -1, 1)\\n z = x.reshape(1, -1, 1)\\n zero = ((x-c)**2 + (y-c)**2 + (z-c)**2) < c**2\\n else:\\n raise ValueError(\\\"Cutout array must have dimension 2 or 3!\\\")\\n a *= zero\\n return a\",\n \"def __init__(self, maxSize=3):\\r\\n try:\\r\\n if maxSize % 2 == 1 and maxSize >= 3:\\r\\n self._maxSize = maxSize\\r\\n else:\\r\\n raise ValueError(\\\"maxSize must be an odd integer >= 3\\\")\\r\\n except ValueError:\\r\\n raise\\r\\n self._data = np.ndarray(0)\",\n \"def get_arraymax_section_data(key_list, max_size=1300000000):\\n result_list = []\\n data_key_list = DATA_BLOCK_SPEC.keys()\\n for key in key_list:\\n if key in data_key_list:\\n result_list.append(max_size)\\n else:\\n result_list.append(0)\\n return np.array(result_list)\",\n \"def cov_seg_max(n, L):\\n n_seg = 1\\n while int(n) > n_seg:\\n n_seg += 1\\n return int(L/n_seg) # Samples within one segment \",\n \"def get_num_bins(train_input: np.array, max_splits: int) -> List[int]:\\n num_bins = [2 for _ in train_input[0]]\\n max_bins = [len(set(column)) for column in train_input.T]\\n entropies = [ExamDropExtractor.__entropy(np.expand_dims(column, axis = 1), 2) for column in train_input.T]\\n options = PriorityQueue()\\n\\n for i, data in enumerate(train_input.T):\\n if max_bins[i] > 2:\\n data = np.expand_dims(data, axis = 1)\\n new_entropy = ExamDropExtractor.__entropy(data, 3)\\n options.put((-(new_entropy - entropies[i]), i))\\n\\n for _ in range(max_splits):\\n if options.empty():\\n break\\n\\n entropy, i = options.get()\\n num_bins[i] = num_bins[i] + 1\\n entropies[i] = entropies[i] - entropy\\n if num_bins[i] != max_bins[i]:\\n data = np.expand_dims(train_input[:, i], axis = 1)\\n new_entropy = ExamDropExtractor.__entropy(data, num_bins[i] + 1)\\n options.put((-(new_entropy - entropies[i]), i))\\n\\n return num_bins\",\n \"def max_noutput_items(self):\\n return _spacegrant_swig.DeNRZI_sptr_max_noutput_items(self)\",\n \"def __reduce__(self):\\n return ImageNetDownsample, (self.cutout,)\",\n \"def rolling_max_nb(a, window, minp=None):\\n out = np.empty_like(a, dtype=np.float_)\\n for col in range(a.shape[1]):\\n out[:, col] = rolling_max_1d_nb(a[:, col], window, minp=minp)\\n return out\",\n \"def max_noutput_items(self):\\n return _spacegrant_swig.G3RUH_descramble_sptr_max_noutput_items(self)\",\n \"def set_max_noutput_items(self, *args, **kwargs):\\n return _TestA_swig.my_qpsk_demod_cb_sptr_set_max_noutput_items(self, *args, **kwargs)\",\n \"def __init__(self, size=(2, 2), **kwargs):\\n super(MaxUnpooling2D, self).__init__(**kwargs)\\n self.size = size\",\n \"def min_noutput_items(self) -> \\\"int\\\":\\n return _beamforming_swig.phasedarray_sptr_min_noutput_items(self)\",\n \"def max_noutput_items(self):\\n return _spacegrant_swig.binary_sink_sptr_max_noutput_items(self)\",\n \"def set_max_noutput_items(self, m):\\n return _spacegrant_swig.binary_sink_sptr_set_max_noutput_items(self, m)\",\n \"def _get_max_sampled_bandit(self)->Bandit:\\n estimates = []\\n for bandit in self.bandits:\\n estimates.append(np.random.normal(loc =self.mu[bandit.id], scale = self.var[bandit.id]))\\n return self.bandits[np.argmax(estimates)]\",\n \"def post_processing(conf_thresh, nms_thresh, output):\\n # anchors = [12, 16, 19, 36, 40, 28, 36, 75, 76, 55, 72, 146, 142, 110, 192, 243, 459, 401]\\n # num_anchors = 9\\n # anchor_masks = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]\\n # strides = [8, 16, 32]\\n # anchor_step = len(anchors) // num_anchors\\n\\n # [batch, num, 1, 4]\\n box_array = output[0]\\n # [batch, num, num_classes]\\n confs = output[1]\\n\\n if type(box_array).__name__ != \\\"ndarray\\\":\\n box_array = box_array.cpu().detach().numpy()\\n confs = confs.cpu().detach().numpy()\\n\\n num_classes = confs.shape[2]\\n\\n # [batch, num, 4]\\n box_array = box_array[:, :, 0]\\n\\n # [batch, num, num_classes] --> [batch, num]\\n max_conf = np.max(confs, axis=2)\\n max_id = np.argmax(confs, axis=2)\\n\\n bboxes_batch = []\\n for batch in range(box_array.shape[0]):\\n\\n argwhere = max_conf[batch] > conf_thresh\\n l_box_array = box_array[batch, argwhere, :]\\n l_max_conf = max_conf[batch, argwhere]\\n l_max_id = max_id[batch, argwhere]\\n\\n bboxes = []\\n # nms for each class\\n for cls_id in range(num_classes):\\n\\n cls_argwhere = l_max_id == cls_id\\n ll_box_array = l_box_array[cls_argwhere, :]\\n ll_max_conf = l_max_conf[cls_argwhere]\\n ll_max_id = l_max_id[cls_argwhere]\\n\\n keep = nms_cpu(ll_box_array, ll_max_conf, nms_thresh)\\n\\n if keep.size > 0:\\n ll_box_array = ll_box_array[keep, :]\\n ll_max_conf = ll_max_conf[keep]\\n ll_max_id = ll_max_id[keep]\\n\\n for box in range(ll_box_array.shape[0]):\\n bboxes.append(\\n [\\n ll_box_array[box, 0],\\n ll_box_array[box, 1],\\n ll_box_array[box, 2],\\n ll_box_array[box, 3],\\n ll_max_conf[box],\\n ll_max_conf[box],\\n ll_max_id[box],\\n ]\\n )\\n\\n bboxes_batch.append(bboxes)\\n\\n return bboxes_batch\",\n \"def nanmax_nb(a):\\n out = np.empty(a.shape[1], dtype=np.float_)\\n for col in range(a.shape[1]):\\n out[col] = np.nanmax(a[:, col])\\n return out\",\n \"def nmax2t(cls, n_max: int, oversampling: float = 10.) -> np.ndarray:\\n critical_res = 4 * SHT.nmax2nside(n_max) - 1\\n return np.linspace(-1, 1, np.ceil(oversampling * critical_res).astype(int))\",\n \"def __init__(self, max_n):\\n self._max_n = max_n\\n self.__pq = [0] * (max_n + 1)\\n self.__qp = [-1] * (max_n + 1)\\n self.__keys = [None] * (max_n + 1)\\n self.__n = 0\",\n \"def adaptive_max_pool2d(input, output_size):\\n args = utils._get_adaptive_pool_args(\\n input.size()[-2:], utils._pair(output_size))\\n return _pool('MAX', utils._pair, input, **args)\",\n \"def set_max_noutput_items(self, m: \\\"int\\\") -> \\\"void\\\":\\n return _beamforming_swig.randomsampler_sptr_set_max_noutput_items(self, m)\",\n \"def max_pool_2x2(x):\\n#{{{\\n return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],\\n strides=[1, 2, 2, 1], padding='SAME')\",\n \"def contraction_max_algos():\\n return cutensor.contractionMaxAlgos()\",\n \"def max_output_buffer(self, i):\\n return _spacegrant_swig.general_burster_2_sptr_max_output_buffer(self, i)\",\n \"def __init__(self):\\n self.counts = [0] * 10\\n self.values = [0] * 10\\n self.softmaxvalues = [0] * 10\\n self.t = 0.3\",\n \"def compute(self, node, input_vals):\\r\\n #start = time.time()\\r\\n\\r\\n #assert len(input_vals) == 1\\r\\n strides = node.const_attr[1]\\r\\n ksize = node.const_attr[0]\\r\\n ish = list(input_vals[0].shape)\\r\\n input = input_vals[0]\\r\\n output = np.zeros([ish[0],(ish[1]-ksize[1])//strides[1]+1,(ish[2]-ksize[2])//strides[2]+1,ish[3]])\\r\\n osh = output.shape\\r\\n #print(osh)\\r\\n for i in range(osh[1]):\\r\\n for j in range(osh[2]):\\r\\n output[:,i,j,:] = np.amax(input[:,i*strides[1]:(i+1)*strides[1],j*strides[1]:(j+1)*strides[1],:],axis=(1,2))\\r\\n #end = time.time() \\r\\n #print(\\\"max_pool\\\") \\r\\n #print(end - start) \\r\\n return output\\r\\n \\r\\n #assert False\\r\",\n \"def test_max_N_too_small(self):\\n\\t\\t\\n\\t\\t\\n\\t\\tparams = DEFAULT_PARAMS.copy()\\n\\t\\tparams[MAX_N] = DEFAULT_MAX_EVALS+1\\n\\t\\t\\n\\t\\titerator = self.watcher.make_layer_iterator(model=self.model, params=params)\\n\\t\\tfor ww_layer in iterator:\\n\\t\\t\\tif ww_layer.N > params[MAX_N]:\\n\\t\\t\\t\\tself.assertTrue(ww_layer.skipped)\\n\\t\\t\\n\\t\\tdetails = self.watcher.describe(max_N=DEFAULT_MAX_EVALS+1)\\n\\t\\tprint(details[['N','M']])\\n\\t\\tself.assertEqual(10,len(details))\\n\\n\\t\\treturn\",\n \"def constraints_max_offer_per_cust(n_row, n_col):\\n constraints = np.identity(n_row * n_col)\\n return constraints\",\n \"def non_maximum_suppression(prediction, iou_threshold=0.45, score_threshold=0.25):\\n\\n # num_classes = len(names)\\n max_wh = 4096\\n max_det = 300\\n max_nms = 30000\\n output = [torch.zeros((0, 6), device=prediction.device)] * prediction.shape[0]\\n\\n for xi, x in enumerate(prediction):\\n x = x[x[..., 4] > score_threshold]\\n\\n # If none remain process next image\\n if not x.shape[0]:\\n continue\\n\\n # Compute conf\\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\\n\\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\\n box = x[:, :4]\\n\\n conf, j = x[:, 5:].max(1, keepdim=True)\\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > score_threshold]\\n\\n # Filter by class\\n # if classes is not None:\\n # x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)]\\n\\n # Check shape\\n n = x.shape[0] # number of boxes\\n if not n: # no boxes\\n continue\\n elif n > max_nms: # excess boxes\\n # sort by confidence\\n x = x[x[:, 4].argsort(descending=True)[:max_nms]]\\n\\n # Batched NMS\\n c = x[:, 5:6] * max_wh # classes\\n # boxes (offset by class), scores\\n boxes, scores = x[:, :4] + c, x[:, 4]\\n i = nms(boxes, scores, iou_threshold) # NMS\\n if i.shape[0] > max_det: # limit detections\\n i = i[:max_det]\\n\\n output[xi] = x[i]\\n\\n return output\",\n \"def max_noutput_items(self):\\n return _spacegrant_swig.hdlc_deframer_sptr_max_noutput_items(self)\",\n \"def set_max_noutput_items(self, m):\\n return _spacegrant_swig.NRZI_sptr_set_max_noutput_items(self, m)\",\n \"def set_max_noutput_items(self, m):\\n return _spacegrant_swig.DeNRZI_sptr_set_max_noutput_items(self, m)\",\n \"def set_max_noutput_items(self, m):\\n return _spacegrant_swig.G3RUH_descramble_sptr_set_max_noutput_items(self, m)\",\n \"def MaxHks(N): \\n return np.log2(N-1)/2\",\n \"def __init__(self, max_len, max_num):\\n self.a = {}\\n self.a[0] = [[]]\\n self.a[1] = [[1]]\\n\\n self.max_len = max_len\\n self.max_num = max_num\",\n \"def nms(boxes, scores, overlap=0.5, top_k=200):\\n\\n keep = torch.Tensor(scores.size(0)).fill_(0).long()\\n if boxes.numel() == 0:\\n return keep\\n x1 = boxes[:, 0]\\n y1 = boxes[:, 1]\\n x2 = boxes[:, 2]\\n y2 = boxes[:, 3]\\n area = torch.mul(x2 - x1, y2 - y1)\\n v, idx = scores.sort(0) # sort in ascending order\\n # I = I[v >= 0.01]\\n idx = idx[-top_k:] # indices of the top-k largest vals\\n xx1 = boxes.new()\\n yy1 = boxes.new()\\n xx2 = boxes.new()\\n yy2 = boxes.new()\\n w = boxes.new()\\n h = boxes.new()\\n\\n # keep = torch.Tensor()\\n count = 0\\n while idx.numel() > 0:\\n i = idx[-1] # index of current largest val\\n # keep.append(i)\\n keep[count] = i\\n count += 1\\n if idx.size(0) == 1:\\n break\\n idx = idx[:-1] # remove kept element from view\\n # load bboxes of next highest vals\\n torch.index_select(x1, 0, idx, out=xx1)\\n torch.index_select(y1, 0, idx, out=yy1)\\n torch.index_select(x2, 0, idx, out=xx2)\\n torch.index_select(y2, 0, idx, out=yy2)\\n # store element-wise max with next highest score\\n xx1 = torch.clamp(xx1, min=x1[i])\\n yy1 = torch.clamp(yy1, min=y1[i])\\n xx2 = torch.clamp(xx2, max=x2[i])\\n yy2 = torch.clamp(yy2, max=y2[i])\\n w.resize_as_(xx2)\\n h.resize_as_(yy2)\\n w = xx2 - xx1\\n h = yy2 - yy1\\n # check sizes of xx1 and xx2.. after each iteration\\n w = torch.clamp(w, min=0.0)\\n h = torch.clamp(h, min=0.0)\\n inter = w*h\\n # IoU = i / (area(a) + area(b) - i)\\n rem_areas = torch.index_select(area, 0, idx) # load remaining areas)\\n union = (rem_areas - inter) + area[i]\\n IoU = inter/union # store result in iou\\n # keep only elements with an IoU <= overlap\\n idx = idx[IoU.le(overlap)]\\n return keep, count\",\n \"def set_max_noutput_items(self, *args, **kwargs):\\n return _TestA_swig.cleanslate_sptr_set_max_noutput_items(self, *args, **kwargs)\",\n \"def hard_nms(box_scores, iou_threshold, top_k=-1, candidate_size=10):\\n # TOP_K was originally -1, to keep all faces, but trying to filter\\n # CANDIDATE_SIZE was originally 200, trying to limit # of faces\\n scores = box_scores[:, -1]\\n boxes = box_scores[:, :-1]\\n picked = []\\n indexes = np.argsort(scores)\\n indexes = indexes[-candidate_size:]\\n while len(indexes) > 0:\\n current = indexes[-1]\\n picked.append(current)\\n if 0 < top_k == len(picked) or len(indexes) == 1:\\n break\\n current_box = boxes[current, :]\\n\\n indexes = indexes[:-1]\\n rest_boxes = boxes[indexes, :]\\n iou = iou_of(\\n rest_boxes,\\n np.expand_dims(current_box, axis=0),\\n )\\n indexes = indexes[iou <= iou_threshold]\\n \\n # additional method of discrimination, only the boxes\\n # with the largest areas are selected\\n new_boxes = box_scores[picked, :]\\n areas = []\\n for box in new_boxes:\\n left_top = np.asarray([box[0], box[1]])\\n right_bottom = np.asarray([box[2], box[3]])\\n area = area_of(left_top, right_bottom)\\n areas.append(area)\\n areas = np.asarray(areas)\\n biggest = np.argsort(areas)\\n last_index = len(biggest) - 1\\n middle = max(len(biggest)// 2, 1)\\n size = min(middle, candidate_size / 2)\\n \\n final_boxes = []\\n for i in range(size):\\n final_boxes.append(new_boxes[biggest[last_index-i]])\\n final_boxes = np.asarray(final_boxes)\\n \\n return final_boxes\\n #return box_scores[picked, :]\",\n \"def max_output_buffer(self, i: \\\"int\\\") -> \\\"long\\\":\\n return _beamforming_swig.phasedarray_sptr_max_output_buffer(self, i)\",\n \"def set_max_noutput_items(self, m):\\n return _spacegrant_swig.hdlc_deframer_sptr_set_max_noutput_items(self, m)\",\n \"def set_max_noutput_items(self, m: \\\"int\\\") -> \\\"void\\\":\\n return _beamforming_swig.beamformer_sptr_set_max_noutput_items(self, m)\",\n \"def max_level(data: np.ndarray) -> int:\\n shape = data.shape[1:] # exclude channel dimension\\n return min(shape).bit_length() - 1\",\n \"def n_largest_channels(summed, n=6):\\r\\n\\r\\n rows, columns = summed.shape\\r\\n\\r\\n # n has to be smaller than the number of rows\\r\\n assert n <= rows\\r\\n\\r\\n n_out_of_m = np.zeros(summed.shape)\\r\\n\\r\\n for col in range(columns):\\r\\n column = summed[:, col]\\r\\n indices = np.argsort(column)[:-n]\\r\\n tmp = column\\r\\n tmp[indices] = 0\\r\\n n_out_of_m[:, col] = tmp\\r\\n\\r\\n return n_out_of_m\",\n \"def __init__(self, max_num_of_rounds_to_retain=100, num_of_last_check_rounds_consider=2):\\n self.data = list()\\n self.max_num_of_rounds_to_retain = max_num_of_rounds_to_retain\\n self.num_of_last_check_rounds_consider = num_of_last_check_rounds_consider\",\n \"def nms(boxes, scores, overlap=0.5, top_k=200):\\n\\n keep = scores.new(scores.size(0)).zero_().long()\\n if boxes.numel() == 0:\\n return keep\\n x1 = boxes[:, 0]\\n y1 = boxes[:, 1]\\n x2 = boxes[:, 2]\\n y2 = boxes[:, 3]\\n area = torch.mul(x2 - x1, y2 - y1)\\n v, idx = scores.sort(0) # sort in ascending order\\n # I = I[v >= 0.01]\\n idx = idx[-top_k:] # indices of the top-k largest vals\\n xx1 = boxes.new()\\n yy1 = boxes.new()\\n xx2 = boxes.new()\\n yy2 = boxes.new()\\n w = boxes.new()\\n h = boxes.new()\\n\\n # keep = torch.Tensor()\\n count = 0\\n while idx.numel() > 0:\\n i = idx[-1] # index of current largest val\\n # keep.append(i)\\n keep[count] = i\\n count += 1\\n if idx.size(0) == 1:\\n break\\n idx = idx[:-1] # remove kept element from view\\n # load bboxes of next highest vals\\n torch.index_select(x1, 0, idx, out=xx1)\\n torch.index_select(y1, 0, idx, out=yy1)\\n torch.index_select(x2, 0, idx, out=xx2)\\n torch.index_select(y2, 0, idx, out=yy2)\\n # store element-wise max with next highest score\\n xx1 = torch.clamp(xx1, min=x1[i])\\n yy1 = torch.clamp(yy1, min=y1[i])\\n xx2 = torch.clamp(xx2, max=x2[i])\\n yy2 = torch.clamp(yy2, max=y2[i])\\n w.resize_as_(xx2)\\n h.resize_as_(yy2)\\n w = xx2 - xx1\\n h = yy2 - yy1\\n # check sizes of xx1 and xx2.. after each iteration\\n w = torch.clamp(w, min=0.0)\\n h = torch.clamp(h, min=0.0)\\n inter = w*h\\n # IoU = i / (area(a) + area(b) - i)\\n rem_areas = torch.index_select(area, 0, idx) # load remaining areas)\\n union = (rem_areas - inter) + area[i]\\n IoU = inter/union # store result in iou\\n # keep only elements with an IoU <= overlap\\n idx = idx[IoU.le(overlap)]\\n return keep, count\",\n \"def max_output_buffer(self, i):\\n return _add_vector_swig.add_vector_2_cpp_sptr_max_output_buffer(self, i)\",\n \"def set_max_noutput_items(self, m):\\n return _spacegrant_swig.hdlc_framer_sptr_set_max_noutput_items(self, m)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5717705","0.5661527","0.5603735","0.5556727","0.5533146","0.54946077","0.54890066","0.5484546","0.54764545","0.5465916","0.54387826","0.54167676","0.5408915","0.5392852","0.5391776","0.53902745","0.5386068","0.53750616","0.5368087","0.5362609","0.5357239","0.53557456","0.53500104","0.5347422","0.5346802","0.53459895","0.5344874","0.53320915","0.53192997","0.531634","0.531553","0.5312746","0.5309329","0.5303385","0.53004473","0.5283153","0.52820146","0.5268377","0.52659464","0.52625155","0.52608544","0.5254505","0.5253804","0.52489066","0.52300704","0.52268285","0.52228117","0.5220608","0.5216667","0.5216445","0.52157915","0.52139103","0.52054644","0.52045923","0.52042705","0.5201294","0.5181019","0.5180875","0.51801574","0.51800007","0.51779133","0.51764745","0.51695186","0.51625425","0.5158056","0.51523143","0.5150153","0.51498204","0.514667","0.5145773","0.51413447","0.51408887","0.5130253","0.51254153","0.51242703","0.5122433","0.51210934","0.5105053","0.5104855","0.5104497","0.5095511","0.5094798","0.50944513","0.50830334","0.5082763","0.50778705","0.5074727","0.5071113","0.5070279","0.5069339","0.5065598","0.50636744","0.50618577","0.50573176","0.5055059","0.5045263","0.50441986","0.50359535","0.5035791","0.5029401"],"string":"[\n \"0.5717705\",\n \"0.5661527\",\n \"0.5603735\",\n \"0.5556727\",\n \"0.5533146\",\n \"0.54946077\",\n \"0.54890066\",\n \"0.5484546\",\n \"0.54764545\",\n \"0.5465916\",\n \"0.54387826\",\n \"0.54167676\",\n \"0.5408915\",\n \"0.5392852\",\n \"0.5391776\",\n \"0.53902745\",\n \"0.5386068\",\n \"0.53750616\",\n \"0.5368087\",\n \"0.5362609\",\n \"0.5357239\",\n \"0.53557456\",\n \"0.53500104\",\n \"0.5347422\",\n \"0.5346802\",\n \"0.53459895\",\n \"0.5344874\",\n \"0.53320915\",\n \"0.53192997\",\n \"0.531634\",\n \"0.531553\",\n \"0.5312746\",\n \"0.5309329\",\n \"0.5303385\",\n \"0.53004473\",\n \"0.5283153\",\n \"0.52820146\",\n \"0.5268377\",\n \"0.52659464\",\n \"0.52625155\",\n \"0.52608544\",\n \"0.5254505\",\n \"0.5253804\",\n \"0.52489066\",\n \"0.52300704\",\n \"0.52268285\",\n \"0.52228117\",\n \"0.5220608\",\n \"0.5216667\",\n \"0.5216445\",\n \"0.52157915\",\n \"0.52139103\",\n \"0.52054644\",\n \"0.52045923\",\n \"0.52042705\",\n \"0.5201294\",\n \"0.5181019\",\n \"0.5180875\",\n \"0.51801574\",\n \"0.51800007\",\n \"0.51779133\",\n \"0.51764745\",\n \"0.51695186\",\n \"0.51625425\",\n \"0.5158056\",\n \"0.51523143\",\n \"0.5150153\",\n \"0.51498204\",\n \"0.514667\",\n \"0.5145773\",\n \"0.51413447\",\n \"0.51408887\",\n \"0.5130253\",\n \"0.51254153\",\n \"0.51242703\",\n \"0.5122433\",\n \"0.51210934\",\n \"0.5105053\",\n \"0.5104855\",\n \"0.5104497\",\n \"0.5095511\",\n \"0.5094798\",\n \"0.50944513\",\n \"0.50830334\",\n \"0.5082763\",\n \"0.50778705\",\n \"0.5074727\",\n \"0.5071113\",\n \"0.5070279\",\n \"0.5069339\",\n \"0.5065598\",\n \"0.50636744\",\n \"0.50618577\",\n \"0.50573176\",\n \"0.5055059\",\n \"0.5045263\",\n \"0.50441986\",\n \"0.50359535\",\n \"0.5035791\",\n \"0.5029401\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58375233"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":1,"numItemsPerPage":100,"numTotalItems":95772,"offset":100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3MzQ2NjY4MSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM0NzAyODEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.35XzVrp3zXSRm4Fs_uBTf8HLWkbAU060RHD6Fm23D1_7FPUNmr7oIHrwvocsrjH4ainiZhnCHibDp7-Tfs62Dg","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 |
|---|---|---|---|---|---|---|
The `ComputeCluster` data source can be used to discover the ID of a cluster in vSphere. This is useful to fetch the ID of a cluster that you want to use for virtual machine placement via the `VirtualMachine` resource, allowing to specify the cluster's root resource pool directly versus using the alias available through the `ResourcePool` data source. > You may also wish to see the `ComputeCluster` resource for more information about clusters and how to managed the resource in this provider. Example Usage ```python import pulumi import pulumi_vsphere as vsphere datacenter = vsphere.get_datacenter(name="dc01") compute_cluster = vsphere.get_compute_cluster(name="cluster01", datacenter_id=datacenter.id) ``` | def get_compute_cluster_output(datacenter_id: Optional[pulumi.Input[Optional[str]]] = None,
name: Optional[pulumi.Input[str]] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetComputeClusterResult]:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_compute_cluster(datacenter_id: Optional[str] = None,\n name: Optional[str] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetComputeClusterResult:\n __args__ = dict()\n __args__['datacenterId'] = datacenter_id\n __args__['name'] = n... | [
"0.72311264",
"0.70518404",
"0.67735595",
"0.6768537",
"0.6736824",
"0.6736824",
"0.6736824",
"0.6736824",
"0.6736824",
"0.66624004",
"0.66624004",
"0.66624004",
"0.66624004",
"0.6613303",
"0.660601",
"0.660601",
"0.6474703",
"0.6474703",
"0.6474703",
"0.63924193",
"0.6386118... | 0.70052683 | 2 |
Despliega el formulario de creacion de usuario y empleado para una sucursal. | def get(self,request,*args,**kwargs):
sucursal = Sucursal.objects.get(id=kwargs['spk'])
user_form = UserForm()
empleado_form = EmpleadoForm( initial={'sucursal':sucursal.id} )
forms = [user_form,empleado_form]
context = {
'section_title':'Nuevo Empleado',
'button_text':'Crear',
'sucursal':sucursal,
'user_form':user_form,
'empleado_form':empleado_form }
return render_to_response(
'empleado/empleado_form.html',
context,
context_instance=RequestContext(request)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_user(request):\n user = User.objects.get(username=request.user.username)\n #Validacion de permisos----------------------------------------------\n roles = UsuarioRolSistema.objects.filter(usuario = user).only('rol')\n permisos_obj = []\n for i in roles:\n permisos_obj.extend(i.rol.per... | [
"0.67103773",
"0.65624523",
"0.64488596",
"0.62953645",
"0.62946165",
"0.62440854",
"0.62051827",
"0.6188632",
"0.60768074",
"0.60262233",
"0.6007331",
"0.5995433",
"0.5959869",
"0.592796",
"0.5894467",
"0.58874565",
"0.58790886",
"0.58777773",
"0.5834341",
"0.5799069",
"0.57... | 0.5909672 | 14 |
Test addition for Complex with Complex, complex, int and float | def test_add():
z = Complex(1, -2)
w = Complex(1, 1)
assert (z + w) == Complex(2, -1)
assert (z + (1+1j)) == Complex(2, -1)
assert (z + 2) == Complex(3, -2)
assert (z + 2.0) == Complex(3, -2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def complex_sum(c_1,c_2):\n return c_1 + c_2",
"def _cmplx_add_ ( s , o ) :\n return o + complex ( s )",
"def __add__(self, other):\n if isinstance(other, float) or isinstance(other, int):\n return Complex(self._reNum + other, self._imNum)\n if isinstance(other, complex):\... | [
"0.76475245",
"0.7613455",
"0.73216003",
"0.7232131",
"0.7204029",
"0.7114866",
"0.6915121",
"0.69098693",
"0.6900085",
"0.6607692",
"0.6509762",
"0.6498399",
"0.6357027",
"0.6335295",
"0.63045627",
"0.6205945",
"0.61870325",
"0.6182034",
"0.6174292",
"0.6170315",
"0.61585486... | 0.81614006 | 0 |
Test subtraction for Complex with Complex, complex, int and float | def test_sub():
z = Complex(1, -2)
w = Complex(1, 1)
assert (z - w) == Complex(0, -3)
assert (z - (1+1j)) == Complex(0, -3)
assert (z - 2) == Complex(-1, -2)
assert (z - 2.0) == Complex(-1, -2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def complex_difference(c_1,c_2):\n return c_1 - c_2",
"def _cmplx_sub_ ( s , o ) :\n return (-o ) + complex ( s )",
"def complex(real, imag):",
"def __sub__(self,other):\n\t\treal = self.realPart - other.realPart\n\t\timaginary = self.imaginaryPart - other.imaginaryPart\n\n\t\t#create and retu... | [
"0.73002094",
"0.69852185",
"0.6779295",
"0.6768346",
"0.6679916",
"0.6596779",
"0.6549099",
"0.64673406",
"0.6422183",
"0.6415886",
"0.63986313",
"0.628705",
"0.6265425",
"0.62318534",
"0.61975026",
"0.6182748",
"0.6176905",
"0.6081503",
"0.60485506",
"0.6047534",
"0.6038145... | 0.75719965 | 0 |
(12i)(2+2i) = 2 + 2i 4i + 4 = 6 2i | def test_mul():
z = Complex(1, -2)
v = Complex(2, 2)
assert z*v == Complex(6, -2)
assert v*z == z*v
assert z*2 == Complex(2, -4)
assert z*2.0 == Complex(2, -4)
assert z*(2+2j) == v*z | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sw(n):\n return 4*n*n + 2*n + 1",
"def problem():\n size = 1001\n return sum(n**2 * 4 - 6 * n + 6 for n in range(3, size+1, 2)) + 1",
"def f(x):\n return ((x[0] - 1) ** 2) + ((x[1] + 3) ** 2)",
"def triangular_number_solution():\n return 5 * partial_sum(199) + 3 * partial_sum(333) - 15 * p... | [
"0.6762975",
"0.61464405",
"0.6060709",
"0.599007",
"0.59566283",
"0.59457093",
"0.5927478",
"0.59023225",
"0.5873529",
"0.5866177",
"0.58424276",
"0.58367133",
"0.58342266",
"0.58271873",
"0.58252615",
"0.5824011",
"0.5807665",
"0.58015585",
"0.5773675",
"0.5770493",
"0.5753... | 0.0 | -1 |
Compute LDA model & find perplexity, save topics list for coherence calc | def lda_models(doc_term_matrix, n_topics, vectorizer, rand_start):
perplexity_values = []
lda_time = []
topics_list = []
i = rand_start
for num_topics in n_topics:
# create model
t1 = time.time()
lda_model = LatentDirichletAllocation(n_components=num_topics, doc_topic_prior = 1/num_topics,
topic_word_prior=0.1, n_jobs=39, random_state = i)
lda_model.fit_transform(doc_term_matrix)
t2 = time.time()
lda_time.append(t2-t1)
print(f" Model time: {t2-t1}", flush = True)
# compute perplexity
perplexity_values.append(lda_model.bound_)
# create list of topics
topics = list_topics(lda_model.components_, vectorizer, top_n=10)
topics_list.append(topics)
# output completion message
i = i+1
print('Number of topics =', num_topics, "complete.", flush = True)
return perplexity_values, lda_time, topics_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_lda_model(self):\n self.id2word = corpora.Dictionary(self.documents)\n self.id2word.filter_extremes(no_below=20, no_above=0.5)\n corpus = [self.id2word.doc2bow(text) for text in self.documents]\n coherence_c_v = []\n coherence_u_mass = []\n print(\"Fitting models\"... | [
"0.7421184",
"0.73544043",
"0.72307",
"0.7002529",
"0.6943727",
"0.673741",
"0.6723259",
"0.6671794",
"0.6657565",
"0.6648194",
"0.6644296",
"0.66000706",
"0.6559571",
"0.6551705",
"0.65513426",
"0.65454745",
"0.6489818",
"0.64809227",
"0.6480784",
"0.6443412",
"0.63931346",
... | 0.744949 | 0 |
In case we're running innon autoreload mode we need to restart server | def reload(self):
puts('Reloading application...')
local('touch ../reload.txt') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def webserver_restart():\n try:\n run(\"kill -HUP $(cat %s)\" % GUNICORN_PIDFILE)\n except:\n webserver_start()",
"def _restart(self):\n pass",
"def at_server_reload(self):\n self.db.started = True",
"def restart_nginx():\n run_command_on_selected_server(_restart_nginx)",... | [
"0.72675717",
"0.72130495",
"0.704559",
"0.668948",
"0.66131496",
"0.65728164",
"0.65231895",
"0.6460572",
"0.64301753",
"0.6418728",
"0.6396875",
"0.63923776",
"0.6356839",
"0.63194877",
"0.6300053",
"0.6296835",
"0.6279461",
"0.6236136",
"0.62225044",
"0.62004274",
"0.62004... | 0.6135069 | 27 |
Workaround manage.py migrate complications run syncdb in case it's our first run, so we make sure south_migrationhistory table is created run migrate to apply latest migrations run syncdb again to populate contrib.auth.models | def smart_syncdb_migrate(self):
local('python manage.py syncdb')
local('python manage.py migrate')
local('python manage.py syncdb --all') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def migrate():\n puts(yellow(\"Run South migrations\"))\n django_manage('migrate')",
"def post_migrations(self):",
"def migrate(self):\n\tpass",
"def syncdb():\n with virtualenv():\n run('python manage.py syncdb --noinput')\n run('python manage.py migrate')",
"def update_db():\r\n ... | [
"0.7362598",
"0.7175394",
"0.6962745",
"0.67925906",
"0.66853064",
"0.665665",
"0.66325575",
"0.65849835",
"0.6555793",
"0.65435",
"0.6471299",
"0.6459678",
"0.6422288",
"0.6384289",
"0.63629246",
"0.6273245",
"0.615992",
"0.61169046",
"0.6091286",
"0.60912824",
"0.60731256",... | 0.7330435 | 1 |
Takes an image and assigns a speed from 01 based upon it. | def process(img):
global start
frame = cv2.GaussianBlur(img, (21, 21), 0)
fgmask = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
fgmask = cv2.absdiff(start, fgmask)
avg = max(np.average(fgmask), 10)
fgmask = cv2.dilate(fgmask, None, iterations=2)
ret, fgmask = cv2.threshold(fgmask, avg, 255, cv2.THRESH_BINARY)
image, contours, hierarchy = cv2.findContours(fgmask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
bigContours = []
for contour in contours:
if cv2.contourArea(contour) >= 3000:
bigContours.append(contour)
ax = 0
ay = 0
for contour in bigContours:
moments = cv2.moments(contour)
cx = int(moments['m10']/moments['m00'])
cy = int(moments['m01']/moments['m00'])
ax += cx
ay += cy
if not bigContours:
speed = 0
else:
ax /= len(bigContours)
ay /= len(bigContours)
my, mx, channels = img.shape
my /= 2
mx /= 2
dist = math.sqrt((ax - mx)**2 + (ay - my)**2)
speed = max(min((mx - dist) / my, 1), 0.1)
if speed > 0.8:
speed = 1
return speed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def speed(self, speed: int, time: int = 0, /) -> None:",
"def set_speed(speed):\n if speed >255:\n speed =255\n elif speed <0:\n speed =0\n set_left_speed(speed)\n #time.sleep(.1)\n set_right_speed(speed)",
"def set_speed():\n pass",
"def speed(self, value: int, /) -> None:",
... | [
"0.6555752",
"0.6486258",
"0.63528025",
"0.63336885",
"0.6330112",
"0.6309524",
"0.6249848",
"0.6223644",
"0.61646354",
"0.615034",
"0.6127424",
"0.6127424",
"0.60513264",
"0.60458",
"0.6031286",
"0.6002849",
"0.5983297",
"0.5926888",
"0.5913099",
"0.5911406",
"0.5908372",
... | 0.0 | -1 |
Ready handler. Import signals. | def ready(self):
import roles.signals # pylint: disable=unused-import | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ready(self):\n import main.signals # noqa",
"def ready(self):\n\n from . import signals # noqa",
"def ready(self):\n import exams.signals # pylint: disable=unused-import",
"def ready(self):\n logger.info('game.ready')\n import game.signals",
"def ready(self):\n ... | [
"0.85961705",
"0.8477948",
"0.7967753",
"0.795883",
"0.77848405",
"0.7611131",
"0.7388606",
"0.7360492",
"0.7330842",
"0.7245289",
"0.72177434",
"0.7132327",
"0.705162",
"0.69547033",
"0.691362",
"0.6873511",
"0.68556416",
"0.672121",
"0.6704173",
"0.66943926",
"0.6646311",
... | 0.7746457 | 5 |
ssum([1,2,3]) 6 ssum([2,3]) 5 ssum([3]) 3 ssum([]) 0 | def ssum(L: list) -> int:
return 0 if not L else L[0]+ssum(L[1:]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def zero_sum(list):\n if not list:\n return 0\n else:\n return sum(list)",
"def sum_unique(l):\n pass",
"def sum_of_squares(seq):\n if len(seq) == 0:\n return 0\n else:\n result = 0\n for num in seq:\n result += num ** 2\n return result",
"d... | [
"0.6345257",
"0.62525344",
"0.6204409",
"0.61191237",
"0.6101727",
"0.6077421",
"0.60648704",
"0.60515577",
"0.60255706",
"0.5993455",
"0.5983791",
"0.5964002",
"0.5958428",
"0.594942",
"0.5904664",
"0.5882846",
"0.5862508",
"0.5862386",
"0.5833747",
"0.582293",
"0.58177805",... | 0.7876537 | 0 |
factorial(5) > 120 factorial(4) > 24 factorial(3) > 6 factorial(2) > 2 factorial(1) > 1 factorial(0) > 1 | def factorial(N: int) -> int:
return N*factorial(N-1) if N else 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def factorial(n):\n\n # the code for factorial",
"def factorial(n):\n return reduce(mul, range(1, n), 1)",
"def calculateFactorials():\n\n ni = []\n ni.append( 295232799039604140847618609643520000000) # 34!\n ITERATIONS = 34\n for n in range( 1, ITERATIONS,1 ) :\n ni.append(math.floor... | [
"0.8139361",
"0.79235435",
"0.78876895",
"0.7874468",
"0.7866474",
"0.784772",
"0.7841788",
"0.7832985",
"0.7827345",
"0.7794977",
"0.7794691",
"0.7788781",
"0.7775511",
"0.7756817",
"0.77249163",
"0.77127343",
"0.76884425",
"0.7687114",
"0.7661024",
"0.76508266",
"0.7629169"... | 0.74416447 | 44 |
hello hell hel he h | def pars_str(stroka: str) -> None:
print(stroka)
return pars_str(stroka[:-1]) if stroka else 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shout(word):\n print(word+\"!\")",
"def middle(word):\n return word[1:-1]",
"def think(s):",
"def middle(word):\n\treturn word[1:-1]",
"def gibberish(*args):\n \n # Initialize an empty string: hodgepodge\n hodgepodge = ''\n\n # Concatenate the strings in args\n for word in args:\n ... | [
"0.58079946",
"0.5710749",
"0.56786484",
"0.5669718",
"0.56644154",
"0.5633301",
"0.56264555",
"0.55352926",
"0.55349237",
"0.55043215",
"0.5499545",
"0.5480967",
"0.54765",
"0.54765",
"0.54730135",
"0.54675144",
"0.5462265",
"0.54491264",
"0.5444947",
"0.5444947",
"0.5444947... | 0.0 | -1 |
print_stars(5) \n\n\n\n\n print_stars(4) \n\n\n\n print_stars(3) \n\n\n print_stars(2) \n\n print_stars(1) \n print_stars(0) '' | def print_stars(N: int) -> str:
# if N:
# return f'*\n{print_stars(N-1)}'
# return ''
return '' if not N else f'*\n{print_stars(N-1)}' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_stars():\n for i in range(2):\n for j in range(35):\n print(\"*\", end = '')\n print('')",
"def star():\n print('*', end='')",
"def starry_box(phrase):\n numStars = len(phrase) + 4\n print '*' * numStars\n print '*', phrase, '*'\n print '*' * num... | [
"0.78595215",
"0.7326586",
"0.6608579",
"0.66084236",
"0.64868563",
"0.6461798",
"0.62855875",
"0.6244473",
"0.6224193",
"0.621459",
"0.61932653",
"0.61023444",
"0.6071811",
"0.59977406",
"0.5921401",
"0.5901315",
"0.58597124",
"0.5856981",
"0.58483934",
"0.5816308",
"0.57875... | 0.8280417 | 0 |
Mutual Information by Entropy norm between specific items. | def mmi_norm(self, x, y, tuples):
P_ = {x: self.P(x, tuples), y: self.P(y, tuples)}
P_xy = self.condP(x, y, tuples)
return - P_[x] * log2(P_[x]) - P_[y] * (-P_xy * log2(P_xy)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalized_mutual_information(cl: np.ndarray, org: np.ndarray):\n assert cl.shape == org.shape\n\n return mutual_info_score(org, cl) / (abs(entropy(cl) + entropy(org)) / 2)",
"def mutual_information(mc_preds):\n mutual_info = entropy(np.mean(mc_preds, axis=0)) - np.mean(entropy(mc_preds),\n ... | [
"0.6674753",
"0.61827624",
"0.60942334",
"0.6003122",
"0.5959863",
"0.5958628",
"0.5811477",
"0.57843643",
"0.569512",
"0.5683817",
"0.56066775",
"0.55940205",
"0.5578646",
"0.557442",
"0.5545874",
"0.55332446",
"0.55060184",
"0.55060184",
"0.5491687",
"0.5481766",
"0.5452757... | 0.5009674 | 49 |
Mutual Information by Entropy norm between specific item and the D_k text sample. | def cmi_norm(self, query, tuples):
P_, vocab, H_D = self.entropy_norm(tuples)
I_D = [] # I(D; q) = H(D) - H(D|q)
I_as = H_D # I(D; q1, q2,...,qn) = H(D) - H(D|q1) - ... - H(D|qn)
for q in query:
P_wq = odict({w + '|' + q: self.condP(w, q, tuples)
for w in vocab})
H_Dq = -P_[q] * sum(P_wq[pwq] * log2(P_wq[pwq])
for pwq in P_wq.keys())
I_D.append((q, H_D - H_Dq))
I_as -= H_Dq
# TODO: define a,b,c for giving negative reward
# if not (mmi_norm(a,b, tuples) > mmi_norm(b,c, tuples) > mmi_norm(a,c, tuples)):
# I_as = self.zeta
return I_D, I_as | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalized_mutual_information(cl: np.ndarray, org: np.ndarray):\n assert cl.shape == org.shape\n\n return mutual_info_score(org, cl) / (abs(entropy(cl) + entropy(org)) / 2)",
"def mutual_information(mc_preds):\n mutual_info = entropy(np.mean(mc_preds, axis=0)) - np.mean(entropy(mc_preds),\n ... | [
"0.5616423",
"0.5585292",
"0.5472835",
"0.53419083",
"0.5322406",
"0.5318265",
"0.5269511",
"0.526485",
"0.5195288",
"0.5182691",
"0.51384085",
"0.5133426",
"0.5114074",
"0.5107224",
"0.5082305",
"0.50695926",
"0.5055395",
"0.50359356",
"0.5018013",
"0.5010474",
"0.50092155",... | 0.51792824 | 10 |
a RPA that adds a word to Anki | def add_word(word, option, scraped_info, t_sleep=2.75):
subprocess.Popen('C:\\Program Files\\Anki\\anki.exe') # opening the anki program
time.sleep(t_sleep+5)
focus_screen()
time.sleep(t_sleep)
pyautogui.hotkey('a') # opening the add window - in the front area
n_example = len(glob.glob(f'./words/{word}/meaning_{option}/example[0-9].txt')) # numbers of examples
time.sleep(t_sleep)
pyautogui.write(word + '\n')
try: # try to write the inflections
with open(f'./words/{word}/inflections.txt') as file: # add inflection (if exist)
pyautogui.write('Inflections: ' + file.readline() + '\n\n')
except FileNotFoundError: # inflections not found, pass
pass
if scraped_info['searched word']['mp3'] != None: # adding the word pronunciation
pyautogui.hotkey('f3') # attach picture/audio/video
time.sleep(t_sleep)
pyautogui.hotkey('ctrl', 'l') # path insert mode
pyautogui.write(os.getcwd() + f'\\words\\{word}')
time.sleep(t_sleep)
pyautogui.press('enter')
time.sleep(t_sleep)
pyautogui.hotkey('alt', 'n')
time.sleep(t_sleep)
pyautogui.write(f'{word}.mp3')
time.sleep(t_sleep)
pyautogui.press('enter')
for example_number in range(n_example):
with open(f'./words/{word}/meaning_{option}/example{example_number}.txt', 'r') as file:
pyautogui.write(('\n' if example_number!=0 else '') + f'Example {example_number+1}:' + next(file) + '\n') # write the example
pyautogui.hotkey('f3') # attach picture/audio/video
time.sleep(t_sleep)
pyautogui.hotkey('ctrl', 'l') # path insert mode
pyautogui.write(os.getcwd() + f'\\words\\{word}\\meaning_{option}')
time.sleep(t_sleep)
pyautogui.press('enter')
time.sleep(t_sleep)
pyautogui.hotkey('alt', 'n')
time.sleep(t_sleep)
pyautogui.write(f'example{example_number}.mp3')
time.sleep(t_sleep)
pyautogui.press('enter')
time.sleep(t_sleep)
pyautogui.press('tab') # switch to back
with open(f'./words/{word}/meaning_{option}/meaning{option}.txt') as file:
pyautogui.write(next(file)) # insert the meaning
time.sleep(t_sleep)
pyautogui.press('tab') # switch to back
with open(f'./words/{word}/meaning_{option}/tag.txt') as file:
pyautogui.write(next(file) + ' [CLAC]') # insert the vim
time.sleep(t_sleep)
pyautogui.press('tab') # switch to back
time.sleep(t_sleep)
pyautogui.press('enter')
time.sleep(t_sleep)
pyautogui.press('esc') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addWord(self, word: str) -> None:\n tmp = self.root\n for i, letter in enumerate(word):\n if letter not in tmp.seq:\n tmp.seq[letter] = Node()\n \n tmp = tmp.seq[letter]\n \n tmp.value = word",
"def add_word(self, word):\... | [
"0.6528331",
"0.64054376",
"0.636892",
"0.62993944",
"0.6260526",
"0.62493396",
"0.61003536",
"0.61003536",
"0.6083645",
"0.6070733",
"0.6045671",
"0.6045019",
"0.60449773",
"0.603758",
"0.6037229",
"0.6024666",
"0.6018381",
"0.5992664",
"0.59754694",
"0.59717524",
"0.5958048... | 0.5661711 | 62 |
Theano implementation of the Fast Gradient Sign method. | def fgm(x, predictions, y=None, eps=0.3, ord=np.inf, clip_min=None,
clip_max=None):
assert ord == np.inf, "Theano implementation not available for this norm."
if y is None:
# Using model predictions as ground truth to avoid label leaking
y = T.eq(predictions, T.max(predictions, axis=1, keepdims=True))
y = T.cast(y, utils_th.floatX)
y = y / T.sum(y, 1, keepdims=True)
# Compute loss
loss = utils_th.model_loss(y, predictions, mean=True)
# Define gradient of loss wrt input
grad = T.grad(loss, x)
# Take sign of gradient
signed_grad = T.sgn(grad)
# Multiply by constant epsilon
scaled_signed_grad = eps * signed_grad
# Add perturbation to original example to obtain adversarial example
adv_x = theano.gradient.disconnected_grad(x + scaled_signed_grad)
# If clipping is needed, reset all values outside of [clip_min, clip_max]
if (clip_min is not None) and (clip_max is not None):
adv_x = T.clip(adv_x, clip_min, clip_max)
return adv_x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def grad_sigmoid(self):\n return self.sigmoid(self.x)*(self.sigmoid(-self.x))\n raise NotImplementedError(\"Sigmoid gradient not implemented\")",
"def sigmoid_grad(self, X):\n var=self.sigmoid(X)\n return var*(1-var)",
"def sigmoid_grad(z):\n return Sigmoid(z) * (1 - Sigmoid(z))"... | [
"0.62575996",
"0.620261",
"0.6106974",
"0.6093499",
"0.60716397",
"0.5985662",
"0.5984108",
"0.59664273",
"0.59456444",
"0.590908",
"0.5791624",
"0.574362",
"0.5741642",
"0.5734987",
"0.5703245",
"0.56998265",
"0.5676139",
"0.566065",
"0.5639867",
"0.5634217",
"0.5617749",
... | 0.0 | -1 |
Assert that the first (leftmost) protocol value is correctly fetched from the xforwardedheader. | def test_get_protocol_with_more_than_one_value():
request = Mock(
headers={"X-Forwarded-Proto": "https,http,http"},
protocol="http",
)
expected = "https"
protocol = get_browser_protocol(request)
assert expected == protocol | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_h2_header_ok(self):\n self.set_frang_config(frang_config=\"http_strict_host_checking true;\")\n client = self.get_client(\"deproxy-1\")\n client.start()\n client.parsing = False\n\n first_headers = [(\":authority\", \"localhost\"), (\":path\", \"/\")]\n second_hea... | [
"0.6413071",
"0.6368929",
"0.63600814",
"0.6126467",
"0.6093351",
"0.6008764",
"0.597977",
"0.59638256",
"0.5935303",
"0.5915244",
"0.59103775",
"0.588814",
"0.58332074",
"0.5819531",
"0.58032525",
"0.57846427",
"0.5782095",
"0.57428664",
"0.5648308",
"0.5636194",
"0.5635823"... | 0.72213775 | 0 |
Assert that a dict of k/v's is correctly created when receiving encoded values. | def test_convert_request_arguments_with_encoded_items_to_dict():
arguments = {
"key1": [b"value1"],
"key2": [b"value2"],
"key3": [b"value3"],
}
expected = {
"key1": "value1",
"key2": "value2",
"key3": "value3",
}
result = convert_request_to_dict(arguments)
assert expected == result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_dict(self):\n self.assertValue(\n {'foo': 'foo', 'bar': 43, 'zippy': 'zoo'},\n 'bar: 43 foo: foo zippy: zoo\\n'\n )",
"def verifyData(self, expectedDict):\n pass",
"def test_key_dict(self):\n key = Key({\"warning\": False, \"inCar\": True})\n\n ... | [
"0.7359073",
"0.68950987",
"0.6765567",
"0.6608221",
"0.6606146",
"0.6555588",
"0.64671695",
"0.6464478",
"0.64596117",
"0.6452391",
"0.64428294",
"0.64428294",
"0.64036715",
"0.63711655",
"0.63386524",
"0.63026303",
"0.629081",
"0.6284405",
"0.6279023",
"0.6257576",
"0.62568... | 0.656517 | 5 |
Extract metadata like original image name and crop position from the given file name. Change this function to use a different file name pattern. | def get_metadata_from_filename(file_name: str) -> namedtuple:
if os.path.isabs(f):
file_name = os.path.basename(file_name)
original_image_name = file_name.split('-')[0]
x_pos = int(file_name.split('.')[-2].split('+')[-2:][0])
Metadata = namedtuple('Metadata', ['original_image_name', 'x_pos'])
return Metadata(original_image_name, x_pos) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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... | [
"0.7071573",
"0.66357124",
"0.64707863",
"0.6266383",
"0.61719465",
"0.6033898",
"0.600292",
"0.59774214",
"0.59133536",
"0.5879702",
"0.5877382",
"0.5843988",
"0.5837125",
"0.5832479",
"0.58029586",
"0.57413375",
"0.5720259",
"0.57090443",
"0.5669945",
"0.5668011",
"0.564875... | 0.6781023 | 1 |
Insert the crop represented by file_name into this image. | def insert(self, file_path: str, annot_type: str) -> None:
if self._valid_file_name_regex.match(os.path.basename(file_path)) is None:
raise ValueError(f'Illegal file name: {os.path.basename(file_path)}')
x_pos = get_metadata_from_filename(file_path).x_pos
if x_pos in self._x_positions:
col = self._cols[x_pos]
else:
col = Column()
self._x_positions.append(x_pos)
self._x_positions.sort()
col.insert(Crop(file_path, annot_type))
self._cols[x_pos] = col
self.n_cols = len(self._cols) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_current(self, image_name):\n # Sets the position of the crop\n self.j ,self.i = 0, 0\n\n # loads the image\n self.image = convert2int(tifffile.imread(image_name)).astype(numpy.float32)\n\n # Computes the number of crops in x and y\n self.ny = numpy.ceil(self.image.... | [
"0.60004956",
"0.5452988",
"0.53952855",
"0.53464556",
"0.53207326",
"0.52505255",
"0.5239172",
"0.518678",
"0.5163597",
"0.5147501",
"0.5141308",
"0.513236",
"0.5121384",
"0.5045127",
"0.5008329",
"0.50027025",
"0.49967998",
"0.4968934",
"0.49625248",
"0.4922145",
"0.4885444... | 0.56664383 | 1 |
Randomly divide this image into training, validation and test split. The image is divided into three randomly ordered consecutive patches. The fractions of the image going into each patch are given by val_split, test_split, and 1 (val_split + test_split), respectively. Columns in which the patches overlap are removed. | def select_randomly(self, val_split: float, test_split: float) -> {str: int}:
def _select(start, n, label) -> int:
"""
Label all columns in [start, start+n) with label.
"""
n_selected = 0
for i in range(start, int(start + n)):
x = self._x_positions[i]
n_selected += self._cols[x].mark_as(label)
return n_selected
def _remove_overlaps(start, end) -> int:
"""
Remove unlabelled columns in [start-col_width, end+col_width].
"""
start = self._x_positions[start % self.n_cols]
end = self._x_positions[int(end) % self.n_cols]
n_removed = 0
for x, col in self._cols.items():
if start - self.col_width <= x <= start or end <= x <= end + self.col_width:
if col.label is None:
n_removed += col.mark_as('ignore')
return n_removed
def _next_unlabelled_col(x):
"""
Return index of first unlabelled column after x.
"""
for i in range(self.n_cols):
idx = (x + i) % self.n_cols
x_current = self._x_positions[idx]
if self._cols[x_current].label is None:
return idx
# When computing number of columns per split we must take into account
# that some columns will be removed, i.e. we want to compute the split
# sizes as fraction of the number of actual selected columns, not of
# the total number of columns.
delta_x = self._x_positions[1] - self._x_positions[0]
n_to_remove_per_split = self.col_width / delta_x
# * 2 because 2 gaps between 3 splits
n_to_keep = self.n_cols - n_to_remove_per_split * 2
n_val = round(n_to_keep * val_split)
n_test = round(n_to_keep * test_split)
n_train = n_to_keep - n_val - n_test
n_selected_crops_per_split = dict.fromkeys(['training', 'validation', 'test', 'ignore'], 0)
# Place patches in arbitrary order
start = 0
for n, label in random.sample(list(zip([n_train, n_val, n_test], ['training', 'validation', 'test'])), k=3):
# Mark patch
n_selected_crops_per_split[label] += _select(start, n, label)
# Remove columns overlapping this patch
n_selected_crops_per_split['ignore'] += _remove_overlaps(start, start + n - 1)
# Next patch starts at next unlabelled column
start = _next_unlabelled_col(start)
return n_selected_crops_per_split | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split(self):\n\n ratio_c = 1 - self.ratio\n self.train, self.test = self.df.randomSplit([self.ratio, ratio_c], seed=12345)",
"def split_valid_sampling(inpath,\n patch_size, \n train_prop,\n val_prop,\n outpath,\n padding_mode='constant', \n padding_valu... | [
"0.6673594",
"0.6663889",
"0.6621361",
"0.65526426",
"0.6512163",
"0.6374599",
"0.63245976",
"0.6266016",
"0.62305325",
"0.62242997",
"0.6173855",
"0.61674833",
"0.61449915",
"0.612918",
"0.610995",
"0.6105582",
"0.6080789",
"0.6075082",
"0.6059651",
"0.6052234",
"0.6046871",... | 0.0 | -1 |
Label all columns in [start, start+n) with label. | def _select(start, n, label) -> int:
n_selected = 0
for i in range(start, int(start + n)):
x = self._x_positions[i]
n_selected += self._cols[x].mark_as(label)
return n_selected | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_excel_column_labels(start: str, end: str):\n if not start or not end:\n raise ValueError(\"{0} missing\".format(\"start\" if start is None else \"end\"))\n\n end = end.upper()\n start = start.upper()\n\n _check_start_end_acceptable(start, end)\n\n range_builder = [start]\n\n start... | [
"0.6146362",
"0.60743713",
"0.6023064",
"0.5982423",
"0.5977497",
"0.5878763",
"0.5794926",
"0.56516623",
"0.5605927",
"0.55946416",
"0.55929387",
"0.5586301",
"0.54550844",
"0.5445182",
"0.5400012",
"0.5359969",
"0.5359969",
"0.5359969",
"0.5359969",
"0.5342608",
"0.53189415... | 0.6012854 | 3 |
Remove unlabelled columns in [startcol_width, end+col_width]. | def _remove_overlaps(start, end) -> int:
start = self._x_positions[start % self.n_cols]
end = self._x_positions[int(end) % self.n_cols]
n_removed = 0
for x, col in self._cols.items():
if start - self.col_width <= x <= start or end <= x <= end + self.col_width:
if col.label is None:
n_removed += col.mark_as('ignore')
return n_removed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cols_drop():",
"def CleanUp(self):\n blankColumnPattern = re.compile('^-*$')\n blankColumns = []\n for columnIndex in range(self.alignment.get_alignment_length() - 1):\n columnValues = self.alignment[:,columnIndex]\n match = blankColumnPattern.search(columnValue... | [
"0.6347648",
"0.60383844",
"0.5991607",
"0.5967662",
"0.57150346",
"0.56798846",
"0.5672258",
"0.5656547",
"0.56305486",
"0.5617258",
"0.55419534",
"0.5483048",
"0.54566985",
"0.54525024",
"0.5401275",
"0.5390643",
"0.5390326",
"0.5388381",
"0.53292286",
"0.53068745",
"0.5285... | 0.67192227 | 0 |
Return index of first unlabelled column after x. | def _next_unlabelled_col(x):
for i in range(self.n_cols):
idx = (x + i) % self.n_cols
x_current = self._x_positions[idx]
if self._cols[x_current].label is None:
return idx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def XToCol(self, x):\r\n \r\n colLeft = 0\r\n numColumns = self.GetColumnCount()\r\n for col in xrange(numColumns):\r\n \r\n if not self.IsColumnShown(col):\r\n continue \r\n\r\n column = self.GetColumn(col)\r\n\r\n if x < (colLeft ... | [
"0.670367",
"0.66707695",
"0.65949285",
"0.63676727",
"0.6300657",
"0.62851495",
"0.6224062",
"0.62041897",
"0.61869335",
"0.6082615",
"0.6070392",
"0.6063719",
"0.60264426",
"0.6016226",
"0.59535724",
"0.59106576",
"0.58775485",
"0.5842333",
"0.5821943",
"0.5775763",
"0.5773... | 0.84793603 | 0 |
Return a mapping of column positions and labels. | def get_labels(self) -> {int: str}:
return {x: col.label for x, col in self._cols.items()} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def label_columns(mapping):\n columns = []\n for name, column in mapping.items():\n columns.append(column.label(name))\n return columns",
"def get_label_ix_mapping(labels):\n return {label: i for i, label in enumerate(labels)}",
"def column_labels(self):\n return tuple(self._columns.k... | [
"0.73458505",
"0.72522795",
"0.68872035",
"0.68740356",
"0.6553106",
"0.650619",
"0.64447373",
"0.6226804",
"0.61503714",
"0.60560364",
"0.6047371",
"0.6043159",
"0.59742296",
"0.5932194",
"0.5919516",
"0.5908463",
"0.5892866",
"0.5887391",
"0.5864398",
"0.5817711",
"0.579350... | 0.7213927 | 2 |
Move all files of this image to the output directories defined by each column's label. Returns number of files moved. | def to_disk(self, dry_run: bool) -> int:
file_counter = 0
for k, col in self._cols.items():
self._moved_cols.append(k)
file_counter += col.move(dry_run=dry_run)
return file_counter | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _move_image(self, label, ind):\r\n root, file_name = os.path.split(self.df.sorted_in_folder[ind])\r\n # two lines below check if the filepath contains as an ending a folder with the name of one of the labels\r\n # if so, this folder is being cut out of the path\r\n if os.path.split(... | [
"0.6666721",
"0.6293736",
"0.61736655",
"0.6053043",
"0.59070665",
"0.5705878",
"0.56739455",
"0.5666597",
"0.5597771",
"0.55276024",
"0.55109316",
"0.5431153",
"0.54137915",
"0.5404886",
"0.5398599",
"0.53864944",
"0.53838104",
"0.5334871",
"0.532649",
"0.53132355",
"0.53118... | 0.6105557 | 3 |
Undo all former file movements. | def rollback(self) -> None:
for k in self._moved_cols:
self._cols[k].move_back() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def undo_moves(self):\r\n logging.info(\"Undoing all moves held in records\")\r\n for move in self.record.keys():\r\n logging.debug('Moving {} to {}'.format(move, self.record[move]))\r\n try:\r\n os.rename(move, self.record[move])\r\n os.removedirs(... | [
"0.7702794",
"0.7388811",
"0.7248675",
"0.71586466",
"0.71578836",
"0.70705074",
"0.69751996",
"0.6805957",
"0.6794466",
"0.6791538",
"0.6788477",
"0.67617655",
"0.6698153",
"0.66829187",
"0.6664879",
"0.66583955",
"0.66569996",
"0.6571274",
"0.65703166",
"0.65516204",
"0.645... | 0.58613473 | 48 |
Move the file associated with this crop to the directory path/annot_type, where annot_type is this crop's annotation type. | def move_to(self, path: str) -> None:
self._new_path = os.path.join(path, self.annot_type, os.path.basename(self._file_path))
os.rename(self._file_path, self._new_path)
self._file_was_moved = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def moveFile(self, srcPath):\n # Gets the classification for the file type of the path moved\n classification = self.classifyFile(srcPath)\n\n if classification:\n # Gets the output path given the file type\n newPath = self.outPaths[classification][\"outPath\"] + srcPath.... | [
"0.6297892",
"0.5993658",
"0.58924556",
"0.58497065",
"0.574657",
"0.5685253",
"0.5554716",
"0.544296",
"0.5296529",
"0.5167809",
"0.5167291",
"0.51232123",
"0.5116003",
"0.51118386",
"0.5106717",
"0.50523245",
"0.5047933",
"0.50246215",
"0.50095254",
"0.5005804",
"0.49968418... | 0.7432932 | 0 |
Undo a former file movement by moving the file back to its origin. | def move_back(self) -> None:
if self._file_was_moved:
os.rename(self._new_path, self._file_path)
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def undo(backup):\r\n backup.load_backup()\r\n backup.undo_moves()",
"def undo():\n\n try:\n my_file.undo()\n except FileNotFoundError:\n print('No file has been read yet')\n except Exception:\n print('You must make an edit to undo')",
"def undo():",
"def undo_moves(self):... | [
"0.6898709",
"0.6796202",
"0.67440903",
"0.66569364",
"0.6606794",
"0.6522146",
"0.6483597",
"0.6466735",
"0.6456174",
"0.6436866",
"0.64312315",
"0.6424864",
"0.63239264",
"0.62896913",
"0.62687606",
"0.61865735",
"0.6161903",
"0.614128",
"0.6138943",
"0.6126032",
"0.6055876... | 0.7445615 | 0 |
Insert the Crop into this column. | def insert(self, item: Crop) -> None:
self._content.append(item)
self._file_counts[item.annot_type] = self._file_counts.get(item.annot_type, 0) + 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert(self, file_path: str, annot_type: str) -> None:\n if self._valid_file_name_regex.match(os.path.basename(file_path)) is None:\n raise ValueError(f'Illegal file name: {os.path.basename(file_path)}')\n x_pos = get_metadata_from_filename(file_path).x_pos\n if x_pos in self._x... | [
"0.61796373",
"0.55629903",
"0.5431215",
"0.5284711",
"0.5271825",
"0.52523685",
"0.5205015",
"0.51911217",
"0.5175209",
"0.5126394",
"0.51254916",
"0.51038134",
"0.50434446",
"0.49886337",
"0.49873215",
"0.49750116",
"0.49747944",
"0.49618477",
"0.49073657",
"0.48555687",
"0... | 0.4963357 | 17 |
Mark this column with the provided label. Returns number of labelled crops. | def mark_as(self, label: str) -> int:
self.label = label
return len(self._content) // len(ANNOTATIONS) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hit(self, label=None):\n self.labels[label] += 1",
"def label_index(self, label: Text) -> int:\n count = 0\n for l in self.le.classes_:\n if(l == label):\n return count\n count += 1",
"def get_count_by_label(self, label=None):\n if label is N... | [
"0.6160278",
"0.6008114",
"0.5806169",
"0.54976237",
"0.5418939",
"0.5353223",
"0.5351463",
"0.5350682",
"0.52923065",
"0.5270436",
"0.52658045",
"0.52610487",
"0.52374464",
"0.5227169",
"0.5211575",
"0.5198103",
"0.51884943",
"0.5185271",
"0.51499337",
"0.5137268",
"0.510938... | 0.6514316 | 0 |
Move all files of this column to the corresponding directory, if this column is not labeled to be ignored. Returns number of files moved. | def move(self, dry_run: bool) -> int:
if self.label == 'ignore':
return 0
file_counter = 0
for crop in self._content:
if not dry_run:
crop.move_to(self.label)
file_counter += 1
return file_counter | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_disk(self, dry_run: bool) -> int:\n file_counter = 0\n for k, col in self._cols.items():\n self._moved_cols.append(k)\n file_counter += col.move(dry_run=dry_run)\n return file_counter",
"def organizeDir(self):\n # Classify every file in dir\n for fi... | [
"0.6540349",
"0.6040318",
"0.59826165",
"0.5923412",
"0.5619923",
"0.55904424",
"0.5581633",
"0.54979753",
"0.54583585",
"0.5416308",
"0.53824425",
"0.53258795",
"0.5291548",
"0.52602667",
"0.52368546",
"0.5232204",
"0.52239007",
"0.52128977",
"0.52018017",
"0.5200375",
"0.51... | 0.6531521 | 1 |
Undo all former file movements. | def move_back(self) -> None:
if self.label == 'ignore':
return
for crop in self._content:
crop.move_back() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def undo_moves(self):\r\n logging.info(\"Undoing all moves held in records\")\r\n for move in self.record.keys():\r\n logging.debug('Moving {} to {}'.format(move, self.record[move]))\r\n try:\r\n os.rename(move, self.record[move])\r\n os.removedirs(... | [
"0.7702279",
"0.73885363",
"0.7248035",
"0.7157842",
"0.7157292",
"0.70697516",
"0.69746536",
"0.680541",
"0.6793342",
"0.67908883",
"0.67872065",
"0.67608637",
"0.66969573",
"0.66815704",
"0.6664292",
"0.6657332",
"0.6656268",
"0.6570457",
"0.6570197",
"0.6550941",
"0.645881... | 0.5601747 | 71 |
Defines and returns a parser for given command line arguments. | def get_args_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(
description='Partition the Ecotron-EInsect-2018 dataset into training, validation, and testing sets.',
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog=__doc__
)
data_group = parser.add_argument_group('Data input')
data_group.add_argument(
'--images',
type=pathlib.Path,
required=True,
metavar='DIR',
help='directory with images'
)
data_group.add_argument(
'--roots',
type=pathlib.Path,
required=True,
metavar='DIR',
help='directory with root masks for given images'
)
data_group.add_argument(
'--centerlines',
type=pathlib.Path,
required=True,
metavar='DIR',
help='directory with center line masks for given images'
)
data_group.add_argument(
'--radii',
type=pathlib.Path,
required=True,
metavar='DIR',
help='directory with radii maps for given images'
)
data_group.add_argument(
'--sin',
type=pathlib.Path,
required=True,
metavar='DIR',
help='directory with sine maps for given images'
)
data_group.add_argument(
'--cos',
type=pathlib.Path,
required=True,
metavar='DIR',
help='directory with cosine maps for given images'
)
data_group.add_argument(
'--crop-width',
type=int,
required=True,
metavar='INT',
help='crop width'
)
split_group = parser.add_argument_group('Split control')
split_group.add_argument(
'--val-split',
type=int,
required=True,
metavar='INT',
help='percentage of data going into validation set'
)
split_group.add_argument(
'--test-split',
type=int,
required=True,
metavar='INT',
help='percentage of data going into test set'
)
parser.add_argument(
'-y', '--yes',
action='store_true',
help='Assume answer "yes" for all questions'
)
parser.add_argument(
'--dry-run',
action='store_true',
help='Only simulate the process, don\'t actually touch anything'
)
parser.add_argument(
'--vis',
action='store_true',
help='Create visualization of selection in ./vis (requires matplotlib)'
)
parser.add_argument(
'-r', '--random-seed',
metavar='INT',
type=int,
help='Seed for the random number generator'
)
return parser | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_parser():\n parser = argparse.ArgumentParser()\n parser.add_argument('webpage', help='webpage to search')\n\n return parser",
"def get_parser():\n p = argparse.ArgumentParser(description='such a good program')\n p.add_argument('infile')\n p.add_argument('outfile')\n return p",
"... | [
"0.7608149",
"0.75529045",
"0.7468674",
"0.7456568",
"0.7440838",
"0.7423374",
"0.7418182",
"0.7364865",
"0.7351196",
"0.7348984",
"0.73461956",
"0.7296354",
"0.72922224",
"0.72769743",
"0.7264185",
"0.7261001",
"0.72606117",
"0.7259605",
"0.72396505",
"0.7237962",
"0.7237962... | 0.0 | -1 |
Fetch Forex datasets. Fetches the ECB Forex and Coindesk Bitcoin datasets. More info at | def fetch(start=date(2015, 1, 1), end=date.today(), currency_1='USD',
currency_2='EUR'):
if currency_1 == 'BTC':
X = _load_bitcoin(start=start, end=end, currency=currency_2)
descr = 'BTC-' + str(currency_2)
elif currency_2 == 'BTC':
X = _load_bitcoin(start=start, end=end, currency=currency_1)
descr = 'BTC-' + str(currency_1)
else:
X = _load_forex(start=start, end=end, currency_1=currency_1,
currency_2=currency_2)
descr = str(currency_1) + '-' + str(currency_2)
descr = descr + start.strftime('%Y-%m-%d') + '-' + end.strftime('%Y-%m-%d')
return Bunch(data=X, target=None, data_test=None, target_test=None,
inner_cv=None, outer_cv=None, DESCR=descr) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch(tickers: List[str], limit:Optional[int]=None):\n srs = [tck.split(\".\")[1] for tck in tickers]\n resp = requests.get(URL, verify=False)\n if resp.ok:\n df = pd.read_csv(StringIO(resp.text), delimiter=\";\", decimal=\",\")\n else:\n logger.error(f\"Data from {resp.url} not avail... | [
"0.63306177",
"0.6272984",
"0.62559444",
"0.62323636",
"0.6168453",
"0.6152495",
"0.5925996",
"0.5868122",
"0.58555883",
"0.5853049",
"0.5850573",
"0.58333457",
"0.5734732",
"0.57281804",
"0.57072836",
"0.56839794",
"0.5660408",
"0.56425864",
"0.562225",
"0.56212765",
"0.5619... | 0.5893806 | 7 |
Create metrics of gauge type for filesystem replica link lag, with the local filesystem name, replication direction, remote array name, remote filesystem name and replication status as labels. | def _replica_links_lag(self):
for f in self.fb.get_filesystem_replica_links():
self.replica_links_lag.add_metric([f.local_file_system.name,
f.direction,
f.remote.name,
f.remote_file_system.name,
f.status], -1 if f.lag is None else f.lag) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_metrics():\n p = os.path.join(os.sep, \"mnt\", \"glusterfs\")\n mount_stats = os.statvfs(p)\n # block size * total blocks\n total_space = mount_stats.f_blocks * mount_stats.f_bsize\n free_space = mount_stats.f_bfree * mount_stats.f_bsize\n # capsize only operates on i64 values\n us... | [
"0.5539488",
"0.5088195",
"0.507494",
"0.5027533",
"0.49304163",
"0.4900687",
"0.4889911",
"0.47771588",
"0.47663313",
"0.47630692",
"0.47085527",
"0.46948",
"0.46515706",
"0.45758998",
"0.45718196",
"0.4553225",
"0.45504344",
"0.45424002",
"0.453815",
"0.45122313",
"0.451044... | 0.5900812 | 0 |
Builds and sends an embed message with new commits information. | async def process_push_hook(push: models.PushHook):
repository = push.repository
project = push.project
commit_str = "commit" if push.total_commits_count == 1 else "commits"
# Show link to commit compare if there's more than one commit
if push.total_commits_count > 1:
embed_url = f"{repository.homepage}/compare/{push.before[:7]}...{push.after[:7]}"
else:
embed_url = f"{repository.homepage}/commit/{push.after[:7]}"
if push.before == EMPTY_COMMIT:
embed = discord.Embed(title=f"[{project.namespace}/{project.name}] New branch created {push.branch}",
url=embed_url, colour=discord.Colour.light_grey())
embed.set_author(name=push.user_name, icon_url=push.user_avatar)
await send_message(None, embed=embed, avatar_url=push.project.avatar_url)
elif push.after == EMPTY_COMMIT:
embed = discord.Embed(title=f"[{project.namespace}/{project.name}] Branch deleted {push.branch}",
url=embed_url, colour=discord.Colour.light_grey())
embed.set_author(name=push.user_name, icon_url=push.user_avatar)
await send_message(None, embed=embed, avatar_url=push.project.avatar_url)
# If there are no commits, do not show a message
if not push.total_commits_count:
return
embed = discord.Embed(title=f"[{project.namespace}/{project.name}:{push.branch}] "
f"{push.total_commits_count} new {commit_str}",
url=embed_url, colour=discord.Colour.blurple())
embed.set_author(name=push.user_name, icon_url=push.user_avatar)
embed.description = ""
for commit in push.commits:
message = commit.message.splitlines()[0]
embed.description += f"[`{commit.id[:7]}`]({commit.url}) {message} - {commit.author.name}\n"
print("Sending push message")
await send_message(None, embed=embed, avatar_url=push.project.avatar_url) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def command(self, bot, comm, groups):\n commit_message = self.plugin.get_commit_message()\n bot.reply(comm, u'{user}: {msg}', kwvars={'msg': commit_message})",
"def _generate_commit(\n self, msg: Optional[str] = None, author: Optional[str] = None\n ) -> dict:\n if author:\n... | [
"0.5981543",
"0.5900061",
"0.58865404",
"0.5829465",
"0.5829347",
"0.58225244",
"0.5794675",
"0.5761677",
"0.5699984",
"0.56958634",
"0.5648896",
"0.5571014",
"0.5564511",
"0.5560195",
"0.5509813",
"0.550364",
"0.54569304",
"0.54245734",
"0.5418751",
"0.5418156",
"0.53992987"... | 0.6393245 | 0 |
Builds and sends an embed message with issues information. | async def process_issue_hook(issue_data):
project = issue_data.project
issue = issue_data.issue
user = issue_data.user
description = ""
action = "Issue updated"
colour = discord.Colour.light_grey()
if issue.action == "open":
action = "Issue opened"
description = issue.description
colour = discord.Colour.green()
elif issue.action == "close":
action = "Issue closed"
colour = discord.Colour.dark_grey()
embed = discord.Embed(title=f"[{project.namespace}/{project.name}] {action}: #{issue.iid} {issue.title}"
, url=issue.url, description=description, colour=colour)
embed.set_author(name=user.username, icon_url=user.avatar_url)
await send_message(None, embed=embed) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def issue(msg: telebot.types.Message) -> None:\n data = msg.text.split()\n if len(data) == 1:\n bot.send_message(\n msg.from_user.id,\n 'Use this command to tell the developer about an issue. '\n 'Example usage: `/issue I got 4 in a row but game did not end.`',\n ... | [
"0.6676813",
"0.63654536",
"0.6173436",
"0.59853166",
"0.5810283",
"0.57947206",
"0.57469696",
"0.57408506",
"0.56667405",
"0.56306005",
"0.5611144",
"0.5595954",
"0.5525713",
"0.55207026",
"0.55166113",
"0.5467382",
"0.54175764",
"0.5404614",
"0.53625447",
"0.5345686",
"0.53... | 0.5929863 | 4 |
Builds and sends an embed message with notes information. | async def process_note_hook(data: models.NoteHook):
note = data.note
user = data.user
project = data.project
colour = discord.Colour.greyple()
embed = discord.Embed(url=note.url, description=note.description, colour=colour)
embed.set_author(name=user.username, icon_url=user.avatar_url)
if data.issue:
issue = data.issue
embed.title = f"[{project.namespace}/{project.name}] New comment on issue #{issue.iid}: {issue.title}"
if data.commit:
commit = data.commit
embed.title = f"[{project.namespace}/{project.name}] New comment on commit `{commit.id[:7]}`"
if data.merge_request:
merge = data.merge_request
embed.title = f"[{project.namespace}/{project.name}] New comment on merge request !{merge.iid}: {merge.title}"
await send_message(None, embed=embed) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def embed():",
"async def note(self, ctx):\n note_embed = discord.Embed(color=discord.Color.blurple())\n note_embed.add_field(name=\"__**Please Note**__\", value=RULES_NOTE)\n await ctx.send(embed=note_embed)",
"async def _create_embed(self, event, info):\n\n e = discord.Embed(url=i... | [
"0.653712",
"0.6195667",
"0.5904277",
"0.59017",
"0.58894485",
"0.58441114",
"0.5828449",
"0.5747832",
"0.5732143",
"0.57031065",
"0.5664874",
"0.56358755",
"0.55843145",
"0.5578333",
"0.55621606",
"0.5557521",
"0.55531627",
"0.5505942",
"0.54942673",
"0.54742163",
"0.5460713... | 0.63638 | 1 |
Builds and sends an embed message with merge request information. | async def process_merge_request_hook(data: models.MergeRequestHook):
project = data.project
merge = data.merge_request
user = data.user
description = ""
action = "Issue updated"
colour = discord.Colour.light_grey()
if merge.action == "open":
action = "Merge request opened"
description = merge.description
colour = discord.Colour.dark_green()
elif merge.action == "close":
action = "Merge request closed"
colour = discord.Colour.dark_grey()
embed = discord.Embed(title=f"[{project.namespace}/{project.name}] {action}: !{merge.iid} {merge.title}",
url=merge.url, description=description, colour=colour)
embed.set_author(name=user.username, icon_url=user.avatar_url)
embed.set_footer(text=f"{merge.source_branch} → {merge.target_branch}")
await send_message(None, embed=embed) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_commit_msg(author, reviewers, source_branch, target_branch,\n commit_message, mp_web_link):\n return \"Merge {} into {} [a={}] [r={}]\\n\\n{}\\n\\nMP: {}\".format(\n source_branch, target_branch, author,\n reviewers, commit_message, mp_web_link)",
"def build_embed(s... | [
"0.5688839",
"0.51731527",
"0.514443",
"0.5102154",
"0.50153357",
"0.5012565",
"0.4874328",
"0.48101324",
"0.47793704",
"0.46545884",
"0.46417007",
"0.46417007",
"0.46417007",
"0.4641089",
"0.46038324",
"0.45967078",
"0.45881125",
"0.4585066",
"0.45759517",
"0.4558107",
"0.45... | 0.6398354 | 0 |
Test of function that open another window | def credits_window():
credits = tk.Toplevel()
credits_lbl = tk.Label(credits, text='Software Developed By Allan / SpideyKeiiti\n'
'Made for Prototype purposes for Streets Of Rage Remake Community!')
credits_lbl.pack() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_window_loaded(self):",
"def test_openDialog_pass(self):\n self.run_script(\"\"\"\n foo.openDialog(\"foo\")\n foo.openDialog(\"chrome://foo/bar\")\n \"\"\")\n self.assert_silent()",
"def _open_window(self):\r\n\t\t# Creating the window\r\n\t\tself._window = Window(sel... | [
"0.70974696",
"0.703137",
"0.68839926",
"0.6804897",
"0.6764545",
"0.6681683",
"0.65590286",
"0.6494494",
"0.6479063",
"0.64303726",
"0.61622506",
"0.6118606",
"0.60861903",
"0.60753334",
"0.60275924",
"0.6021859",
"0.6018818",
"0.6013958",
"0.6012709",
"0.6001387",
"0.599817... | 0.0 | -1 |
Function that represents the window which Character Mods can be applied. | def chars_window():
path_dir = r'Sor_Mods_Storage\chars'
char_mods_dict = sor_module.list_char_mods(path_dir=path_dir)
# Loading Images to screen
chars = tk.Toplevel()
mainTitleImg = ImageTk.PhotoImage(Image.open(r'img/axel_daniel2221.png'))
imgRandom_label = tk.Label(chars, image=mainTitleImg)
title = tk.Label(chars, text="Characters Mods")
comboBox_chars = ttk.Combobox(chars, values=list(char_mods_dict.keys()))
def apply_char_mod():
char_selected = comboBox_chars.get()
result_window = tk.Toplevel()
value = ''
if char_selected == '':
value = f'{value} Please Select an Mod to Apply!'
else:
sor_module.apply_mod(mod_dir=path_dir, mod=char_selected, type='chars')
value = f'Character Mod {char_selected} applied!'
result_label = tk.Label(result_window, text=value)
result_label.pack()
btn_apply = tk.Button(chars, text='Apply', command=apply_char_mod)
title.grid(row=0, column=0)
comboBox_chars.grid(row=1, column=0)
imgRandom_label.grid(row=1, column=1)
btn_apply.grid(row=2, column=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def window_function(self):\n return self._wndfnc, self._wndfnc_norm",
"def get_window(self): # real signature unknown; restored from __doc__\n pass",
"def _get_window_width(self):",
"def modifiers_coding_map_creator(self):\n self.mapCreatorWindow = map_creator.ModifiersMapCreatorWindow()... | [
"0.60196453",
"0.5610308",
"0.5482973",
"0.5434321",
"0.5421594",
"0.5412486",
"0.5364167",
"0.5364138",
"0.5340363",
"0.5302406",
"0.530197",
"0.5284308",
"0.5282597",
"0.5280957",
"0.52492845",
"0.52104515",
"0.517051",
"0.5156331",
"0.5152639",
"0.51405567",
"0.51250046",
... | 0.65728295 | 0 |
Function that represents the window which Enemy Mods can be applied. | def enemy_window():
path_dir = r'Sor_Mods_Storage\enemies'
enemy_mods_dict = sor_module.list_char_mods(path_dir=path_dir)
# Loading Images to screen
enemies = tk.Toplevel()
mainTitleImg = ImageTk.PhotoImage(Image.open(r'img/axel_daniel2221.png'))
imgRandom_label = tk.Label(enemies, image=mainTitleImg)
title = tk.Label(enemies, text="Enemies Mods")
comboBox_enemies = ttk.Combobox(enemies, values=list(enemy_mods_dict.keys()))
def apply_enemy_mod():
char_selected = comboBox_enemies.get()
result_window = tk.Toplevel()
value = ''
if char_selected == '':
value = f'{value} Please Select an Mod to Apply!'
else:
sor_module.apply_mod(mod_dir=path_dir, mod=char_selected, type='enemies')
value = f'Enemy Mod {char_selected} applied!'
result_label = tk.Label(result_window, text=value)
result_label.pack()
btn_apply = tk.Button(enemies, text='Apply', command=apply_enemy_mod)
title.grid(row=0, column=0)
comboBox_enemies.grid(row=1, column=0)
imgRandom_label.grid(row=1, column=1)
btn_apply.grid(row=2, column=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_window(self): # real signature unknown; restored from __doc__\n pass",
"def get_main_window():\n\n pass",
"def createGameWindow():\n gameWindow = g.GraphWin(\"game\", 450, 800) #Window to show game\n\n return gameWindow",
"def maya_window():\n return to_qwidget(\"MayaWindow\")",
... | [
"0.64761674",
"0.63803315",
"0.6314744",
"0.6216543",
"0.62010247",
"0.6149478",
"0.60766095",
"0.60618967",
"0.6037659",
"0.60210836",
"0.60210836",
"0.600711",
"0.6003741",
"0.5992173",
"0.59492654",
"0.58889663",
"0.58503634",
"0.57341456",
"0.56976503",
"0.56692207",
"0.5... | 0.678502 | 0 |
Function that represents the window which Enemy Mods can be applied. | def pallete_window():
path_dir = r'Sor_Mods_Storage\palletes'
char_mods_dict = sor_module.list_char_mods(path_dir=path_dir)
# Loading Images to screen
palletes = tk.Toplevel()
mainTitleImg = ImageTk.PhotoImage(Image.open(r'img/axel_daniel2221.png'))
imgRandom_label = tk.Label(palletes, image=mainTitleImg)
title = tk.Label(palletes, text="Pallete Mods")
comboBox_palletes = ttk.Combobox(palletes, values=list(char_mods_dict.keys()))
def apply_pallete_mod():
pallete_selected = comboBox_palletes.get()
result_window = tk.Toplevel()
value = ''
if pallete_selected == '':
value = f'{value} Please Select an Pallete to Apply!'
else:
sor_module.apply_mod(mod_dir=path_dir, mod=pallete_selected, type='palletes')
value = f'Enemy Mod {pallete_selected} applied!'
result_label = tk.Label(result_window, text=value)
result_label.pack()
btn_apply = tk.Button(palletes, text='Apply', command=apply_pallete_mod)
title.grid(row=0, column=0)
comboBox_palletes.grid(row=1, column=0)
imgRandom_label.grid(row=1, column=1)
btn_apply.grid(row=2, column=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enemy_window():\n path_dir = r'Sor_Mods_Storage\\enemies'\n enemy_mods_dict = sor_module.list_char_mods(path_dir=path_dir)\n\n # Loading Images to screen\n enemies = tk.Toplevel()\n mainTitleImg = ImageTk.PhotoImage(Image.open(r'img/axel_daniel2221.png'))\n\n imgRandom_label = tk.Label(enemie... | [
"0.67854697",
"0.6475978",
"0.63797003",
"0.63149863",
"0.6215324",
"0.62009335",
"0.6149193",
"0.60768974",
"0.60621846",
"0.6039159",
"0.6020179",
"0.6020179",
"0.6007678",
"0.60024905",
"0.599055",
"0.5948242",
"0.58887446",
"0.585083",
"0.5733424",
"0.56965476",
"0.567042... | 0.56174505 | 26 |
Function that represents the window which Stage Mods can be applied. | def stage_window():
path_dir = r'Sor_Mods_Storage\stages'
stage_mods_dict = sor_module.list_char_mods(path_dir=path_dir)
# Loading Images to screen
stages = tk.Toplevel()
mainTitleImg = ImageTk.PhotoImage(Image.open(r'img/axel_daniel2221.png'))
imgRandom_label = tk.Label(stages, image=mainTitleImg)
title = tk.Label(stages, text="Stage Mods")
comboBox_chars = ttk.Combobox(stages, values=list(stage_mods_dict.keys()))
def apply_stage_mod():
stage_selected = comboBox_chars.get()
result_window = tk.Toplevel()
value = ''
if stage_selected == '':
value = f'{value} Please Select an Stage Mod to Apply!'
else:
sor_module.apply_mod(mod_dir=path_dir, mod=stage_selected, type='stages')
value = f'Enemy Mod {stage_selected} applied!'
result_label = tk.Label(result_window, text=value)
result_label.pack()
btn_apply = tk.Button(stages, text='Apply', command=apply_stage_mod)
title.grid(row=0, column=0)
comboBox_chars.grid(row=1, column=0)
imgRandom_label.grid(row=1, column=1)
btn_apply.grid(row=2, column=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_window(self): # real signature unknown; restored from __doc__\n pass",
"def get_main_window():\n\n pass",
"def GetWindow(self):\r\n\r\n return self.window",
"def window(self):\n return self._window",
"def window(self):\n return self._window",
"def showWindow(*args, ... | [
"0.6928395",
"0.684634",
"0.6601684",
"0.6564466",
"0.6564466",
"0.64463425",
"0.6378235",
"0.6353312",
"0.6351047",
"0.629362",
"0.62887776",
"0.6145612",
"0.6136457",
"0.6110733",
"0.60973674",
"0.6074384",
"0.6053072",
"0.6018539",
"0.59742665",
"0.5963318",
"0.59591293",
... | 0.6935589 | 0 |
takes list of files as parameter, prints out readible version Fn strips each file by line, gets rid of duplicates, then splits the line into usable chunks before printing out the usable version | def turn_files_into_pretty_text(text_files):
list_of_all_lines = []
for item in text_files:
for line in item:
line = line.rstrip()
if line not in list_of_all_lines:
list_of_all_lines.append(line)
for item in list_of_all_lines:
words = item.split('|')
melon = words[0]
count = words[1]
amount = words[2]
print "Delivered {} {}s for total of ${}".format(count, melon, amount) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def findDuplicateReleaseFiles(self, initialList, workingTowerName, newInfix):\n Release_Tower_Name = self.getReleaseVersion(workingTowerName, newInfix)\n Duplicate_List = []\n for fname in initialList:\n prefixStream, postfixStream = string.split(fname, workingTowerName)\n ... | [
"0.5725787",
"0.5708584",
"0.5698696",
"0.5599208",
"0.5580545",
"0.5571598",
"0.5569876",
"0.5565192",
"0.5528212",
"0.55211085",
"0.551443",
"0.55045366",
"0.54886717",
"0.54601747",
"0.5417886",
"0.54174167",
"0.5414416",
"0.54129356",
"0.5406018",
"0.53970194",
"0.5385436... | 0.52034676 | 43 |
Description Handle missing values by replacing them with either the default value or the mean/min/max value (for nontext columns only). An indicator column can optionally be concatenated, if theinput column type is numeric. | def transforms_missingvaluehandler(
column,
data,
output_data=None,
model=None,
replace_with='Def',
impute_by_slot=True,
concat=True,
**params):
entrypoint_name = 'Transforms.MissingValueHandler'
inputs = {}
outputs = {}
if column is not None:
inputs['Column'] = try_set(
obj=column,
none_acceptable=False,
is_of_type=list,
is_column=True)
if data is not None:
inputs['Data'] = try_set(
obj=data,
none_acceptable=False,
is_of_type=str)
if replace_with is not None:
inputs['ReplaceWith'] = try_set(
obj=replace_with,
none_acceptable=True,
is_of_type=str,
values=[
'DefaultValue',
'Mean',
'Minimum',
'Maximum'])
if impute_by_slot is not None:
inputs['ImputeBySlot'] = try_set(
obj=impute_by_slot,
none_acceptable=True,
is_of_type=bool)
if concat is not None:
inputs['Concat'] = try_set(
obj=concat,
none_acceptable=True,
is_of_type=bool)
if output_data is not None:
outputs['OutputData'] = try_set(
obj=output_data,
none_acceptable=False,
is_of_type=str)
if model is not None:
outputs['Model'] = try_set(
obj=model,
none_acceptable=False,
is_of_type=str)
input_variables = {
x for x in unlist(inputs.values())
if isinstance(x, str) and x.startswith("$")}
output_variables = {
x for x in unlist(outputs.values())
if isinstance(x, str) and x.startswith("$")}
entrypoint = EntryPoint(
name=entrypoint_name, inputs=inputs, outputs=outputs,
input_variables=input_variables,
output_variables=output_variables)
return entrypoint | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fix_missing(df, col, name, na_dict):\n if is_numeric_dtype(col):\n if pd.isnull(col).sum() or (name in na_dict):\n df[name+'_na'] = pd.isnull(col)\n filler = na_dict[name] if name in na_dict else col.median()\n df[name] = col.fillna(filler)\n na_dict[name] ... | [
"0.58770204",
"0.57689667",
"0.5714844",
"0.5643517",
"0.56218046",
"0.5612133",
"0.5571508",
"0.552125",
"0.55067784",
"0.5474215",
"0.5456898",
"0.54213846",
"0.53971267",
"0.53654104",
"0.5360555",
"0.53490347",
"0.53490347",
"0.5342924",
"0.53326184",
"0.53209394",
"0.530... | 0.54455906 | 11 |
Append shore abbreviation to the base reference. | def reference(self):
licence = self.context
if IEnvironmentBase.providedBy(licence):
return licence.reference
to_shore = queryAdapter(licence, IShore)
ref = '{} {}'.format(licence.reference, to_shore.display())
return ref | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def audit_abbr(over_abbreviated, street_name):\n m = over_abbr_re.search(street_name)\n if m:\n abbr = m.group()\n over_abbreviated[abbr].add(street_name)",
"def expand_abbreviation(abbr, doc_type = 'html', profile_name = 'plain'):\n\ttree = parse_into_tree(abbr, doc_type)\n\tif tree:\n\t\tre... | [
"0.59830004",
"0.5703842",
"0.5681109",
"0.5655727",
"0.5474441",
"0.54697645",
"0.5435609",
"0.5420919",
"0.53656024",
"0.53300464",
"0.5218761",
"0.5197725",
"0.51889247",
"0.51828516",
"0.51511014",
"0.5144388",
"0.5134165",
"0.5127529",
"0.51188904",
"0.51158106",
"0.5102... | 0.4860687 | 45 |
if the intent name exists, then return without action, otherwise create a blank intent | def create_intent(intent_name):
try:
response=client.get_intent(
name=intent_name,
version="$LATEST"
)
print "There is a %s intent in your account, please consider delete it or using another name" %(intent_name)
return
except:
pass
response=client.put_intent(
name=intent_name,
description='the demo intent',
sampleUtterances=[
'Can I book a hotel',
],
confirmationPrompt={
'messages': [
{
'contentType': 'PlainText',
'content': 'Your hotel booking is ready, do you want to place an order?'
},
],
'maxAttempts': 2,
},
rejectionStatement={
'messages': [
{
'contentType': 'PlainText' ,
'content': 'Ok. I will discard the hotel booking information'
},
],
},
conclusionStatement={
'messages': [
{
'contentType': 'PlainText',
'content': 'Your hotel booking has been confirmed'
},
],
},
fulfillmentActivity={
'type': 'ReturnIntent'
}
)
print "Intent %s created successfully" %(intent_name)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_intent(self, intent_name):\n for name, intent in self:\n if name == intent_name:\n return intent\n else:\n return None",
"def exists_intent_action(self, intent_keyword):\n pass",
"def get_intent_action(self, intent_keyword):\n pass",
"d... | [
"0.67302954",
"0.6667681",
"0.6538136",
"0.6383118",
"0.61762303",
"0.59395283",
"0.58650994",
"0.58650994",
"0.58105075",
"0.5734404",
"0.5690178",
"0.56890965",
"0.5672978",
"0.5672482",
"0.5650137",
"0.56120867",
"0.55995744",
"0.55600524",
"0.5517704",
"0.54916435",
"0.54... | 0.62379736 | 4 |
delete the specified intentfrom your account. | def delete_intent(intent_name):
try:
client.get_intent(
name=intent_name,
versionOrAlias='$LATEST'
)
answer=raw_input("Do you want to delete %s from your account(Y/y for YES, other NO):" %(intent_name))
if answer in ['Y', 'y']:
client.delete_intent(
name=intent_name
)
print "You chose to delete the intent %s, deleted..." %(intent_name)
else:
print "You chose not to delete the inten t%s, exiting..." %(intent_name)
except:
print "There is no intent called %s, exiting..." %(intent_name)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_account(self, account):\n \n pass",
"def delete(self, args):\n try:\n db = get_db('intents')\n intents = db.delete_intent(args['intent'])\n resp = jsonify(intents=intents)\n resp.status_code = 200\n return resp\n except... | [
"0.7136622",
"0.7109074",
"0.6793135",
"0.6618114",
"0.6454273",
"0.6342631",
"0.63189256",
"0.62924826",
"0.6259348",
"0.6142261",
"0.6112738",
"0.60232806",
"0.5955118",
"0.59354204",
"0.5897123",
"0.58737737",
"0.5854009",
"0.5853782",
"0.5827274",
"0.5824352",
"0.57835615... | 0.7211831 | 0 |
demo function to get the intent's latest configuration | def get_intent_configuration(intent_name, version ="$LATEST"):
response=client.get_intent(
name=intent_name,
version=version
)
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_config():\n return CONFIG",
"def getConfig(self):\n pass",
"def config(self) -> \"AutomationConfig\":",
"def config(self) -> \"AutomationConfig\":",
"def get_config(self,config):\n return self.parser.get(\"main\", config)",
"def get_details(self):\n return self.__config_da... | [
"0.6338923",
"0.6251342",
"0.61532223",
"0.61532223",
"0.6144978",
"0.60848004",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
"0.6024894",
... | 0.73107255 | 0 |
a help function to print the intentinformation in format | def format_print_jobs(intent):
print "\nintentName: %s" %(intent['name'])
for k,v in intent.iteritems():
if k <> 'name':
print "\t" + str(k) + ": " + str(v) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printhelp():",
"def info(self):",
"def info(self):",
"def details(self) -> str:\n return f\"- **language**: [{self.language}]\\n\" \\\n f\"- **opengame**: [{self.opengame}]\\n\" \\\n f\"- **system**: [{self.system}]\\n\" \\\n f\"- **mode**: [{self.mode}]\\... | [
"0.64891857",
"0.64813703",
"0.64813703",
"0.6405768",
"0.6331518",
"0.6306247",
"0.62967855",
"0.6288361",
"0.6245361",
"0.6203289",
"0.61881757",
"0.617994",
"0.6178175",
"0.6174316",
"0.6146131",
"0.614331",
"0.6139111",
"0.61244285",
"0.6111058",
"0.60988563",
"0.60816693... | 0.6709204 | 0 |
Initializes the Crawler and decides which action to take based on the mode. | def __init__(self, restUrl: str,
mode: CrawlMode = CrawlMode.NO,
loginUrl: str = None,
loginName: str = None,
loginPW: str = None,
furtherparams: str = None,
workers: int = 10,
mongoDB: Database = None,
foldername: str = None,
bugList: Union[List, str] = None) -> None:
self.session = requests.session()
self.workers = workers
if loginUrl:
#bugzilla user data
user = loginName
pw = loginPW
#login process
loginURL = loginUrl
self.session.post(loginURL, {'Bugzilla_login': user, 'Bugzilla_password': pw})
#checks for the right ending of restUrl
if restUrl[-1] != '/':
restUrl += '/'
#prepares URLs for crawling of bugs and comments
self.bugURL = restUrl + 'bug?limit=500' + furtherparams
self.commentURL = restUrl + 'bug/{}/comment'
#database if given one
self.mongoDB = mongoDB
#foldername if given one
self.folder = foldername
if foldername:
#creates directory
self.createFolder(foldername)
self.folderpath = foldername + '/'
#checks on which crawl operation to execute
self.decide_action(mode, bugList) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_modes(self):\n self._verify_not_using_threaded_mpm()\n\n self._init_screenshot_mode()\n self._init_debug_mode()\n self._init_webapi_cors_header()\n self.init_theme()",
"def decide_action(self, mode: CrawlMode = CrawlMode.NO, bugList: Union[List, str] = None) -> None:\n... | [
"0.6156874",
"0.5882419",
"0.5669092",
"0.5625389",
"0.56192595",
"0.5612265",
"0.55834305",
"0.5568586",
"0.55475867",
"0.55300885",
"0.5503639",
"0.54796416",
"0.54796416",
"0.5456761",
"0.53957784",
"0.5347344",
"0.53471684",
"0.5346393",
"0.53363496",
"0.53115886",
"0.530... | 0.5355751 | 15 |
Decides which action to start depending on the mode. | def decide_action(self, mode: CrawlMode = CrawlMode.NO, bugList: Union[List, str] = None) -> None:
# checks on which crawl operation to execute
if mode == CrawlMode.BUG:
self.get_all_bugs()
elif mode == CrawlMode.COMMENT:
if bugList:
self.get_all_comments(bugList)
else:
print('Error: No buglist to be found. Please check your params and start again.')
return
elif mode == CrawlMode.BOTH:
bugIDList = self.get_all_bugs()
self.get_all_comments(bugIDList)
elif mode == CrawlMode.CFAST:
self.get_all_comments_mp(bugList, self.workers)
elif mode == CrawlMode.BFAST:
bugsIDList = self.get_all_bugs()
self.get_all_comments_mp(bugsIDList, self.workers)
else:
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def choose_action(self):\r\n pass",
"def _select_mode(self):\n self.__check_mode()\n if self.mode[\"auto_mode\"]:\n self.mode_auto()\n elif self.mode[\"auto_mode\"] is None: # Do Nothing\n self.mode_standby()\n else:\n self.mode_manual()",
"d... | [
"0.67960316",
"0.66079754",
"0.63345975",
"0.61656135",
"0.6149419",
"0.61217403",
"0.6095867",
"0.6050132",
"0.60292625",
"0.60050106",
"0.5970908",
"0.5939976",
"0.592196",
"0.59155333",
"0.5853063",
"0.58509487",
"0.58477354",
"0.5835604",
"0.5818035",
"0.5796116",
"0.5762... | 0.59804595 | 10 |
Crawls all requested bug data and bug ids. Saves them in files (bugIDListP.pickle, bugIDList.csv, bugsData.txt ) and/or Mongo DB collections (BugIDs, BugsData) depending if they are given at initialization. | def get_all_bugs(self) -> List:
#starting point
offset = 0
#list for all bugs
resultBugList = []
#list for bug IDs
bugIDList = []
#checks if there are still results returned
notEmpty = True
#queries in 500 bug steps until the result list is empty
while notEmpty:
print("entered")
#interpretation of result as list plus formatting for eval errors
result = ast.literal_eval(self.session.get(self.bugURL + "&offset=" + str(offset)).text.
replace('true', 'True').replace('false', 'False').replace('null', 'None'))["bugs"]
#checks if the query needs to be set again with a new offset
if result:
resultBugList += result
else:
notEmpty = False
#gets the ID out of all comments
partList = [bug["id"] for bug in result]
bugIDList += partList
#sets new starting point
offset += 500
#inserts bug ids and bugs into db if given one
if self.mongoDB:
for id in bugIDList:
self.mongoDB["BugIDs"].insert_one({"ID": id})
self.mongoDB["BugsData"].insert_many(resultBugList)
#creates files for bug ids and bugs if given a folder
if self.folder:
#saves bug list as python object
with open(self.folderpath + "bugIDListP.pickle", "wb") as a:
pickle.dump(bugIDList, a)
#saves bug list as csv
with open(self.folderpath + "bugIDList.csv", "w") as b:
for id in bugIDList:
b.write(str(id) + "\n")
with open(self.folderpath + "bugsData.txt", "w") as c:
for bug in resultBugList:
c.write(str(bug) + "\n")
#returns List Object for further processing
return(bugIDList) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_comments(self, idList: Union[List, str]) -> None:\n\n #loads pickle list if it is one\n if type(idList) == str and \".pickle\" in idList:\n print(\"pickle load\")\n with open(idList, \"rb\") as f:\n idList = pickle.load(f)\n elif type(idList) ==... | [
"0.6098931",
"0.581118",
"0.58095926",
"0.5599205",
"0.55810404",
"0.55514055",
"0.5436911",
"0.5393213",
"0.5392565",
"0.52618045",
"0.5231558",
"0.52075624",
"0.519109",
"0.514051",
"0.5135371",
"0.5125481",
"0.5122285",
"0.50928766",
"0.50890225",
"0.50798535",
"0.50633335... | 0.7346313 | 0 |
Crawls for all comments belonging to the bugs in the BugIDList. | def get_all_comments(self, idList: Union[List, str]) -> None:
#loads pickle list if it is one
if type(idList) == str and ".pickle" in idList:
print("pickle load")
with open(idList, "rb") as f:
idList = pickle.load(f)
elif type(idList) == str:
print("Error: Buglist parameter seems to be neither a List object or the name of a pickle file "
"(needs to contain .pickle).")
#goes through idList
for id in tqdm(idList):
#performs request and replaces trouble some parts
commentsString = self.session.get(self.commentURL.format(id)).text.\
replace('true', 'True').replace('false', 'False').replace('null', 'None')
#gets only the comments
commentsDict = ast.literal_eval(commentsString)["bugs"][str(id)]["comments"]
#enters comments into db or file if there are any comments for the id
if commentsDict:
if self.mongoDB:
self.mongoDB["Comments"].insert_many(commentsDict)
if self.folder:
with open(self.folderpath + "Bugzilla_Comments.txt", 'a') as f:
f.write(str(commentsDict) + "\n") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_bugs(self) -> List:\n #starting point\n offset = 0\n #list for all bugs\n resultBugList = []\n #list for bug IDs\n bugIDList = []\n #checks if there are still results returned\n notEmpty = True\n\n #queries in 500 bug steps until the result... | [
"0.64830816",
"0.6414829",
"0.64109683",
"0.6044062",
"0.5997073",
"0.5927429",
"0.5870754",
"0.58518946",
"0.57999045",
"0.5750483",
"0.5748707",
"0.5685098",
"0.5681446",
"0.5678411",
"0.5673924",
"0.56592536",
"0.5652936",
"0.5610223",
"0.5589951",
"0.55766493",
"0.5568257... | 0.7094204 | 0 |
Crawls for all comments belonging to the bugs in the BugIDList utilizing parallelization. | def get_all_comments_mp(self, list: Union[List, str], workers: int = 10) -> None:
# loads pickle list if it is one
if type(list) == str and ".pickle" in list:
print("wat")
with open(list, "rb") as f:
list = pickle.load(f)
elif type(list) == str:
print("Error: Buglist parameter seems to be neither a List object or the name of a pickle file "
"(needs to contain .pickle).")
#gets workers and splits list into chunks fitting the worker amount
pool = Pool(workers)
list = np.array(list)
lists = np.array_split(list, workers)
#each worker crawls for comments
for sub_list in lists:
print(sub_list)
pool.apply_async(self.get_all_comments, (sub_list,))
pool.close()
pool.join() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_comments(self, idList: Union[List, str]) -> None:\n\n #loads pickle list if it is one\n if type(idList) == str and \".pickle\" in idList:\n print(\"pickle load\")\n with open(idList, \"rb\") as f:\n idList = pickle.load(f)\n elif type(idList) ==... | [
"0.6642331",
"0.6419399",
"0.6326556",
"0.590753",
"0.58366686",
"0.5725965",
"0.56005704",
"0.55982554",
"0.55817443",
"0.5574108",
"0.5573544",
"0.55464286",
"0.5534647",
"0.55332947",
"0.55286044",
"0.5525885",
"0.55153495",
"0.54998296",
"0.549831",
"0.5463732",
"0.544268... | 0.64263386 | 1 |
Creates a directory if it doesn't exist already | def createFolder(self, foldername: str) -> None:
try:
if not os.path.exists(foldername):
os.makedirs(foldername)
except OSError:
print('Error: Creating following directory: ' + foldername) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_dir(path):\n if not os.path.exists(path):\n os.makedirs(path)",
"def create_dir_if_doesnt_exist(dir_path):\n if not os.path.exists(dir_path):\n os.makedirs(dir_path)\n return",
"def create_directory(dir_path):\r\n if not os.path.exists(dir_path):\r\n os.makedirs(dir_... | [
"0.84880376",
"0.84691334",
"0.8421431",
"0.8365199",
"0.83478045",
"0.83478045",
"0.83265615",
"0.8294003",
"0.8283774",
"0.82814693",
"0.8278838",
"0.8278838",
"0.82774234",
"0.827556",
"0.8255593",
"0.824047",
"0.82380694",
"0.82136655",
"0.82106537",
"0.8207876",
"0.82056... | 0.0 | -1 |
download sequencing file from SRA archive requires local install of SRA tools in path requires verification of filenames and paths | def download_SRA(SRA):
print("Downloading SRA archive")
output = subprocess.run(['prefetch', '-f', 'yes', SRA], stderr=subprocess.STDOUT)
print("Extracting FASTQ data")
output = subprocess.run(['fastq-dump', '--gzip', NCBI_DIR+SRA+'.sra'], stderr=subprocess.STDOUT) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_sra_files(remote_location, local_location = '', max_recursion = 3, verbose = False):\n\n downloaded_files = list();\n\n def printv(*args):\n if(verbose):\n print(*args);\n sys.stdout.flush();\n\n printv(\"Reading folder: \", remote_location);\n\n req = urllib2.... | [
"0.6527539",
"0.63202286",
"0.6183208",
"0.61473656",
"0.6141469",
"0.5976712",
"0.5897661",
"0.58915883",
"0.58283",
"0.5815497",
"0.5812849",
"0.58102864",
"0.58102864",
"0.5790022",
"0.57642645",
"0.5758532",
"0.57328504",
"0.57257515",
"0.57255936",
"0.5705985",
"0.570499... | 0.77889556 | 0 |
put path to indices / pass paths as arg, e.g. STAR_DIR | def build_indices(genome_fasta, genome_gtf, rRNA_fasta, transcriptome_fasta):
if not os.path.exists("data/indices"):
os.mkdir("data/indices")
# 1. Bowtie index
print("Building Bowtie index")
if not os.path.exists(BOWTIE_DIR):
os.mkdir(BOWTIE_DIR)
cmd_bowtie = 'bowtie-build' + ' ' + genome_fasta + ' ' + BOWTIE_DIR+'/yeast'
output = subprocess.run(cmd_bowtie, shell=True)
cmd_rRNA = 'bowtie-build' + ' ' + rRNA_fasta + ' ' + BOWTIE_DIR+'/rRNA'
output = subprocess.run(cmd_rRNA, shell=True)
# 2. STAR index
print("Building STAR index")
if not os.path.exists(STAR_DIR):
os.mkdir(STAR_DIR)
cmd_STAR = 'STAR' + ' ' + '--runThreadN' + ' ' + '4' + ' ' + '--runMode' + ' ' + 'genomeGenerate' + ' ' + '--genomeDir' + ' ' + STAR_DIR + ' ' + '--genomeFastaFiles' + ' ' + genome_fasta + ' ' + '--sjdbGTFfile' + ' ' + genome_gtf #+ ' ' + '--sjdbOverhang' + ' ' + 'max(ReadLength)-1'
output = subprocess.run(cmd_STAR, shell=True)
# run build transcriptome fasta.
if not os.path.exists(STAR_TRANSCRIPTOME_DIR):
os.mkdir(STAR_TRANSCRIPTOME_DIR)
cmd_STAR = 'STAR' + ' ' + '--runThreadN' + ' ' + '4' + ' ' + '--runMode' + ' ' + 'genomeGenerate' + ' ' + '--genomeDir' + ' ' + STAR_TRANSCRIPTOME_DIR + ' ' + '--genomeFastaFiles' + ' ' + transcriptome_fasta # + ' ' + '--sjdbGTFfile' + ' ' + genome_gtf #+ ' ' + '--sjdbOverhang' + ' ' + 'max(ReadLength)-1'
output = subprocess.run(cmd_STAR, shell=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indexes_path(dataset, work_dir=consts.WORK_DIR):\r\n return join_path(dataset_path(dataset, work_dir), consts.INDEXES_DIR)",
"def index_STAR(args):\n\n # make STAR index folder for merged path\n merged_STAR_watson_index = os.path.join(args.output_dir,'STAR_merged_watson')\n merged_STAR_crick_inde... | [
"0.6537887",
"0.63956136",
"0.6359709",
"0.60461843",
"0.58392173",
"0.56591266",
"0.5648433",
"0.5629673",
"0.56082153",
"0.5570931",
"0.5479381",
"0.5462276",
"0.5429903",
"0.54241526",
"0.5421316",
"0.5394815",
"0.5362421",
"0.53275514",
"0.5321562",
"0.5312183",
"0.530585... | 0.57987577 | 5 |
maps reads (bowtie to rRNA for legacy?) to extract ambiguous and uniquely mapped reads | def map_reads(SRA):
#1. bowtie to rRNA
print("Bowtie alignement on contaminant RNA...")
cmd_bowtie = 'bowtie'+ ' ' + '-a' + ' ' + '-p6' + ' ' + '-S' + ' ' + '--un' + ' ' + TMP_DIR+SRA+'_rrnaUnmapped.fastq' + ' ' + BOWTIE_DIR+'/rRNA' + ' ' + TMP_DIR+SRA+'_trimmed.fastq' + ' ' + '|' + ' ' + 'samtools view -@ 6 -bS' + ' ' + '>' + TMP_DIR+SRA+'_trimmed_rrna.bam'
output = subprocess.run(cmd_bowtie, shell=True)
# 2. STAR to ref genome
print("STAR alignement to yeast genome...")
cmd_STAR = 'STAR --outSAMtype BAM Unsorted --runThreadN 6 --winAnchorMultimapNmax 200 --seedSearchStartLmax 15 --genomeDir' + ' ' + STAR_DIR + ' ' + '--readFilesIn' + ' ' + TMP_DIR+SRA+'_rrnaUnmapped.fastq' + ' ' + '--outFileNamePrefix' + ' ' + TMP_DIR+SRA+'_STAR_'
output = subprocess.run(cmd_STAR, shell=True)
# 3. Samtools keep uniquely mapped reads and sort
print("Samtools to keep uniquely mapped reads and sort...")
cmd_samtools1 = 'samtools view -@ 6 -b -q 255 -o' + ' ' + TMP_DIR+SRA+'_yeast_uniqueMapped_reads.bam' + ' ' + TMP_DIR+SRA+'_STAR_Aligned.out.bam'
output = subprocess.run(cmd_samtools1, shell=True)
cmd_samtools2 = 'samtools sort -@ 6 -o' + ' ' + TMP_DIR+SRA+'_yeast_uniqueMapped_reads_sorted.bam' + ' ' + TMP_DIR+SRA+'_yeast_uniqueMapped_reads.bam'
output = subprocess.run(cmd_samtools2, shell=True)
cmd_samtools3 = 'samtools index' + ' ' + TMP_DIR+SRA+'_yeast_uniqueMapped_reads_sorted.bam'
output = subprocess.run(cmd_samtools3, shell=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_read_candidates(self, read):\n self.read_allele_dictionary = {}\n ref_alignment_start = read.reference_start\n ref_alignment_stop = self.get_read_stop_position(read)\n # if the region has reached a very high coverage, we are not going to parse through all the reads\n if ... | [
"0.6826506",
"0.66215014",
"0.6525083",
"0.6418822",
"0.6416063",
"0.631023",
"0.6223504",
"0.6182403",
"0.60843307",
"0.6026228",
"0.6004919",
"0.5979466",
"0.5960708",
"0.59569067",
"0.59227425",
"0.59207463",
"0.5912195",
"0.58296555",
"0.5819795",
"0.5811446",
"0.5797608"... | 0.6700885 | 1 |
wrapper to run scikitribo from the same pipeline requires local install of modified scikitribo toolbox requires local install of all dependencies of scikitribo environment (see conda environment file) | def run_scikit_ribo(SRA, genome_fasta, genome_gtf):
# 3. Scikit-ribo index
print("Building scikit-ribo index")
if not os.path.exists(SCIKIT_DIR):
os.mkdir(SCIKIT_DIR)
cmd_scikit = 'python' + ' ' + SCIKIT_PATH + 'scikit-ribo-build.py' + ' ' + '-g' + ' ' + genome_gtf + ' ' + '-f' + ' ' + genome_fasta + ' ' + '-p' + ' ' + SRA + ' ' + '-o' + SCIKIT_DIR
output = subprocess.run(cmd_scikit, shell=True)
print("scikit-ribo-run.py...")
cmd_scikit = 'python' + ' ' + SCIKIT_PATH + 'scikit-ribo-run.py' + ' ' + '-i' + ' ' + TMP_DIR+SRA+'_yeast_uniqueMapped_reads_sorted.bam' + ' ' + '-f' + ' ' + SCIKIT_DIR + ' ' + '-p' + ' ' + SRA + ' ' + '-o' + ' ' + 'TMP/scikit_'+SRA
output = subprocess.run(cmd_scikit, shell=True)
print("plot_ribo_density_dict.py...")
cmd_scikit = 'python' + ' ' + SCIKIT_PATH + 'plot_ribo_density_dict_noCDT.py' + ' ' + '-i' + ' ' + TMP_DIR+'scikit_'+SRA+'/riboseq_input.txt' + ' ' + '-g' + ' ' + 'all' + ' ' + '-o' + ' ' + TMP_DIR+'scikit_'+SRA #+'_profiles'
output = subprocess.run(cmd_scikit, shell=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transformation_catalog():\n tc = TransformationCatalog()\n\n # Add docker container\n #crisis_container = Container(\n # 'crisis_container',\n # Container.DOCKER,\n # image = \"docker://slnagark/crisis_wf:latest\",\n # arguments=\"--runtime=nvidi... | [
"0.57629657",
"0.56087464",
"0.54360694",
"0.54355013",
"0.5393979",
"0.53826815",
"0.5367081",
"0.5317132",
"0.52905655",
"0.5287661",
"0.52496874",
"0.5199404",
"0.51819116",
"0.51798064",
"0.51774645",
"0.5171329",
"0.50645137",
"0.50610745",
"0.50353134",
"0.5028036",
"0.... | 0.6405816 | 0 |
identify all reads that map ambigously and their positions | def run_multimapping(SRA):
if not os.path.exists("TMP/ambiguous_reads/"):
os.mkdir("TMP/ambiguous_reads/")
cmd_STAR = 'STAR --outSAMtype BAM SortedByCoordinate --runThreadN 8 --winAnchorMultimapNmax 200 --seedSearchStartLmax 15 --genomeDir' + ' ' + STAR_TRANSCRIPTOME_DIR + ' ' + '--readFilesIn' + ' ' + TMP_DIR+SRA+'_rrnaUnmapped.fastq' + ' ' + '--outFileNamePrefix' + ' ' + TMP_DIR+'ambiguous_reads/'+SRA+'_STAR_transcriptome_'
output = subprocess.run(cmd_STAR, shell=True)
# Keep only multi-mapping reads:
cmd_filter = 'python code/sam_STAR_mapq_filtering.py' + ' ' + TMP_DIR+'ambiguous_reads/'+SRA+'_STAR_transcriptome_Aligned.sortedByCoord.out.bam' + ' ' + TMP_DIR+'ambiguous_reads/'+SRA+'_STAR_transcriptome_multi_mapped_sorted.bam' + ' ' + 'all'
output = subprocess.run(cmd_filter, shell=True)
cmd_samtools2 = 'samtools index' + ' ' + TMP_DIR+'ambiguous_reads/'+SRA+'_STAR_transcriptome_multi_mapped_sorted.bam'
output = subprocess.run(cmd_samtools2, shell=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def determine_crossmapped_reads(self, read_alignment_path):\n references_by_species = self._get_references_by_species()\n crossmapped_reads = set()\n done_replicon_comparison = []\n with pysam.AlignmentFile(read_alignment_path) as bam:\n for org, replicon_ids in references_by... | [
"0.6598933",
"0.64177066",
"0.6393043",
"0.6074415",
"0.6032629",
"0.60148144",
"0.57585204",
"0.5614244",
"0.55744815",
"0.55740666",
"0.5564409",
"0.55503625",
"0.5542675",
"0.55369735",
"0.55324143",
"0.55242544",
"0.5486904",
"0.547165",
"0.5459795",
"0.54455733",
"0.5401... | 0.0 | -1 |
consolidate results into dataframes | def parse_dataframes(genome_gtf, sralist):
def gather_strand_by_geneID_dict(genome_gtf):
"""
Returns dictionary with strand orientation as values and geneIDs as Keys/
e.g.: {'YAL012W': '+',
'YAL069W': '+',
'YAL068W-A': '+',
"""
strand_by_geneID_dict = {}
with open(genome_gtf) as f:
for line in f:
current_line = line.split('\t')
if current_line[2] == "CDS":
current_orf = current_line[8].split(';')[2].split()[1].strip('\"')
current_strand = current_line[6]
strand_by_geneID_dict[current_orf] = current_strand
return strand_by_geneID_dict
def import_scikit_data(sralist):
"""
Import results from scikit pipeline for all datasets contained in datsets_names.
"""
scikit_data_dict = {}
for dataset in sralist:
with open(TMP_DIR+'scikit_'+dataset+'/ALL_genes_profile_dict.json', 'r') as scikit_data:
scikit_data_dict[dataset] = [json.load(scikit_data)]
return scikit_data_dict
def build_mat_scikit_strandOriented(sralist, scikit_data):
"""
Building of scikit_df based on the output of plot_ribo_density_dict.py script.
C/-/reverse/complementary strand are taken into account and the profile values
("codon_density_profile", "codon_triplet", "codon_AA") are reversed. This is
performed by adding [::-1] to C strands profile ends.
Same profile values are also have their extremities trimmed out of 8 codons.
(This is because the scikit-ribo pipeline considers 8 extra codons on each end,
but here we are only interested in the coding sequence). This is performed by
adding [8:-8] to profile lists ends.
"""
scikit_mat = {}
seq_codons = {}
seq_aa = {}
for geneID in scikit_data[sralist[0]][0].keys():
for ix, dataset in enumerate(sralist):
if geneID in scikit_data[dataset][0].keys():
current_profile = scikit_data[dataset][0].get(geneID, np.nan)
current_ribo = current_profile[0]
current_ribo = current_ribo[8:-8]
N = len(sralist)
M = len(current_ribo)
print(geneID, M)
if ix == 0:
current_matrix = np.zeros((N,M)) * np.nan
current_seq_codons = current_profile[1]
current_seq_codons = current_seq_codons[8:-8]
current_seq_aa = current_profile[2]
current_seq_aa = current_seq_aa[8:-8]
if strand_by_geneID_dict.get(geneID, "NA") == "+":
seq_codons[geneID] = current_seq_codons
seq_aa[geneID] = current_seq_aa
elif strand_by_geneID_dict.get(geneID, "NA") == "-":
seq_codons[geneID] = current_seq_codons[::-1]
seq_aa[geneID] = current_seq_aa[::-1]
if strand_by_geneID_dict.get(geneID, "NA") == "+":
current_matrix[ix,:] = current_ribo
elif strand_by_geneID_dict.get(geneID, "NA") == "-":
current_matrix[ix,:] = current_ribo[::-1]
if np.sum(current_matrix) > 0:
scikit_mat[geneID] = current_matrix
# scikit_df = pd.DataFrame(values_list, columns=columns_list)
return scikit_mat, seq_codons, seq_aa
def mean_norm(row):
codon_dens_prof = row.codon_density_profile
profile_average = np.average(codon_dens_prof)
return [x/profile_average for x in codon_dens_prof]
#scikit_data_df["mean_norm_codon_density_profile"] = scikit_data_df.apply(mean_norm, axis=1)
#scikit_data_df["mean_norm_codon_density_profile"] = scikit_data_df['mean_norm_codon_density_profile'].apply(lambda x: x[8:-8])
strand_by_geneID_dict = gather_strand_by_geneID_dict(genome_gtf)
scikit_data_dict = import_scikit_data(sralist)
scikit_data_mat, seq_codons_dict, seq_aa_dict = build_mat_scikit_strandOriented(sralist, scikit_data_dict)
with open('../data/processed/scikit_mat.pkl', 'wb') as f:
pickle.dump(scikit_data_mat, f)
with open('../data/processed/scikit_codonseq.pkl', 'wb') as f_seq:
pickle.dump(seq_codons_dict, f_seq)
return scikit_data_mat | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_results_dataframe(self):\n LOG.debug(\"Creating Results Dataframes.\")\n results_df = tfs.TfsDataFrame(index=self.twiss_df.index)\n results_df[\"S\"] = self.twiss_df[\"S\"]\n return results_df",
"def consolidate_results(path='./Data'):\n model_files = [load(os.path.join(p... | [
"0.6732909",
"0.66638446",
"0.6632721",
"0.65633905",
"0.65257215",
"0.6472688",
"0.6428347",
"0.63872194",
"0.6289251",
"0.6240572",
"0.6240572",
"0.62322944",
"0.6207928",
"0.61921304",
"0.61735207",
"0.61727184",
"0.6156177",
"0.61521775",
"0.6060341",
"0.6056508",
"0.6026... | 0.0 | -1 |
Returns dictionary with strand orientation as values and geneIDs as Keys/ | def gather_strand_by_geneID_dict(genome_gtf):
strand_by_geneID_dict = {}
with open(genome_gtf) as f:
for line in f:
current_line = line.split('\t')
if current_line[2] == "CDS":
current_orf = current_line[8].split(';')[2].split()[1].strip('\"')
current_strand = current_line[6]
strand_by_geneID_dict[current_orf] = current_strand
return strand_by_geneID_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_gene_map(self) -> OrderedDict:\n if \"gene\" not in self.data:\n return OrderedDict()\n\n genes: OrderedDict = OrderedDict()\n for idx, genestr in self.data[\"gene\"].items():\n if pd.isnull(genestr):\n continue\n for gene in genestr.spl... | [
"0.6775984",
"0.63313013",
"0.6185268",
"0.6166058",
"0.61002773",
"0.5993038",
"0.5952857",
"0.5945249",
"0.5915649",
"0.59024686",
"0.5877856",
"0.5875492",
"0.5870065",
"0.5817717",
"0.57851946",
"0.57501155",
"0.57454574",
"0.5728968",
"0.57258415",
"0.56919414",
"0.56362... | 0.6580928 | 1 |
Import results from scikit pipeline for all datasets contained in datsets_names. | def import_scikit_data(sralist):
scikit_data_dict = {}
for dataset in sralist:
with open(TMP_DIR+'scikit_'+dataset+'/ALL_genes_profile_dict.json', 'r') as scikit_data:
scikit_data_dict[dataset] = [json.load(scikit_data)]
return scikit_data_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_processed_dataset(name):\n assert name in VALID_NAMES, 'Invalid data set requested. Please make sure name is one of ' + ', '.join(VALID_NAMES) + '.'\n path = os.path.join('downloads', name)\n path_processed = os.path.join(path, 'processed')\n\n if name == 'iris':\n return pd.read_csv(os... | [
"0.6478788",
"0.6423142",
"0.6417792",
"0.6409163",
"0.64047015",
"0.6366228",
"0.62911695",
"0.62740004",
"0.6178644",
"0.61630666",
"0.6153745",
"0.6104244",
"0.6079098",
"0.6072685",
"0.6070125",
"0.60272676",
"0.60272676",
"0.59892446",
"0.5962235",
"0.59133875",
"0.59104... | 0.0 | -1 |
Building of scikit_df based on the output of plot_ribo_density_dict.py script. C//reverse/complementary strand are taken into account and the profile values ("codon_density_profile", "codon_triplet", "codon_AA") are reversed. This is | def build_mat_scikit_strandOriented(sralist, scikit_data):
scikit_mat = {}
seq_codons = {}
seq_aa = {}
for geneID in scikit_data[sralist[0]][0].keys():
for ix, dataset in enumerate(sralist):
if geneID in scikit_data[dataset][0].keys():
current_profile = scikit_data[dataset][0].get(geneID, np.nan)
current_ribo = current_profile[0]
current_ribo = current_ribo[8:-8]
N = len(sralist)
M = len(current_ribo)
print(geneID, M)
if ix == 0:
current_matrix = np.zeros((N,M)) * np.nan
current_seq_codons = current_profile[1]
current_seq_codons = current_seq_codons[8:-8]
current_seq_aa = current_profile[2]
current_seq_aa = current_seq_aa[8:-8]
if strand_by_geneID_dict.get(geneID, "NA") == "+":
seq_codons[geneID] = current_seq_codons
seq_aa[geneID] = current_seq_aa
elif strand_by_geneID_dict.get(geneID, "NA") == "-":
seq_codons[geneID] = current_seq_codons[::-1]
seq_aa[geneID] = current_seq_aa[::-1]
if strand_by_geneID_dict.get(geneID, "NA") == "+":
current_matrix[ix,:] = current_ribo
elif strand_by_geneID_dict.get(geneID, "NA") == "-":
current_matrix[ix,:] = current_ribo[::-1]
if np.sum(current_matrix) > 0:
scikit_mat[geneID] = current_matrix
# scikit_df = pd.DataFrame(values_list, columns=columns_list)
return scikit_mat, seq_codons, seq_aa | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n super().__init__()\n self.upperBoundUsed = False # True if the distribution is right truncated\n self.lowerBoundUsed = False # True if the distribution is left truncated\n self.hasInfiniteBound = False # True if the untruncated distribution has bounds of +- syst... | [
"0.5600742",
"0.5545156",
"0.5511175",
"0.5406428",
"0.5405446",
"0.53374326",
"0.52538216",
"0.52383655",
"0.5226638",
"0.519781",
"0.51927817",
"0.51903063",
"0.516903",
"0.5139694",
"0.5136511",
"0.5129903",
"0.51277244",
"0.51252174",
"0.50994223",
"0.5087249",
"0.5086157... | 0.0 | -1 |
dictionary of boolean multimapping matrices | def build_mm_df(sralist):
def convert_to_codon(nts_array):
"""
pysam output is in nucleotides resolution, but scikit_curated_df uses codon resolution.
This function converts nucleotide arrays to codon length (nts to codon resolution):
"""
nts_array = np.array(nts_array)
codon_array = np.sum( np.reshape(A, (int(np.floor(nts_array[1]/3)),3) ), 1)/3.
return codon_array
def compute_mm(mmdata):
"""
get per gene average multi-mapping score
"""
mm_df = pd.DataFrame(columns=['ORF', 'MM'])
counter = 0
for gene in mmdata.keys():
current_matrix = mmdata[gene]
current_avrg = np.mean( np.sum(current_matrix, 1) / current_matrix.shape[1] )
mm_df.loc[counter] = [gene, current_avrg]
counter += 1
return mm_df
mm_mat = {}
mm_pct = {}
N = len(sralist)
for ix, dataset in enumerate(sralist):
samfile = pysam.AlignmentFile(TMP_DIR+'/ambiguous_reads/'+dataset+'_STAR_transcriptome_multi_mapped_sorted.bam', 'rb')
genes_list = list(samfile.references)
print(ix, dataset)
for geneID in genes_list:
# count the coverage of genomic positions by reads in region.
# Returns: four array.arrays of the same length in order A C G T
# The coverage is computed per-base [ACGT]
cov = samfile.count_coverage(geneID, read_callback='nofilter')
# Summ all 4 arrays
cov_sum = np.sum(cov, axis=0)
#print(geneID, cov_sum)
codon_cov = convert_to_codon(cov_sum)
codon_bool = np.asarray([1 if i > 0 else 0 for i in codon_cov])
M = len(codon_bool)
if ix == 0:
mm_mat[geneID] = np.zeros((N,M)) * np.nan
current_matrix = mm_mat[geneID]
current_matrix[ix,:] = np.copy(codon_bool)
mm_mat[geneID] = current_matrix
mm_avrg = compute_mm(mm_mat)
#mm_avrg.to_json('yeast_mm.json')
#mm_avrg.to_csv('yeast_mm.txt', header=True, index=False, sep='\t')
mm_profile = {}
theta_mm = 5
for orf in mm_mat.keys():
current_mat = mm_mat[orf]
current_bool = np.sum(current_mat, 0) <= theta_mm
mm_profile[orf] = current_bool
with open('../data/processed/mm_consensus.pkl', 'wb') as f_mm:
pickle.dump(mm_profile, f_mm)
return mm_mat, mm_avrg, mm_profile | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_dict_of_bool2(self):\n pass",
"def eye(m):\n data = dict()\n for i, j in itertools.product(range(m), range(m)):\n data[i, j] = mpfr(i == j)\n return MPMatrix((m, m), data)",
"def getMatrixMap(self):\n return self.M_array",
"def buildDicts(resComp, comparisons, matrices, ... | [
"0.6008547",
"0.559379",
"0.5578552",
"0.55711734",
"0.5570441",
"0.5570441",
"0.55518544",
"0.5523987",
"0.5333082",
"0.5278061",
"0.5247944",
"0.5236596",
"0.5219008",
"0.5200241",
"0.5198334",
"0.51891565",
"0.5130926",
"0.5113897",
"0.51134247",
"0.50944567",
"0.5081737",... | 0.0 | -1 |
pysam output is in nucleotides resolution, but scikit_curated_df uses codon resolution. | def convert_to_codon(nts_array):
nts_array = np.array(nts_array)
codon_array = np.sum( np.reshape(A, (int(np.floor(nts_array[1]/3)),3) ), 1)/3.
return codon_array | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_mm_df(sralist):\n\n def convert_to_codon(nts_array):\n \"\"\"\n pysam output is in nucleotides resolution, but scikit_curated_df uses codon resolution.\n This function converts nucleotide arrays to codon length (nts to codon resolution):\n \"\"\"\n \n nts_arra... | [
"0.55647254",
"0.49846494",
"0.48036072",
"0.4783149",
"0.47653148",
"0.47555912",
"0.47205758",
"0.47141117",
"0.46780866",
"0.4677644",
"0.46744534",
"0.4664888",
"0.46561313",
"0.4651731",
"0.46359685",
"0.46011293",
"0.4596688",
"0.45749894",
"0.45679227",
"0.45530605",
"... | 0.0 | -1 |
get per gene average multimapping score | def compute_mm(mmdata):
mm_df = pd.DataFrame(columns=['ORF', 'MM'])
counter = 0
for gene in mmdata.keys():
current_matrix = mmdata[gene]
current_avrg = np.mean( np.sum(current_matrix, 1) / current_matrix.shape[1] )
mm_df.loc[counter] = [gene, current_avrg]
counter += 1
return mm_df | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_avg_score(df, score):\n avg_score = (df.groupby(['condition', 'gene_a', 'gene_b'])\n .agg({score: 'mean'})\n .reset_index())\n return avg_score",
"def compute_ave_score_w_sample(genes, samples):\n\n scores = np.zeros(len(genes), dtype=np.uint32)\n\n for i, v in... | [
"0.6643462",
"0.6452144",
"0.62165403",
"0.6171676",
"0.60874385",
"0.60116637",
"0.5967243",
"0.59489244",
"0.5940046",
"0.5897672",
"0.5886396",
"0.5863131",
"0.584357",
"0.58260745",
"0.58122647",
"0.58121586",
"0.5747593",
"0.5738639",
"0.5724953",
"0.5721815",
"0.5719977... | 0.0 | -1 |
Determine relevant entries in crkeng.xml and build a smaller xml file for testing. | def build_test_xml():
crkeng_file_path = find_latest_xml_file(shared_res_dir / "dictionaries")
print(f"Building test dictionary files using {crkeng_file_path.name}")
crkeng_root = ET.parse(str(crkeng_file_path)).getroot()
# relevant entries in crkeng.xml file we want to determine
relevant_xml_ls: Set[str] = set()
xml_ls: Set[str] = set()
crkeng_entries = crkeng_root.findall(".//e")
for element in crkeng_entries:
xml_l = extract_l_str(element)
xml_ls.add(xml_l)
test_words = get_test_words()
print(f"Analyzing xml l elements and test words")
word_to_analyses = morphodict.analysis.relaxed_analyzer().bulk_lookup(
xml_ls | test_words
)
print("Analysis done")
test_word_lemmas: Set[str] = set()
for test_word in test_words:
for analysis in word_to_analyses[test_word]:
lemma = fst_analysis_parser.extract_lemma(analysis)
if lemma is None:
logger.warn(
"Skipping test word: %s. "
"Could not extract lemma from its analysis: %s",
test_word,
analysis,
)
continue
test_word_lemmas.add(lemma)
for xml_l in tqdm(xml_ls, desc="screening relevant entries in crkeng.xml"):
if xml_l in test_words:
relevant_xml_ls.add(xml_l)
continue
for xml_l_analysis in word_to_analyses[xml_l]:
xml_lemma = partition_analysis(xml_l_analysis)[1]
for test_word_lemma in test_word_lemmas:
if test_word_lemma == xml_lemma:
relevant_xml_ls.add(xml_l)
break
relevant_crkeng_entries = []
for element in crkeng_entries:
xml_l = extract_l_str(element)
if xml_l in relevant_xml_ls:
relevant_crkeng_entries.append(element)
crkeng_xml_utils.write_xml_from_elements(
list(crkeng_root.findall(".//source")) + relevant_crkeng_entries,
shared_res_dir / "test_dictionaries" / "crkeng.xml",
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def XML_EC_PL(Name, InputsFile, OutputFile, emin,emax):\n\n\t#On commence par afficher ce qu'on fait\r\n\tprint \" Build xml file \"\r\n\r\tprint InputsFile\n\t#ouverture du fichier dans lequel on place le source model\n\ttry:\n\t\tfresult = open(OutputFile, 'w')\n\texcept:\n\t\tprint \"Coucou\"\r\n \t#ecriture... | [
"0.61072654",
"0.5717132",
"0.5615994",
"0.5543528",
"0.55028045",
"0.53621995",
"0.5347263",
"0.5297309",
"0.5269815",
"0.5254691",
"0.52032775",
"0.5177183",
"0.5130147",
"0.5118681",
"0.51131713",
"0.51111734",
"0.5094071",
"0.50852966",
"0.5085046",
"0.50843346",
"0.50589... | 0.72865844 | 0 |
r"""The constructor for Config class Initializes the Config class | def __init__(self, config_file_name="config.json"):
with open(config_file_name, "r") as config:
f = dict(json.load(config))
for key, value in f.items():
setattr(self, key, value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs):\r\n super().__init__()\r\n self._cfg = ConfigDict() # current configuration\r\n self._default_config = ConfigDict() # default configuration\r\n self._temp_config = OrderedDict() # temporary configuration\r\n self._path = Path() # current c... | [
"0.8203434",
"0.7962474",
"0.78200513",
"0.77837414",
"0.77558804",
"0.77334917",
"0.77334917",
"0.7729926",
"0.7703412",
"0.7703412",
"0.7703412",
"0.7694449",
"0.7644489",
"0.7622834",
"0.75704795",
"0.7559002",
"0.754742",
"0.75234354",
"0.75190806",
"0.74873096",
"0.74624... | 0.69338214 | 52 |
r"""Class constructor for Config | def __init__(self, config_file_name="config.json"):
self.config_file_name = config_file_name
self._config = self._open_config_file() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, config: Dict[str, Any]) -> None:\n self.config = config",
"def __init__(self, *args, **kwargs):\r\n super().__init__()\r\n self._cfg = ConfigDict() # current configuration\r\n self._default_config = ConfigDict() # default configuration\r\n self._temp_config... | [
"0.8146151",
"0.81249666",
"0.7914005",
"0.7902959",
"0.7902959",
"0.78517556",
"0.7830942",
"0.78164166",
"0.7816199",
"0.78047544",
"0.78047544",
"0.78047544",
"0.7794701",
"0.7631528",
"0.7613544",
"0.76106983",
"0.7570277",
"0.7570083",
"0.7505082",
"0.7465383",
"0.745413... | 0.7287139 | 22 |
Load the config file | def _open_config_file(self):
try:
with open(self.config_file_name,encoding='utf-8') as json_data_file:
conf = json.load(json_data_file)
return conf
except FileNotFoundError:
with open(self.config_file_name, 'w',encoding='utf-8') as json_data_file:
json.dump({},json_data_file,indent=2)
return {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_config(self):\n pass",
"def load_config(self):\r\n with open('config.json', 'r') as f:\r\n self.config = json.load(f)",
"def load_config(self):\n if os.path.exists(self.config_file):\n with open(self.config_file) as f:\n conf = json.load(f)\n\n... | [
"0.8379018",
"0.8353927",
"0.8132022",
"0.8111965",
"0.8104528",
"0.79837865",
"0.7953077",
"0.78238404",
"0.7770456",
"0.77264285",
"0.77023524",
"0.7679735",
"0.7665702",
"0.7665702",
"0.76194495",
"0.76163685",
"0.7611368",
"0.75783414",
"0.7574488",
"0.7554147",
"0.752987... | 0.0 | -1 |
Saves the config file | def save_config_file(self):
with open(self.config_file_name, 'w',encoding='utf-8') as outfile:
json.dump(self._config, outfile,indent=2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self):\n file = open(self.path, 'w')\n self.config.write(file)\n file.close()",
"def save(self):\r\n with open(self.filename, 'wb') as configfile:\r\n self.write(configfile)",
"def save_config(self):\n config.save_config(self.config, self.config_file)",
... | [
"0.9018369",
"0.89983326",
"0.87025833",
"0.8437155",
"0.83241445",
"0.8323876",
"0.8261388",
"0.82597125",
"0.8157242",
"0.8059971",
"0.80546784",
"0.805303",
"0.7990608",
"0.79761726",
"0.79709685",
"0.79246825",
"0.7923481",
"0.7910758",
"0.7910608",
"0.78848404",
"0.78846... | 0.8239592 | 8 |
Return value stored in config | def get(self, key, default_val=None):
if key not in self._config.keys(): # we don't want KeyError
return default_val # just return None if not found
return self._config[key] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_config_value(self, name):\r\n if name in self.config_values:\r\n return self.config_values[name]",
"def _get_config_value(self, section, key):\n return config.get(section, key)",
"def value(self) -> str:\n return self._config.get('value')",
"def get(self, key):\n ... | [
"0.8236148",
"0.78571916",
"0.78411025",
"0.77996963",
"0.7762611",
"0.7640735",
"0.7605088",
"0.7578148",
"0.7571694",
"0.7504212",
"0.7446086",
"0.7428434",
"0.7364911",
"0.7358118",
"0.7330266",
"0.73145777",
"0.7290636",
"0.72804093",
"0.7263993",
"0.7168558",
"0.7160482"... | 0.0 | -1 |
Update the config file | def update(self):
self.save_config_file() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conf_update(self):\n pass",
"def updateConfig(self):\n # Make sure to keep the default values in place.\n if self.newConfig['sensor'] == 0:\n self.newConfig['sensor'] = self.config['sensor']\n if self.newConfig['camera'] == 0:\n self.newConfig['camera'] = sel... | [
"0.8264877",
"0.7606795",
"0.74441475",
"0.726482",
"0.7236753",
"0.72217864",
"0.7091417",
"0.7060331",
"0.70171785",
"0.70084494",
"0.6937647",
"0.69036394",
"0.6887495",
"0.68652135",
"0.6852088",
"0.6795112",
"0.679408",
"0.67330885",
"0.6727831",
"0.6705917",
"0.66979545... | 0.88768095 | 0 |
FILL COLUMN2 WITH MOST LIKELY VALUES BASED ON COLUMN1 | def fillgaps(column1,column2,train,test):
ddict={}
d1=test[[column1,column2]].dropna().values
d2=train[[column1,column2]].dropna().values
c1=np.array(d1[:,0].tolist()+d2[:,0].tolist())
c2=np.array(d1[:,1].tolist()+d2[:,1].tolist())
for ic1 in np.unique(c1):
ddict[ic1]=(c2[c1==ic1].mean(),c2[c1==ic1].std())
full_data = [train, test]
for dataset in full_data:
for missing in np.where(np.isnan(dataset[column2]))[0]:
m,s=ddict[dataset[column1][missing]]
if s<=0:
dataset[column2][missing]=m
else:
dataset[column2][missing]=np.random.normal(loc=m,scale=s,size=1)
return (train,test) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _fill_col1_val_where_col2_notna(col1, col2, val):\n fill_ser = col1.copy()\n fill_ser[col2.notna()] = val\n return col1.fillna(fill_ser)",
"def fill_col(col, x):\n col.append(x)\n return col",
"def merge(line):\n #Step1. Putting 0 to the end of the list.\n result = []\n for cell in ... | [
"0.6066896",
"0.5588243",
"0.5520393",
"0.5153865",
"0.5142474",
"0.5100762",
"0.50284475",
"0.50032073",
"0.4990765",
"0.4952544",
"0.49398243",
"0.49170038",
"0.4903504",
"0.4887256",
"0.48762384",
"0.48469424",
"0.48462567",
"0.48410118",
"0.47721502",
"0.47698507",
"0.475... | 0.57042193 | 1 |
Returns true if player has 3 of spades in their hand. | def has_3_spades(self):
if Card('3', 'spades') in self.hand:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_three_of_a_kind(self):\n self.suit_hist()\n for val in self.ranks.values():\n if val >= 3:\n self.rank_per_hand['2'] = \"three of a kind\"\n return True\n return False",
"def is_three_of_a_kind(hand):\n count = {c:0 for c in cards.keys()}\n... | [
"0.72666436",
"0.7080395",
"0.70760804",
"0.6595992",
"0.65198547",
"0.6504807",
"0.6470795",
"0.6453197",
"0.63943964",
"0.6391937",
"0.6380108",
"0.63546914",
"0.63495284",
"0.63185066",
"0.62931806",
"0.6260325",
"0.61777973",
"0.61756945",
"0.61107355",
"0.6093892",
"0.60... | 0.89362204 | 0 |
Return all components that match the given type and filter | def queryComponent(type=None, filter=None, all=0): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_components(self, filter_type=None):\n\n if filter_type is None:\n out = self.components\n elif isinstance(filter_type, str):\n out = {}\n cls = co.str_to_comp(filter_type)\n for comp in self.get_components():\n if isinstance(self.comp... | [
"0.7252907",
"0.6754801",
"0.6730381",
"0.66894734",
"0.6564939",
"0.6288751",
"0.6273336",
"0.62642753",
"0.6115402",
"0.5971226",
"0.59191287",
"0.5848749",
"0.58480895",
"0.5832433",
"0.5759755",
"0.5755212",
"0.56894547",
"0.56826574",
"0.5639281",
"0.56076664",
"0.559276... | 0.74276376 | 0 |
Inform a service component that it is providing a service Called when an immediatelycontaining service manager binds this object to perform the named service. | def bound(name): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def service(self, service):\n \n self._service = service",
"def register_service(self) -> None:\n strategy = cast(Strategy, self.context.strategy)\n description = strategy.get_register_service_description()\n self._register(description, \"registering agent's service on the SOEF... | [
"0.6836905",
"0.6561478",
"0.63746643",
"0.62869096",
"0.61396533",
"0.61276996",
"0.6079517",
"0.6064858",
"0.60322297",
"0.60286254",
"0.6019076",
"0.6012391",
"0.60076535",
"0.5998224",
"0.5997815",
"0.5986478",
"0.5975217",
"0.59336156",
"0.59249896",
"0.5881597",
"0.5861... | 0.0 | -1 |
Inform a service component that it is no longer providing a service Called when an immediatelycontaining service manager unbinds this object from performing the named service. | def unbound(name): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_service_departure(self, svc_ref):\n with self._lock:\n if svc_ref is self.reference:\n # Injected service going away...\n service = self._value\n\n # Clear the instance values\n self._current_ranking = None\n self._... | [
"0.770065",
"0.717073",
"0.69855356",
"0.6912879",
"0.6827076",
"0.67656344",
"0.66443497",
"0.64091897",
"0.6407706",
"0.63915473",
"0.6383925",
"0.63309795",
"0.6218311",
"0.61347353",
"0.612612",
"0.6044134",
"0.60432863",
"0.60367554",
"0.60173887",
"0.60062134",
"0.60048... | 0.0 | -1 |
checkKey is used to check for authentication | def checkKey(self):
# TO DO for checking API authentication
if self.apikey is None:
return False
else:
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_auth_publickey(self, username, key):\n return AUTH_FAILED",
"def _check_key(self, key):\n raise NotImplementedError",
"def api_key_check():\n req_path = request.path\n method_type = request.method\n app.logger.info(\">>> path = {}, method = {}\".format(req_path, method_type))\n... | [
"0.7483722",
"0.7159838",
"0.7102654",
"0.70746124",
"0.70519286",
"0.69825",
"0.69745266",
"0.6936464",
"0.6857674",
"0.6834089",
"0.67978585",
"0.6719186",
"0.661024",
"0.65871054",
"0.64848256",
"0.6452751",
"0.6445985",
"0.644107",
"0.6375559",
"0.6362564",
"0.6354385",
... | 0.76604617 | 0 |
This function is used to update API endpoints | def update(self):
# TO DO for updating urls if changed
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update_api(self) -> None:\n LOG.debug(\"%sTrying to update RestAPI through client\", self.log_prefix)\n response_put = cast(\n Dict,\n self._api_client.put_rest_api(restApiId=self._api_physical_id, mode=\"overwrite\", body=self._swagger_body),\n )\n LOG.debug(... | [
"0.74739033",
"0.7205048",
"0.71335983",
"0.66851205",
"0.6498618",
"0.6447019",
"0.63703203",
"0.62712914",
"0.6245343",
"0.6233306",
"0.62273663",
"0.6156109",
"0.6128922",
"0.6088179",
"0.6088179",
"0.6088179",
"0.60405344",
"0.60191697",
"0.6019072",
"0.6019072",
"0.60190... | 0.6032268 | 17 |
getData is used to get satellite json data from the server. | def getSearch(self, satellite: str,
startDate: str, endDate: str,
latitude: float, longitude: float,
minCloudCover=None, maxCloudCover=None,
minCoverage=None, maxCoverage=None,
) -> list:
if satellite.lower() == 'landsat8':
satellite = 'l8'
minCloudCover = self.minCloudCover if minCloudCover is None else minCloudCover
maxCloudCover = self.maxCloudCover if maxCloudCover is None else maxCloudCover
minCoverage = self.minCoverage if minCoverage is None else minCoverage
maxCoverage = self.maxCoverage if maxCoverage is None else maxCoverage
param = {
'table_name': 'satellite_dataset_prod',
'satellite': satellite.lower(),
'start_date': startDate,
'end_date': endDate,
'min_cloudcover': int(minCloudCover),
'max_cloudcover': int(maxCloudCover),
'min_coverage': int(minCoverage),
'max_coverage': int(maxCoverage),
'x': float(longitude),
'y': float(latitude)
}
try:
response = requests.get(url=self.searchEndpoint, params=param)
except Exception as e:
raise exceptions(
'Unable to reach to server. \
Make sure url is correct, updated and \
you are connected to Internet. Error : {}'.format(e))
return response.json() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n return",
"def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n ... | [
"0.7276632",
"0.7044919",
"0.7044919",
"0.7044919",
"0.6988719",
"0.6904598",
"0.67315245",
"0.67315245",
"0.6711421",
"0.6699119",
"0.66586465",
"0.6641715",
"0.65758157",
"0.65712667",
"0.6570018",
"0.6539462",
"0.6526975",
"0.64456314",
"0.64355475",
"0.6282369",
"0.626784... | 0.0 | -1 |
getData is used to get satellite json data from the server. | def getValue(self, url: str, latitude: list,
longitude: list, satellite='l8', index='ndvi'):
if type(latitude) is not list:
latitude = [str(latitude)]
else:
latitude = [str(l) for l in latitude]
if type(longitude) is not list:
longitude = [str(longitude)]
else:
longitude = [str(l) for l in longitude]
param = {
'url': url,
'x': ','.join(longitude),
'y': ','.join(latitude),
'satellite': satellite,
'index': index
}
try:
response = requests.get(url=self.valueEndpoint, params=param)
except Exception as e:
raise exceptions(
'Unable to reach to value endpoint. Error: {}'.format(e))
return response.json() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n return",
"def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n ... | [
"0.72779673",
"0.7046692",
"0.7046692",
"0.7046692",
"0.6990083",
"0.6905413",
"0.67326444",
"0.67326444",
"0.67116404",
"0.67000073",
"0.6659789",
"0.66423845",
"0.657657",
"0.65723705",
"0.6571265",
"0.6539489",
"0.6527483",
"0.64475584",
"0.6434517",
"0.6281322",
"0.626736... | 0.0 | -1 |
getData is used to get satellite json data from the server. | def getStats(self, url: str, latitude: list,
longitude: list, satellite='l8', index='ndvi'):
if type(latitude) is not list:
latitude = [str(latitude)]
else:
latitude = [str(l) for l in latitude]
if type(longitude) is not list:
longitude = [str(longitude)]
else:
longitude = [str(l) for l in longitude]
param = {
'url': url,
'x': ','.join(longitude),
'y': ','.join(latitude),
'satellite': satellite,
'index': index
}
try:
response = requests.get(url=self.statsEndpoint, params=param)
except Exception as e:
raise exceptions(
'Unable to reach to statistics endpoint. Error: {}'.format(e))
return response.json() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n return",
"def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n ... | [
"0.72779673",
"0.7046692",
"0.7046692",
"0.7046692",
"0.6990083",
"0.6905413",
"0.67326444",
"0.67326444",
"0.67116404",
"0.67000073",
"0.6659789",
"0.66423845",
"0.657657",
"0.65723705",
"0.6571265",
"0.6539489",
"0.6527483",
"0.64475584",
"0.6434517",
"0.6281322",
"0.626736... | 0.0 | -1 |
getData is used to get satellite json data from the server. | def getTimelineValue(self, url: str, latitude: float,
longitude: float, startDate: str, endDate: str,
minCloudCover=None, maxCloudCover=None,
minCoverage=None, maxCoverage=None,
satellite='l8', index='ndvi'):
latitude = str(latitude)
longitude = str(longitude)
minCloudCover = self.minCloudCover if minCloudCover is None else minCloudCover
maxCloudCover = self.maxCloudCover if maxCloudCover is None else maxCloudCover
minCoverage = self.minCoverage if minCoverage is None else minCoverage
maxCoverage = self.maxCoverage if maxCoverage is None else maxCoverage
param = {
'url': url,
'x': str(longitude),
'y': str(latitude),
'satellite': satellite.lower(),
'index': index,
'start_date': startDate,
'end_date': endDate,
'min_cloudcover': int(minCloudCover),
'max_cloudcover': int(maxCloudCover),
'min_coverage': int(minCoverage),
'max_coverage': int(maxCoverage),
}
try:
response = requests.get(url=self.timelineValueEndpoint, params=param)
except Exception as e:
raise exceptions(
'Unable to reach to value endpoint. Error: {}'.format(e))
return response.json() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n return",
"def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n ... | [
"0.72748417",
"0.7042909",
"0.7042909",
"0.7042909",
"0.6986527",
"0.69044787",
"0.6730157",
"0.6730157",
"0.67095935",
"0.6698002",
"0.6657195",
"0.66411364",
"0.6575214",
"0.65689933",
"0.6568993",
"0.6539387",
"0.6526602",
"0.64448017",
"0.643305",
"0.62808186",
"0.6266045... | 0.0 | -1 |
getData is used to get satellite json data from the server. | def getTimelineStats(self, url: str, latitude: list,
longitude: list, startDate: str, endDate: str,
minCloudCover=None, maxCloudCover=None,
minCoverage=None, maxCoverage=None,
satellite='l8', index='ndvi'):
if type(latitude) is not list:
latitude = [str(latitude)]
else:
latitude = [str(l) for l in latitude]
if type(longitude) is not list:
longitude = [str(longitude)]
else:
longitude = [str(l) for l in longitude]
minCloudCover = self.minCloudCover if minCloudCover is None else minCloudCover
maxCloudCover = self.maxCloudCover if maxCloudCover is None else maxCloudCover
minCoverage = self.minCoverage if minCoverage is None else minCoverage
maxCoverage = self.maxCoverage if maxCoverage is None else maxCoverage
param = {
'url': url,
'x': ','.join(longitude),
'y': ','.join(latitude),
'satellite': satellite.lower(),
'index': index,
'start_date': startDate,
'end_date': endDate,
'min_cloudcover': int(minCloudCover),
'max_cloudcover': int(maxCloudCover),
'min_coverage': int(minCoverage),
'max_coverage': int(maxCoverage),
}
try:
response = requests.get(url=self.timelineStatsEndpoint, params=param)
except Exception as e:
raise exceptions(
'Unable to reach to value endpoint. Error: {}'.format(e))
return response.json() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n return",
"def _get_data(self, url: str)->dict:\n data = None\n resp = self._get(url)\n if resp:\n data = resp.json()['data']\n ... | [
"0.7276632",
"0.7044919",
"0.7044919",
"0.7044919",
"0.6988719",
"0.6904598",
"0.67315245",
"0.67315245",
"0.6711421",
"0.6699119",
"0.66586465",
"0.6641715",
"0.65758157",
"0.65712667",
"0.6570018",
"0.6539462",
"0.6526975",
"0.64456314",
"0.64355475",
"0.6282369",
"0.626784... | 0.0 | -1 |
make the cosmos and DES meds files | def make_all_cosmos_des(run, cosmos_config, des_config, catfile, tileid):
flist = files.get_cosmos_flist(tileid)
cosmos_meds = files.get_meds_file(run, tileid, 'cosmos','i')
print('making cosmos MEDS:',cosmos_meds)
maker = CosmosMEDSMaker(
config_path=cosmos_config,
catname=catfile,
flistname=flist,
)
maker.write(cosmos_meds)
for band in ['u','g','r','i','z']:
band_flist = files.get_des_flist(band)
band_meds = files.get_meds_file(run, tileid, 'des',band)
print('making DES MEDS:',band_meds)
maker = CosmosMEDSMaker(
config_path=des_config,
catname=cosmos_meds,
flistname=band_flist,
)
maker.write(band_meds) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_data_raw (mdp,do_makedata,filename):\n #\n fin = open(filename,'r')\n for line in fin:\n lsp = line.split(' ')\n if len(lsp) > 1: # skip empty lines\n if lsp[0] == \"for\": # indicates when to get correlator\n lsp.pop(0)\n update_params(mdp,lsp)\n ## -- do_makedata tells it to go ahead with g... | [
"0.637841",
"0.6184567",
"0.6101035",
"0.6063938",
"0.59966964",
"0.5898186",
"0.5831032",
"0.5792886",
"0.56806254",
"0.5673659",
"0.5642974",
"0.56186104",
"0.5612226",
"0.5589771",
"0.55712795",
"0.55688566",
"0.55426204",
"0.5509481",
"0.5476108",
"0.5453811",
"0.5441293"... | 0.7661663 | 0 |
write compressed meds file | def write(self, filename):
assert filename[-3:]=='.fz','name must end in .fz'
files.makedir_fromfile(filename)
ucfilename=filename[0:-3]
bname = os.path.basename(ucfilename)
tmp_path = os.path.join(
files.get_temp_dir(),
bname,
)
files.makedir_fromfile(tmp_path)
with TempFile(tmp_path) as tfile:
super(CosmosMEDSMaker,self).write(tfile.path)
self._compress_meds_file(tfile.path, filename) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_compressed(self, filename):\n\n # Define which molecules to use \n # (counting indices of processed data set)\n indices = np.arange(len(self))\n # All charges and position arrays have the same size\n # (the one of the biggest molecule)\n size = np.max( self.num_a... | [
"0.66734606",
"0.6449204",
"0.61703485",
"0.6010072",
"0.5976385",
"0.5969885",
"0.59663653",
"0.59331244",
"0.5882864",
"0.5877286",
"0.5830967",
"0.5827414",
"0.5769662",
"0.574796",
"0.57416415",
"0.5724244",
"0.5712031",
"0.56908506",
"0.5682276",
"0.5674419",
"0.56734663... | 0.6046685 | 3 |
build the object data, filling in the stub we read note position offsets appear nowhere in this function | def _build_meds_layout(self):
nim = self.image_info.size
nobj = self.obj_data.size
trim_to_coadd = self.get('trim_to_coadd',False)
if trim_to_coadd:
print(' trimming to coadd')
coadd_wcs, coadd_pos, coadd_bnds, coadd_q = \
self._get_pos_and_bounds(self.obj_data, 0)
in_bnds = coadd_bnds.contains_points(coadd_pos['zrow'], coadd_pos['zcol'])
w_in_bnds, = np.where(in_bnds == True)
assert w_in_bnds.size > 0,"none found in coadd"
w_in_bnds = coadd_q[w_in_bnds]
self.obj_data = self.obj_data[w_in_bnds]
self._do_psf_setup()
# box sizes are even
half_box_size = self.obj_data['box_size']//2
for file_id in range(nim):
wcs, pos, bnds, q = self._get_pos_and_bounds(self.obj_data, file_id)
# do the test
in_bnds = bnds.contains_points(pos['zrow'], pos['zcol'])
q_rc, = np.where(in_bnds == True)
print(' second cut: %6d of %6d objects' % (len(q_rc),len(q)))
# now make sure everything is there
if self['check_in_first_image']:
if file_id == 0 and len(self.obj_data['ra']) != len(q_rc):
raise MEDSCreationError('Not all objects were found in first image for '
'MEDS making (which is the coadd/detection '
'image by convention).')
# compose them
q = q[q_rc]
# fill in the object_data structure
# note q_rc since pos was created using obj_data[q]
qrow = pos['zrow'][q_rc]
qcol = pos['zcol'][q_rc]
icut = self.obj_data['ncutout'][q]
self.obj_data['file_id'][q,icut] = file_id
self.obj_data['orig_row'][q,icut] = qrow
self.obj_data['orig_col'][q,icut] = qcol
# this results in the object center being close to
# the natural center (dim-1.)/2.
ostart_row = qrow.astype('i4') - half_box_size[q] + 1
ostart_col = qcol.astype('i4') - half_box_size[q] + 1
crow = qrow - ostart_row
ccol = qcol - ostart_col
self.obj_data['orig_start_row'][q,icut] = ostart_row
self.obj_data['orig_start_col'][q,icut] = ostart_col
self.obj_data['cutout_row'][q,icut] = crow
self.obj_data['cutout_col'][q,icut] = ccol
# do jacobian, in original, not-offset coords
# note q_rc since pos was created using self.obj_data[q]
jacob = wcs.get_jacobian(
x=pos['wcs_col'][q_rc],
y=pos['wcs_row'][q_rc])
# jacob is a tuple of arrays
self.obj_data['dudcol'][q,icut] = jacob[0]
self.obj_data['dudrow'][q,icut] = jacob[1]
self.obj_data['dvdcol'][q,icut] = jacob[2]
self.obj_data['dvdrow'][q,icut] = jacob[3]
# increment
self.obj_data['ncutout'][q] += 1
w,=np.where(self.obj_data['ncutout'] > 0)
print('%d/%d had ncut > 0' % (w.size, self.obj_data.size))
#self.obj_data = self.obj_data[w]
self.obj_data = self._make_resized_data(self.obj_data)
print('setting number field as sequential')
self.obj_data['number'] = 1+np.arange(self.obj_data.size)
self._set_start_rows_and_pixel_count()
if self['survey']=='cosmos':
self._set_psf_layout_hst()
else:
self._set_psf_layout_psfex() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_raw_data(self, idx: int):\n info = super().prepare_raw_data(idx)\n if self.cache_reader is not None:\n self.human_data = self.cache_reader.get_item(idx)\n idx = idx % self.cache_reader.slice_size\n\n if 'smplx' in self.human_data:\n smplx_dict = sel... | [
"0.6157046",
"0.6072608",
"0.58471173",
"0.58050644",
"0.57371134",
"0.5713524",
"0.5703575",
"0.5679709",
"0.56751573",
"0.5645145",
"0.5609161",
"0.5597858",
"0.5583448",
"0.556738",
"0.55536085",
"0.5551123",
"0.5549294",
"0.5537869",
"0.5534043",
"0.55129117",
"0.55097",
... | 0.0 | -1 |
write the cutouts for the specified type | def _write_psf_cutouts_hst(self):
print('writing psf cutouts')
obj_data=self.obj_data
psf_data=self.psf_data
nfile=self.image_info.size
nobj=obj_data.size
cutout_hdu = self.fits['psf']
for iobj in range(nobj):
if (iobj+1) % 100 == 0:
print(' %d/%d' % (iobj+1,obj_data.size))
# HST psf is same for every cutout, in fact ncut should always
# be 1
try:
psf_im = self.psf_data.get_psf(iobj)
except AttributeError:
psf_im = None
ncut=obj_data['ncutout'][iobj]
for icut in range(ncut):
if psf_im is None:
row = obj_data['orig_row'][iobj, icut]
col = obj_data['orig_col'][iobj, icut]
file_id = obj_data['file_id'][iobj,icut]
p = self.psf_data[file_id]
psf_im = p.get_rec(row,col)
expected_psf_shape = (
obj_data['psf_row_size'][iobj,icut],
obj_data['psf_col_size'][iobj,icut],
)
file_id = obj_data['file_id'][iobj, icut]
row = obj_data['orig_row'][iobj, icut]
col = obj_data['orig_col'][iobj, icut]
start_row = obj_data['psf_start_row'][iobj, icut]
if psf_im.shape != expected_psf_shape:
raise ValueError("psf size mismatch, expected %s "
"got %s" % (expected_psf_shape, psf_im.shape))
cutout_hdu.write(psf_im, start=start_row) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_moleculetype(top_file: IO, mol_name: str, nrexcl: int = 3):\n top_file.write(\"[ moleculetype ]\\n\")\n top_file.write(\"; Name\\tnrexcl\\n\")\n top_file.write(f\"{mol_name}\\t{nrexcl}\\n\\n\")",
"def write(self, out):",
"def write_output(self):",
"def write(self):",
"def write(self):",... | [
"0.55175173",
"0.5354752",
"0.53262687",
"0.52530247",
"0.52530247",
"0.5227527",
"0.5203227",
"0.5147186",
"0.5113114",
"0.5088805",
"0.5083531",
"0.5081513",
"0.5079073",
"0.5070704",
"0.5031757",
"0.50116146",
"0.49944216",
"0.4976218",
"0.49679434",
"0.4965163",
"0.496383... | 0.5732155 | 0 |
set the box sizes and start row for each psf image | def _set_psf_layout_hst(self):
print('setting psf layout for HST')
obj_data=self.obj_data
total_psf_pixels = 0
psf_start_row = 0
for iobj in range(obj_data.size):
if (iobj+1) % 100 == 0:
print(' %d/%d' % (iobj+1,obj_data.size))
# note assuming same psf for all "epochs"
psf_im = self.psf_data.get_psf(iobj)
psf_shape = psf_im.shape
psf_npix = psf_im.size
cen = (np.array(psf_shape)-1.0)/2.0
# we will expand the psfs
for icut in range(obj_data['ncutout'][iobj]):
obj_data['psf_row_size'][iobj,icut] = psf_shape[0]
obj_data['psf_col_size'][iobj,icut] = psf_shape[1]
obj_data['psf_cutout_row'][iobj,icut] = cen[0]
obj_data['psf_cutout_col'][iobj,icut] = cen[1]
obj_data['psf_start_row'][iobj,icut] = psf_start_row
psf_start_row += psf_npix
total_psf_pixels += psf_npix
self.total_psf_pixels = total_psf_pixels | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_psf_layout_psfex(self):\n\n print('setting psf layout for PSFEx')\n\n obj_data=self.obj_data\n psf_data=self.psf_data\n\n total_psf_pixels = 0\n\n #psf_npix = psf_size*psf_size\n\n psf_start_row = 0\n for iobj in range(obj_data.size):\n for icut ... | [
"0.6761654",
"0.6085298",
"0.6009164",
"0.58949316",
"0.58541226",
"0.58446145",
"0.5767578",
"0.5712032",
"0.5706543",
"0.5674811",
"0.5674811",
"0.5674811",
"0.5674811",
"0.5674811",
"0.5668548",
"0.5650026",
"0.5615289",
"0.5615289",
"0.5593645",
"0.55755764",
"0.55713177"... | 0.62900573 | 1 |
set the box sizes and start row for each psf image | def _set_psf_layout_psfex(self):
print('setting psf layout for PSFEx')
obj_data=self.obj_data
psf_data=self.psf_data
total_psf_pixels = 0
#psf_npix = psf_size*psf_size
psf_start_row = 0
for iobj in range(obj_data.size):
for icut in range(obj_data['ncutout'][iobj]):
row = obj_data['orig_row'][iobj, icut]
col = obj_data['orig_col'][iobj, icut]
file_id = obj_data['file_id'][iobj,icut]
p = psf_data[file_id]
pim = p.get_rec(row,col)
cen = p.get_center(row,col)
psf_shape = pim.shape
psf_npix = pim.size
obj_data['psf_row_size'][iobj,icut] = psf_shape[0]
obj_data['psf_col_size'][iobj,icut] = psf_shape[1]
obj_data['psf_cutout_row'][iobj,icut] = cen[0]
obj_data['psf_cutout_col'][iobj,icut] = cen[1]
obj_data['psf_start_row'][iobj,icut] = psf_start_row
psf_start_row += psf_npix
total_psf_pixels += psf_npix
self.total_psf_pixels = total_psf_pixels | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_psf_layout_hst(self):\n\n print('setting psf layout for HST')\n obj_data=self.obj_data\n\n total_psf_pixels = 0\n psf_start_row = 0\n\n for iobj in range(obj_data.size):\n if (iobj+1) % 100 == 0:\n print(' %d/%d' % (iobj+1,obj_data.size))\n\n... | [
"0.62900573",
"0.6085298",
"0.6009164",
"0.58949316",
"0.58541226",
"0.58446145",
"0.5767578",
"0.5712032",
"0.5706543",
"0.5674811",
"0.5674811",
"0.5674811",
"0.5674811",
"0.5674811",
"0.5668548",
"0.5650026",
"0.5615289",
"0.5615289",
"0.5593645",
"0.55755764",
"0.55713177... | 0.6761654 | 0 |
read the cosmos catalog | def _read_catalog(self, catname):
print('loading catalog:',catname)
with fitsio.FITS(catname,lower=True) as fits:
#cat = fits[1][100000:110000]
if 'object_data' in fits:
print('reading from MEDS object data')
ext='object_data'
else:
ext=1
cat = fits[ext][:]
# one cut here based on if we matched to the galsim cat
w, = np.where(
#(cat['mu_class'] < 3)
#&
#(cat['mask']==0)
#&
(cat['gscosmos_index'] >= 0)
)
print('initial cuts %d/%d %g%%' % (w.size,cat.size,w.size/cat.size*100))
cat = cat[w]
return cat | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_catalog(catalog):\n with open(catalog, \"r\") as f:\n header = f.readline()\n if header.startswith('#EventID | Time | Latitude | Longitude | Depth/km'):\n catalog = _read_iris(f)\n elif header.startswith('time, latitude, longitude, depth, depthUnits, magnitude'):\n ... | [
"0.69564354",
"0.63602346",
"0.6289939",
"0.6274737",
"0.6120884",
"0.60243875",
"0.5962401",
"0.59330785",
"0.5929398",
"0.59037805",
"0.5888229",
"0.58801526",
"0.58801526",
"0.587579",
"0.586561",
"0.582441",
"0.582154",
"0.57935977",
"0.57935977",
"0.57935977",
"0.5793597... | 0.67307436 | 1 |
add fields from the cat some will not be in the odata but some will. When copy is True We will copy over the ones that are in both, in some cases | def _add_cat_fields(self, odata, copy=True):
# these are required fileds from get_meds_output_dtype
# that we have put into the input catalog
always_copy=[
'id',
'ra',
'dec',
]
cat = self.cat_orig
add_dt = []
for d in cat.dtype.descr:
n = d[0]
if n not in odata.dtype.names:
add_dt.append(d)
obj_data = eu.numpy_util.add_fields(
odata,
add_dt,
)
if copy:
for n in always_copy:
obj_data[n] = cat[n]
for d in add_dt:
n = d[0]
if n in always_copy:
continue
# don't clobber things that should be left at
# their default values
if n not in odata.dtype.names:
obj_data[n] = cat[n]
return obj_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copyAttributes(self, other, add_nxpars=False):\n import copy\n \n self.setTitle(other.getTitle())\n self.setDataSetType(other.getDataSetType())\n self.setAllAxisLabels(other.getAllAxisLabels())\n self.setAllAxisUnits(other.getAllAxisUnits())\n self.setYLabel(oth... | [
"0.60299045",
"0.5626615",
"0.55989486",
"0.55208635",
"0.54832995",
"0.54745245",
"0.5468035",
"0.54594445",
"0.5416989",
"0.54133993",
"0.53944564",
"0.5360663",
"0.5277778",
"0.5271018",
"0.52541333",
"0.5244835",
"0.5185914",
"0.518226",
"0.5180149",
"0.51750094",
"0.5171... | 0.7400884 | 0 |
make a new struct with ncutoutsizedarrays based on the actual maximum ncutout | def _make_resized_data(self, odata):
nmax = odata['file_id'].shape[1]
new_nmax = odata['ncutout'].max()
if new_nmax < 2:
new_nmax = 2
temp_obj_data = odata
nobj = temp_obj_data.size
new_data = meds.util.get_meds_output_struct(
nobj,
new_nmax,
extra_fields=self._get_fields(new_nmax),
)
new_data = self._add_cat_fields(new_data, copy=False)
for name in new_data.dtype.names:
if name in temp_obj_data.dtype.names:
shape = new_data[name].shape
lshape = len(shape)
if lshape > 1 and shape[1] == new_nmax:
new_data[name][:,:] = temp_obj_data[name][:,0:new_nmax]
else:
new_data[name][:] = temp_obj_data[name][:]
del temp_obj_data
return new_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_maxcut_data_model():\n n = 5\n V = np.arange(0, n, 1)\n E = [(0, 1, 3.0), (1, 2, 2.0), (2, 3, 2.0), (3, 4, 3.0), (4, 0, 1.0), (0, 3, 3.0)]\n\n G = nx.Graph()\n G.add_nodes_from(V)\n G.add_weighted_edges_from(E)\n return G",
"def expanding_max_nb(a, minp=1):\n out = np.empty_like(a... | [
"0.5717705",
"0.5661527",
"0.5603735",
"0.5556727",
"0.5533146",
"0.54946077",
"0.54890066",
"0.5484546",
"0.54764545",
"0.5465916",
"0.54387826",
"0.54167676",
"0.5408915",
"0.5392852",
"0.5391776",
"0.53902745",
"0.5386068",
"0.53750616",
"0.5368087",
"0.5362609",
"0.535723... | 0.58375233 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.