straight from DMAP...grrr...\\n op2.time = op2.add_data_parameter(data, 'time', b'f', 5) ## time step\\n op2.data_names = op2.apply_data_code_value('data_names', ['time'])\\n else:\\n raise RuntimeError('invalid analysis_code...analysis_code=%s' %\\n op2.analysis_code)\\n\\n op2.fix_format_code()\\n if op2.is_debug_file:\\n op2.binary_debug.write(' approach_code = %r\\\\n' % op2.approach_code)\\n op2.binary_debug.write(' tCode = %r\\\\n' % op2.tCode)\\n op2.binary_debug.write(' isubcase = %r\\\\n' % op2.isubcase)\\n op2._read_title(data)\\n op2._write_debug_bits()\",\n \"def _read_input(input_file):\\n with open(input_file, 'r') as f:\\n input_dict = yaml.load(f, yaml.SafeLoader)\\n # dafi inputs\\n inputs_dafi = input_dict['dafi']\\n inputs_dafi['save_level'] = inputs_dafi.get('save_level', 'time')\\n # inverse method inputs\\n if 'inverse' not in input_dict or input_dict['inverse'] is None:\\n inputs_inverse = dict()\\n else:\\n inputs_inverse = input_dict['inverse']\\n # physics model inputs\\n if 'model' not in input_dict or input_dict['model'] is None:\\n inputs_model = dict()\\n else:\\n inputs_model = input_dict['model']\\n return inputs_dafi, inputs_inverse, inputs_model\",\n \"def parse():\\n file = open(INPUT, 'r')\\n\\n expect_eff = False\\n expect_vout = False\\n\\n eff_dict = {}\\n vout_dict = {}\\n\\n for line in file:\\n if line.startswith('PCC'):\\n id = line.strip()\\n expect_eff = True\\n elif expect_eff:\\n if line.startswith('efficiency'):\\n eff_str = line.strip().split(':')[1]\\n # get rid of % symbol\\n eff = int(eff_str.split('%')[0])\\n eff_dict[id] = .01 * eff\\n\\n expect_vout = True\\n\\n expect_eff = False\\n elif expect_vout:\\n if line.startswith('output voltage'):\\n vout_str = line.strip().split(':')[1]\\n vout = int(vout_str)\\n vout_dict[id] = vout\\n\\n expect_vout = False\\n\\n with open(EFF_OUTPUT, 'w') as f:\\n json.dump(eff_dict, f)\\n\\n with open(VOUT_OUTPUT, 'w') as f:\\n json.dump(vout_dict, f)\\n\\n # plot stats of eff and vout\\n plot_hist(eff_dict.values(), 'Efficiency', 'eff', bins=50)\\n plot_hist(vout_dict.values(), 'V_out', 'vout', bins=50)\",\n \"def read_input():\\n return Path(__file__).with_name('input.txt').read_text().splitlines()\",\n \"def read_model(input_file):\\n with open(input_file) as inp:\\n labels = inp.readline().strip().split(\\\" \\\")\\n init_conc = np.array(list(map(float, inp.readline().strip().split(\\\" \\\"))))\\n\\n stoich = []\\n for i in range(len(labels)):\\n stoich.append(list(map(float, inp.readline().strip().split(\\\" \\\"))))\\n S_matrix = np.array(stoich)\\n\\n educt = []\\n for i in range(len(labels)):\\n educt.append(list(map(float, inp.readline().strip().split(\\\" \\\"))))\\n educt_matrix = np.array(educt)\\n\\n kin_par = np.array(list(map(float, inp.readline().strip().split(\\\" \\\"))))\\n t_T, t_eval_step = list(map(float, inp.readline().strip().split(\\\" \\\")))\\n\\n return labels, init_conc, S_matrix, educt_matrix, kin_par, t_T, t_eval_step\",\n \"def read(self,isOutputFile = False, headerCols = None, verbose = 0):\\n \\n #\\n # TODO TODO also need a 'readFinal' one to read the FINAL information!!\\n # set a flag in MonteFormat.py to select which cs info to read...\\n\\n if verbose == 1:\\n print \\\"Reading %s chemical shift list %s\\\" % (self.format,self.name)\\n\\n fin = open(self.name, 'rU')\\n\\n line = fin.readline()\\n \\n spinSystemId = 0\\n resLabel = oldResLabel = None\\n\\n while line:\\n\\n if self.patt['%sComment' % self.format].search(line):\\n\\n if not isOutputFile and not self.chemShifts and not headerCols:\\n\\n #\\n # Get atom info from first line...\\n #\\n \\n headerCols = line.split()\\n headerCols.pop(0)\\n\\n line = fin.readline()\\n continue\\n\\n if self.patt['emptyline'].search(line):\\n line = fin.readline()\\n continue\\n \\n #\\n # Make sure header info is available - otherwise no point\\n #\\n \\n if not headerCols:\\n raise \\\"Error: no header column information available. Try reading .par file!\\\"\\n return\\n \\n #\\n # Get the info... should really come for .par file!!\\n #\\n \\n cols = line.split()\\n \\n infoCode = None\\n \\n if not isOutputFile:\\n \\n stripId = returnFloat(cols.pop(0))\\n\\n #\\n # NOt necessarily info string available...\\n #\\n\\n if self.patt['onlyFloat'].search(cols[0]):\\n seqCode = None\\n resLabel = None\\n\\n else:\\n assignment = cols.pop(0)\\n\\n searchAssignment = self.patt['%sAssignment' % self.format].search(assignment)\\n\\n resLabel = searchAssignment.group(1)\\n seqCode = searchAssignment.group(2)\\n \\n else:\\n \\n seqCode = cols.pop(0)\\n if seqCode[-1] in '+':\\n seqCode = seqCode[:-1]\\n infoCode = seqCode[-1]\\n \\n oldResLabel = resLabel\\n resLabel = cols.pop(0)\\n stripId = returnFloat(cols.pop(0))\\n voidCol = cols.pop(0)\\n \\n #\\n # Set up info for atoms...\\n #\\n \\n if not seqCode or seqCode == '?':\\n seqCode = None\\n spinSystemId = spinSystemId + 2\\n else:\\n seqCode = returnInt(seqCode)\\n\\n if len(cols) == 1:\\n cols = cols.split(',')\\n\\n values = returnFloats(cols)\\n\\n for i in range(0,len(values)):\\n atomId = headerCols[i]\\n value = values[i]\\n \\n if value == 0.0:\\n continue\\n \\n atomSearch = self.patt['%sAtomInfo' % self.format].search(atomId)\\n \\n atomName = atomSearch.group(1)\\n atomPlace = atomSearch.group(2)\\n \\n if atomName == 'HA1':\\n nextAtomValue = values[i+1]\\n if nextAtomValue == 0.00:\\n atomName = 'HA'\\n \\n curSeqCode = seqCode\\n curResLabel = None\\n \\n if seqCode == None:\\n curSpinSystemId = spinSystemId\\n prevSpinSystemId = spinSystemId - 1\\n else:\\n curSpinSystemId = None\\n prevSpinSystemId = None\\n \\n if atomPlace == '(i-1)' or atomPlace == '-1':\\n\\n if seqCode != None:\\n curSeqCode = seqCode - 1\\n else:\\n curSpinSystemId = spinSystemId - 1\\n prevSpinSystemId = None\\n \\n if not isOutputFile:\\n curResLabel = resLabel\\n else:\\n curResLabel = oldResLabel\\n \\n elif isOutputFile:\\n curResLabel = resLabel\\n\\n self.chemShifts.append(MonteChemShift(value,atomName,curSeqCode,curSpinSystemId,stripId,curResLabel,self.defaultMolCode, infoCode = infoCode, prevSpinSystemId = prevSpinSystemId))\\n\\n line = fin.readline()\\n\\n fin.close()\",\n \"def read_data(path):\\n with h5py.File(path, 'r') as hf:\\t\\n input_ = np.array(hf.get('input'))\\n label_ = np.array(hf.get('label'))\\n return input_, label_\",\n \"def read_input():\\n \\n argv = sys.argv\\n\\n # Read file names from sd input\\n f_dy = argv[1] # matdyn.modes\\n f_pat = argv[2] # path.out (should be in crystal coords)\\n f_ph = argv[3] # ph.x output (Gamma point)\\n\\n # Read input card\\n f_inp = open(\\\"input.dat\\\",'r')\\n l1 = f_inp.readline()\\n l2 = f_inp.readline()\\n l3 = f_inp.readline().split()\\n f_inp.close()\\n\\n # Open files\\n\\n f = open(f_dy,'r') # matdyn.modes \\n f_dyn = f.readlines()\\n f.close()\\n\\n f = open(f_pat,'r') # path.out\\n f_path = f.readlines()\\n f.close()\\n\\n f = open(f_ph,'r') # ph.x output\\n f_zs = f.readlines()\\n f.close()\\n\\n # Assign values to a0, nat, M, nqp\\n a0, vol = float(l1.split()[0]), float(l1.split()[1])\\n nat = int(l2) \\n mass = np.zeros(nat)\\n for iat in range(nat):\\n mass[iat] = float(l3[iat])\\n\\n # Assign values to G (reciprocal lattice vec)\\n ig = 0 ; i = 0\\n for line in f_zs:\\n if \\\"reciprocal axes:\\\" in line:\\n ig = i + 1 \\n break\\n i += 1 \\n\\n rG = np.zeros((3,3))\\n for ic in range(3):\\n rGtext = f_zs[ig+ic][23:48].split()\\n rG[ic,:] = np.array([float(rGtext[0]), float(rGtext[1]), float(rGtext[2])])\\n\\n # Read Z* tensor from f_zs\\n i = 0\\n iz = 0\\n zstart = []\\n for line in f_zs:\\n if \\\"(d P / du)\\\" in line:\\n iz = i + 3\\n if \\\"Px\\\" in line:\\n zstart.append(i)\\n\\n i += 1\\n\\n # Read the dielectric tensor from f_zs\\n i = 0\\n ie = 0\\n for line in f_zs:\\n if \\\"Dielectric constant in cartesian axis\\\" in line:\\n ie = i + 2\\n break\\n\\n i += 1\\n\\n # Assign Z* values\\n zs = np.zeros((nat,3,3)) # initialize Z*\\n\\n for iat in range(nat):\\n for ic in range(3):\\n ztext = f_zs[zstart[iat]+ic][19:56].split()\\n for jc in range(3):\\n zs[iat][ic][jc] = float(ztext[jc])\\n\\n # Assing the dielectric tensor\\n eps = np.zeros((3,3))\\n\\n for ic in range(3):\\n epstext = f_zs[ie+ic][16:66].split()\\n for jc in range(3):\\n eps[ic][jc] = float(epstext[jc])\\n\\n # Number of modes and q-points\\n nmodes = 3 * nat\\n nqpt = int(f_path[0].split()[0])\\n\\n # Read the q-points\\n q = np.zeros((nqpt,4)) # 4th dimension is lenght for q-points on a line, weights for q-points on a grid \\n for iq in range(1,nqpt+1):\\n q[iq-1,] = np.array([float(f_path[iq].split()[0]),float(f_path[iq].split()[1]), \\\\\\n float(f_path[iq].split()[2]),float(f_path[iq].split()[3])])\\n\\n # Read the eigenvalues(om) and eigenvectors(eig) \\n # Initiate first\\n om = np.zeros((nmodes,nqpt))\\n eig = np.zeros((nmodes,nqpt,nat,3), dtype=complex) \\n\\n # Get the starting lines for each q-pt\\n i = 0\\n i_q = []\\n for line in f_dyn:\\n if \\\"q =\\\" in line:\\n i_q.append(i+2)\\n i += 1\\n\\n #Assign values to om and eig\\n for iq in range(nqpt):\\n for imod in range(nmodes):\\n omtext = f_dyn[i_q[iq]+imod*(nat+1)][43:55]\\n om[imod][iq] = float(omtext)\\n for iat in range(nat):\\n etext = f_dyn[i_q[iq]+imod*(nat+1)+iat+1][2:72].split()\\n for ic in range(3):\\n eig.real[imod][iq][iat][ic]=float(etext[2*ic])*np.sqrt(mass[iat])\\n eig.imag[imod][iq][iat][ic]=float(etext[2*ic+1])*np.sqrt(mass[iat])\\n\\n #Normalize the eigenvectors\\n t1 = eig[imod,iq,:,:]\\n t_nu = np.sum(np.sum(np.conjugate(t1)*t1,axis=0))\\n eig[imod,iq,:,:] = eig[imod,iq,:,:]/np.sqrt(np.abs(t_nu))\\n\\n # Check normalization\\n delta = np.zeros((nmodes,nmodes), dtype=complex)\\n for iat in range(nat):\\n for ic in range(3):\\n t2 = eig[:,iq,iat,ic]\\n delta += np.outer(np.conjugate(t2),t2)\\n\\n unit = np.diag(np.diag(np.ones((nmodes,nmodes)))) # Unit vector\\n test = np.abs( (delta-unit) )\\n if ( np.max(test) > 1e-3):\\n print \\\"Non-orthonormal eigenvector at iq=\\\", q[iq,:]\\n\\n return om, eig, q, zs, eps, mass, a0, vol, rG, nmodes, nqpt, nat\",\n \"def read_dataset(fd):\\n\\n T = int(fd.readline())\\n pair_list = []\\n for _ in xrange(T):\\n line = fd.readline()\\n (left, right) = line.split()\\n pair_list.append((int(left), int(right)))\\n return (T, pair_list)\",\n \"def test_read_EOF2(demo_data):\\n\\n openeeg = openEDF(demo_data)\\n #read 200 samples starting from 100 samples before EOF\\n start = max(openeeg.header.samples) - 100\\n arr = openeeg.read(start, start + 200)\\n assert arr.shape[-1] == 100\\n\\n openeeg.close()\",\n \"def read_data(filename):\\n \\n ######################################################\\n # Disadvantage here: only includes J_up = 11 here, #\\n # please manually add more if you have #\\n # J_up >= 12 CO lines #\\n ######################################################\\n \\n ascii_data = ascii.read(\\n filename, names=[\\n \\\"SOURCE\\\", \\\"z\\\", \\\"D_L\\\", \\\"line_width\\\",\\n \\\"CO_J_1\\\", \\\"eCO_J_1\\\", \\\"CO_J_2\\\", \\\"eCO_J_2\\\", \\\"CO_J_3\\\", \\\"eCO_J_3\\\",\\n \\\"CO_J_4\\\", \\\"eCO_J_4\\\", \\\"CO_J_5\\\", \\\"eCO_J_5\\\", \\\"CO_J_6\\\", \\\"eCO_J_6\\\",\\n \\\"CO_J_7\\\", \\\"eCO_J_7\\\", \\\"CO_J_8\\\", \\\"eCO_J_8\\\", \\\"CO_J_9\\\", \\\"eCO_J_9\\\",\\n \\\"CO_J_10\\\", \\\"eCO_J_10\\\", \\\"CO_J_11\\\", \\\"eCO_J_11\\\", \\\"CI_1\\\", \\\"eCI_1\\\",\\n \\\"CI_2\\\", \\\"eCI_2\\\"])\\n\\n pd = ascii_data.to_pandas()\\n pd = pd.set_index('SOURCE')\\n return pd.T\",\n \"def read_pendf_xs(file,start,finish):\\n with open(file) as f:\\n e = []\\n cs = []\\n\\n break_outer = False\\n\\n for i,line in enumerate(f):\\n # -------------------------------\\n # Stop the loop once finish is reached\\n # -------------------------------\\n if i == finish:\\n break\\n if i >= start-1:\\n \\t# -------------------------------\\n \\t# Only include first 66 columns, split on space\\n \\t# and convert to an array of strings\\n \\t# -------------------------------\\n word_len = 11\\n word_start = 0\\n for j in range(6):\\n word = line[word_start:word_start+11]\\n\\n if( j%2 == 0 ):\\n # -------------------------------\\n # Grab the energies, convert to readable format\\n # -------------------------------\\n if( word == ' ' ):\\n break_outer = True\\n break # end of TAB1\\n e.append(word.replace('-','e-').replace('+','e+'))\\n else:\\n # -------------------------------\\n # Grab cross section, convert to readable format\\n # -------------------------------\\n if( word == ' ' ):\\n break_outer = True\\n break # end of TAB1\\n cs.append(word.replace('-','e-').replace('+','e+'))\\n word_start+=word_len\\n\\n if( break_outer ):\\n break # end of TAB1\\n \\n # -------------------------------\\n # Convert to floats\\n # -------------------------------\\n e = np.array(e).astype(float)\\n cs = np.array(cs).astype(float)\\n\\n # -------------------------------\\n # Stack them into a numpy array\\n # -------------------------------\\n pointwise_cs = np.array([e,cs])\\n \\n return pointwise_cs\",\n \"def read_input(self, xml, mode):\\n # get specs for allowable inputs\\n specs = self.get_input_specs()()\\n specs.parseNode(xml)\\n self.name = specs.parameterValues['name']\\n self.raiseADebug('Loading component \\\"{}\\\"'.format(self.name))\\n for item in specs.subparts:\\n if self.get_interaction() and item.getName() in ['produces', 'stores', 'demands']:\\n self.raiseAnError(NotImplementedError, 'Currently each Component can only have one interaction (produces, stores, demands)! Check Component \\\"{}\\\"'.format(self.name))\\n # read in producers\\n if item.getName() == 'produces':\\n prod = Producer(messageHandler=self.messageHandler)\\n try:\\n prod.read_input(item, mode, self.name)\\n except IOError as e:\\n self.raiseAWarning('Errors while reading component \\\"{}\\\"!'.format(self.name))\\n raise e\\n self._produces.append(prod)\\n # read in storages\\n elif item.getName() == 'stores':\\n store = Storage(messageHandler=self.messageHandler)\\n store.read_input(item, mode, self.name)\\n self._stores.append(store)\\n # read in demands\\n elif item.getName() == 'demands':\\n demand = Demand(messageHandler=self.messageHandler)\\n demand.read_input(item, mode, self.name)\\n self._demands.append(demand)\\n # read in economics\\n elif item.getName() == 'economics':\\n econ_node = item # need to read AFTER the interactions!\\n # after looping over nodes, finish up\\n if econ_node is None:\\n self.raiseAnError(IOError, '<economics> node missing from component \\\"{}\\\"!'.format(self.name))\\n CashFlowUser.read_input(self, econ_node)\",\n \"def read_input():\\n # Define return object\\n objects = []\\n\\n # Check if input file exists in folder, else notify user and exit with error.\\n try:\\n input_file = open(INPUTFILE, 'r')\\n except FileNotFoundError:\\n print(\\n \\\"Input file {} not found in current directory. Make sure the file is in the same directory!\\\"\\n .format(INPUTFILE))\\n exit(1)\\n\\n # Start generating the object with values from the input file\\n for line in input_file:\\n obj = {}\\n\\n if line.startswith(\\\"[mod]\\\"):\\n a_original = None\\n b_original = None\\n f_original = None\\n g_original = None\\n h_original = None\\n deg_original = None\\n additional_data = None\\n\\n obj['mod'] = int(line.split()[1])\\n obj['operation'] = input_file.readline()[1:-2]\\n\\n if '{' in obj['operation']:\\n operation = obj['operation'].split()\\n obj['operation'] = operation[0].strip(']')\\n obj['operation_values_original'] = operation[1] + '}'\\n obj['operation_values'] = set_to_array(operation[1])\\n\\n # Parse rest\\n for current_line in input_file:\\n if current_line == '\\\\n': # If we find an empty line, the block is finished\\n break\\n\\n key = current_line.split()[0][1:-1]\\n\\n if key == 'a':\\n a_original = current_line[:-1]\\n elif key == 'b':\\n b_original = current_line[:-1]\\n elif key == 'f':\\n f_original = current_line[:-1]\\n elif key == 'g':\\n g_original = current_line[:-1]\\n elif key == 'h':\\n h_original = current_line[:-1]\\n elif key == 'deg':\\n deg_original = current_line[:-1]\\n elif '[' not in key and key != '' and key != 'answer':\\n additional_data = key\\n\\n # Convert given values to arrays, keeping the old values\\n if a_original:\\n a = set_to_array(a_original.split()[1])\\n obj['a_original'] = a_original\\n obj['a'] = a\\n\\n if b_original:\\n b = set_to_array(b_original.split()[1])\\n obj['b_original'] = b_original\\n obj['b'] = b\\n\\n if f_original:\\n f = set_to_array(f_original.split()[1])\\n obj['f_original'] = f_original\\n obj['f'] = f\\n\\n if g_original:\\n g = set_to_array(g_original.split()[1])\\n obj['g_original'] = g_original\\n obj['g'] = g\\n\\n if h_original:\\n h = set_to_array(h_original.split()[1])\\n obj['h_original'] = h_original\\n obj['h'] = h\\n\\n if deg_original:\\n obj['deg_original'] = deg_original\\n obj['deg'] = int(deg_original.split()[1])\\n\\n if additional_data:\\n obj['additional_data'] = additional_data\\n\\n objects.append(obj)\\n else:\\n continue\\n\\n return objects\",\n \"def pyread(eeg, start, stop, channels=None):\\n\\n if not channels:\\n chs = range(len(eeg.chan_info['ch_names']) - 1) #-1 for annotations\\n else:\\n chs = channels\\n\\n result = []\\n for channel in chs:\\n #pyedf is inclusive of stop\\n result.append(eeg.read_samples(channel, start, stop-1))\\n return np.array(result)\",\n \"def read_2hps2_acc(filename, multi_header=True):\\n\\n num_headers = 27\\n header_row = 16\\n units_row = 17\\n timestamp_row = 20\\n\\n with open(filename, \\\"r\\\") as f:\\n accreader = csv.reader(f, delimiter=\\\" \\\")\\n\\n # Skip file info headers\\n for i in range(num_headers):\\n if i == header_row - 1:\\n channels = next(accreader)\\n elif i == units_row - 1:\\n units = next(accreader)\\n elif i == timestamp_row - 1:\\n ts_start = next(accreader)\\n else:\\n next(accreader)\\n\\n # Read body - drop blanks\\n data = [[x for x in line if x != \\\"\\\"] for line in accreader]\\n\\n # Convert column names list so that split by \\\",\\\" not \\\" \\\", drop \\\"Time\\\" item and trim\\n channels = \\\" \\\".join(channels).split(\\\",\\\")[1:]\\n channels = [c.strip() for c in channels]\\n\\n # Read the start timestamp marker and get start datetime\\n ts_start = [int(i) for i in ts_start[5:]]\\n dt_start = datetime(\\n ts_start[5], # year\\n ts_start[4], # month\\n ts_start[3], # day\\n ts_start[2], # hour\\n ts_start[1], # minute\\n ts_start[0], # second\\n )\\n\\n # Create dataframe and timestamps using start timestamp marker and time steps column\\n df = pd.DataFrame(data, dtype=\\\"float\\\")\\n ts = df.iloc[:, 0].values\\n timestamps = [dt_start + timedelta(seconds=t) for t in ts]\\n\\n # For raw data module\\n if multi_header is True:\\n # Create multi-index header of channel names and units and time steps index\\n units = \\\" \\\".join(units).split(\\\",\\\")[1:]\\n units = [i.strip().split(\\\"(\\\")[1][:-1] for i in units]\\n header = list(zip(channels, units))\\n header.insert(0, (\\\"Timestamp\\\", \\\"\\\"))\\n header = pd.MultiIndex.from_tuples(header, names=[\\\"channels\\\", \\\"units\\\"])\\n df = df.set_index(df.columns[0])\\n df.index.name = \\\"Time (s)\\\"\\n df.insert(loc=0, column=\\\"Timestamp\\\", value=timestamps)\\n # For screening module\\n else:\\n # Create single row header of only channel names (i.e. strip out the units)\\n # Replace time steps column with timestamps and use range index\\n header = [\\\"Timestamp\\\"] + channels\\n df.iloc[:, 0] = timestamps\\n\\n # Set desired header (single or multi-index)\\n df.columns = header\\n\\n return df\",\n \"def get_expression(data_series, probes_to_genes):\\n with open(data_series, 'r') as mtx:\\n stage_columns = {'all_stages': {'sample_ids': []}} # will always need an average, other stages are determined by the file\\n sample_ids = None\\n for line in mtx:\\n if line.startswith('!Sample_title'):\\n sample_stages = [x.strip().replace('\\\"','').split(\\\",\\\")[0] for x in line.split(\\\"\\\\t\\\")[1:]] # this line is likely dataset specific.\\n elif line.startswith('\\\"ID_REF\\\"'): # this comes after the sample titles\\n sample_ids = [x.strip().replace('\\\"','') for x in line.split(\\\"\\\\t\\\")[1:]]\\n # now have the ids and their stages, convert to dict\\n \\\"\\\"\\\"\\n if named differently, may need to modify this.\\n ultimately, stage_columns should be a dictionary with the following properties:\\n - the keys are the stage names. \\n - each 'stage' dict should have a key 'sample_ids' that has a list the sample_ids belonging to that stage.\\n {\\n 'stage1': {\\n 'sample_ids': ['sample_id1','sample_id2', ..., 'sample_idn']\\n },\\n 'stage2': {\\n 'sample_ids': ['sample_idn+1', ...]\\n },\\n ...\\n }\\n \\\"\\\"\\\"\\n for i in range(0, len(sample_stages)):\\n if sample_stages[i] not in stage_columns:\\n stage_columns[sample_stages[i]] = {'sample_ids': []}\\n stage_columns[sample_stages[i]]['sample_ids'].append(sample_ids[i])\\n stage_columns['all_stages']['sample_ids'].append(sample_ids[i]) # add every sample to this\\n elif sample_ids is not None:\\n row = [x.strip().replace('\\\"','') for x in line.split('\\\\t')]\\n \\\"\\\"\\\"\\n here, the stage_columns dictionary is being updated with the expression data for each gene.\\n {\\n 'stage1': {\\n 'sample_ids': ['sample_id1','sample_id2', ..., 'sample_idn'],\\n 'genes': { <- **NEW KEY**\\n 'entrezID-1': ['sample_id1ExpLevel', 'sample_id2ExpLevel', ..., 'sample_idnExpLevel'],\\n 'entrezID-2': ['sample_id1ExpLevel', 'sample_id2ExpLevel', ..., 'sample_idnExpLevel'],\\n ... (if PERCENTILE_RANK is True, all in dataset are recorded otherwise, just the genes of interest )\\n }\\n },\\n ...\\n }\\n \\\"\\\"\\\"\\n if row[0] in probes_to_genes:\\n # get gene from probe\\n entrez_id = probes_to_genes[row[0]]\\n # add the average expression for all the samples in a stage for the gene\\n for stage, stage_data in stage_columns.items():\\n stage_data['genes'] = {} if 'genes' not in stage_data else stage_data['genes'] # initialize\\n for sample_id in stage_data['sample_ids']:\\n # get the index of the sample_id in the row\\n sample_idx = sample_ids.index(sample_id) + 1\\n if entrez_id not in stage_data['genes']:\\n stage_data['genes'][entrez_id] = [float(row[sample_idx])]\\n else:\\n stage_data['genes'][entrez_id].append(float(row[sample_idx]))\\n\\n return stage_columns\",\n \"def read_track(fp, colnames=None):\\n # read lines\\n f = open(fp, \\\"r+\\\")\\n s = f.readlines()\\n\\n # get info\\n MIST_version = re.split(r\\\"\\\\s+\\\", s[0].strip())[-1]\\n MESA_revision = re.split(r\\\"\\\\s+\\\", s[1].strip())[-1]\\n\\n Yinit, Zinit, FeH, aFe, vvcrit = re.split(r\\\"\\\\s+\\\", s[4].strip())[1:]\\n Yinit = np.float(Yinit)\\n Zinit = np.float(Zinit)\\n FeH = np.float(FeH)\\n aFe = np.float(aFe)\\n vvcrit = np.float(vvcrit)\\n\\n initial_mass, N_pts, N_EEP, N_col, phase, type_ = \\\\\\n re.split(r\\\"\\\\s+\\\", s[7].strip())[1:]\\n initial_mass = np.float(initial_mass)\\n N_pts = np.int(N_pts)\\n N_EEP = np.int(N_EEP)\\n N_col = np.int(N_col)\\n\\n # get eep info\\n EEPs = tuple([np.int(_) for _ in re.split(r\\\"\\\\s+\\\", s[8].strip())[2:]])\\n # eep = np.arange(EEPs[0], EEPs[-1] + 1) sometimes inconsistent with data\\n\\n # add eep column\\n # _eep\\n t = Table.read(s[11:], format=\\\"ascii.commented_header\\\")\\n eep = np.arange(EEPs[0], EEPs[0] + len(t))\\n eep_ok = eep[-1] == EEPs[-1] + 1\\n t.add_column(Column(eep, \\\"_eep\\\"))\\n # _lgmass\\n t.add_column(Column(np.ones(len(t), )*np.log10(initial_mass), \\\"_lgmass\\\"))\\n # _lgage\\n t.add_column(Column(np.log10(t[\\\"star_age\\\"].data), \\\"_lgage\\\"))\\n # _feh\\n t.add_column(Column(np.ones(len(t), ) * FeH, \\\"_feh_ini\\\"))\\n t.add_column(Column(t[\\\"log_surf_z\\\"]-np.log10(Zsun), \\\"_feh\\\"))\\n\\n # add meta info\\n meta = OrderedDict(\\n MIST_version=MIST_version,\\n MESA_revision=MESA_revision,\\n Yinit=Yinit,\\n Zinit=Zinit,\\n FeH=FeH,\\n aFe=aFe,\\n vvcrit=vvcrit,\\n initial_mass=initial_mass,\\n N_pts=N_pts,\\n N_EEP=N_EEP,\\n N_col=N_col,\\n phase=phase,\\n type_=type_,\\n EEPs=EEPs,\\n EEP0=EEPs[0],\\n EEP1=EEPs[-1],\\n EEP1ACT=EEPs[0] + len(t),\\n EEPOK=eep_ok,\\n INTERP=(\\\"_INTERP\\\" in fp)\\n )\\n t.meta = meta\\n\\n if colnames is None:\\n return t\\n else:\\n for colname in colnames:\\n try:\\n assert colname in t.colnames\\n except AssertionError as ae:\\n raise(ae(\\\"{} not in track.colnames!!!\\\".format(colname)))\\n return t[colnames]\",\n \"def dummy_splice_junction_reads(dummy_isoform_reads):\\n from outrigger.common import READS\\n\\n s = 'sample_id,junction,{reads}\\\\n'.format(reads=READS)\\n for junction_id, reads in dummy_isoform_reads.iteritems():\\n s += 'sample1,{junction_id},{reads}\\\\n'.format(junction_id=junction_id,\\n reads=reads)\\n data = pd.read_csv(six.StringIO(s), comment='#')\\n data = data.dropna()\\n data = data.set_index(\\n ['junction', 'sample_id'])\\n data = data.sort_index()\\n return data\",\n \"def input_data(self):\\n return read_file(self.file_path)\",\n \"def read_old(lookup_cnfg, lookup_qn, diagram, T, directory, verbose=0):\\n\\n data = []\\n\\n for cnfg in lookup_cnfg:\\n # filename and path\\n filename = directory + '/' + diagram + '_cnfg%i' % cnfg + '.h5'\\n # open file\\n try:\\n fh = h5py.File(filename, \\\"r\\\")\\n except IOError:\\n print 'file %s not found' % filename\\n raise\\n\\n # to achieve hirarchical indexing for quantum numbers build DataFrame for\\n # each loop seperately\\n # TODO: is it necessary to build that completely or can that be \\n # constructed by successively storing each operator with pd.HDFStore()?\\n data_qn = pd.DataFrame()\\n# print DataFrame(lookup_p)\\n# print DataFrame(lookup_g)\\n ndata = 0\\n nfailed = 0\\n\\n for op in lookup_qn.index:\\n ndata += 1\\n # generate operator name\\n p = lookup_qn.ix[op, ['p_{so}', 'p_{si}']]\\n g = lookup_qn.ix[op, ['\\\\gamma_{so}', '\\\\gamma_{si}']]\\n groupname = set_groupname(diagram, p, g)\\n\\n # read operator from file and store in data frame\\n try:\\n tmp = np.asarray(fh[groupname])\\n except KeyError:\\n #if diagram == 'C4+C' and cnfg == 714:\\n # print(\\\"could not read %s for config %d\\\" % (groupname, cnfg))\\n nfailed += 1\\n continue\\n data_qn[op] = pd.DataFrame(tmp, columns=['re/im'])\\n if nfailed > 0 and verbose > 0:\\n print(\\\"could not read %d of %d data\\\" % (nfailed, ndata))\\n\\n # append all data for one config and close the file\\n data.append(data_qn)\\n fh.close()\\n # generate data frame containing all operators for all configs\\n data = pd.concat(data, keys=lookup_cnfg, axis=0, names=['cnfg', 'T'])\\n\\n if verbose:\\n print '\\\\tfinished reading'\\n\\n return data.sort_index(level=[0,1])\\n ##############################################################################\",\n \"def read_input():\\n\\n parameters = sys.argv[1:]\\n \\n stop_id = parameters[0]\\n month = parameters[1]\\n day_of_week = parameters[2]\\n rain = parameters[3]\\n temp = parameters[4]\\n planned_arrival = parameters[5]\\n\\n df = pd.DataFrame({\\n 'stop_id': [stop_id],\\n 'day': [day_of_week],\\n 'month': [month],\\n 'rain': [rain],\\n 'temp': [temp],\\n 'planned_arrival': [planned_arrival]\\n })\\n\\n df = df.astype({\\n 'stop_id': 'int32',\\n 'day': 'int32',\\n 'month': 'int32',\\n 'rain': 'float64',\\n 'temp': 'float64',\\n 'planned_arrival': 'int32'\\n })\\n\\n return df\",\n \"def read_stream(params):\\n # Ignore file integrity issues; thus far the only station affected is DR11,\\n # with no seeming impact on the seismic trace itself. Consider treating as\\n # an error in future implementation.\\n warnings.simplefilter(\\\"error\\\", category=InternalMSEEDWarning)\\n\\n start_search = params.start_processing.floor('D')\\n stop_search = params.stop_processing.floor('D')\\n dts = pd.date_range(start_search, stop_search)\\n count = 0\\n for i, dt in enumerate(dts):\\n if params.name_format == 1:\\n fname = f\\\"{params.network}.{params.station}.{params.channel}.{dt.year}.{dt.dayofyear:03d}.mseed\\\"\\n if params.station == \\\"*\\\":\\n # filespec = f\\\"{params.network}/**/{params.network}.{params.station}.{params.channel}.{dt.year}.{dt.dayofyear:03d}.mseed\\\"\\n filespec = os.path.join(params.network, \\\"**\\\", fname)\\n else:\\n # filespec = f\\\"{params.network}/{params.station}/{params.network}.{params.station}.{params.channel}.{dt.year}.{dt.dayofyear:03d}.mseed\\\"\\n filespec = os.path.join(params.network, params.station, fname)\\n elif params.name_format == 2:\\n filespec = f\\\"{params.network}.{params.station}..{params.channel}__{dt.year}{dt.month:02d}{dt.day:02d}T*\\\"\\n\\n try:\\n if count == 0:\\n # st = read(f\\\"{params.sourcepath}/MSEED/{filespec}\\\")\\n st = read(os.path.join(params.sourcepath, \\\"MSEED\\\", filespec))\\n # st = read(f\\\"{params.sourcepath}/{filespec}\\\")\\n else:\\n # st += read(f\\\"{params.sourcepath}/MSEED/{filespec}\\\")\\n st += read(os.path.join(params.sourcepath, \\\"MSEED\\\", filespec))\\n # st += read(f\\\"{params.sourcepath}/{filespec}\\\")\\n count += 1\\n except:\\n pass\\n\\n if count > 0:\\n st.merge(fill_value=\\\"interpolate\\\", interpolation_samples=1)\\n st.trim(\\n starttime=UTCDateTime(params.start_processing),\\n endtime=UTCDateTime(params.stop_processing)\\n )\\n return st\\n else:\\n return -1\",\n \"def read(self):\\n try:\\n datos = self.base.readData()\\n for i in range(len(datos)):\\n self.verDatos.insert('', i+1, text = i+1, values = (datos[i][0], datos[i][1], datos[i][2]))\\n except:\\n showerror(\\\"Error\\\", exc_info()[1])\",\n \"def read_microsatellite_lines(raw_lines):\\n lines = Util.get_stripped_lines(raw_lines)\\n if len(lines) % 2:\\n raise ValueError('expected an even number of lines')\\n if len(lines) < 2:\\n raise ValueError('expected at least two lines')\\n full_rows = [x.split() for x in lines]\\n nfullcols = len(full_rows[0])\\n if nfullcols < 2:\\n raise ValueError('expected at least two columns')\\n for row in full_rows:\\n if len(row) != nfullcols:\\n msg = 'each row should have the same number of elements'\\n raise ValueError(msg)\\n a_full_rows = [row for i, row in enumerate(full_rows) if i % 2 == 0]\\n b_full_rows = [row for i, row in enumerate(full_rows) if i % 2 == 1]\\n a_headers = [row[0] for row in a_full_rows]\\n b_headers = [row[0] for row in b_full_rows]\\n for h in a_headers:\\n if not h.endswith('a'):\\n msg = 'each odd row label should end with the letter a'\\n raise ValueError(msg)\\n for h in b_headers:\\n if not h.endswith('b'):\\n msg = 'each even row label should end with the letter b'\\n raise ValueError(msg)\\n headers = [h[:-1] for h in a_headers]\\n # get the unique elements of each column\\n rows = [row[1:] for row in full_rows]\\n cols = zip(*rows)\\n uniques = [list(iterutils.unique_everseen(col)) for col in cols]\\n # get the results for each row\\n a_rows = [row[1:] for row in a_full_rows]\\n b_rows = [row[1:] for row in b_full_rows]\\n a_columns = zip(*a_rows)\\n b_columns = zip(*b_rows)\\n a_binary_rows = Carbone.get_binary_rows_helper(a_columns, uniques)\\n b_binary_rows = Carbone.get_binary_rows_helper(b_columns, uniques)\\n # add the elements entrywise and return as a list of lists\\n bin_row_groups = [a_binary_rows, b_binary_rows]\\n binary_rows = np.array(bin_row_groups).sum(axis=0).tolist()\\n return headers, binary_rows\",\n \"def get_transformed_io(data_path, data_dir):\\n sents, labels = read_line_examples_from_file(data_path)\\n\\n # the input is just the raw sentence\\n inputs = [s.copy() for s in sents]\\n\\n task = 'asqp'\\n if task == 'aste':\\n targets = get_para_aste_targets(sents, labels)\\n elif task == 'tasd':\\n targets = get_para_tasd_targets(sents, labels)\\n elif task == 'asqp':\\n targets = get_para_asqp_targets(sents, labels)\\n else:\\n raise NotImplementedError\\n\\n return inputs, targets\",\n \"def data(dataset=\\\"bio_eventrelated_100hz\\\"):\\n # TODO: one could further improve this function with like\\n # selectors 'ecg=True, eda=True, restingstate=True' that would\\n # find the most appropriate dataset\\n\\n dataset = dataset.lower()\\n\\n # TODO: change this path back to \\\"master\\\"\\n path = \\\"https://raw.githubusercontent.com/neuropsychology/NeuroKit/dev/data/\\\"\\n\\n # Signals as vectors =======================\\n if dataset in [\\\"eeg\\\", \\\"eeg_150hz\\\", \\\"eeg.txt\\\"]:\\n return pd.read_csv(path + \\\"eeg.txt\\\").values[:, 0]\\n\\n if dataset in [\\\"rsp\\\", \\\"rsp_1000hz\\\", \\\"rsp_1000hz.txt\\\"]:\\n return pd.read_csv(path + \\\"rsp_1000hz.txt\\\", header=None).values[:, 0]\\n\\n if dataset in [\\\"ecg\\\", \\\"ecg_1000hz\\\", \\\"ecg_1000hz.csv\\\"]:\\n return pd.read_csv(path + \\\"ecg_1000hz.csv\\\")[\\\"ECG\\\"].values\\n\\n if dataset in [\\\"ecg_3000hz\\\", \\\"ecg_3000hz.csv\\\"]:\\n return pd.read_csv(path + \\\"ecg_1000hz.csv\\\")[\\\"ECG\\\"].values\\n\\n if dataset in [\\\"eog\\\", \\\"veog\\\", \\\"eog_100hz\\\", \\\"eog_100hz.csv\\\"]:\\n return pd.read_csv(path + \\\"eog_100hz.csv\\\")[\\\"vEOG\\\"].values\\n\\n # Dataframes ===============================\\n if dataset == \\\"iris\\\":\\n info = sklearn_datasets.load_iris()\\n data = pd.DataFrame(\\n info.data, columns=[\\\"Sepal.Length\\\", \\\"Sepal.Width\\\", \\\"Petal.Length\\\", \\\"Petal.Width\\\"]\\n )\\n data[\\\"Species\\\"] = info.target_names[info.target]\\n return data\\n\\n if dataset in [\\\"eogs\\\", \\\"eogs_200hz\\\", \\\"eog_200hz\\\", \\\"eog_200hz.csv\\\"]:\\n return pd.read_csv(path + \\\"eog_200hz.csv\\\")\\n\\n # Add extension\\n if dataset in [\\\"bio_resting_8min_200hz\\\"]:\\n dataset += \\\".json\\\"\\n\\n # Specific case for json file\\n if dataset.endswith(\\\".json\\\"):\\n if \\\"https\\\" not in dataset:\\n data = pd.read_json(path + dataset, orient=\\\"index\\\")\\n else:\\n data = pd.read_json(dataset, orient=\\\"index\\\")\\n df = {}\\n for participant, row in data.iterrows():\\n for _, data_string in row.items():\\n data_list = json.loads(data_string)\\n data_pd = pd.DataFrame(data_list)\\n df[participant] = data_pd\\n\\n return df\\n\\n # TODO: Add more EEG (fif and edf datasets)\\n if dataset in [\\\"eeg_1min_200hz\\\"]:\\n\\n return pickle.load(\\n urllib.request.urlopen(\\n \\\"https://github.com/neuropsychology/NeuroKit/blob/dev/data/eeg_1min_200hz.pickle?raw=true\\\"\\n )\\n )\\n\\n # General case\\n file, ext = os.path.splitext(dataset) # pylint: disable=unused-variable\\n if ext == \\\"\\\":\\n df = pd.read_csv(path + dataset + \\\".csv\\\")\\n else:\\n if \\\"https\\\" not in dataset:\\n df = pd.read_csv(path + dataset)\\n else:\\n df = pd.read_csv(dataset)\\n return df\",\n \"def read_inputs(argn=1):\\n if len(sys.argv) < argn+1:\\n raise IOError(\\\"Hey, no input file was passed as argument to\\\"\\n \\\" the program!!\\\")\\n if not os.path.exists(sys.argv[argn]):\\n raise FileNotFoundError(\\\"Input file '{}' not found.\\\".\\n format(sys.argv[argn]))\\n return read_config_file(sys.argv[argn], attribution_char='=')\",\n \"def structure(self, ism_input):\\n f = open(ism_input, 'r')\\n data = []\\n for line in f:\\n line = line.replace('\\\\\\\"', '')\\n line = line.replace('],[', '];[')\\n line = line.strip()\\n line = line.replace(']', '')\\n line = line.replace('[', '')\\n line = line.split(';')\\n line[0] = line[0].split('|')\\n ls = list(map(lambda x: x.split(','), line[1:]))\\n ls = list(map(lambda x: list(map(lambda y: y.split('|'), x)), ls))\\n line[1:] = ls\\n data.append(line)\\n data = np.array(data[1:]) \\n \\n return data\",\n \"def readData(file):\\n \\n inputValues=list()\\n outputValue=list()\\n totalData=list()\\n \\n with open(file) as fp :\\n for line in fp:\\n if line.strip( ) == '':\\n continue\\n attributeValue = line.strip().split(\\\",\\\")\\n inputValue1 = float(attributeValue[0])\\n inputValue2 = float(attributeValue[1])\\n \\n inputValues+=[[inputValue1]+[inputValue2]]\\n outputValue+=[int(attributeValue[2])]\\n totalData+=[[inputValue1]+[inputValue2]+[int(attributeValue[2])]]\\n \\n \\n return inputValues,outputValue,totalData\",\n \"def create(self): # , **kwargs):\\n\\n # Preamble\\n csvReader = CSVReader()\\n csvReader.inputs.in_file = self.csv_file.default_value\\n csvReader.inputs.header = self.hasHeader.default_value\\n csvOut = csvReader.run()\\n\\n print((\\\"=\\\" * 80))\\n print((csvOut.outputs.__dict__))\\n print((\\\"=\\\" * 80))\\n\\n iters = OrderedDict()\\n label = list(csvOut.outputs.__dict__.keys())[0]\\n result = eval(\\\"csvOut.outputs.{0}\\\".format(label))\\n iters[\\\"tests\\\"], iters[\\\"trains\\\"] = sample_crossvalidation_set(\\n result, self.sample_size.default_value\\n )\\n # Main event\\n out_fields = [\\\"T1\\\", \\\"T2\\\", \\\"Label\\\", \\\"trainindex\\\", \\\"testindex\\\"]\\n inputsND = Node(\\n interface=IdentityInterface(fields=out_fields),\\n run_without_submitting=True,\\n name=\\\"inputs\\\",\\n )\\n inputsND.iterables = [\\n (\\\"trainindex\\\", iters[\\\"trains\\\"]),\\n (\\\"testindex\\\", iters[\\\"tests\\\"]),\\n ]\\n if not self.hasHeader.default_value:\\n inputsND.inputs.T1 = csvOut.outputs.column_0\\n inputsND.inputs.Label = csvOut.outputs.column_1\\n inputsND.inputs.T2 = csvOut.outputs.column_2\\n else:\\n inputsND.inputs.T1 = csvOut.outputs.__dict__[\\\"t1\\\"]\\n inputsND.inputs.Label = csvOut.outputs.__dict__[\\\"label\\\"]\\n inputsND.inputs.T2 = csvOut.outputs.__dict__[\\\"t2\\\"]\\n pass # TODO\\n metaflow = Workflow(name=\\\"metaflow\\\")\\n metaflow.config[\\\"execution\\\"] = {\\n \\\"plugin\\\": \\\"Linear\\\",\\n \\\"stop_on_first_crash\\\": \\\"false\\\",\\n \\\"stop_on_first_rerun\\\": \\\"false\\\",\\n # This stops at first attempt to rerun, before running, and before deleting previous results.\\n \\\"hash_method\\\": \\\"timestamp\\\",\\n \\\"single_thread_matlab\\\": \\\"true\\\", # Multi-core 2011a multi-core for matrix multiplication.\\n \\\"remove_unnecessary_outputs\\\": \\\"true\\\",\\n \\\"use_relative_paths\\\": \\\"false\\\", # relative paths should be on, require hash update when changed.\\n \\\"remove_node_directories\\\": \\\"false\\\", # Experimental\\n \\\"local_hash_check\\\": \\\"false\\\",\\n }\\n\\n metaflow.add_nodes([inputsND])\\n \\\"\\\"\\\"import pdb; pdb.set_trace()\\\"\\\"\\\"\\n fusionflow = FusionLabelWorkflow()\\n self.connect(\\n [\\n (\\n metaflow,\\n fusionflow,\\n [\\n (\\\"inputs.trainindex\\\", \\\"trainT1s.index\\\"),\\n (\\\"inputs.T1\\\", \\\"trainT1s.inlist\\\"),\\n ],\\n ),\\n (\\n metaflow,\\n fusionflow,\\n [\\n (\\\"inputs.trainindex\\\", \\\"trainLabels.index\\\"),\\n (\\\"inputs.Label\\\", \\\"trainLabels.inlist\\\"),\\n ],\\n ),\\n (\\n metaflow,\\n fusionflow,\\n [\\n (\\\"inputs.testindex\\\", \\\"testT1s.index\\\"),\\n (\\\"inputs.T1\\\", \\\"testT1s.inlist\\\"),\\n ],\\n ),\\n ]\\n )\",\n \"def readVCTPINPUTS(self): \\n #fname= os.environ['VMECFDIR'] +\\\"/CFG/ctp/DB/VALID.CTPINPUTS\\\"\\n fname= os.environ['VMECFDIR'] +\\\"/CFG/ctp/DB/ctpinputs.cfg\\\"\\n try:\\n database=open(fname,\\\"r\\\") \\n except IOError:\\n print \\\"Cannot open \\\",fname\\n return None\\n else:\\n print \\\"File \\\",fname,\\\" open successfuly.\\\"\\n #print \\\"database= \\\",database\\n lines=database.readlines()\\n database.close() \\n #print lines,len(lines) \\n dbinputs=[]\\n count=0\\n #print \\\"look for me if you want different inputs range...\\\"\\n for i in lines:\\n if(i[0] == 'l' and i[1] == '0'): continue\\n if i == \\\"\\\\n\\\": continue\\n if(i[0] != '#'):\\n items=string.split(i)\\n #print 'items= ',items,len(items)\\n if(len(items)<6):\\n print \\\"Error parsing database, not enough items in line:\\\"\\n print items\\n continue\\n #return None\\n if items[3] == 'M': continue\\n count=count+1\\n #if count<6 or count>11 : continue\\n #if count>10 and count<24 : continue\\n #if count<16: continue\\n #if count > 4 and count < 15: continue\\n #if items[3] != '1': continue\\n #if items[2] != \\\"EMCAL\\\": continue\\n #if (items[2] != \\\"SPD\\\") and (items[2] != \\\"T0\\\"): continue\\n flag=1\\n for i in self.detectors:\\n if items[2].find(i)>=0 or i.find(\\\"ALL\\\")>=0:\\n flag=0;\\n break\\n if flag: continue\\n # input not connected\\n if items[7] == '0' and items[3] == '0': continue\\n db={}\\n db['name']=items[0]\\n db['detector']=items[2]\\n db['level']='L'+items[3]\\n db['signature']=items[4]\\n #db['number']=items[5]\\n db['number']=items[7]\\n db['numberDIM']=items[6]\\n db['ctpnum']=items[5]\\n db['Edge'] = items[8]\\n db['Delay'] = items[9]\\n dbinputs.append(db)\\n #print \\\"Adding: \\\", db\\n return dbinputs\",\n \"def read_one(paths_in, paths_out, current_fis=0):\\n\\n f = open(f\\\"{paths_out[current_fis]}\\\", \\\"r\\\")\\n if f.read() != \\\"\\\":\\n print(\\\"Output is already written for this input!\\\")\\n return None\\n f.close()\\n f = open(f\\\"{paths_in[current_fis]}\\\", \\\"r\\\")\\n \\n line = f.readline()\\n line_spaces = line.split(\\\" \\\")\\n line_dest = line.split(\\\",\\\")\\n time_begin, time_end = line_spaces[0].strip(), line_spaces[1].strip()\\n\\n autobuze = []\\n\\n line = f.readline()\\n line_spaces = line.split(\\\" \\\")\\n line_dest = line.split(\\\",\\\")\\n while line_spaces[0].isnumeric() and line_spaces[1][0].isnumeric():\\n id = int(line_spaces[0])\\n price = float(line_spaces[1][:-3])\\n break_duration = int(line_spaces[2][:-3])\\n trip_duration = int(line_spaces[3][:-3])\\n path = [get_dest(line_dest[0])] + get_multiple_dest(line_dest[1:])\\n autobuze.append( Autobuz(id, price, break_duration, trip_duration, path) )\\n\\n line = f.readline()\\n line_spaces = line.split(\\\" \\\")\\n line_dest = line.split(\\\",\\\")\\n \\n nr_oameni = int(line_spaces[0])\\n oameni = []\\n\\n for _ in range(nr_oameni):\\n line = f.readline()\\n line_spaces = line.split(\\\" \\\")\\n line_dest = line.split(\\\",\\\")\\n\\n name = line_spaces[0]\\n money = float(line_spaces[1][:-3])\\n destinations = [get_dest(line_dest[0])] + get_multiple_dest(line_dest[1:])\\n oameni.append( Om(name, money, destinations) )\\n\\n return time_begin, time_end, autobuze, oameni\",\n \"def readAMBERTop(self, phys, filename):\\r\\n\\r\\n def skipLine(data):\\r\\n nl = data.index('\\\\n')\\r\\n return data[nl+1:len(data)]\\r\\n\\r\\n def jumpTo(data, target):\\r\\n fp = data.index(target)\\r\\n return data[fp:len(data)]\\r\\n\\r\\n def readRemove(data, size):\\r\\n retval = data[0:size-1]\\r\\n return data[size:len(data)]\\r\\n\\r\\n def getInteger(data):\\r\\n pos = 0\\r\\n retval = \\\"\\\"\\r\\n while (not data[pos].isdigit()):\\r\\n pos = pos + 1\\r\\n while (data[pos].isdigit()):\\r\\n retval = retval + data[pos]\\r\\n pos = pos + 1\\r\\n data = data[pos:len(data)]\\r\\n return int(retval), data\\r\\n\\r\\n def parse(data, arr, str, count, dtype, tupsize=1):\\r\\n data = jumpTo(data, \\\"%FLAG \\\"+str)\\r\\n data = jumpTo(data, \\\"%FORMAT\\\")\\r\\n numPerLine, data = getInteger(data)\\r\\n fieldsize, data = getInteger(data)\\r\\n data = skipLine(data) \\r\\n \\r\\n arr2 = []\\r\\n numread = 0\\r\\n for j in range(0, (tupsize*count-1) / numPerLine + 1):\\r\\n for i in range(0, numPerLine):\\r\\n if (tupsize == 1):\\r\\n arr.append(dtype(data[0:fieldsize].strip()))\\r\\n else:\\r\\n arr2.append(dtype(data[0:fieldsize].strip()))\\r\\n if (len(arr2) == tupsize):\\r\\n arr.append(arr2)\\r\\n arr2 = []\\r\\n numread += 1\\r\\n data = data[fieldsize:len(data)]\\r\\n if (numread == tupsize*count):\\r\\n break\\r\\n data = skipLine(data) \\r\\n return data\\r\\n\\r\\n def scan(data, str):\\r\\n return (data.count(str) != 0)\\r\\n\\r\\n\\r\\n f = open(filename, 'r')\\r\\n data = f.read()\\r\\n\\r\\n # First Line: VERSION ...\\r\\n data = skipLine(data)\\r\\n\\r\\n # Go To: %FLAG POINTERS\\r\\n data = jumpTo(data, '%FLAG POINTERS')\\r\\n\\r\\n data = jumpTo(data, '%FORMAT')\\r\\n numPerLine, data = getInteger(data)\\r\\n fieldsize, data = getInteger(data)\\r\\n data = skipLine(data)\\r\\n \\r\\n temp = []\\r\\n numread = 0\\r\\n for j in range(0, 31 / numPerLine + 1):\\r\\n for i in range(0, numPerLine):\\r\\n temp.append(int(data[0:8]))\\r\\n data = data[8:len(data)]\\r\\n numread += 1\\r\\n if (numread == 31):\\r\\n break\\r\\n data = skipLine(data)\\r\\n \\r\\n [natoms, ntypes, nbonh, mbona, ntheth, mtheta, nphih, mphia, nhparm, nparm, nnb, nres, nbona, ntheta, nphia, numbnd, numang, nptra, natyp, nphb, ifpert, nbper, ngper, ndper, mbper, mgper, mdper, ifbox, nmxrs, ifcap, numextra] = temp \\r\\n\\r\\n\\r\\n #################################################\\r\\n # Read AtomTypes\\r\\n atomnames = []\\r\\n charges = []\\r\\n masses = []\\r\\n atindex = []\\r\\n exclusions = []\\r\\n nparams = []\\r\\n reslabels = []\\r\\n respointers = []\\r\\n forceconstants = [[], [], []] # bond, angle, dihedral\\r\\n equilvals = [[], [], [[], []]] # bond, angle, dihedral\\r\\n scee_scales = []\\r\\n scnb_scales = []\\r\\n solty = []\\r\\n lj_acoef = []\\r\\n lj_bcoef = []\\r\\n\\r\\n data = parse(data, atomnames, \\\"ATOM_NAME\\\", natoms, str) \\r\\n data = parse(data, charges, \\\"CHARGE\\\", natoms, float)\\r\\n data = parse(data, masses, \\\"MASS\\\", natoms, float)\\r\\n data = parse(data, atindex, \\\"ATOM_TYPE_INDEX\\\", natoms, int)\\r\\n data = parse(data, exclusions, \\\"NUMBER_EXCLUDED_ATOMS\\\", natoms, int)\\r\\n data = parse(data, nparams, \\\"NONBONDED_PARM_INDEX\\\", ntypes*ntypes, int)\\r\\n data = parse(data, reslabels, \\\"RESIDUE_LABEL\\\", nres, str)\\r\\n data = parse(data, respointers, \\\"RESIDUE_POINTER\\\", nres, int)\\r\\n data = parse(data, forceconstants[0], \\\"BOND_FORCE_CONSTANT\\\", numbnd, float)\\r\\n data = parse(data, equilvals[0], \\\"BOND_EQUIL_VALUE\\\", numbnd, float)\\r\\n data = parse(data, forceconstants[1], \\\"ANGLE_FORCE_CONSTANT\\\", numang, float)\\r\\n data = parse(data, equilvals[1], \\\"ANGLE_EQUIL_VALUE\\\", numang, float)\\r\\n data = parse(data, forceconstants[2], \\\"DIHEDRAL_FORCE_CONSTANT\\\", nptra, float)\\r\\n data = parse(data, equilvals[2][0], \\\"DIHEDRAL_PERIODICITY\\\", nptra, float)\\r\\n data = parse(data, equilvals[2][1], \\\"DIHEDRAL_PHASE\\\", nptra, float)\\r\\n if (scan(data, \\\"SCEE_SCALE_FACTOR\\\")):\\r\\n data = parse(data, scee_scales, \\\"SCEE_SCALE_FACTORS\\\", nptra, float)\\r\\n else:\\r\\n for i in range(0, nptra):\\r\\n scee_scales.append(1.2) # Default \\r\\n if (scan(data, \\\"SCNB_SCALE_FACTOR\\\")):\\r\\n data = parse(data, scnb_scales, \\\"SCNB_SCALE_FACTORS\\\", nptra, float)\\r\\n else:\\r\\n for i in range(0, nptra):\\r\\n scnb_scales.append(2.0) # Default \\r\\n\\r\\n data = parse(data, solty, \\\"SOLTY\\\", natyp, float)\\r\\n data = parse(data, lj_acoef, \\\"LENNARD_JONES_ACOEF\\\", ntypes*(ntypes+1)/2, float)\\r\\n data = parse(data, lj_bcoef, \\\"LENNARD_JONES_BCOEF\\\", ntypes*(ntypes+1)/2, float)\\r\\n\\r\\n\\r\\n ##########################################################\\r\\n # STRUCTURE\\r\\n\\r\\n bonds = [[], []] # With H, Without H\\r\\n angles = [[], []] # With H, Without H\\r\\n dihedrals = [[], []] # With H, Without H\\r\\n impropers = [[], []] # With H, Without H\\r\\n excluded_atoms = [] \\r\\n hbond_acoef = []\\r\\n hbond_bcoef = []\\r\\n hbcut = []\\r\\n amber_atom_types = []\\r\\n tree_chain = []\\r\\n join_array = []\\r\\n irotat = []\\r\\n radii = []\\r\\n screen = []\\r\\n\\r\\n data = parse(data, bonds[0], \\\"BONDS_INC_HYDROGEN\\\", nbonh, int, 3)\\r\\n data = parse(data, bonds[1], \\\"BONDS_WITHOUT_HYDROGEN\\\", nbona, int, 3)\\r\\n data = parse(data, angles[0], \\\"ANGLES_INC_HYDROGEN\\\", ntheth, int, 4)\\r\\n data = parse(data, angles[1], \\\"ANGLES_WITHOUT_HYDROGEN\\\", ntheta, int, 4)\\r\\n data = parse(data, dihedrals[0], \\\"DIHEDRALS_INC_HYDROGEN\\\", nphih, int, 5)\\r\\n data = parse(data, dihedrals[1], \\\"DIHEDRALS_WITHOUT_HYDROGEN\\\", nphia, int, 5)\\r\\n \\r\\n # MERGE ARRAYS - PM HANDLES THE H+\\r\\n final_bonds = bonds[0] + bonds[1]\\r\\n final_angles = angles[0] + angles[1]\\r\\n final_dihedrals = dihedrals[0] + dihedrals[1]\\r\\n final_impropers = []\\r\\n \\r\\n # CLEAN UP THE TRASH\\r\\n del(bonds)\\r\\n del(angles)\\r\\n del(dihedrals)\\r\\n \\r\\n\\r\\n # Move impropers into their own array\\r\\n i = 0\\r\\n while (i < len(final_dihedrals)):\\r\\n if (final_dihedrals[i][2] < 0): # 1-4 exclusions are handled by our back end\\r\\n final_dihedrals[i][2] *= -1\\r\\n if (final_dihedrals[i][3] < 0):\\r\\n final_dihedrals[i][3] *= -1 # Make + again\\r\\n final_impropers.append(final_dihedrals[i])\\r\\n final_dihedrals.remove(final_dihedrals[i])\\r\\n i -= 1\\r\\n i += 1\\r\\n\\r\\n # Convert charge units\\r\\n for i in range(0, len(charges)):\\r\\n charges[i] /= 18.223\\r\\n\\r\\n\\r\\n data = parse(data, excluded_atoms, \\\"EXCLUDED_ATOMS_LIST\\\", nnb, int)\\r\\n data = parse(data, hbond_acoef, \\\"HBOND_ACOEF\\\", nphb, float)\\r\\n data = parse(data, hbond_bcoef, \\\"HBOND_BCOEF\\\", nphb, float)\\r\\n data = parse(data, hbcut, \\\"HBCUT\\\", nphb, float)\\r\\n data = parse(data, amber_atom_types, \\\"AMBER_ATOM_TYPE\\\", natoms, str)\\r\\n data = parse(data, tree_chain, \\\"TREE_CHAIN_CLASSIFICATION\\\", natoms, str)\\r\\n data = parse(data, join_array, \\\"JOIN_ARRAY\\\", natoms, int)\\r\\n data = parse(data, irotat, \\\"IROTAT\\\", natoms, int)\\r\\n data = parse(data, radii, \\\"RADII\\\", natoms, float)\\r\\n data = parse(data, screen, \\\"SCREEN\\\", natoms, float)\\r\\n\\r\\n # Further process dihedrals and impropers\\r\\n # Deal with multiplicity\\r\\n # A bit ugly, but the fastest for now\\r\\n # forceconstants[2][dihedrals[0][i][4]-1], int(equilvals[2][0][dihedrals[0][i][4]-1]), equilvals[2][1][dihedrals[0][i][4]-1]\\r\\n\\r\\n mult_di = dict()\\r\\n mult_im = dict()\\r\\n for i in range(0, len(final_dihedrals)):\\r\\n di_id = str(final_dihedrals[i][0])+' '+str(final_dihedrals[i][1])+' '+str(final_dihedrals[i][2])+' '+str(final_dihedrals[i][3])\\r\\n if (not mult_di.has_key(di_id)):\\r\\n mult_di[di_id] = [1, False, [forceconstants[2][final_dihedrals[i][4]-1]], [int(equilvals[2][0][final_dihedrals[i][4]-1])], [equilvals[2][1][final_dihedrals[i][4]-1]]]\\r\\n else:\\r\\n mult_di[di_id][0] += 1\\r\\n mult_di[di_id][2].append(forceconstants[2][final_dihedrals[i][4]-1])\\r\\n mult_di[di_id][3].append(int(equilvals[2][0][final_dihedrals[i][4]-1]))\\r\\n mult_di[di_id][4].append(equilvals[2][1][final_dihedrals[i][4]-1])\\r\\n \\r\\n for i in range(0, len(final_impropers)):\\r\\n im_id = str(final_impropers[i][0])+' '+str(final_impropers[i][1])+' '+str(final_impropers[i][2])+' '+str(final_impropers[i][3])\\r\\n if (not mult_im.has_key(di_id)):\\r\\n mult_im[im_id] = [1, False, [forceconstants[2][final_impropers[i][4]-1]], [int(equilvals[2][0][final_impropers[i][4]-1])], [equilvals[2][1][final_impropers[i][4]-1]]]\\r\\n else:\\r\\n mult_im[im_id][0] += 1\\r\\n mult_im[im_id][2].append(forceconstants[2][final_impropers[i][4]-1])\\r\\n mult_im[im_id][3].append(int(equilvals[2][0][final_impropers[i][4]-1]))\\r\\n mult_im[im_id][4].append(equilvals[2][1][final_impropers[i][4]-1])\\r\\n\\r\\n\\r\\n\\r\\n \\r\\n #[natoms, ntypes, nbonh, mbona, ntheth, mtheta, nphih, mphia, nhparm, nparm, nnb, nres, nbona, ntheta, nphia, numbnd, numang, nptra, natyp, nphb, ifpert, nbper, ngper, ndper, mbper, mgper, mdper, ifbox, nmxrs, ifcap, numextra] = temp \\r\\n #phys.myPSF.createAll(natoms, nbonh+mbona, ntheth+mtheta,\\r\\n # len(dihedrals[0])+len(dihedrals[1]),\\r\\n # len(impropers[0])+len(impropers[1]),\\r\\n # 0, 0, 0, 0)\\r\\n \\r\\n # Add atoms\\r\\n curres = 1\\r\\n for i in range(0, natoms):\\r\\n phys.myPSF.addAtom(i, 'SIM', curres, reslabels[curres-1],\\r\\n atomnames[i], atomnames[i], charges[i],\\r\\n masses[i]) \\r\\n if (curres != nres and i >= respointers[curres]):\\r\\n curres += 1\\r\\n\\r\\n # Add bonds\\r\\n for i in range(0, nbonh+nbona):\\r\\n phys.myPSF.addBond(i+1, final_bonds[i][0]/3+1, final_bonds[i][1]/3+1)\\r\\n phys.myPAR.addBond(i+1, atomnames[final_bonds[i][0]/3], atomnames[final_bonds[i][1]/3], forceconstants[0][final_bonds[i][2]/3], equilvals[0][final_bonds[i][2]/3])\\r\\n \\r\\n # Add angles\\r\\n for i in range(0, ntheth+ntheta):\\r\\n phys.myPSF.addAngle(i+1, final_angles[i][0]/3+1, final_angles[i][1]/3+1, final_angles[i][2]/3+1)\\r\\n phys.myPAR.addAngle(i+1, atomnames[final_angles[i][0]/3], atomnames[final_angles[i][1]/3], atomnames[final_angles[i][2]/3], forceconstants[1][final_angles[i][3]/3], equilvals[1][final_angles[i][3]/3])\\r\\n \\r\\n # Add dihedrals\\r\\n for i in range(0, len(final_dihedrals)):\\r\\n di_id = str(final_dihedrals[i][0])+' '+str(final_dihedrals[i][1])+' '+str(final_dihedrals[i][2])+' '+str(final_dihedrals[i][3])\\r\\n mult = mult_di[di_id][0]\\r\\n checked = mult_di[di_id][1]\\r\\n print di_id, \\\" \\\", mult\\r\\n if (not checked):\\r\\n if (mult == 1):\\r\\n phys.myPSF.addDihedral(i+1, final_dihedrals[i][0]/3+1, final_dihedrals[i][1]/3+1, int(numpy.abs(final_dihedrals[i][2]))/3+1, final_dihedrals[i][3]/3+1)\\r\\n phys.myPAR.addDihedral(i+1, atomnames[final_dihedrals[i][0]/3], atomnames[final_dihedrals[i][1]/3], atomnames[int(numpy.abs(final_dihedrals[i][2]))/3], atomnames[final_dihedrals[i][3]/3], forceconstants[2][final_dihedrals[i][4]-1], int(equilvals[2][0][final_dihedrals[i][4]-1]), equilvals[2][1][final_dihedrals[i][4]-1])\\r\\n else:\\r\\n mult_di[di_id][1] = True\\r\\n # Add dihedral with the appropriate multiplicity\\r\\n # Force constants, periodicity and phase shifts are in [2], [3], and [4] respectively\\r\\n fcvec = PARReader.VectorOfDouble()\\r\\n periodvec = PARReader.VectorOfInt()\\r\\n phasevec = PARReader.VectorOfDouble() \\r\\n for j in range(0, len(mult_di[di_id][2])):\\r\\n fcvec.push_back(mult_di[di_id][2][j])\\r\\n periodvec.push_back(mult_di[di_id][3][j])\\r\\n phasevec.push_back(mult_di[di_id][4][j])\\r\\n phys.myPSF.addDihedral(i+1, final_dihedrals[i][0]/3+1, final_dihedrals[i][1]/3+1, int(numpy.abs(final_dihedrals[i][2]))/3+1, final_dihedrals[i][3]/3+1)\\r\\n phys.myPAR.addDihedral(i+1, atomnames[final_dihedrals[i][0]/3], atomnames[final_dihedrals[i][1]/3], atomnames[int(numpy.abs(final_dihedrals[i][2]))/3], atomnames[final_dihedrals[i][3]/3], mult, fcvec, periodvec, phasevec)\\r\\n \\r\\n\\r\\n\\r\\n\\r\\n for i in range(0, len(final_impropers)):\\r\\n im_id = str(final_impropers[i][0])+' '+str(final_impropers[i][1])+' '+str(final_impropers[i][2])+' '+str(final_impropers[i][3])\\r\\n mult = mult_im[im_id][0]\\r\\n checked = mult_im[im_id][1]\\r\\n print im_id, \\\" \\\", mult\\r\\n if (not checked):\\r\\n if (mult == 1):\\r\\n phys.myPSF.addImproper(i+1, final_impropers[i][0]/3+1, final_impropers[i][1]/3+1, int(numpy.abs(final_impropers[i][2]))/3+1, final_impropers[i][3]/3+1)\\r\\n phys.myPAR.addImproper(i+1, atomnames[final_impropers[i][0]/3], atomnames[final_impropers[i][1]/3], atomnames[int(numpy.abs(final_impropers[i][2]))/3], atomnames[final_impropers[i][3]/3], forceconstants[2][final_impropers[i][4]-1], int(equilvals[2][0][final_impropers[i][4]-1]), equilvals[2][1][final_impropers[i][4]-1])\\r\\n else:\\r\\n mult_im[im_id][1] = True\\r\\n # Add dihedral with the appropriate multiplicity\\r\\n # Force constants, periodicity and phase shifts are in [2], [3], and [4] respectively\\r\\n fcvec = PARReader.VectorOfDouble()\\r\\n periodvec = PARReader.VectorOfInt()\\r\\n phasevec = PARReader.VectorOfDouble() \\r\\n for j in range(0, len(mult_im[im_id][2])):\\r\\n fcvec.push_back(mult_im[im_id][2][j])\\r\\n periodvec.push_back(mult_im[im_id][3][j])\\r\\n phasevec.push_back(mult_im[im_id][4][j])\\r\\n phys.myPSF.addImproper(i+1, final_impropers[i][0]/3+1, final_impropers[i][1]/3+1, int(numpy.abs(final_impropers[i][2]))/3+1, final_impropers[i][3]/3+1)\\r\\n phys.myPAR.addImproper(i+1, atomnames[final_impropers[i][0]/3], atomnames[final_impropers[i][1]/3], atomnames[int(numpy.abs(final_impropers[i][2]))/3], atomnames[final_impropers[i][3]/3], mult, fcvec, periodvec, phasevec)\\r\\n\\r\\n \\r\\n # Need to add garbage nonbonded stuff for now\\r\\n for i in range(0, natoms):\\r\\n phys.myPAR.addNonbonded(i, atomnames[i], 1, 1, 1, 1, 1, 1)\\r\\n\\r\\n # Add VDW parameters\\r\\n # AMBER has the Aij and Bij already in the parameter file\\r\\n # This actually makes life easier.\\r\\n # CHARMM does not, they simply have the original sigma and epsilon.\\r\\n # To compensate for this, for now we will leave the nonbondeds empty in phys.myPAR\\r\\n # We will then access the LennardJones parameter table in Topology directly\\r\\n k = 0\\r\\n phys.myTop.resizeLennardJonesParameters(ntypes)\\r\\n for i in range(0, ntypes):\\r\\n for j in range(i, ntypes):\\r\\n params = GenericTopology.LennardJonesParameters(lj_acoef[k], lj_bcoef[k])\\r\\n k += 1\\r\\n phys.myTop.setLennardJonesParameters(i, j, params)\\r\\n \\r\\n phys.myPAR.readFlag = 1\\r\\n phys.build()\",\n \"def generate_input_from_cweeds(outdir, cweed2_paths, cweed3_paths, year_range):\\n if not isinstance(cweed2_paths, (list, tuple)):\\n cweed2_paths = [cweed2_paths]\\n if not isinstance(cweed3_paths, (list, tuple)):\\n cweed3_paths = [cweed3_paths]\\n\\n print('Reading CWEEDS files...', end=' ')\\n lat_dd = []\\n lon_dd = []\\n stations = []\\n data = []\\n for cweed2, cweed3 in zip(cweed2_paths, cweed3_paths):\\n daily_wy2 = read_cweeds_file(cweed2, format_to_daily=True)\\n daily_wy3 = read_cweeds_file(cweed3, format_to_daily=True)\\n wy23_df = join_daily_cweeds_wy2_and_wy3(daily_wy2, daily_wy3)\\n\\n lat_dd.append(wy23_df['Latitude'])\\n lon_dd.append(wy23_df['Longitude'])\\n stations.append(wy23_df['Location'])\\n\\n indexes = np.where((wy23_df['Years'] >= year_range[0]) &\\n (wy23_df['Years'] <= year_range[1]))[0]\\n data.append(wy23_df['Irradiance'][indexes])\\n data = nan_as_text_tolist(np.array(data).astype(float).transpose())\\n print('done')\\n\\n fname = osp.join(outdir, 'solrad_input_data.csv')\\n print('Saving {} data to {}...'.format('solrad', fname), end=' ')\\n\\n # Create an array of datestring and lat/lon\\n Ndt = len(wy23_df['Years'][indexes])\\n start = datetime.datetime(year_range[0], 1, 1)\\n datetimes = [start + datetime.timedelta(days=i) for i in range(Ndt)]\\n datestrings = [dt.strftime(\\\"%d/%m/%Y\\\") for dt in datetimes]\\n\\n # Save the data to file.\\n fheader = [['Global solar irradiance in MJ/m²'],\\n ['', ''],\\n ['Created by ' + __namever__],\\n ['Created on ' + strftime(\\\"%d/%m/%Y\\\")],\\n ['Created from CWEED files'],\\n ['', ''],\\n ['Stations'] + stations,\\n ['Latitude (dd)'] + lat_dd,\\n ['Longitude (dd)'] + lon_dd,\\n ['', '']]\\n fdata = [[datestrings[i]] + data[i] for i in range(Ndt)]\\n fcontent = fheader + fdata\\n save_content_to_csv(fname, fcontent)\\n print('done')\",\n \"def read_dataset_v1():\\n path = load_config()\\n T = feather.read_dataframe(path['data_dir'] / 'T_dat.feather')\\n E = feather.read_dataframe(path['data_dir'] / 'E_dat.feather')\\n M = feather.read_dataframe(path['data_dir'] / 'Meta.feather')\\n data = sio.loadmat(path['data_dir'] / 'highvar_genes.mat', squeeze_me=True)\\n return T, E, M, data\",\n \"def read(lookup_cnfg, lookup_qn, diagram, T, directory, verbose=0):\\n\\n data = []\\n comb = True if diagram == 'C4+D' else False\\n\\n for cnfg in lookup_cnfg:\\n # filename and path\\n filename = directory + '/' + diagram + '_cnfg%i' % cnfg + '.h5'\\n try:\\n fh = h5py.File(filename, \\\"r\\\")\\n except IOError:\\n print 'file %s not found' % filename\\n raise\\n\\n # to achieve hirarchical indexing for quantum numbers build DataFrame for\\n # each loop seperately\\n # TODO: is it necessary to build that completely or can that be \\n # constructed by successively storing each operator with pd.HDFStore()?\\n data_qn = DataFrame()\\n# print DataFrame(lookup_p)\\n# print DataFrame(lookup_g)\\n\\n for op in lookup_qn.index:\\n p = lookup_qn.ix[op, ['p_{so}', 'p_{si}']]\\n g = lookup_qn.ix[op, ['\\\\gamma_{so}', '\\\\gamma_{si}']]\\n groupname = set_groupname(diagram, p, g)\\n\\n # read data from file as numpy array and interpret as complex\\n # numbers for easier treatment\\n try:\\n tmp = np.asarray(fh[groupname]).view(complex)\\n except KeyError:\\n print(\\\"could not read %s for config %d\\\" % (groupname, cnfg))\\n continue\\n\\n # in case diagram is C4+D perform last mutliplication of factorizing\\n # traces\\n # the file contains 4 numbers per time slice: ReRe, ReIm, ImRe, and ImIm,\\n # here combined 2 complex number\\n if comb:\\n # reshaping so we can extract the data easier\\n tmp = tmp.reshape((-1,2))\\n # extracting right combination, assuming ImIm contains only noise\\n dtmp = 1.j * (tmp[:,1].real + tmp[:,0].imag) + tmp[:,0].real\\n tmp = dtmp.copy()\\n\\n # save data into data frame\\n data_qn[op] = pd.DataFrame(tmp, columns=['re/im'])\\n data.append(data_qn)\\n data = pd.concat(data, keys=lookup_cnfg, axis=0, names=['cnfg', 'T'])\\n\\n if verbose:\\n print '\\\\tfinished reading'\\n\\n return data.sort_index(level=[0,1])\",\n \"def read_results():\\r\\n with open(\\\"packing.nfo\\\", \\\"r\\\") as fin:\\r\\n fin.readline()\\r\\n fin.readline()\\r\\n por_theory = float(fin.readline().split()[2])\\r\\n por_final = float(fin.readline().split()[2])\\r\\n print('Theoretical porosity:', por_theory)\\r\\n print('Final porosity:', por_final)\\r\\n with open(\\\"packing.xyzd\\\", \\\"rb\\\") as fin:\\r\\n btxt = fin.read()\\r\\n txt = list(struct.unpack(\\\"<\\\" + \\\"d\\\" * (len(btxt) // 8), btxt))\\r\\n data = array(zip(*[iter(txt)] * 4))\\r\\n data[:, 3] = data[:, 3] * \\\\\\r\\n ((1 - por_final) / (1 - por_theory))**(1 / 3)\\r\\n return data\",\n \"def parse_seqscreen(input, output):\\n \\n df = pd.read_csv(input, sep='\\\\t', index_col=0, na_values='-')\\n pathogenicity_features = df.loc[:, 'disable_organ':'virulence_regulator'].fillna(0).astype(int).sum(axis=1)\\n\\n pathogenic_genes_df = df.loc[pathogenicity_features > 0, ['taxid', \\n 'centrifuge_multi_tax', \\n 'diamond_multi_tax',\\n 'go',\\n 'multi_taxids_confidence',\\n 'go_id_confidence',\\n 'size',\\n 'organism',\\n 'gene_name',\\n 'uniprot',\\n 'uniprot evalue']]\\n \\n pathogenic_genes_df['taxid'] = pathogenic_genes_df['taxid'].astype(int)\\n \\n pathogenic_genes_df.index.name = 'gene'\\n \\n \\n pathogenic_genes = pathogenicity_features[pathogenicity_features > 0].index\\n \\n gene_pathogenicity_features_dict = {}\\n \\n for gene, row in df.loc[pathogenic_genes,'disable_organ':'virulence_regulator'].iterrows():\\n gene_pathogenicity_features_dict[gene] = ';'.join(row[row>0].index)\\n \\n pathogenicity_df = pd.DataFrame.from_dict(gene_pathogenicity_features_dict, \\n orient='index',\\n columns=['Pathogenicity'])\\n\\n pathogenicity_df.index.name = 'gene'\\n\\n pd.merge(pathogenic_genes_df, pathogenicity_df, left_index=True, right_index=True).to_csv(output, sep='\\\\t')\",\n \"def read_input_file():\\n \\n global input\\n \\n config = ConfigParser.RawConfigParser()\\n config.read(os.path.join(os.getcwd(), 'INPUT.cfg'))\\n\\n input = {}\\n input['datapath'] = config.get('Address_info', 'datapath')\\n input['inter_address'] = config.get('Address_info', 'interactive_address')\\n input['target_folder'] = config.get('Address_info', 'target_folder')\\n input['save_folder'] = config.get('Address_info', 'save_folder')\\n \\n if not os.path.isabs(input['datapath']):\\n input['datapath'] = os.path.join(os.getcwd(), input['datapath'])\\n \\n if not os.path.isabs(input['inter_address']):\\n input['inter_address'] = os.path.join(os.getcwd(), input['inter_address'])\\n \\n if not os.path.isabs(input['target_folder']):\\n input['target_folder'] = os.path.join(os.getcwd(), input['target_folder'])\\n \\n if not os.path.isabs(input['save_folder']):\\n input['save_folder'] = os.path.join(os.getcwd(), input['save_folder'])\\n \\n \\n input['min_date'] = str(eval(config.get('Event_Request', 'min_datetime')))\\n input['max_date'] = str(eval(config.get('Event_Request', 'max_datetime')))\\n input['min_mag'] = config.getfloat('Event_Request', 'min_magnitude')\\n input['max_mag'] = config.getfloat('Event_Request', 'max_magnitude')\\n input['min_depth'] = config.getfloat('Event_Request', 'min_depth')\\n input['max_depth'] = config.getfloat('Event_Request', 'max_depth')\\n input['evlonmin'] = config.getfloat('Event_Request', 'evlonmin')\\n input['evlonmax'] = config.getfloat('Event_Request', 'evlonmax')\\n input['evlatmin'] = config.getfloat('Event_Request', 'evlatmin')\\n input['evlatmax'] = config.getfloat('Event_Request', 'evlatmax')\\n input['preset'] = config.getfloat('Event_Request', 'preset')\\n input['offset'] = config.getfloat('Event_Request', 'offset')\\n input['max_result'] = config.getint('Event_Request', 'max_results')\\n \\n input['get_events'] = config.get('Request', 'get_events')\\n input['input_period'] = config.get('Parallel', 'input_period')\\n input['IRIS'] = config.get('Request', 'IRIS')\\n input['ArcLink'] = config.get('Request', 'ArcLink')\\n input['time_iris'] = config.get('Request', 'time_iris')\\n input['time_arc'] = config.get('Request', 'time_arc')\\n \\n input['nodes'] = config.get('Parallel', 'nodes')\\n\\n input['waveform'] = config.get('Request', 'waveform')\\n input['response'] = config.get('Request', 'response')\\n input['SAC'] = config.get('Request', 'SAC')\\n \\n input['net'] = config.get('specifications_request', 'network')\\n input['sta'] = config.get('specifications_request', 'station')\\n \\n if config.get('specifications_request', 'location') == \\\"''\\\":\\n input['loc'] = ''\\n elif config.get('specifications_request', 'location') == '\\\"\\\"':\\n input['loc'] = ''\\n else:\\n input['loc'] = config.get('specifications_request', 'location')\\n \\n input['cha'] = config.get('specifications_request', 'channel')\\n\\n if config.get('specifications_request', 'lat') == 'None':\\n input['lat_cba'] = None\\n else:\\n input['lat_cba'] = config.get('specifications_request', 'lat')\\n \\n if config.get('specifications_request', 'lon') == 'None':\\n input['lon_cba'] = None\\n else:\\n input['lon_cba'] = config.get('specifications_request', 'lon')\\n \\n if config.get('specifications_request', 'minradius') == 'None':\\n input['mr_cba'] = None\\n else:\\n input['mr_cba'] = config.get('specifications_request', 'minradius')\\n \\n if config.get('specifications_request', 'maxradius') == 'None':\\n input['Mr_cba'] = None\\n else:\\n input['Mr_cba'] = config.get('specifications_request', 'maxradius')\\n \\n \\n if config.get('specifications_request', 'minlat') == 'None':\\n input['mlat_rbb'] = None\\n else:\\n input['mlat_rbb'] = config.get('specifications_request', 'minlat')\\n \\n if config.get('specifications_request', 'maxlat') == 'None':\\n input['Mlat_rbb'] = None\\n else:\\n input['Mlat_rbb'] = config.get('specifications_request', 'maxlat')\\n \\n if config.get('specifications_request', 'minlon') == 'None':\\n input['mlon_rbb'] = None\\n else:\\n input['mlon_rbb'] = config.get('specifications_request', 'minlon')\\n \\n if config.get('specifications_request', 'maxlon') == 'None':\\n input['Mlon_rbb'] = None\\n else:\\n input['Mlon_rbb'] = config.get('specifications_request', 'maxlon')\\n\\n \\n input['test'] = config.get('test', 'test')\\n input['test_num'] = config.getint('test', 'test_num')\\n \\n input['update_interactive'] = config.get('update', 'update_interactive')\\n input['iris_update'] = config.get('update', 'iris_update')\\n input['arc_update'] = config.get('update', 'arc_update')\\n\\n input['QC_IRIS'] = config.get('QC', 'QC_IRIS')\\n input['QC_ARC'] = config.get('QC', 'QC_ARC')\\n \\n input['email'] = config.get('email', 'email')\\n input['email_address'] = config.get('email', 'email_address')\\n \\n input['report'] = config.get('report', 'report')\\n \\n input['corr_unit'] = config.get('instrument_correction', 'corr_unit')\\n input['pre_filt'] = config.get('instrument_correction', 'pre_filter')\\n \\n input['plt_event'] = config.get('ObsPyPT', 'plot_event')\\n input['plt_sta'] = config.get('ObsPyPT', 'plot_sta')\\n input['plt_ray'] = config.get('ObsPyPT', 'plot_ray')\\n\\n input['llcrnrlon'] = config.getfloat('ObsPyPT', 'llcrnrlon')\\n input['urcrnrlon'] = config.getfloat('ObsPyPT', 'urcrnrlon')\\n input['llcrnrlat'] = config.getfloat('ObsPyPT', 'llcrnrlat')\\n input['urcrnrlat'] = config.getfloat('ObsPyPT', 'urcrnrlat')\\n \\n input['lon_0'] = config.getfloat('ObsPyPT', 'lon_0')\\n input['lat_0'] = config.getfloat('ObsPyPT', 'lat_0')\",\n \"def readOutputfile(filename, verbose=False):\\n\\n # -----------------------------------------------------------------------------\\n # Defining the classes for data structure\\n T_Simulation = namedtuple('Simulation', ['step'])\\n T_Step = namedtuple('Step', ['element', 'node'])\\n\\n T_Displacement = namedtuple('Displacement', ['ux', 'uy'])\\n\\n T_Element = namedtuple('Element', ['gp', 'avstrain', 'avstress', 'eqstrain'])\\n T_GP = namedtuple('GP', ['stress', 'strain'])\\n T_Stresses = namedtuple('Stresses', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\\n T_Strains = namedtuple('Strains', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\\n # -----------------------------------------------------------------------------\\n\\n nSteps = 0 # Simulation step counter\\n\\n SimData = T_Simulation(list())\\n\\n with open(filename) as f:\\n line = f.readline() # Read in the first line of the input file\\n while True: # Loop over all lines of the input file\\n # Read the nodes displacements\\n #line = f.readline()\\n #print(line)\\n if line == 'DofManager output:\\\\n': # String starts a list of nodes displacement information\\n nSteps += 1 # The above string starts a new simulation step\\n line = f.readline() # Cancel ---------- seperator\\n line = f.readline()\\n Nodes = list() # Initialize/clear list of nodes\\n\\n while line != '\\\\n' and line != 'Element output:\\\\n': # Strings that finish the list\\n #\\t\\t\\t\\tnNode = int(line.strip().split()[1]) # Node id\\n line = f.readline()\\n dim1 = float(line.strip().split()[3]) # Displacement dim1\\n line = f.readline()\\n dim2 = float(line.strip().split()[3]) # Displacement dim2\\n Nodes.append(\\n T_Displacement(dim1, dim2)) # Append displacements of the current node to the node list\\n line = f.readline()\\n\\n\\n if verbose:\\n print('Step {}: Dofs completed.\\\\n'.format(nSteps))\\n print('---------------------------------\\\\n')\\n\\n # Read the stresses an strains at Gauss points\\n elif line == 'Element output:\\\\n': # String starts a list elements, GPs, strains and stresses\\n line = f.readline() # Cancel ---------- seperator\\n line = f.readline()\\n Elements = list() # Initialize/clear list of elements\\n\\n while line != '\\\\n' and line != '\\\\tR E A C T I O N S O U T P U T:\\\\n': # Strings that finish the list\\n #\\t\\t\\t\\t\\tnElement = line.strip().split()[2] # Element id\\n line = f.readline()\\n GPs = T_Element(list(), 0, 0, 0) # List of Gauss points\\n\\n while line != '\\\\n' and line.strip().split()[0] == 'GP': # String that starts a new GP\\n #\\t\\t\\t\\t\\t\\tnGP = int(line.strip().split()[1].split('.')[1]) # GP id\\n tmp = [float(i) for i in line.strip().split()[4:10]] # Read the strains\\n strain = T_Strains(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\\n line = f.readline()\\n tmp = [float(i) for i in line.strip().split()[1:7]] # Read the stresses\\n stress = T_Stresses(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\\n GPs.gp.append(\\n T_GP(stress, strain)) # Append stresses and strains of the current GP to the GP list\\n line = f.readline()\\n\\n\\n Elements.append(GPs) # Append GP list of the current element to the element list\\n\\n if verbose:\\n print('Step {}: GPs completed.\\\\n'.format(nSteps))\\n print('---------------------------------\\\\n')\\n\\n SimData.step.append(T_Step(Elements, Nodes)) # Append element and node list of the current step to the step list\\n #print('the file input ends')\\n #print(nSteps)\\n # only needed with a while loop\\n # Jump over the lines until we reach the next time step (Caught by if-clause)\\n try:\\n line = f.readline() # Will generate an error if files end is reached\\n if line == \\\"\\\":\\n raise EOFError\\n except:\\n if verbose: print(\\\"End of file reached.\\\\n\\\")\\n break # Break the 'while True' loop\\n\\n # -----------------------------------------------------------------------------\\n\\n\\n print('averaging the stress')\\n # Averaging of strains and stress of GPs of each element\\n for istep in range(len(SimData.step)):\\n\\n for ielement in range(len(SimData.step[istep].element)):\\n print(len)\\n # Initialization before each element\\n stresses = np.array([0., 0., 0., 0., 0., 0.])\\n strains = np.array([0., 0., 0., 0., 0., 0.])\\n\\n for igp in range(len(SimData.step[istep].element[ielement])):\\n print(igp)\\n # Add up all data of all GPs\\n #stresses[:] += SimData.step[istep].element[ielement].gp[igp].stress[:]\\n strains[:] += SimData.step[istep].element[ielement].gp[igp].strain[:]\\n\\n # Divide GP sum by number of GPs\\n stresses /= len(SimData.step[istep].element[ielement])\\n strains /= len(SimData.step[istep].element[ielement])\\n # Replace the field (initialized with 0) with new information\\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\\n avstress=T_Stresses(stresses[0], stresses[1], stresses[2], stresses[3], stresses[4], stresses[5]))\\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\\n avstrain=T_Strains(strains[0], strains[1], strains[2], strains[3], strains[4], strains[5]))\\n print('Analysis finished')\\n return SimData\",\n \"def split_inputs(self):\\n\\n lca = self.lca\\n inputs = self.inputs\\n\\n inputs_dict = {} # Only store exchanges with uncertainty\\n\\n # Keep track of which tech_params and bio_params are already included to the analysis\\n # Needed to avoid running sa indices computations twice for the same tech or bio params. \\n # Initialize with parameterized exchanges\\n if self.parameters != None and self.ParametersModel != None:\\n indices_tech_all = self.parameters_dict['tech_params_where']\\n indices_bio_all = self.parameters_dict['bio_params_where']\\n else:\\n indices_tech_all = np.array([], dtype=int)\\n indices_bio_all = np.array([], dtype=int)\\n\\n for input_ in inputs:\\n\\n if input_ == 'biosphere':\\n continue\\n\\n inputs_dict[input_] = {}\\n\\n indices_tech = np.array([], dtype=int)\\n indices_bio = np.array([], dtype=int)\\n\\n if input_ == 'technosphere':\\n indices_tech = np.where(lca.tech_params['uncertainty_type']!=0)[0]\\n if 'biosphere' in inputs:\\n indices_bio = np.where(lca.bio_params['uncertainty_type']!=0)[0]\\n\\n elif input_ == 'demand_exc':\\n # Select all products that pertain to activities in the given demand vector\\n for act_index in np.nonzero(lca.demand_array)[0]:\\n mask_tech = np.all([lca.tech_params['uncertainty_type']!=0, lca.tech_params['col']==act_index], axis=0)\\n indices_tech = np.concatenate([indices_tech, np.where(mask_tech)[0]])\\n if 'biosphere' in inputs:\\n mask_bio = np.all([lca.bio_params['uncertainty_type']!=0, lca.bio_params['col']==act_index], axis=0)\\n indices_bio = np.concatenate([indices_bio, np.where(mask_bio)[0]])\\n\\n elif input_ in self.databases:\\n # Select all products and flows that are linked to the given database\\n # Indices corresponding to exchanges in the tech_params depending on the given database\\n db_act_indices_tech = [val for key,val in lca.activity_dict.items() if key[0]==input_]\\n if len(db_act_indices_tech) > 0:\\n db_act_index_min_tech = db_act_indices_tech[0]\\n db_act_index_max_tech = db_act_indices_tech[-1]\\n mask = lambda i : np.all( [lca.tech_params['uncertainty_type']!=0, \\n lca.tech_params['col']==i,\\n lca.tech_params['amount']!=0], axis=0 )\\n indices_tech = [ np.where( mask(i) ) [0] for i in range(db_act_index_min_tech, db_act_index_max_tech+1) ]\\n indices_tech = np.concatenate(indices_tech)\\n\\n # Indices corresponding to flows in the biosphere params depending on the given database\\n if 'biosphere' in inputs:\\n mask = lambda j : np.all( [lca.bio_params['uncertainty_type']!=0, lca.bio_params['col']==j], axis=0 )\\n indices_bio = [ np.where(mask(j))[0] for j in range(db_act_index_min_tech, db_act_index_max_tech+1) ]\\n indices_bio = np.concatenate(indices_bio)\\n\\n indices_tech = np.sort(indices_tech)\\n indices_bio = np.sort(indices_bio)\\n\\n # Do not add indices_tech that are already in the indices_tech_all\\n indices_tech_same = np.intersect1d(indices_tech, indices_tech_all)\\n pos_tech = np.array([ np.where(indices_tech==s)[0] for s in indices_tech_same ]).flatten()\\n indices_tech = np.delete(indices_tech, pos_tech)\\n np.append(indices_tech_all, indices_tech)\\n\\n # Do not add indices_bio that are already in the indices_bio_all\\n indices_bio_same = np.intersect1d(indices_bio, indices_bio_all)\\n pos_bio = np.array([ np.where(indices_bio==s)[0] for s in indices_bio_same ]).flatten()\\n indices_bio = np.delete(indices_bio, pos_bio)\\n np.append(indices_bio_all, indices_bio)\\n \\n inputs_dict[input_]['tech_params'] = lca.tech_params[indices_tech] #TODO maybe remove later, indices should be sufficient\\n inputs_dict[input_]['tech_params_where'] = indices_tech\\n inputs_dict[input_]['tech_n_params'] = len(indices_tech) #TODO remove later\\n\\n inputs_dict[input_]['bio_params'] = lca.bio_params[indices_bio] #TODO maybe remove later\\n inputs_dict[input_]['bio_params_where'] = indices_bio\\n inputs_dict[input_]['bio_n_params'] = len(indices_bio)\\n\\n\\n self.indices_tech_all = indices_tech_all #TODO remove later\\n self.indices_bio_all = indices_bio_all\\n self.inputs_dict = inputs_dict\",\n \"def read_outputs(self, fname, out_props, refined_blocks=None):\\r\\n for prop in out_props:\\r\\n attr_name = prop[0].replace(\\\" \\\", \\\"\\\").strip()\\r\\n attr_title = prop[1]\\r\\n self.out_props[attr_title] = {}\\r\\n if not hasattr(self, 'times'):\\r\\n self.times = []\\r\\n build = False\\r\\n found = False\\r\\n\\r\\n print('Reading ' + attr_title + ' output')\\r\\n with open(fname, \\\"r\\\") as fp:\\r\\n for line in fp:\\r\\n item = line.split()\\r\\n if len(item) > 0:\\r\\n # Find current time step\\r\\n if item[0] == 'Time':\\r\\n time = item[2]\\r\\n continue\\r\\n attr = line.replace(\\\" \\\", \\\"\\\").strip()\\r\\n\\r\\n # Locate attribute name\\r\\n if attr == attr_name:\\r\\n build = True\\r\\n found = True\\r\\n layers = [[[] for j in range(self.size[1])] for i in range(self.size[2])]\\r\\n I = None\\r\\n J = None\\r\\n K = '1'\\r\\n continue\\r\\n\\r\\n if build:\\r\\n if item[0] == 'All':\\r\\n v = self._str_to_float(item[3])\\r\\n grid = np.full((self.size[2], self.size[1], self.size[0]), v)\\r\\n self.out_props[attr_title][time] = grid\\r\\n build = False\\r\\n continue\\r\\n\\r\\n if item[0] == 'Plane':\\r\\n K = item[3]\\r\\n if len(item) > 4:\\r\\n if item[4] == 'All':\\r\\n v = self._str_to_float(item[-1])\\r\\n k_layer = np.full((self.size[1], self.size[0]), v)\\r\\n layers[int(K)-1] = k_layer\\r\\n I = [self.size[0]]\\r\\n J = []\\r\\n JIdx = self.size[1]\\r\\n else:\\r\\n I = None\\r\\n continue\\r\\n\\r\\n # Detects line indices under which 'I' properties are printed\\r\\n if item[0] == 'I':\\r\\n J = None\\r\\n prop_i = []\\r\\n I = item[2:]\\r\\n prev_digit = False\\r\\n for i in range(len(line)):\\r\\n if line[i].isdigit():\\r\\n if not prev_digit:\\r\\n prop_i.append([i])\\r\\n else:\\r\\n prop_i[-1].append(i)\\r\\n prev_digit = True\\r\\n else:\\r\\n prev_digit = False\\r\\n continue\\r\\n\\r\\n # Check if there are any missing values in J line\\r\\n skip_i = []\\r\\n if item[0] == 'J=':\\r\\n JIdx = item[1]\\r\\n J = item[2:]\\r\\n for i in range(len(prop_i)):\\r\\n skip = True\\r\\n for j in prop_i[i]:\\r\\n if line[j] != ' ':\\r\\n skip = False\\r\\n if skip:\\r\\n skip_i.append(i)\\r\\n n_skip = 0\\r\\n for i in range(len(I)):\\r\\n if i in skip_i:\\r\\n # layers[int(K)-1][int(JIdx)-1].append('NULL')\\r\\n layers[int(K) - 1][int(JIdx) - 1].append(-1)\\r\\n n_skip += 1\\r\\n else:\\r\\n if J[i - n_skip][-1] == 'r':\\r\\n J[i - n_skip] = J[i - n_skip][:-1]\\r\\n\\r\\n v = self._str_to_float(J[i - n_skip])\\r\\n layers[int(K) - 1][int(JIdx) - 1].append(v)\\r\\n # layers[int(K)-1][int(JIdx)-1].append(J[i - n_skip])\\r\\n continue\\r\\n\\r\\n # Put entire grid worth of property in dictionary for current time step\\r\\n if I is not None and J is not None:\\r\\n if int(I[-1]) == self.size[0] and int(JIdx) == self.size[1] and int(K) == self.size[2]:\\r\\n if build:\\r\\n self.out_props[attr_title][time] = layers\\r\\n build = False\\r\\n\\r\\n # Add local grid refinements\\r\\n if refined_blocks:\\r\\n refined = self.refine_outputs(fp, copy.deepcopy(refined_blocks))\\r\\n for c in list(refined.keys()):\\r\\n idx = c.split(',')\\r\\n self.out_props[attr_title][time][idx[2]][idx[1]][int(idx[0])-1] = refined[c]\\r\\n if not found:\\r\\n print(attr_title + ' was not found in output file!')\\r\\n del self.out_props[attr_title]\\r\\n else:\\r\\n if len(self.times) == 0:\\r\\n self.times = list(self.out_props[attr_title].keys())\",\n \"def read_edges(f=sys.stdin):\\n edges = []\\n k = ['first', 'last', 'capacity', 'flow', 'used']\\n lines = f.readlines()\\n for line in lines:\\n v = [int(s) for s in line.split(\\\" \\\")] + [0, False]\\n edges.append(dict(zip(k,v)))\\n \\n\\n return edges\",\n \"def parse_ensembl_exons(lines):\\n header = []\\n for index, line in enumerate(lines):\\n # File allways start with a header line\\n if index == 0:\\n header = line.rstrip().split(\\\"\\\\t\\\")\\n continue\\n\\n exon_info = parse_ensembl_line(line, header)\\n\\n exon = {\\n \\\"chrom\\\": str(exon_info[\\\"chrom\\\"]),\\n \\\"gene\\\": exon_info[\\\"ensembl_gene_id\\\"],\\n \\\"transcript\\\": exon_info[\\\"ensembl_transcript_id\\\"],\\n \\\"ens_exon_id\\\": exon_info[\\\"ensembl_exon_id\\\"],\\n \\\"exon_chrom_start\\\": exon_info[\\\"exon_start\\\"],\\n \\\"exon_chrom_end\\\": exon_info[\\\"exon_end\\\"],\\n \\\"strand\\\": exon_info[\\\"strand\\\"],\\n \\\"rank\\\": exon_info[\\\"exon_rank\\\"],\\n }\\n try:\\n exon[\\\"5_utr_start\\\"] = int(exon_info.get(\\\"utr_5_start\\\"))\\n except (ValueError, TypeError):\\n exon[\\\"5_utr_start\\\"] = None\\n\\n try:\\n exon[\\\"5_utr_end\\\"] = int(exon_info.get(\\\"utr_5_end\\\"))\\n except (ValueError, TypeError):\\n exon[\\\"5_utr_end\\\"] = None\\n\\n try:\\n exon[\\\"3_utr_start\\\"] = int(exon_info.get(\\\"utr_3_start\\\"))\\n except (ValueError, TypeError):\\n exon[\\\"3_utr_start\\\"] = None\\n\\n try:\\n exon[\\\"3_utr_end\\\"] = int(exon_info.get(\\\"utr_3_end\\\"))\\n except (ValueError, TypeError):\\n exon[\\\"3_utr_end\\\"] = None\\n\\n # Recalculate start and stop (taking UTR regions into account for end exons)\\n if exon[\\\"strand\\\"] == 1:\\n # highest position: start of exon or end of 5' UTR\\n # If no 5' UTR make sure exon_start is allways choosen\\n start = max(exon[\\\"exon_chrom_start\\\"], exon[\\\"5_utr_end\\\"] or -1)\\n # lowest position: end of exon or start of 3' UTR\\n end = min(exon[\\\"exon_chrom_end\\\"], exon[\\\"3_utr_start\\\"] or float(\\\"inf\\\"))\\n elif exon[\\\"strand\\\"] == -1:\\n # highest position: start of exon or end of 3' UTR\\n start = max(exon[\\\"exon_chrom_start\\\"], exon[\\\"3_utr_end\\\"] or -1)\\n # lowest position: end of exon or start of 5' UTR\\n end = min(exon[\\\"exon_chrom_end\\\"], exon[\\\"5_utr_start\\\"] or float(\\\"inf\\\"))\\n\\n exon[\\\"start\\\"] = start\\n exon[\\\"end\\\"] = end\\n exon_id = \\\"-\\\".join([str(exon[\\\"chrom\\\"]), str(start), str(end)])\\n exon[\\\"exon_id\\\"] = exon_id\\n\\n if start > end:\\n raise ValueError(\\\"ERROR: %s\\\" % exon_id)\\n\\n yield exon\",\n \"def read(f):\\n \\n if isinstance(f, basestring):\\n # If the input is a string, treat as file name\\n with open(f) as fh: # Ensure file is closed\\n return read(fh) # Call again with file object\\n \\n # First line contains the date\\n date = f.readline()\\n if not date:\\n raise IOError(\\\"Cannot read from input file \\\"+str(filename))\\n \\n # Second is description\\n desc = f.readline()\\n \\n token = file_numbers(f)\\n \\n # Third contains number of mesh points\\n try:\\n npsi = int(token.next())\\n ntheta = int(token.next())\\n isym = int(token.next())\\n except StopIteration:\\n raise IOError(\\\"Unexpected end of file while reading grid size\\\")\\n except ValueError:\\n raise IOError(\\\"Third line should contain npsi, ntheta and isym\\\")\\n \\n # Check values\\n if (isym < 0) or (isym > 1):\\n raise IOError(\\\"isym must be either 0 or 1\\\")\\n if (npsi < 1) or (ntheta < 1):\\n raise IOError(\\\"Invalid npsi=\\\"+str(npsi)+\\\" or ntheta=\\\" + str(ntheta))\\n \\n # Read normalisation factors\\n\\n try:\\n rcnt = float(token.next())\\n xma = float(token.next())\\n zma = float(token.next())\\n btor = float(token.next())\\n curtot = float(token.next())\\n eaxe = float(token.next())\\n dnorm = float(token.next())\\n except:\\n raise IOError(\\\"Couldn't read normalisation factors\\\")\\n \\n def read_array(n, name=\\\"Unknown\\\"):\\n data = np.zeros([n])\\n try:\\n for i in np.arange(n):\\n data[i] = float(token.next())\\n except:\\n raise IOError(\\\"Failed reading array '\\\"+name+\\\"' of size \\\", n)\\n return data\\n\\n def read_2d(nx, ny, name=\\\"Unknown\\\"):\\n data = np.zeros([nx, ny])\\n for i in np.arange(nx):\\n data[i,:] = read_array(ny, name+\\\"[\\\"+str(i)+\\\"]\\\")\\n return data\\n\\n # Read 1D arrays\\n psiflux = read_array(npsi, \\\"psiflux\\\")\\n fnorm = read_array(npsi, \\\"fnorm\\\")\\n ffpnorm = read_array(npsi, \\\"ffpnorm\\\")\\n ponly = read_array(npsi, \\\"ponly\\\")\\n pponly = read_array(npsi, \\\"pponly\\\")\\n qsf = read_array(npsi, \\\"qsf\\\")\\n d = read_array(npsi, \\\"d\\\")\\n \\n dpdz = read_array(ntheta, \\\"dpdz\\\")\\n dpdr = read_array(ntheta, \\\"dpdr\\\")\\n \\n # 2D arrays\\n \\n xnorm = read_2d(ntheta, npsi, \\\"xnorm\\\")\\n znorm = read_2d(ntheta, npsi, \\\"znorm\\\")\\n \\n # Try to read Br and Bz (may be present)\\n try:\\n Br = read_2d(ntheta, npsi, \\\"Br\\\")\\n Bz = read_2d(ntheta, npsi, \\\"Bz\\\")\\n except:\\n Br = Bz = None\\n \\n ny = ntheta\\n\\n if isym == 1:\\n # Fill in values for up-down symmetric case\\n print(\\\"Grid is up-down symmetric. Reflecting grid about midplane\\\")\\n ny = tsize = 2*(ntheta - 1) + 1\\n \\n def reflect(data, mapfunc = lambda x:x):\\n \\\"\\\"\\\" Reflect a variable about midplane\\n Optionally supply a mapping function\\\"\\\"\\\"\\n data2 = np.zeros([tsize, npsi])\\n # Copy the original data\\n for i in np.arange(ntheta):\\n data2[i,:] = data[i,:]\\n # Now fill in the remainder\\n for i in np.arange(ntheta, tsize):\\n t0 = tsize - 1 - i\\n data2[i,:] = mapfunc(data[t0,:])\\n return data2\\n \\n xnorm = reflect(xnorm)\\n znorm = reflect(znorm, lambda x: 2.*zma - x) # Reflect about zma\\n if Br != None:\\n Br = reflect(Br, lambda x:-x) # Br reverses\\n if Bz != None:\\n Bz = reflect(Bz) # Bz remains the same\\n theta = tsize\\n\\n # Make sure we have Br, Bz and Bpol\\n\\n if (Br == None) or (Bz == None):\\n # Calculate Bpol from psi then Br and Bz from Bpol\\n # Use dpsi = R*Bp dx (for now)\\n Bpol = np.zeros([ny, npsi])\\n \\n def deriv(f):\\n n = np.size(f)\\n dfdi = np.zeros(n)\\n dfdi[1:-1] = (f[2:n] - f[0:-2])/2. # Central difference in the middle\\n dfdi[0] = f[1] - f[0]\\n dfdi[-1] = f[-1] - f[-2]\\n return dfdi\\n \\n for i in np.arange(ntheta):\\n drdi = deriv(xnorm[i, :])\\n dzdi = deriv(znorm[i, :])\\n dldi = sqrt(drdi**2 + dzdi**2) # Arc length\\n dpsidi = deriv(psiflux)\\n \\n Bpol[i, :] = dpsidi / (dldi * xnorm[i,:])\\n else:\\n Bpol = np.sqrt(Br**2 + Bz**2)\\n \\n # Calculate toroidal field\\n Btor = fnorm / xnorm\\n \\n #########################################\\n # Create a dictionary of values to return\\n # \\n # Need to transpose 2D arrays to [psi, theta] \\n # to be consistent with elite inputs\\n \\n var = {\\\"npsi\\\":npsi, \\\"npol\\\":ny, # Sizes\\n \\n \\\"psi\\\":psiflux,\\n \\\"f(psi)\\\":fnorm,\\n \\\"p\\\":ponly,\\n \\n \\\"R\\\": np.transpose(xnorm),\\n \\\"Z\\\": np.transpose(znorm),\\n\\n \\\"Bp\\\":np.transpose(Bpol),\\n \\\"Bt\\\":np.transpose(Btor),\\n\\n \\\"q\\\":qsf,\\n\\n \\\"ffprime\\\":ffpnorm,\\n \\\"pprime\\\":pponly}\\n\\n if Br != None:\\n var['Br'] = np.transpose(Br)\\n if Bz != None:\\n var['Bz'] = np.transpose(Bz)\\n \\n return var\",\n \"def read_data_set():\\n # shapes of datasets -- [] means expanded form:\\n # - X: J\\n # - net.R: J [x J x 1]\\n # - F_DIST: J x J x num_features\\n # - F_DIST_w1: J x J x num_features\\n # - w['except_first'][-1]: (last weights) J x num_features [x 1]\\n # - w['except_first'][1:-1]: (second to last weights) J x J x num_features\\n # - first weights **were** also J x J x num_features\\n # - w['first_for_r']: J x 1 x num_features\\n\\n read_X()\\n read_weights(read_FDIST())\",\n \"def read_1D_comsol_data(self):\\n x=[]\\n y=[]\\n with open(self.file, 'r') as rf:\\n reader = csv.reader(rf, delimiter=',')\\n for row in reader:\\n x.append(row[0])\\n y.append(row[1])\\n x = np.asarray((x),dtype=float)\\n y = np.asarray((y),dtype=float)\\n return x,y\",\n \"def read():\\n try:\\n #Open and parse input files.\\n nodeFile = open(sys.argv[1], 'r')\\n edgeFile = open(sys.argv[2], 'r')\\n\\t\\n parse_nodes(nodeFile)\\n parse_edges(edgeFile)\\n nodeFile.close()\\n\\tedgeFile.close()\\n\\treturn \\n except:\\n print 'problem parsing input'\\n #Put here some more information - usage...\",\n \"def _read_input_file(self):\\n file_type = 'np.array'\\n with open(self._file_properties['file_name'], 'r') as in_file:\\n for line in in_file.readlines():\\n if line[0:5] == '$$SOE':\\n file_type = 'Horizons'\\n break\\n\\n if not isfile(self._file_properties['file_name']):\\n msg = 'Horizons files {:} does not exists.'\\n message = msg.format(self._file_properties['file_name'])\\n raise FileExistsError(message)\\n if file_type == 'Horizons':\\n self._read_horizons_file()\\n else:\\n (time, x, y, z) = np.loadtxt(\\n self._file_properties['file_name'],\\n usecols=(0, 1, 2, 3), unpack=True)\\n self._time = time\\n if int(astropy_version[0]) >= 4:\\n self._xyz = SkyCoord(x=x, y=y, z=z,\\n representation_type='cartesian')\\n else:\\n self._xyz = SkyCoord(x=x, y=y, z=z,\\n representation='cartesian')\",\n \"def read():\\n # TODO\",\n \"def ReadSalome(self, filename, element_type=\\\"tri\\\", read_surface_info=False):\\n\\n if element_type == \\\"line\\\":\\n el = \\\"102\\\"\\n bel = \\\"\\\"\\n elif element_type == \\\"tri\\\":\\n el = \\\"203\\\"\\n bel = \\\"102\\\"\\n elif element_type == \\\"quad\\\":\\n el = \\\"204\\\"\\n bel = \\\"102\\\"\\n elif element_type == \\\"tet\\\":\\n el = \\\"304\\\"\\n bel = \\\"203\\\"\\n elif element_type == \\\"hex\\\":\\n el = \\\"308\\\"\\n bel = \\\"204\\\"\\n\\n if read_surface_info is True and element_type == \\\"line\\\":\\n warn(\\\"No surface info for lines. I am going to ignore this\\\")\\n read_surface_info = False\\n\\n\\n with open(filename,'r') as f:\\n lines = f.readlines()\\n\\n info = lines[0].rstrip().split()\\n\\n self.nnode = int(info[0])\\n all_nelem = int(info[1])\\n\\n nodes = lines[1:self.nnode+1]\\n\\n points = []\\n for line in nodes:\\n points.append([float(i) for i in line.rstrip().split()[1:4]])\\n self.points = np.array(points,copy=True)\\n self.nnode = self.points.shape[0]\\n\\n edges, faces, elements = [], [], []\\n for counter in range(self.nnode+1,len(lines)):\\n line = lines[counter].rstrip().split()\\n if read_surface_info:\\n if bel == line[1]:\\n faces.append([int(i) for i in line[2:]])\\n if el == line[1]:\\n elements.append([int(i) for i in line[2:]])\\n\\n self.element_type = element_type\\n self.elements = np.array(elements,dtype=np.int64,copy=True) - 1\\n self.nelem = self.elements.shape[0]\\n if self.nelem == 0:\\n raise ValueError(\\\"file does not contain {} elements\\\".format(element_type))\\n\\n ndim = self.InferSpatialDimension()\\n if self.element_type == \\\"tri\\\" or self.element_type == \\\"quad\\\":\\n self.GetEdges()\\n self.GetBoundaryEdges()\\n elif self.element_type == \\\"tet\\\" or self.element_type == \\\"hex\\\":\\n self.GetFaces()\\n self.GetBoundaryFaces()\\n self.GetBoundaryEdges()\",\n \"def gen_ep_data(self,ntrials,trlen):\\n self.resort_emat()\\n ## instruction\\n # for each trial, generate random instruction encoding sequence\\n i_encoding_input = np.array([\\n np.random.permutation(np.arange(1,self.nmaps+1)) \\n for i in range(ntrials)\\n ])\\n i_test_input = np.zeros([ntrials,trlen])\\n i_input = np.concatenate([\\n i_encoding_input,i_test_input],\\n 1).astype(int).reshape(-1) # (ntrials,trlen+)\\n ## stimulus\\n x_encoding_input = i_encoding_input\\n x_test_input = np.random.randint(1,self.nmaps+1,[ntrials,trlen])\\n x_input = np.concatenate([x_encoding_input,x_test_input],1)\\n # print('X',x_input)\\n ''' \\n embed x_input: \\n [ntrials,nmaps+trlen] -> s_input [ntrials*(nmaps+trlen),edim]\\n explicit loop required for flatten and embedd x_input\\n because if switchmaps=1, matrix is resorted between trials\\n and therefore same stimulus token integers correspond to\\n different stimulus embeddings on different trials\\n '''\\n s_input = -np.ones([ntrials,(self.nmaps+trlen),self.stimdim])\\n for trialn,x_input_trial in enumerate(x_input): \\n if self.switchmaps: self.resort_emat()\\n s_input[trialn] = self.emat[x_input_trial]\\n # format output\\n i_input = tr.unsqueeze(tr.LongTensor(i_input),1)\\n s_input = tr.unsqueeze(tr.Tensor(np.concatenate(s_input)),1)\\n yseq = tr.unsqueeze(tr.LongTensor(x_input.reshape(-1)),1)\\n return i_input,s_input,yseq\",\n \"def read_record(self, file_, num_evo_entries,get_data,mode='dist',return_seq=True):\\n # This method and the Switch Class were taken from the original ProteinNet repo.\\n # arg is a open file, num_evo_entries is 20 by default\\n #\\n # Strip the dict and insert lists for each of the types of entries\\n desc_dict = utils.load_obj('desc_dict.pkl')\\n desc_dict_rev = {int(self.aa_dict[k]):v for (k,v) in desc_dict.items()}\\n\\n # this will be stripped soon.\\n if get_data == 'all':\\n get_data = ['id','primary','evolutionary','secondary','tertiary','mask']\\n aa_dict = {'A': '0', 'C': '1', 'D': '2', 'E': '3', 'F': '4', 'G': '5', 'H': '6', 'I': '7', 'K': '8', 'L': '9', 'M': '10', 'N': '11', 'P': '12', 'Q': '13', 'R': '14', 'S': '15', 'T': '16', 'V': '17', 'W': '18', 'Y': '19'}\\n _mask_dict = {'-': '0', '+': '1'}\\n while True:\\n next_line = file_.readline()\\n for case in switch(next_line):\\n if case('[ID]' + '\\\\n'):\\n if 'id' in get_data:\\n id_ = file_.readline()[:-1]\\n \\n elif case('[PRIMARY]' + '\\\\n'):\\n if 'primary' in get_data: \\n prim = file_.readline()[:-1]\\n primary = self.letter_to_num(prim, self.aa_dict)\\n \\n \\n elif case('[EVOLUTIONARY]' + '\\\\n'):\\n if 'evo' in get_data:\\n evolutionary = []\\n for residue in range(num_evo_entries): evolutionary.append(np.asarray([float(step) for step in file_.readline().split()]))\\n evolutionary = np.array(evolutionary)\\n evolutionary = evolutionary.T # this will turn evo into an array of shape (-1, 20) Fuck yeah\\n \\n elif case('[TERTIARY]' + '\\\\n'):\\n if 'tert' in get_data:\\n tertiary = []\\n for axis in range(3): tertiary.append([float(coord) for coord in file_.readline().split()])\\n \\n elif case('[MASK]' + '\\\\n'):\\n if 'mask' in get_data:\\n mask = file_.readline()[:-1]\\n mask = self.letter_to_num(mask, _mask_dict)\\n \\n # ends reading a Single record\\n elif case('\\\\n'):\\n # perform preprocessing\\n if 0 in mask:\\n return -1\\n if len(primary) > self.seq_cutoff:\\n return -1\\n prop = utils.make_prop_array(primary,desc_dict_rev)\\n x = np.concatenate([tc(primary,num_classes=20),evolutionary,prop],axis=1)\\n tertiary = dhc.get_backbone_coords(np.array(tertiary))\\n if mode == 'dih':\\n y = dhc.fix_array(dhc.get_phi_psi(tertiary))\\n y = y.astype('float32')\\n elif mode =='dist':\\n y = self.pairwise_distance(tertiary)\\n elif mode == 'zmat':\\n tertiary = tertiary.reshape((1,-1,3,3))\\n tertiary = tertiary[:,:,1,:].reshape((1,-1,1,3)).astype('float32')/100\\n dist = dhc.calc_dist_vector(tertiary).numpy().reshape((1,-1,1))\\n ang = np.radians(dhc.calc_angle_vector(tertiary).numpy().reshape((1,-1,1)))\\n dih = dhc.calc_dihedral_vector(tertiary).numpy()\\n y = np.concatenate([dist,ang,dih],axis=-1)\\n elif mode == 'tert':\\n #tertiary = tertiary.reshape((1,-1,3,3))\\n tertiary = tertiary.reshape((-1,3,3))\\n #tertiary = tertiary[:,:,1,:].reshape((1,-1,1,3)).astype('float32')/100\\n #y = self.pairwise_distance(tertiary)\\n return [x.astype('float32',copy=False), tertiary.astype('float32',copy=False), np.asarray(id_), primary]\\n if return_seq:\\n return [x.astype('float32',copy=False), y.astype('float32',copy=False), np.asarray(id_), tertiary.astype('float32',copy=False), primary]\\n else:# if anything changes, i will be replacing this with a more pythonic way soon enough\\n # if I really need tertiary structure at anytime, i just code it her\\n return [x.astype('float32',copy=False), y.astype('float32',copy=False), np.asarray(id_)]\\n \\n elif case(''):\\n return None\",\n \"def read(self, epsg=None):\\n if self.data is None:\\n self.process.compute()\\n self.data = self.process.output.data\\n out_data = self.data\\n if epsg and self.get_epsg() != epsg:\\n out_data = reproject(self.data, epsg)\\n return out_data\",\n \"def main():\\n args = get_args()\\n\\n entries = []\\n\\n noe_dim = \\\"h1\\\" if args.hch else \\\"c1\\\" # save the name of the noe dimension\\n\\n with open(args.sparkylist) as lines:\\n\\n lines = lines.readlines()\\n # lines = set(lines) # remove duplicate lines\\n peak = 1\\n for idx, line in enumerate(lines):\\n idx = idx + 1\\n\\n try:\\n label, c1, c2, h2, intensity, *rest = line.split()\\n\\n c1 = float(c1) # convert these to floats\\n c2 = float(c2)\\n h2 = float(h2)\\n intensity = float(intensity)\\n\\n label = f\\\"peak{peak}\\\"\\n peak += 1\\n\\n except ValueError:\\n print(f\\\"invalid NOE definition on line {idx}\\\")\\n continue\\n\\n dic = {\\\"label\\\": label, noe_dim: c1,\\n \\\"c2\\\": c2, \\\"h2\\\": h2, \\\"intensity\\\": intensity}\\n\\n entries.append(dic)\\n\\n # create dataframe and write out\\n csv = pd.DataFrame(entries)\\n order = [\\\"label\\\", noe_dim, \\\"c2\\\", \\\"h2\\\", \\\"intensity\\\"]\\n csv.to_csv(args.output, columns=order, index=False)\",\n \"def gen_ep_data(self,ntrials,trlen):\\n ## instruction\\n # for each trial, generate random instruction encoding sequence\\n i_encoding_input = np.array([\\n np.random.permutation(np.arange(1,self.nmaps+1)) \\n for i in range(ntrials)\\n ])\\n i_test_input = np.zeros([ntrials,trlen])\\n i_input = np.concatenate([\\n i_encoding_input,i_test_input],\\n 1).astype(int).reshape(-1) # (ntrials,trlen+)\\n ## stimulus\\n x_encoding_input = i_encoding_input\\n x_test_input = np.random.randint(1,self.nmaps+1,[ntrials,trlen])\\n x_input = np.concatenate([i_encoding_input,x_test_input],1)\\n ''' \\n embed x_input: \\n [ntrials,nmaps+trlen] -> s_input [ntrials*(nmaps+trlen),edim]\\n explicit loop required for flatten and embedd x_input\\n because if switchmaps=1, matrix is resorted between trials\\n and therefore same stimulus token integers correspond to\\n different stimulus embeddings on different trials\\n '''\\n s_input = -np.ones([ntrials,(self.nmaps+trlen),self.stimdim])\\n for trialn,x_input_trial in enumerate(x_input): \\n if self.switchmaps: self.resort_emat()\\n s_input[trialn] = self.emat[x_input_trial]\\n \\n # format output\\n i_input = tr.unsqueeze(tr.LongTensor(i_input),1)\\n s_input = tr.unsqueeze(tr.Tensor(np.concatenate(s_input)),1)\\n yseq = tr.unsqueeze(tr.LongTensor(x_input.reshape(-1)),1)\\n if return_trial_flag:\\n tr_flag = np.concatenate([i*np.ones(self.nmaps+trlen) for i in range(ntrials)])\\n tr_flag = tr.unsqueeze(tr.LongTensor(tr_flag),1)\\n return tr_flag,i_input,s_input,yseq,\\n else:\\n return i_input,s_input,yseq\",\n \"def _read_file(self) -> Tuple[np.ndarray, h5py.File]:\\n assert os.path.exists(self.datafile)\\n LOGGER.info(f\\\"Found datafile: {self.datafile}\\\")\\n\\n # get ELM indices from datafile\\n hf = h5py.File(self.datafile, \\\"r\\\")\\n LOGGER.info(f\\\"Number of ELM events in the datafile: {len(hf)}\\\")\\n elm_index = np.array([int(key) for key in hf], dtype=np.int32)\\n return elm_index, hf\",\n \"def read_2D_comsol_data(self):\\n x=[]\\n y=[]\\n z=[]\\n with open(self.file, 'r') as rf:\\n reader = csv.reader(rf, delimiter=',')\\n for row in reader:\\n x.append(row[0])\\n y.append(row[1])\\n z.append(row[2])\\n x = np.asarray((x),dtype=float)\\n y = np.asarray((y),dtype=float)\\n z = np.asarray((z),dtype=float)\\n return x,y,z\",\n \"def readWaveform(self):\\n # prepare data holder\\n y = [ 0 for j in range(4) ]\\n # in case of previous errors\\n self.flushInput()\\n for ch in self.chs:\\n # mostly for TDS\\n self.setCh(ch)\\n # calibration factor we will need soon\\n (vmult, voff) = self.calibV()\\n # read and calibrate data\\n data = (numpy.array(self.readData()) - voff) * vmult\\n # This is from the formula in TDS manual, without the\\n # \\\"vzero\\\" in it---I couldn't figure out when that wouldn't\\n # be exactly zero.\\n y[ch-1]=data[:]\\n\\n (hstep, hoff) = self.calibH()\\n # initialize time array\\n t = numpy.array(range(len(y[0])))\\n t = (t * hstep) + hoff\\n\\n # update the sequence number (... for isUpdated())\\n self.seq = self.readSeq()\\n\\n return (t, y)\",\n \"def _get_econt_info(self, out_log):\\n f = open_general(out_log)\\n tmptxt = f.readlines()\\n f.close()\\n econt = {}\\n itmp = search_string('[read_energy] number of energy points', tmptxt)\\n if itmp>=0: econt['Nepts'] = int(tmptxt.pop(itmp).split()[-1])\\n itmp = search_string('energies and weights are:', tmptxt)\\n if itmp>=0:\\n tmp = []\\n for ie in range(econt['Nepts']):\\n tmpline = tmptxt[itmp+4+ie].split()[1:]\\n tmp.append([float(tmpline[0]), float(tmpline[1]), float(tmpline[2]), float(tmpline[3])])\\n tmp = array(tmp)\\n econt['epts'] = tmp[:,:2]\\n econt['weights'] = tmp[:,2:]\\n econt['emin'] = tmp[0,0]\\n return econt\",\n \"def readPubTator(args):\\n if not os.path.exists('/'.join(args.output_file.split('/')[:-1])):\\n os.makedirs('/'.join(args.output_file.split('/')[:-1]))\\n\\n abstracts = OrderedDict()\\n entities = OrderedDict()\\n relations = OrderedDict()\\n\\n with open(args.input_file, 'r') as infile:\\n for line in tqdm(infile):\\n\\n # text\\n if len(line.rstrip().split('|')) == 3 and \\\\\\n (line.strip().split('|')[1] == 't' or line.strip().split('|')[1] == 'a'):\\n line = line.strip().split('|')\\n\\n pmid = line[0]\\n text = line[2] # .replace('>', '\\\\n')\\n\\n # replace weird symbols and spaces\\n text = replace2symbol(text)\\n text = replace2space(text)\\n\\n if pmid not in abstracts:\\n abstracts[pmid] = [TextStruct(pmid, text)]\\n else:\\n abstracts[pmid] += [TextStruct(pmid, text)]\\n\\n # entities\\n elif len(line.rstrip().split('\\\\t')) == 6:\\n line = line.strip().split('\\\\t')\\n pmid = line[0]\\n offset1 = int(line[1])\\n offset2 = int(line[2])\\n ent_name = line[3]\\n ent_type = line[4]\\n kb_id = line[5].split('|')\\n\\n # replace weird symbols and spaces\\n ent_name = replace2symbol(ent_name)\\n ent_name = replace2space(ent_name)\\n\\n # currently consider each possible ID as another entity\\n for k in kb_id:\\n if pmid not in entities:\\n entities[pmid] = [EntStruct(pmid, ent_name, offset1, offset2, ent_type, [k], -1, [], [])]\\n else:\\n entities[pmid] += [EntStruct(pmid, ent_name, offset1, offset2, ent_type, [k], -1, [], [])]\\n\\n elif len(line.rstrip().split('\\\\t')) == 7:\\n line = line.strip().split('\\\\t')\\n pmid = line[0]\\n offset1 = int(line[1])\\n offset2 = int(line[2])\\n ent_name = line[3]\\n ent_type = line[4]\\n kb_id = line[5].split('|')\\n extra_ents = line[6].split('|')\\n\\n # replace weird symbols and spaces\\n ent_name = replace2symbol(ent_name)\\n ent_name = replace2space(ent_name)\\n for i, e in enumerate(extra_ents):\\n if pmid not in entities:\\n entities[pmid] = [EntStruct(pmid, ent_name, offset1, offset2, ent_type, [kb_id[i]], -1, [], [])]\\n else:\\n entities[pmid] += [EntStruct(pmid, ent_name, offset1, offset2, ent_type, [kb_id[i]], -1, [], [])]\\n\\n # relations\\n elif len(line.rstrip().split('\\\\t')) == 4:\\n line = line.strip().split('\\\\t')\\n pmid = line[0]\\n rel_type = line[1]\\n arg1 = tuple((line[2].split('|')))\\n arg2 = tuple((line[3].split('|')))\\n\\n if pmid not in relations:\\n relations[pmid] = [RelStruct(pmid, rel_type, arg1, arg2)]\\n else:\\n relations[pmid] += [RelStruct(pmid, rel_type, arg1, arg2)]\\n\\n elif line == '\\\\n':\\n continue\\n\\n return abstracts, entities, relations\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59410346","0.567626","0.5638466","0.55620134","0.55526614","0.5529649","0.54932714","0.54829437","0.5475036","0.5426845","0.5419794","0.5365769","0.5346987","0.5330866","0.5302111","0.52904403","0.5289346","0.527683","0.5269207","0.5269175","0.52437896","0.52366996","0.5210274","0.5207666","0.51970017","0.51861376","0.51619816","0.51554906","0.51498806","0.5148883","0.514553","0.5141779","0.51336795","0.51228446","0.5119803","0.511237","0.5107044","0.5102768","0.50953084","0.50946134","0.50920856","0.50803953","0.5077382","0.50719017","0.50682896","0.50659347","0.5057592","0.50512135","0.5038282","0.50350326","0.5031053","0.50220376","0.5015904","0.501049","0.5009224","0.499767","0.49864975","0.49799168","0.49603194","0.49585485","0.4956867","0.49548838","0.49530014","0.49419314","0.49375027","0.49354318","0.49321705","0.49295288","0.492834","0.49245706","0.49207258","0.49206236","0.49152392","0.4913053","0.49120188","0.49055758","0.49030536","0.49017242","0.49006736","0.48972288","0.48913255","0.48904252","0.48825255","0.4879674","0.48667866","0.48657885","0.4858678","0.48529387","0.48478162","0.48477572","0.4844443","0.48434407","0.48346314","0.4833389","0.48307407","0.48287186","0.48283052","0.4826438","0.48232758","0.48203254"],"string":"[\n \"0.59410346\",\n \"0.567626\",\n \"0.5638466\",\n \"0.55620134\",\n \"0.55526614\",\n \"0.5529649\",\n \"0.54932714\",\n \"0.54829437\",\n \"0.5475036\",\n \"0.5426845\",\n \"0.5419794\",\n \"0.5365769\",\n \"0.5346987\",\n \"0.5330866\",\n \"0.5302111\",\n \"0.52904403\",\n \"0.5289346\",\n \"0.527683\",\n \"0.5269207\",\n \"0.5269175\",\n \"0.52437896\",\n \"0.52366996\",\n \"0.5210274\",\n \"0.5207666\",\n \"0.51970017\",\n \"0.51861376\",\n \"0.51619816\",\n \"0.51554906\",\n \"0.51498806\",\n \"0.5148883\",\n \"0.514553\",\n \"0.5141779\",\n \"0.51336795\",\n \"0.51228446\",\n \"0.5119803\",\n \"0.511237\",\n \"0.5107044\",\n \"0.5102768\",\n \"0.50953084\",\n \"0.50946134\",\n \"0.50920856\",\n \"0.50803953\",\n \"0.5077382\",\n \"0.50719017\",\n \"0.50682896\",\n \"0.50659347\",\n \"0.5057592\",\n \"0.50512135\",\n \"0.5038282\",\n \"0.50350326\",\n \"0.5031053\",\n \"0.50220376\",\n \"0.5015904\",\n \"0.501049\",\n \"0.5009224\",\n \"0.499767\",\n \"0.49864975\",\n \"0.49799168\",\n \"0.49603194\",\n \"0.49585485\",\n \"0.4956867\",\n \"0.49548838\",\n \"0.49530014\",\n \"0.49419314\",\n \"0.49375027\",\n \"0.49354318\",\n \"0.49321705\",\n \"0.49295288\",\n \"0.492834\",\n \"0.49245706\",\n \"0.49207258\",\n \"0.49206236\",\n \"0.49152392\",\n \"0.4913053\",\n \"0.49120188\",\n \"0.49055758\",\n \"0.49030536\",\n \"0.49017242\",\n \"0.49006736\",\n \"0.48972288\",\n \"0.48913255\",\n \"0.48904252\",\n \"0.48825255\",\n \"0.4879674\",\n \"0.48667866\",\n \"0.48657885\",\n \"0.4858678\",\n \"0.48529387\",\n \"0.48478162\",\n \"0.48477572\",\n \"0.4844443\",\n \"0.48434407\",\n \"0.48346314\",\n \"0.4833389\",\n \"0.48307407\",\n \"0.48287186\",\n \"0.48283052\",\n \"0.4826438\",\n \"0.48232758\",\n \"0.48203254\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.55652803"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":3285,"cells":{"query":{"kind":"string","value":"trace finds the line, the filename and error message and returns it to the user"},"document":{"kind":"string","value":"def trace():\n import traceback\n tb = sys.exc_info()[2]\n tbinfo = traceback.format_tb(tb)[0]\n # script name + line number\n line = tbinfo.split(\", \")[1]\n # Get Python syntax error\n #\n synerror = traceback.format_exc().splitlines()[-1]\n return line, __file__, synerror"},"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 trace():\n import traceback, inspect\n tb = sys.exc_info()[2]\n tbinfo = traceback.format_tb(tb)[0]\n filename = inspect.getfile(inspect.currentframe())\n # script name + line number\n line = tbinfo.split(\", \")[1]\n # Get Python syntax error\n #\n synerror = traceback.format_exc().splitlines()[-1]\n return line, filename, synerror","def __call__(self, line):\n marker = self.marker\n stripped_line = line.strip()\n if marker == stripped_line:\n assert not self.traceback_section\n self.traceback_section = True\n # print(\"XXX: TRACEBACK-START\")\n elif self.traceback_section:\n matched = self.file_pattern.match(line)\n if matched:\n # matched_range = matched.regs[1]\n filename = matched.groups()[0]\n new_filename = posixpath_normpath(filename)\n if new_filename != filename:\n # print(\"XXX: %r => %r\" % (filename, new_filename))\n line = line.replace(filename, new_filename)\n elif not stripped_line or line[0].isalpha():\n # -- DETECTED TRCAEBACK-END: exception-description\n # print(\"XXX: TRACEBACK-END\")\n self.traceback_section = False\n return line","def traceback(self):","def format_backtrace(trace):\n backtrace = []\n for filename, line, func, _ in traceback.extract_tb(trace):\n desc = {'file': filename,\n 'line': line,\n 'function': func,\n 'text': _}\n backtrace.append(desc)\n return backtrace","def gettrace(): # real signature unknown; restored from __doc__\n pass","def trace(context=1):\r\n return getinnerframes(sys.exc_info()[2], context)","def trace(self, trace=...):\n ...","def report(self, line: int, where: str, message: str):\n output = f'[line {line}] Error{where}: {message}'\n print(output, file=sys.stderr)\n self.had_error = True","def handle_error():\n print \"An error occurred. Trace:\\n\"\n traceback.print_exc()","def _exceptionStackTTB(self,methodName,exc,depth=10):\n stack = \"\"\n # Reconstruct the call stack from where the trace of the exception was initiated by invoking \n # Trace.error() or Trace.severe().\n stackList = traceback.extract_stack()\n try:\n for stackData in stackList:\n sourcefile,line,function,text = stackData\n if (sourcefile.endswith(\"Trace.py\") and (function == \"error\" or function == \"severe\")): break\n sepIndex = sourcefile.rfind(os.sep)\n if (sepIndex >=0 and Trace.SourceFileStyle == Trace.NameOnly):\n sourcefile = sourcefile[sepIndex+1:]\n #endIf\n if (text == None):\n if (not stack):\n # Leave out the newline for the bottom line on the stack\n stack = \"\\t%s(%s) [%s]\" % (sourcefile,line,function)\n else:\n stack = \"\\t%s(%s) [%s]\\n%s\" % (sourcefile,line,function,stack)\n #endIf\n else:\n if (not stack):\n # Leave out the newline for the bottom line on the stack\n stack = \"\\t%s(%s) [%s] - %s\" % (sourcefile,line,function,text)\n else:\n stack = \"\\t%s(%s) [%s] - %s\\n%s\" % (sourcefile,line,function,text,stack)\n #endIf\n #endIf\n #endFor\n stack = \"\\tFrame stack (most recent call first):\\n%s\" % stack\n except:\n # This shouldn't happen, but in case it does...\n exc_type,exc_value = sys.exc_info()[:2]\n stack = \"\\tException getting frame stack. Type: %s, Value: %s\\n%s\" % (exc_type,exc_value,stack)\n #endTry\n\n try:\n tb = sys.exc_info()[2]\n stackList = traceback.extract_tb(tb,depth)\n for stackData in stackList:\n sourcefile,line,function,text = stackData\n sepIndex = sourcefile.rfind(os.sep)\n if (sepIndex >=0 and Trace.SourceFileStyle == Trace.NameOnly):\n sourcefile = sourcefile[sepIndex+1:]\n #endIf\n if (text == None):\n stack = \"\\t%s(%s) [%s]\\n%s\" % (sourcefile,line,function,stack)\n else:\n stack = \"\\t%s(%s) [%s] - %s\\n%s\" % (sourcefile,line,function,text,stack)\n #endIf\n #endFor\n stack = \"\\tException stack (most recent call first):\\n%s\" % stack\n except:\n # This shouldn't happen, but in case it does...\n exc_type,exc_value = sys.exc_info()[:2]\n stack = \"\\tException getting exception stack. Type: %s, Value: %s\\n%s\" % (exc_type,exc_value,stack)\n #endTry\n \n # At the very top - put the exception string\n stack = \"\\t%s\\n%s\" % (exc,stack)\n \n return stack","def _parse_traceback(self, trace):\n p_traceback = [ \"%s:%d:in `%s'\" % (filename, lineno, funcname) \n for filename, lineno, funcname, _\n in traceback.extract_tb(trace) ]\n p_traceback.reverse()\n\n return p_traceback","def extract_detail():\r\n tb = sys.exc_info()[-1]\r\n stk = traceback.extract_tb(tb, -1)[0]\r\n return \"{} in {} line num {} on line {} \".format(\r\n stk.name, stk.filename, stk.lineno, stk.line\r\n )","def StandViz_ReportError( errorobj, args, Header = None ): # error reporting and traceback function\n (MyPath, MyFile) = os.path.split( args[0] ) # retrieve filename and path of running python script\n (MyBaseName, MyExt) = os.path.splitext( MyFile ) # separate basefilename from extension\n errorfilename = \"{}.txt\".format(MyBaseName) # create new error filename based on base of script filename\n ERRFILE = open( errorfilename, 'w' ) # open text file for writting\n if( Header != None ): ERRFILE.write( '%s\\n' % Header ) # if Header defined, write Header to file\n ERRFILE.write( \"Error running '{}'\\n\".format(MyFile) ) # write error message with filename\n MyTrace = errorobj[2] # retrieve error object\n while( MyTrace != None ): # loop through stack trace\n (line, file, name) = ( MyTrace.tb_lineno, MyTrace.tb_frame.f_code.co_filename, MyTrace.tb_frame.f_code.co_name ) # extract line, file, and error name\n F = open( file, 'r' ) # open source file of Python script\n L = F.readlines() # read scripot source into memory\n F.close() # close script file\n code = L[line-1].strip() # extract line of source code that caused error\n ERRFILE.write( \" File '{}', line {}, in {}\\n {}\\n\".format(file, line, name, code) ) # write filename, source code line, error name, and error code\n MyTrace = MyTrace.tb_next # step to next level of call stack trace\n ERRFILE.write( \"errorobj: {}\\n\".format(errorobj) ) # write error object and arguments for call\n ERRFILE.write( \"Calling Argument Vector: {}\\n\".format(args) ) # write calling arguments\n ERRFILE.close() # close text file with error stack trace\n os.system( \"notepad.exe {}\".format(errorfilename) ) # display error log file with notepad.exe","def localTraceback(self, alwaysPrint = False):\n self.log( \"DEBUG TRACEBACK: \" )\n for line in traceback.format_stack():\n self.logPre( line, alwaysPrint )","def lineno():\n return \"line \" + str(inspect.currentframe().f_back.f_lineno) + \": \"","def _exceptionStackBTT(self,methodName,exc,depth=10):\n stack = \"\"\n # Reconstruct the call stack from where the trace of the exception was initiated by invoking \n # Trace.error() or Trace.severe().\n stackList = traceback.extract_stack()\n try:\n stack = \"\\tFrame stack (most recent call last):\\n\"\n for stackData in stackList:\n sourcefile,line,function,text = stackData\n if (sourcefile.endswith(\"Trace.py\") and (function == \"error\" or function == \"severe\")): break\n sepIndex = sourcefile.rfind(os.sep)\n if (sepIndex >=0 and Trace.SourceFileStyle == Trace.NameOnly):\n sourcefile = sourcefile[sepIndex+1:]\n #endIf\n if (text == None):\n stack = \"%s\\t%s(%s) [%s]\\n\" % (stack,sourcefile,line,function)\n else:\n stack = \"%s\\t%s(%s) [%s] - %s\\n\" % (stack,sourcefile,line,function,text)\n #endIf\n #endFor\n except:\n # This shouldn't happen, but in case it does...\n exc_type,exc_value = sys.exc_info()[:2]\n stack = \"%s\\n\\tException getting frame stack. Type: %s, Value: %s\" % (stack,exc_type,exc_value)\n #endTry\n \n try:\n stack = \"%s\\tException stack (most recent call last):\\n\" % stack\n tb = sys.exc_info()[2]\n stackList = traceback.extract_tb(tb,depth)\n for stackData in stackList:\n sourcefile,line,function,text = stackData\n sepIndex = sourcefile.rfind(os.sep)\n if (sepIndex >=0 and Trace.SourceFileStyle == Trace.NameOnly):\n sourcefile = sourcefile[sepIndex+1:]\n #endIf\n if (text == None):\n stack = \"%s\\t%s(%s) [%s]\\n\" % (stack,sourcefile,line,function)\n else: \n stack = \"%s\\t%s(%s) [%s] - %s\\n\" % (stack,sourcefile,line,function,text)\n #endIf\n #endFor\n except:\n # This shouldn't happen, but in case it does...\n exc_type,exc_value = sys.exc_info()[:2]\n stack = \"%s\\tException getting exception stack. Type: %s, Value: %s\\n\" % (stack,exc_type,exc_value)\n #endTry\n\n # At the very end - put the exception string\n stack = \"%s\\t%s\" % (stack,exc)\n \n return stack","def lineno():\n return str(' - Principal - line number: '+str(inspect.currentframe().f_back.f_lineno))","def find_traceback_start(self):\n ### FILL IN ###","def lineno():\n linenum = inspect.currentframe().f_back.f_lineno\n frameinfo = inspect.getframeinfo(inspect.currentframe())\n filename = frameinfo.filename\n return str(\"File: \" + str(filename) + \" Line: \" + str(linenum))","def tidy_error(ex=None) -> str:\r\n from sys import exc_info\r\n from os.path import join, abspath, dirname\r\n from traceback import extract_tb, format_list, format_exception_only\r\n\r\n show = join(dirname(abspath(__file__)), '')\r\n\r\n def _check_file(name):\r\n return name and name.startswith(show)\r\n\r\n def _print(typ, value, tb): # If not debug, generator expression: filter trace to my files.\r\n show = extract_tb(tb) if DEBUG else (fs for fs in extract_tb(tb, limit=3) if _check_file(fs.filename))\r\n fmt = format_list(show) + format_exception_only(typ, value)\r\n return ''.join((f.strip('\"\\'').replace('\\\\n', '') for f in fmt))\r\n\r\n args = ex or exc_info()\r\n return _print(*args)","def lineno():\n return str(' - SecurityGroupIngressPortRangeRule - caller: '+str(inspect.stack()[1][3])+' - line number: '+str(inspect.currentframe().f_back.f_lineno))","def tb():\n etype, value, tb = sys.exc_info()\n return \"%s: %s (%s@%s:%d)\" % (etype.__name__, value, tb.tb_frame.f_code.co_name, os.path.basename(tb.tb_frame.f_code.co_filename), tb.tb_lineno)","def exceptionTraceback(self, alwaysPrint = False):\n self.logPre( traceback.format_exc(), alwaysPrint )","def trace_function(frame, event, arg):\n co = frame.f_code\n func_name = co.co_name\n if func_name == 'write':\n # Ignore write() calls from print statements\n return\n filename = co.co_filename\n if event == 'call':\n # decend into the stack...\n return trace_function\n elif event == 'return':\n if isinstance(arg, basestring) and 'inputlocator' in filename.lower() and not func_name.startswith('_'):\n results_set.add((func_name, arg))\n # print('%s => %s' % (func_name, arg))\n return","def debug(line):\n sys.stderr.write(line + \"\\n\")\n sys.stderr.flush()","def trace(string):\n if trace_enabled:\n print(string)","def lineno():\n return str(' - RDSInstanceMasterUserPasswordRule- caller: '+str(inspect.stack()[1][3])+' - line number: '+str(inspect.currentframe().f_back.f_lineno))","def error(*args, noContext: bool=True, showLineNumber: bool=True, **kwargs)->None:\n pass","def _debug_calc_error(self, line):\n debug(\"RPN Calculator Error: %s\" % line)","def _print_caller(self):\n import traceback\n print '\\n'.join(['%s:%d %s'%(f,l,c) for f,l,m,c in traceback.extract_stack()])","def _log(self,methodName,eventType,msg,exc=None): \n stackDump = None\n threadId = (\"%x\" % thread.get_ident()).rjust(12).replace(\" \",\"0\")\n traceString = \"%s %s %s %s\" % (self._getTimeStamp(),threadId,eventType,self.entityName)\n traceString = \"%s(%s) %s\" % (traceString,self._sourceLineNumber(),methodName)\n \n if (exc):\n # Get stack dump now to keep it with msg text\n if (Trace.StackTraceStyle == Trace.TopToBottom):\n stackDump = self._exceptionStackTTB(methodName,exc)\n elif (Trace.StackTraceStyle == Trace.BottomToTop):\n stackDump = self._exceptionStackBTT(methodName,exc)\n else:\n raise TraceConfigurationException(\"'%s', is not a valid stack trace style. Expected one of %s\" % (Trace.StackTraceStyle,Trace.StackTraceStyles))\n #endIf\n #endIf\n \n # If a logFile was provided then send all trace to trace log\n if (Trace.traceFile):\n # file IO is not thread safe\n # The Jython 2.1 that comes with WAS doesn't support the \"with\" statement.\n try:\n Trace.traceFileLock.acquire()\n if (stackDump):\n Trace.traceFile.write(\"%s : %s\\n%s\\n\" % (traceString, msg, stackDump))\n else:\n Trace.traceFile.write(\"%s : %s\\n\" % (traceString, msg))\n #endIf\n Trace.traceFile.flush()\n finally:\n Trace.traceFileLock.release()\n #endTry\n #endIf\n \n if (not Trace.traceFile or eventType in [\"S\", \"E\", \"W\", \"I\"]):\n # Send severe, error, warning and info trace to stdout\n if (stackDump):\n print \"%s : %s\\n%s\" % (traceString, msg, stackDump)\n else:\n print \"%s : %s\" % (traceString, msg)\n #endIf\n #endIf","def _errpos(self, fpos):\r\n filename, string = self._includestack[-1]\r\n return filename, srow(string, fpos), scol(string, fpos)","def file_name_check(file_name):\n # Please print out which line of the above program contains an error. E.g. if the bug is on line 4 then print 4\n # END OF CONTEXT\n print(\"9\")\n # END OF SOLUTION","def _get_debug_text(self, text):\n\n func = inspect.currentframe().f_back.f_back.f_code\n return \"{}: Function {} in {}:{}\".format(text, func.co_name, os.path.basename(func.co_filename), func.co_firstlineno)","def get_line(cls, frame, sys_context=None):\n\t\tcode = cls._dispatch_frame(frame)\n\n\t\tif not code: \n\t\t\treturn ''\n\t\t\n\t\treturn code.splitlines()[frame.f_lineno]","def trace(self, frame, event, arg):\n if event == \"call\":\n if frame.f_code.co_filename.startswith(\"<memory/\"):\n return self.tracerobot\n else:\n return None\n return trace","def print_error(error: str) -> None:\n # We get the 2nd item in the call stack to find where this function is called from\n frame = inspect.stack()[1]\n # We get the module of the caller\n module = inspect.getmodule(frame[0])\n if module is None:\n filename = \"Unknown\"\n else:\n # We get the file of the module\n filepath = module.__file__\n # We get the relative file path of the module\n filename = os.path.relpath(filepath)\n # We print the info with some color\n rich.print(f\"[bold underline red]ERROR:[/] [blue]({filename})[/] : {error}\")","def getframeinfo(frame, context=1):\r\n if istraceback(frame):\r\n lineno = frame.tb_lineno\r\n frame = frame.tb_frame\r\n else:\r\n lineno = frame.f_lineno\r\n if not isframe(frame):\r\n raise TypeError('{!r} is not a frame or traceback object'.format(frame))\r\n\r\n filename = getsourcefile(frame) or getfile(frame)\r\n if context > 0:\r\n start = lineno - 1 - context//2\r\n try:\r\n lines, lnum = findsource(frame)\r\n except IOError:\r\n lines = index = None\r\n else:\r\n start = max(start, 1)\r\n start = max(0, min(start, len(lines) - context))\r\n lines = lines[start:start+context]\r\n index = lineno - 1 - start\r\n else:\r\n lines = index = None\r\n\r\n return Traceback(filename, lineno, frame.f_code.co_name, lines, index)","def logline(msg):\n print msg","def lineno():\n return str(' - Statement - line number: '+str(inspect.currentframe().f_back.f_lineno))","def exception_handler(exctype, val, trace):\n logger.info(\n ''.join(traceback.format_exception(exctype, val, trace)))","def log_trace(self, msg):\n self.log(msg, level=LOG_TRACE)","def trace_line(self, frame, event, arg):\n\n self.active_frame = frame\n\n self.base_trace(frame, event, arg)","def trace(self, module, message):\n if self.log_level <= consts.LOG_LEVEL_TRACE:\n print(\"TRACE : %s: %s\" % (module, message))","def get_lineage_trace(self) -> str:\n # TODO why do we not want to store the results? The execution script will should stay the same\n # therefore we could cache the result.\n raise NotImplementedError","def print_debug(e):\n print '1', e.__doc__\n print '2', sys.exc_info()\n print '3', sys.exc_info()[0]\n print '4', sys.exc_info()[1]\n print '5', traceback.tb_lineno(sys.exc_info()[2])\n _, _, tb = sys.exc_info()\n print '6', traceback.print_tb(tb)","def _trace(self, message: str, level: Level = Level.DEBUG, exact: bool = False) -> None:\n if level > self._verbosity:\n return\n if exact:\n if level == self._verbosity:\n stderr(message)\n return\n if level <= Level.ERROR:\n stderr(\"error: %s\\n\" % message)\n elif level == Level.INFO:\n stderr(\"info: %s\\n\" % message)\n elif level >= Level.DEBUG:\n stderr(\"debug: %s\\n\" % message)","def user_line(self, frame):\r\n if \"__exc_tuple__\" in frame.f_locals:\r\n del frame.f_locals['__exc_tuple__']\r\n\r\n if self._wait_for_mainpyfile:\r\n if (self.mainpyfile != self.canonic(frame.f_code.co_filename)\r\n or frame.f_lineno <= 0):\r\n return\r\n self._wait_for_mainpyfile = False\r\n self.bottom_frame = frame\r\n\r\n if self.get_break(self.canonic(frame.f_code.co_filename), frame.f_lineno):\r\n self.current_bp = (\r\n self.canonic(frame.f_code.co_filename), frame.f_lineno)\r\n else:\r\n self.current_bp = None\r\n self.ui.update_breakpoints()\r\n\r\n self.interaction(frame)","def trace(fn):\n @functools.wraps(fn)\n def wrapped(*args, **kwds):\n global PREFIX\n reprs = [repr(e) for e in args]\n reprs += [repr(k) + '=' + repr(v) for k, v in kwds.items()]\n log('{0}({1})'.format(fn.__name__, ', '.join(reprs)) + ':')\n PREFIX += ' '\n try:\n result = fn(*args, **kwds)\n PREFIX = PREFIX[:-4]\n except Exception as e:\n log(fn.__name__ + ' exited via exception')\n PREFIX = PREFIX[:-4]\n raise\n # Here, print out the return value.\n log('{0}({1}) -> {2}'.format(fn.__name__, ', '.join(reprs), result))\n return result\n return wrapped","def record_line(self, frame, event, arg): # pylint: disable=unused-argument\n if event == 'line':\n if self.prev_timestamp:\n runtime = time.time() - self.prev_timestamp\n self.lines.append([self.prev_path, self.prev_lineno, runtime])\n self.prev_lineno = frame.f_lineno\n self.prev_path = frame.f_code.co_filename\n self.prev_timestamp = time.time()\n return self.record_line","def my_err_handler(traceback, exec_info):\n print \"Custom function invoked\"\n print \"Formatted exception\"\n print traceback.format_exc()\n print \"System exec info\"\n print exec_info\n exp_type, exp_value, exp_traceback = exec_info\n print \"String formatted exception\"\n print traceback.format_exception(exp_type, exp_value, exp_traceback)\n print \"End of custom function\"","def configureTrace(self,traceString):\n configureTrace(traceString)","def do_read_trace(self, arg):\n try:\n results = self.phil.read_trace()\n except KeyError as exc:\n print('Could not parse argument {}'.format(exc))\n except (TypeError, ValueError, SyntaxError) as exc:\n print(exc)\n else:\n if len(results) == 0:\n return\n headers = ['time', 'diff', 'source_diff', 'source', 'event']\n table_data = []\n diffs = []\n for event in results[\"data\"]:\n row_data = []\n for key_name in headers:\n if key_name == 'diff':\n diffs.append(event[key_name])\n row_data.append(event[key_name])\n table_data.append(row_data)\n print(tabulate(table_data, headers=headers, floatfmt=\".9f\"))\n\n try:\n if len(diffs) > 1:\n diffs = diffs[1:]\n print(\"\\nDifference Stats\")\n print(\" min: {:.9f}\".format(min(diffs)))\n print(\" max: {:.9f}\".format(max(diffs)))\n print(\" mean: {:.9f}\".format(sta.mean(diffs)))\n print(\" median: {:.9f}\".format(sta.median(diffs)))\n print(\" stdev: {:.9f}\".format(sta.stdev(diffs)))\n print(\"variance: {:.9f}\".format(sta.variance(diffs)))\n except ValueError:\n pass","def trace(self, *args, **kwargs): # real signature unknown\n pass","def get_trace_string(self):\n return (\"%s -> %s(0x%s) addr:0x%s\" %\n (self.instr_str, self.rd, self.rd_val, self.addr))","def lineno():\n return str(' - IpAddr - line number: '+str(inspect.currentframe().f_back.f_lineno))","def stack_trace(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:","def showtraceback(self,exc_tuple = None):\n\n # Though this won't be called by syntax errors in the input line,\n # there may be SyntaxError cases whith imported code.\n if exc_tuple is None:\n type, value, tb = sys.exc_info()\n else:\n type, value, tb = exc_tuple\n if type is SyntaxError:\n self.showsyntaxerror()\n else:\n sys.last_type = type\n sys.last_value = value\n sys.last_traceback = tb\n self.InteractiveTB()\n if self.InteractiveTB.call_pdb and self.has_readline:\n # pdb mucks up readline, fix it back\n self.readline.set_completer(self.Completer.complete)","def filename_line(skip: int = 2) -> Tuple[str, int]:\n stack = inspect.stack()\n start = skip\n parentframe = stack[start][0]\n\n filename = 'N/A'\n module = inspect.getmodule(parentframe)\n if module:\n filename = os.path.basename(os.path.realpath(module.__file__))\n\n return filename, parentframe.f_lineno","def _get_caller_detail(n=2):\n if not _show_caller_details:\n return None\n s = inspect.stack()[:n + 1]\n try:\n frame = s[n]\n try:\n return frame[1]\n # WARNING(dhellmann): Using frame.lineno to include the\n # line number in the return value causes some sort of\n # memory or stack corruption that manifests in values not\n # being cleaned up in the cfgfilter tests.\n # return '%s:%s' % (frame[1], frame[2])\n finally:\n del frame\n finally:\n del s","def with_traceback(self, tb): # real signature unknown; restored from __doc__\n pass","def trace(msg):\n import datetime\n print('[{:%Y-%m-%d %H:%M:%S}]: '.format(datetime.datetime.now()) + msg)","def instrument_fail(self, req, where):\n\n if where in req[\"file_details\"][\"backend_filename\"]:\n raise Exception(\"Instrumented Failure: %s\" % where)","def _clean_onerror(func, path, excinfo):\n print(\"%s encountered error when processing %s: %s\" % (func, path, excinfo))","def text(eparams, context=5):\n import os\n import types\n import time\n import traceback\n import linecache\n import inspect\n import pydoc\n\n etype, evalue, etb = eparams\n if isinstance(etype, types.ClassType):\n etype = etype.__name__\n pyver = 'Python ' + sys.version.split()[0] + ': ' + sys.executable\n date = time.ctime(time.time())\n head = \"%s\\n%s\\n%s\\n\" % (str(etype), pyver, date) + '''\nA problem occurred in a Python script. Here is the sequence of\nfunction calls leading up to the error, in the order they occurred.\n'''\n\n frames = []\n records = inspect.getinnerframes(etb, context)\n for frame, file, lnum, func, lines, index in records:\n file = file and os.path.abspath(file) or '?'\n args, varargs, varkw, locals = inspect.getargvalues(frame)\n call = ''\n if func != '?':\n call = 'in ' + func + \\\n inspect.formatargvalues(args, varargs, varkw, locals,\n formatvalue=lambda value: '=' + pydoc.text.repr(value))\n\n highlight = {}\n\n def reader(lnum=[lnum]):\n highlight[lnum[0]] = 1\n try:\n return linecache.getline(file, lnum[0])\n finally:\n lnum[0] += 1\n vars = scanvars(reader, frame, locals)\n\n rows = [' %s %s' % (file, call)]\n if index is not None:\n i = lnum - index\n for line in lines:\n num = '%5d ' % i\n rows.append(num + line.rstrip())\n i += 1\n\n done, dump = {}, []\n for name, where, value in vars:\n if name in done:\n continue\n done[name] = 1\n if value is not __UNDEF__:\n if where == 'global':\n name = 'global ' + name\n elif where == 'local':\n name = name\n else:\n name = where + name.split('.')[-1]\n dump.append('%s = %s' % (name, pydoc.text.repr(value)))\n else:\n dump.append(name + ' undefined')\n\n rows.append('\\n'.join(dump))\n frames.append('\\n%s\\n' % '\\n'.join(rows))\n\n exception = ['%s: %s' % (str(etype), str(evalue))]\n if isinstance(evalue, types.InstanceType):\n for name in dir(evalue):\n value = pydoc.text.repr(getattr(evalue, name))\n exception.append('\\n%s%s = %s' % (\" \" * 4, name, value))\n\n return head + ''.join(frames) + ''.join(exception) + '''\n\nThe above is a description of an error in a Python program. Here is\nthe original traceback:\n\n%s\n''' % ''.join(traceback.format_exception(etype, evalue, etb))","def parse_line_err(self, match):\n self.line = match.group(2)\n self.filename = match.group(1)\n self.message = match.group(4)\n self.keyword = match.group(3)\n\n self.fix_filename()\n self.fix_namespaces()\n self.fix_nonerrors()\n\n if self.message.strip() == \"ld returned 1 exit status\":\n self.error_type = \"Linking Error\"\n self.signal_eof = True\n return \"\"\n\n return_value = \"\"\n if self.filename is not None:\n return_value += \"{}:\".format(self.filename)\n if self.line is not None:\n return_value += \"{}: \".format(self.line)\n if self.keyword is not None:\n return_value += \"{}: \".format(self.keyword)\n if self.message is not None:\n return_value += self.message\n\n if return_value != \"\":\n return_value += \"\\n\"\n return return_value","def _extract_thread_stack_trace(\n self, thread: str, lines: List[str]\n ) -> Optional[List[str]]:\n thread_str = f\"Thread {thread} \"\n i: int = 0\n while i < len(lines) and thread_str not in lines[i]:\n i += 1\n if i != len(lines) and thread_str in lines[i]:\n j: int = i\n while j < len(lines) and lines[j] != \"\\n\":\n j += 1\n start = i - 1\n end = j\n return lines[start:end]\n return None","def find_backtrace(self):\n return [ft for ft in os.listdir(self.output_dir)\n if os.path.isfile(ft) and ft.startswith(\"Backtrace.\")]","def getLineInformation(line):\n \n pass","def trace(msg, minLevel=1):\n global verbose\n if verbose >= minLevel:\n tracePrint(msg)","def dbtrace_show_output(trace_object, output_file):\n\n pass","def handle_line(line):\n print line,\n\n line_parts = log_re.match(line).groupdict()\n action = line_parts['action']\n attacker = line_parts['attacker']\n\n (cmd, status, output) = interact(line_parts, method=opts.method)\n\n if status > 0:\n warnings.warn('IP %s (%s)' % (attacker, output), InteractionWarning)\n print '\\t%s FAILURE' % attacker\n else:\n print '\\t%s SUCCESS' % attacker\n \n print","def print_error(self, msg, line_num=False, errorFunc=SystemError):\n if line_num is False: line_num = self.line_num\n bad_line_ind = self.line_nums[line_num]\n\n err_msg = \"\\n\\n\\n############ ERROR #############\\n\"\n err_msg += \"Error in input_file '%s'\\n\\n---\\n\" % self.inp_filename\n err_msg += msg.strip(\"\\n\")\n err_msg += \"\\n---\\n\\nline number: %i\\n\" % self.line_nums[line_num]\n err_msg += f\"line: '{self.file_ltxt_orig[bad_line_ind]}'\"\n err_msg += \"\\n\"\n err_msg += f\"err id: {self.E_str}\"\n err_msg += \"\\n#################################\\n\\n\"\n raise errorFunc(err_msg)","def traceback(self):\r\n clean = self.raw_traceback\r\n lines = ['Traceback (most recent call last):\\n']\r\n lines += traceback.format_list(clean)\r\n msg = str(self.error)\r\n lines += traceback.format_exception_only(self.exc_info[0], msg)\r\n return ''.join(lines)[:-1]","def degsOutput(err, globalNameSpace):\n lineNumber = err.lineNumber\n columnNumber = err.columnNumber\n err.msg = '\\n' + err.msg + '\\n'\n print(err.msg, file=sys.stderr)\n if not lineNumber == None:\n positionReference = [\"Error caused at line %(lineNumber)i\" % locals()]\n if not columnNumber == None:\n positionReference.append(\", column %(columnNumber)i\" % locals())\n positionReference.append(\":\\n\")\n positionReference.append(globalNameSpace['inputScript'].splitlines(True)[lineNumber-1])\n if not columnNumber == None:\n positionReference.append(\" \"*(columnNumber-1) + \"^~~ here.\")\n print(''.join(positionReference) + '\\n', file=sys.stderr)\n if err.element:\n print(\"In element: \" + err.element.userUnderstandableXPath(), file=sys.stderr)\n else:\n print(\"Unknown element. Please report this error to %s\" % globalNameSpace['bugReportAddress'], file=sys.stderr)","def parse_stack_trace(self, it, line):\n events = []\n stack_traces = []\n\n while self.stack_trace_re.match(line):\n event = self.parse_stack_trace_line(line)\n if event:\n events.append(event)\n\n stack_traces.append(line)\n line = get_next(it)\n\n events.reverse()\n\n return stack_traces, events, line","def log_line(self, line):\n print '%s%s' % (LOG_LINE_PREFIX, line)","def stacktrace(self):\n stacktrace = self.StacktraceParser().Parse(\n self._raw_stacktrace,\n self._dependency_analyzer.regression_version_deps,\n signature=self.signature, top_n_frames=self._top_n_frames)\n if not stacktrace:\n logging.warning('Failed to parse the stacktrace %s',\n self._raw_stacktrace)\n return stacktrace","def ProcessLine(fn, filename, file_extension, clean_lines, line,\n include_state, function_state, nesting_state, error,\n extra_check_functions=[]):\n fn(filename, file_extension, clean_lines, line,\n include_state, function_state, nesting_state,\n makeErrorFn(error, [], [r'(.*)should be indented \\+1 space inside(.*)']),\n extra_check_functions=[])","def settrace(function): # real signature unknown; restored from __doc__\n pass","def handle_awful_failure(fail_text):\r\n if g.debug:\r\n import sys\r\n s = sys.exc_info()\r\n # reraise the original error with the original stack trace\r\n raise s[1], None, s[2]\r\n try:\r\n # log the traceback, and flag the \"path\" as the error location\r\n import traceback\r\n g.log.error(\"FULLPATH: %s\" % fail_text)\r\n g.log.error(traceback.format_exc())\r\n return redditbroke % fail_text\r\n except:\r\n # we are doomed. Admit defeat\r\n return \"This is an error that should never occur. You win.\"","def myHandleError(self, record):\n if raiseExceptions:\n ei = sys.exc_info()\n try:\n traceback.print_exception(ei[0], ei[1], ei[2], None, sys.stderr)\n except IOError:\n pass # see issue 5971\n finally:\n del ei\n raise","def myHandleError(self, record):\n if raiseExceptions:\n ei = sys.exc_info()\n try:\n traceback.print_exception(ei[0], ei[1], ei[2], None, sys.stderr)\n except IOError:\n pass # see issue 5971\n finally:\n del ei\n raise","def log_diagnostics(self, paths):\n\t\tpass","def dispatch_line(self, frame):\n if self.stop_here(frame) or self.break_here(frame):\n self.user_line(frame)\n if self.quitting: raise BdbQuit\n return self.trace_dispatch","def error(self, value='', line_before=False):\n self.errors += 1\n if line_before:\n print('\\n')\n print(Fore.RED + '!!! ' + value)","def log_error(e):\n\tprint(e)","def log_error(e):\n\tprint(e)","def log_error(self, fmt, *args):\r\n pass\r\n # log_error\r","def _show_err(self, msg, lineno, lexpos):\n # get the entire string we just tried to parse\n data = self.lexerObj.lexer.lexdata\n s = data.split('\\n')\n\n col = _find_column(data, lexpos)\n line = s[lineno-1]\n\n leader = 3*' '\n print \"-\"*72\n print \"cvx4py error on line %s:\" % lineno\n print leader, \"\"\">> %s \"\"\" % line.strip()\n print leader, \" \" + (\" \"*(col-1)) + \"^\"\n print\n print \"ERROR:\", msg\n print \"-\"*72","def format_debug(e):\n _, _, tb = sys.exc_info()\n return '1: {doc} \\n2: {exec_info} \\n3: {exec_0} \\n 4: {exec_1} \\n5: {lineno} \\n6: {stack}'.format(\n doc=e.__doc__,\n exec_info=sys.exc_info(),\n exec_0=sys.exc_info()[0],\n exec_1=sys.exc_info()[1],\n lineno=traceback.tb_lineno(sys.exc_info()[2]),\n stack=traceback.print_tb(tb))","def get_err_source_info(original_traceback=None) -> dict:\n try: # carefully try to get the actual place where the error happened\n if not original_traceback:\n original_traceback = sys.exc_info()[2] # class, exc, traceback\n first_call = traceback.extract_tb(original_traceback)[-1]\n return dict(\n src_module=first_call[0],\n src_linenr=first_call[1],\n src_func=first_call[2],\n src_code=first_call[3],\n )\n except Exception as e:\n current_app.warning(\n \"I was unable to retrieve error source information: %s.\" % str(e)\n )\n return dict(module=\"\", linenr=0, method=\"\", src_code=\"\")","def format_h5_backtrace(self, backtrace=None): # reliably restored by inspect\n pass","def show_error(self):\n logging.error('=> ', self.test_script_source.line)\n total_len = 0\n i = 0\n if self.test_script_source.current_pos <= self.test_script_source.total_num_seg:\n if i < self.test_script_source.current_pos - 1:\n total_len = total_len + len(self.test_script_source.line_segments[i])\n i += 1\n else:\n total_len = len(self.test_script_source.line)\n\n if self.test_script_source.current_pos > 1:\n logging.error('=> ', (' ' * (total_len + 1)) + '^')\n else:\n logging.error('=> ', (' ' * total_len) + '^')","def get_caller_context(depth=None, **kwarg):\r\n if TIK_ERROR_MSG.api_source_info is not None:\r\n return TIK_ERROR_MSG.api_source_info\r\n if depth is None:\r\n raise RuntimeError(\"There are two reasons for the error:\\n\"\r\n \"If it is called by the user, please register source\"\r\n \" info before entering decorators;\\n\"\r\n \"If it is an internal call, please specify \"\r\n \"the stack depth;\")\r\n additional_stack = kwarg.get('stack_depth', 0)\r\n depth += additional_stack\r\n if ERROR_MSG_LEVEL.err_msg_level == 0:\r\n caller = stack(depth)\r\n else:\r\n caller = current_frame(depth)\r\n return caller","def get_addr2line(traceback, binfile=\"\", search_dirs=[], shlib_db=None):\n tokens = traceback.split(\"+\")\n afile = tokens[0]\n thefile = \"\"\n if not afile:\n thefile = binfile\n else:\n if shlib_db and afile in shlib_db:\n thefile = shlib_db[afile]\n else:\n thefile = find_shlib(g_search_dirs, afile)\n verbose(\"decoding traceback: \" + traceback + \" file: \" + afile + \" => \" + str(thefile), LEVEL_1)\n if not thefile or not os.path.exists(thefile):\n verbose(\"Failed to decode because \" + afile + \" and \" + str(thefile) + \" do not exist!\", LEVEL_1)\n return traceback + \"\\n\"\n offset = tokens[1]\n elf_type = get_elf_type(thefile)\n verbose(thefile + \" elf_type: \" + elf_type, LEVEL_1)\n if elf_type == \"EXEC\":\n # Calculate absolute address for EXEC type binary, which is then fed to addr2line\n base_addr = get_elf_load_base_addr(thefile)\n verbose(\"The LOAD base address or the rounded down entry address is: \" + hex(base_addr), LEVEL_1)\n offset = hex(int(offset, 0) + base_addr)\n #print (\"the absolute address is: \" + offset)\n addr2line_prog = get_config_value(\"addr2line\")\n if not addr2line_prog:\n addr2line_prog = \"addr2line\"\n cmd = addr2line_prog + \" -f -i -e \" + cmd_quote(thefile) + \" \" + offset + \" || true\"\n verbose(\"The traceback decode cmd is: \" + cmd, LEVEL_1)\n output = subprocess.check_output(cmd, shell=True, universal_newlines=True, stderr=open(os.devnull, 'w'))\n return output","def addExceptionMessage(self, q, inst, traceback):\n self.fail('FAIL: Exception raised: %s' % inst)\n self.addMessage('')\n for line in traceback.format_exc().split('\\n'):\n self.addMessage(line)","def showDebugSource(self, fn, line):\n if not fn.startswith('<'):\n self.openSourceFile(fn, line)\n self.setFileLine(fn, line)","def on_error(self, exception):\n traceback.print_exc()","def report_next_line_error(\n self, context, column_number, line_number_delta=0, extra_error_information=None\n ):\n context.add_triggered_rule(\n context.scan_file,\n context.line_number + line_number_delta,\n column_number,\n self.get_details().plugin_id,\n self.get_details().plugin_name,\n self.get_details().plugin_description,\n extra_error_information,\n )"],"string":"[\n \"def trace():\\n import traceback, inspect\\n tb = sys.exc_info()[2]\\n tbinfo = traceback.format_tb(tb)[0]\\n filename = inspect.getfile(inspect.currentframe())\\n # script name + line number\\n line = tbinfo.split(\\\", \\\")[1]\\n # Get Python syntax error\\n #\\n synerror = traceback.format_exc().splitlines()[-1]\\n return line, filename, synerror\",\n \"def __call__(self, line):\\n marker = self.marker\\n stripped_line = line.strip()\\n if marker == stripped_line:\\n assert not self.traceback_section\\n self.traceback_section = True\\n # print(\\\"XXX: TRACEBACK-START\\\")\\n elif self.traceback_section:\\n matched = self.file_pattern.match(line)\\n if matched:\\n # matched_range = matched.regs[1]\\n filename = matched.groups()[0]\\n new_filename = posixpath_normpath(filename)\\n if new_filename != filename:\\n # print(\\\"XXX: %r => %r\\\" % (filename, new_filename))\\n line = line.replace(filename, new_filename)\\n elif not stripped_line or line[0].isalpha():\\n # -- DETECTED TRCAEBACK-END: exception-description\\n # print(\\\"XXX: TRACEBACK-END\\\")\\n self.traceback_section = False\\n return line\",\n \"def traceback(self):\",\n \"def format_backtrace(trace):\\n backtrace = []\\n for filename, line, func, _ in traceback.extract_tb(trace):\\n desc = {'file': filename,\\n 'line': line,\\n 'function': func,\\n 'text': _}\\n backtrace.append(desc)\\n return backtrace\",\n \"def gettrace(): # real signature unknown; restored from __doc__\\n pass\",\n \"def trace(context=1):\\r\\n return getinnerframes(sys.exc_info()[2], context)\",\n \"def trace(self, trace=...):\\n ...\",\n \"def report(self, line: int, where: str, message: str):\\n output = f'[line {line}] Error{where}: {message}'\\n print(output, file=sys.stderr)\\n self.had_error = True\",\n \"def handle_error():\\n print \\\"An error occurred. Trace:\\\\n\\\"\\n traceback.print_exc()\",\n \"def _exceptionStackTTB(self,methodName,exc,depth=10):\\n stack = \\\"\\\"\\n # Reconstruct the call stack from where the trace of the exception was initiated by invoking \\n # Trace.error() or Trace.severe().\\n stackList = traceback.extract_stack()\\n try:\\n for stackData in stackList:\\n sourcefile,line,function,text = stackData\\n if (sourcefile.endswith(\\\"Trace.py\\\") and (function == \\\"error\\\" or function == \\\"severe\\\")): break\\n sepIndex = sourcefile.rfind(os.sep)\\n if (sepIndex >=0 and Trace.SourceFileStyle == Trace.NameOnly):\\n sourcefile = sourcefile[sepIndex+1:]\\n #endIf\\n if (text == None):\\n if (not stack):\\n # Leave out the newline for the bottom line on the stack\\n stack = \\\"\\\\t%s(%s) [%s]\\\" % (sourcefile,line,function)\\n else:\\n stack = \\\"\\\\t%s(%s) [%s]\\\\n%s\\\" % (sourcefile,line,function,stack)\\n #endIf\\n else:\\n if (not stack):\\n # Leave out the newline for the bottom line on the stack\\n stack = \\\"\\\\t%s(%s) [%s] - %s\\\" % (sourcefile,line,function,text)\\n else:\\n stack = \\\"\\\\t%s(%s) [%s] - %s\\\\n%s\\\" % (sourcefile,line,function,text,stack)\\n #endIf\\n #endIf\\n #endFor\\n stack = \\\"\\\\tFrame stack (most recent call first):\\\\n%s\\\" % stack\\n except:\\n # This shouldn't happen, but in case it does...\\n exc_type,exc_value = sys.exc_info()[:2]\\n stack = \\\"\\\\tException getting frame stack. Type: %s, Value: %s\\\\n%s\\\" % (exc_type,exc_value,stack)\\n #endTry\\n\\n try:\\n tb = sys.exc_info()[2]\\n stackList = traceback.extract_tb(tb,depth)\\n for stackData in stackList:\\n sourcefile,line,function,text = stackData\\n sepIndex = sourcefile.rfind(os.sep)\\n if (sepIndex >=0 and Trace.SourceFileStyle == Trace.NameOnly):\\n sourcefile = sourcefile[sepIndex+1:]\\n #endIf\\n if (text == None):\\n stack = \\\"\\\\t%s(%s) [%s]\\\\n%s\\\" % (sourcefile,line,function,stack)\\n else:\\n stack = \\\"\\\\t%s(%s) [%s] - %s\\\\n%s\\\" % (sourcefile,line,function,text,stack)\\n #endIf\\n #endFor\\n stack = \\\"\\\\tException stack (most recent call first):\\\\n%s\\\" % stack\\n except:\\n # This shouldn't happen, but in case it does...\\n exc_type,exc_value = sys.exc_info()[:2]\\n stack = \\\"\\\\tException getting exception stack. Type: %s, Value: %s\\\\n%s\\\" % (exc_type,exc_value,stack)\\n #endTry\\n \\n # At the very top - put the exception string\\n stack = \\\"\\\\t%s\\\\n%s\\\" % (exc,stack)\\n \\n return stack\",\n \"def _parse_traceback(self, trace):\\n p_traceback = [ \\\"%s:%d:in `%s'\\\" % (filename, lineno, funcname) \\n for filename, lineno, funcname, _\\n in traceback.extract_tb(trace) ]\\n p_traceback.reverse()\\n\\n return p_traceback\",\n \"def extract_detail():\\r\\n tb = sys.exc_info()[-1]\\r\\n stk = traceback.extract_tb(tb, -1)[0]\\r\\n return \\\"{} in {} line num {} on line {} \\\".format(\\r\\n stk.name, stk.filename, stk.lineno, stk.line\\r\\n )\",\n \"def StandViz_ReportError( errorobj, args, Header = None ): # error reporting and traceback function\\n (MyPath, MyFile) = os.path.split( args[0] ) # retrieve filename and path of running python script\\n (MyBaseName, MyExt) = os.path.splitext( MyFile ) # separate basefilename from extension\\n errorfilename = \\\"{}.txt\\\".format(MyBaseName) # create new error filename based on base of script filename\\n ERRFILE = open( errorfilename, 'w' ) # open text file for writting\\n if( Header != None ): ERRFILE.write( '%s\\\\n' % Header ) # if Header defined, write Header to file\\n ERRFILE.write( \\\"Error running '{}'\\\\n\\\".format(MyFile) ) # write error message with filename\\n MyTrace = errorobj[2] # retrieve error object\\n while( MyTrace != None ): # loop through stack trace\\n (line, file, name) = ( MyTrace.tb_lineno, MyTrace.tb_frame.f_code.co_filename, MyTrace.tb_frame.f_code.co_name ) # extract line, file, and error name\\n F = open( file, 'r' ) # open source file of Python script\\n L = F.readlines() # read scripot source into memory\\n F.close() # close script file\\n code = L[line-1].strip() # extract line of source code that caused error\\n ERRFILE.write( \\\" File '{}', line {}, in {}\\\\n {}\\\\n\\\".format(file, line, name, code) ) # write filename, source code line, error name, and error code\\n MyTrace = MyTrace.tb_next # step to next level of call stack trace\\n ERRFILE.write( \\\"errorobj: {}\\\\n\\\".format(errorobj) ) # write error object and arguments for call\\n ERRFILE.write( \\\"Calling Argument Vector: {}\\\\n\\\".format(args) ) # write calling arguments\\n ERRFILE.close() # close text file with error stack trace\\n os.system( \\\"notepad.exe {}\\\".format(errorfilename) ) # display error log file with notepad.exe\",\n \"def localTraceback(self, alwaysPrint = False):\\n self.log( \\\"DEBUG TRACEBACK: \\\" )\\n for line in traceback.format_stack():\\n self.logPre( line, alwaysPrint )\",\n \"def lineno():\\n return \\\"line \\\" + str(inspect.currentframe().f_back.f_lineno) + \\\": \\\"\",\n \"def _exceptionStackBTT(self,methodName,exc,depth=10):\\n stack = \\\"\\\"\\n # Reconstruct the call stack from where the trace of the exception was initiated by invoking \\n # Trace.error() or Trace.severe().\\n stackList = traceback.extract_stack()\\n try:\\n stack = \\\"\\\\tFrame stack (most recent call last):\\\\n\\\"\\n for stackData in stackList:\\n sourcefile,line,function,text = stackData\\n if (sourcefile.endswith(\\\"Trace.py\\\") and (function == \\\"error\\\" or function == \\\"severe\\\")): break\\n sepIndex = sourcefile.rfind(os.sep)\\n if (sepIndex >=0 and Trace.SourceFileStyle == Trace.NameOnly):\\n sourcefile = sourcefile[sepIndex+1:]\\n #endIf\\n if (text == None):\\n stack = \\\"%s\\\\t%s(%s) [%s]\\\\n\\\" % (stack,sourcefile,line,function)\\n else:\\n stack = \\\"%s\\\\t%s(%s) [%s] - %s\\\\n\\\" % (stack,sourcefile,line,function,text)\\n #endIf\\n #endFor\\n except:\\n # This shouldn't happen, but in case it does...\\n exc_type,exc_value = sys.exc_info()[:2]\\n stack = \\\"%s\\\\n\\\\tException getting frame stack. Type: %s, Value: %s\\\" % (stack,exc_type,exc_value)\\n #endTry\\n \\n try:\\n stack = \\\"%s\\\\tException stack (most recent call last):\\\\n\\\" % stack\\n tb = sys.exc_info()[2]\\n stackList = traceback.extract_tb(tb,depth)\\n for stackData in stackList:\\n sourcefile,line,function,text = stackData\\n sepIndex = sourcefile.rfind(os.sep)\\n if (sepIndex >=0 and Trace.SourceFileStyle == Trace.NameOnly):\\n sourcefile = sourcefile[sepIndex+1:]\\n #endIf\\n if (text == None):\\n stack = \\\"%s\\\\t%s(%s) [%s]\\\\n\\\" % (stack,sourcefile,line,function)\\n else: \\n stack = \\\"%s\\\\t%s(%s) [%s] - %s\\\\n\\\" % (stack,sourcefile,line,function,text)\\n #endIf\\n #endFor\\n except:\\n # This shouldn't happen, but in case it does...\\n exc_type,exc_value = sys.exc_info()[:2]\\n stack = \\\"%s\\\\tException getting exception stack. Type: %s, Value: %s\\\\n\\\" % (stack,exc_type,exc_value)\\n #endTry\\n\\n # At the very end - put the exception string\\n stack = \\\"%s\\\\t%s\\\" % (stack,exc)\\n \\n return stack\",\n \"def lineno():\\n return str(' - Principal - line number: '+str(inspect.currentframe().f_back.f_lineno))\",\n \"def find_traceback_start(self):\\n ### FILL IN ###\",\n \"def lineno():\\n linenum = inspect.currentframe().f_back.f_lineno\\n frameinfo = inspect.getframeinfo(inspect.currentframe())\\n filename = frameinfo.filename\\n return str(\\\"File: \\\" + str(filename) + \\\" Line: \\\" + str(linenum))\",\n \"def tidy_error(ex=None) -> str:\\r\\n from sys import exc_info\\r\\n from os.path import join, abspath, dirname\\r\\n from traceback import extract_tb, format_list, format_exception_only\\r\\n\\r\\n show = join(dirname(abspath(__file__)), '')\\r\\n\\r\\n def _check_file(name):\\r\\n return name and name.startswith(show)\\r\\n\\r\\n def _print(typ, value, tb): # If not debug, generator expression: filter trace to my files.\\r\\n show = extract_tb(tb) if DEBUG else (fs for fs in extract_tb(tb, limit=3) if _check_file(fs.filename))\\r\\n fmt = format_list(show) + format_exception_only(typ, value)\\r\\n return ''.join((f.strip('\\\"\\\\'').replace('\\\\\\\\n', '') for f in fmt))\\r\\n\\r\\n args = ex or exc_info()\\r\\n return _print(*args)\",\n \"def lineno():\\n return str(' - SecurityGroupIngressPortRangeRule - caller: '+str(inspect.stack()[1][3])+' - line number: '+str(inspect.currentframe().f_back.f_lineno))\",\n \"def tb():\\n etype, value, tb = sys.exc_info()\\n return \\\"%s: %s (%s@%s:%d)\\\" % (etype.__name__, value, tb.tb_frame.f_code.co_name, os.path.basename(tb.tb_frame.f_code.co_filename), tb.tb_lineno)\",\n \"def exceptionTraceback(self, alwaysPrint = False):\\n self.logPre( traceback.format_exc(), alwaysPrint )\",\n \"def trace_function(frame, event, arg):\\n co = frame.f_code\\n func_name = co.co_name\\n if func_name == 'write':\\n # Ignore write() calls from print statements\\n return\\n filename = co.co_filename\\n if event == 'call':\\n # decend into the stack...\\n return trace_function\\n elif event == 'return':\\n if isinstance(arg, basestring) and 'inputlocator' in filename.lower() and not func_name.startswith('_'):\\n results_set.add((func_name, arg))\\n # print('%s => %s' % (func_name, arg))\\n return\",\n \"def debug(line):\\n sys.stderr.write(line + \\\"\\\\n\\\")\\n sys.stderr.flush()\",\n \"def trace(string):\\n if trace_enabled:\\n print(string)\",\n \"def lineno():\\n return str(' - RDSInstanceMasterUserPasswordRule- caller: '+str(inspect.stack()[1][3])+' - line number: '+str(inspect.currentframe().f_back.f_lineno))\",\n \"def error(*args, noContext: bool=True, showLineNumber: bool=True, **kwargs)->None:\\n pass\",\n \"def _debug_calc_error(self, line):\\n debug(\\\"RPN Calculator Error: %s\\\" % line)\",\n \"def _print_caller(self):\\n import traceback\\n print '\\\\n'.join(['%s:%d %s'%(f,l,c) for f,l,m,c in traceback.extract_stack()])\",\n \"def _log(self,methodName,eventType,msg,exc=None): \\n stackDump = None\\n threadId = (\\\"%x\\\" % thread.get_ident()).rjust(12).replace(\\\" \\\",\\\"0\\\")\\n traceString = \\\"%s %s %s %s\\\" % (self._getTimeStamp(),threadId,eventType,self.entityName)\\n traceString = \\\"%s(%s) %s\\\" % (traceString,self._sourceLineNumber(),methodName)\\n \\n if (exc):\\n # Get stack dump now to keep it with msg text\\n if (Trace.StackTraceStyle == Trace.TopToBottom):\\n stackDump = self._exceptionStackTTB(methodName,exc)\\n elif (Trace.StackTraceStyle == Trace.BottomToTop):\\n stackDump = self._exceptionStackBTT(methodName,exc)\\n else:\\n raise TraceConfigurationException(\\\"'%s', is not a valid stack trace style. Expected one of %s\\\" % (Trace.StackTraceStyle,Trace.StackTraceStyles))\\n #endIf\\n #endIf\\n \\n # If a logFile was provided then send all trace to trace log\\n if (Trace.traceFile):\\n # file IO is not thread safe\\n # The Jython 2.1 that comes with WAS doesn't support the \\\"with\\\" statement.\\n try:\\n Trace.traceFileLock.acquire()\\n if (stackDump):\\n Trace.traceFile.write(\\\"%s : %s\\\\n%s\\\\n\\\" % (traceString, msg, stackDump))\\n else:\\n Trace.traceFile.write(\\\"%s : %s\\\\n\\\" % (traceString, msg))\\n #endIf\\n Trace.traceFile.flush()\\n finally:\\n Trace.traceFileLock.release()\\n #endTry\\n #endIf\\n \\n if (not Trace.traceFile or eventType in [\\\"S\\\", \\\"E\\\", \\\"W\\\", \\\"I\\\"]):\\n # Send severe, error, warning and info trace to stdout\\n if (stackDump):\\n print \\\"%s : %s\\\\n%s\\\" % (traceString, msg, stackDump)\\n else:\\n print \\\"%s : %s\\\" % (traceString, msg)\\n #endIf\\n #endIf\",\n \"def _errpos(self, fpos):\\r\\n filename, string = self._includestack[-1]\\r\\n return filename, srow(string, fpos), scol(string, fpos)\",\n \"def file_name_check(file_name):\\n # Please print out which line of the above program contains an error. E.g. if the bug is on line 4 then print 4\\n # END OF CONTEXT\\n print(\\\"9\\\")\\n # END OF SOLUTION\",\n \"def _get_debug_text(self, text):\\n\\n func = inspect.currentframe().f_back.f_back.f_code\\n return \\\"{}: Function {} in {}:{}\\\".format(text, func.co_name, os.path.basename(func.co_filename), func.co_firstlineno)\",\n \"def get_line(cls, frame, sys_context=None):\\n\\t\\tcode = cls._dispatch_frame(frame)\\n\\n\\t\\tif not code: \\n\\t\\t\\treturn ''\\n\\t\\t\\n\\t\\treturn code.splitlines()[frame.f_lineno]\",\n \"def trace(self, frame, event, arg):\\n if event == \\\"call\\\":\\n if frame.f_code.co_filename.startswith(\\\"<memory/\\\"):\\n return self.tracerobot\\n else:\\n return None\\n return trace\",\n \"def print_error(error: str) -> None:\\n # We get the 2nd item in the call stack to find where this function is called from\\n frame = inspect.stack()[1]\\n # We get the module of the caller\\n module = inspect.getmodule(frame[0])\\n if module is None:\\n filename = \\\"Unknown\\\"\\n else:\\n # We get the file of the module\\n filepath = module.__file__\\n # We get the relative file path of the module\\n filename = os.path.relpath(filepath)\\n # We print the info with some color\\n rich.print(f\\\"[bold underline red]ERROR:[/] [blue]({filename})[/] : {error}\\\")\",\n \"def getframeinfo(frame, context=1):\\r\\n if istraceback(frame):\\r\\n lineno = frame.tb_lineno\\r\\n frame = frame.tb_frame\\r\\n else:\\r\\n lineno = frame.f_lineno\\r\\n if not isframe(frame):\\r\\n raise TypeError('{!r} is not a frame or traceback object'.format(frame))\\r\\n\\r\\n filename = getsourcefile(frame) or getfile(frame)\\r\\n if context > 0:\\r\\n start = lineno - 1 - context//2\\r\\n try:\\r\\n lines, lnum = findsource(frame)\\r\\n except IOError:\\r\\n lines = index = None\\r\\n else:\\r\\n start = max(start, 1)\\r\\n start = max(0, min(start, len(lines) - context))\\r\\n lines = lines[start:start+context]\\r\\n index = lineno - 1 - start\\r\\n else:\\r\\n lines = index = None\\r\\n\\r\\n return Traceback(filename, lineno, frame.f_code.co_name, lines, index)\",\n \"def logline(msg):\\n print msg\",\n \"def lineno():\\n return str(' - Statement - line number: '+str(inspect.currentframe().f_back.f_lineno))\",\n \"def exception_handler(exctype, val, trace):\\n logger.info(\\n ''.join(traceback.format_exception(exctype, val, trace)))\",\n \"def log_trace(self, msg):\\n self.log(msg, level=LOG_TRACE)\",\n \"def trace_line(self, frame, event, arg):\\n\\n self.active_frame = frame\\n\\n self.base_trace(frame, event, arg)\",\n \"def trace(self, module, message):\\n if self.log_level <= consts.LOG_LEVEL_TRACE:\\n print(\\\"TRACE : %s: %s\\\" % (module, message))\",\n \"def get_lineage_trace(self) -> str:\\n # TODO why do we not want to store the results? The execution script will should stay the same\\n # therefore we could cache the result.\\n raise NotImplementedError\",\n \"def print_debug(e):\\n print '1', e.__doc__\\n print '2', sys.exc_info()\\n print '3', sys.exc_info()[0]\\n print '4', sys.exc_info()[1]\\n print '5', traceback.tb_lineno(sys.exc_info()[2])\\n _, _, tb = sys.exc_info()\\n print '6', traceback.print_tb(tb)\",\n \"def _trace(self, message: str, level: Level = Level.DEBUG, exact: bool = False) -> None:\\n if level > self._verbosity:\\n return\\n if exact:\\n if level == self._verbosity:\\n stderr(message)\\n return\\n if level <= Level.ERROR:\\n stderr(\\\"error: %s\\\\n\\\" % message)\\n elif level == Level.INFO:\\n stderr(\\\"info: %s\\\\n\\\" % message)\\n elif level >= Level.DEBUG:\\n stderr(\\\"debug: %s\\\\n\\\" % message)\",\n \"def user_line(self, frame):\\r\\n if \\\"__exc_tuple__\\\" in frame.f_locals:\\r\\n del frame.f_locals['__exc_tuple__']\\r\\n\\r\\n if self._wait_for_mainpyfile:\\r\\n if (self.mainpyfile != self.canonic(frame.f_code.co_filename)\\r\\n or frame.f_lineno <= 0):\\r\\n return\\r\\n self._wait_for_mainpyfile = False\\r\\n self.bottom_frame = frame\\r\\n\\r\\n if self.get_break(self.canonic(frame.f_code.co_filename), frame.f_lineno):\\r\\n self.current_bp = (\\r\\n self.canonic(frame.f_code.co_filename), frame.f_lineno)\\r\\n else:\\r\\n self.current_bp = None\\r\\n self.ui.update_breakpoints()\\r\\n\\r\\n self.interaction(frame)\",\n \"def trace(fn):\\n @functools.wraps(fn)\\n def wrapped(*args, **kwds):\\n global PREFIX\\n reprs = [repr(e) for e in args]\\n reprs += [repr(k) + '=' + repr(v) for k, v in kwds.items()]\\n log('{0}({1})'.format(fn.__name__, ', '.join(reprs)) + ':')\\n PREFIX += ' '\\n try:\\n result = fn(*args, **kwds)\\n PREFIX = PREFIX[:-4]\\n except Exception as e:\\n log(fn.__name__ + ' exited via exception')\\n PREFIX = PREFIX[:-4]\\n raise\\n # Here, print out the return value.\\n log('{0}({1}) -> {2}'.format(fn.__name__, ', '.join(reprs), result))\\n return result\\n return wrapped\",\n \"def record_line(self, frame, event, arg): # pylint: disable=unused-argument\\n if event == 'line':\\n if self.prev_timestamp:\\n runtime = time.time() - self.prev_timestamp\\n self.lines.append([self.prev_path, self.prev_lineno, runtime])\\n self.prev_lineno = frame.f_lineno\\n self.prev_path = frame.f_code.co_filename\\n self.prev_timestamp = time.time()\\n return self.record_line\",\n \"def my_err_handler(traceback, exec_info):\\n print \\\"Custom function invoked\\\"\\n print \\\"Formatted exception\\\"\\n print traceback.format_exc()\\n print \\\"System exec info\\\"\\n print exec_info\\n exp_type, exp_value, exp_traceback = exec_info\\n print \\\"String formatted exception\\\"\\n print traceback.format_exception(exp_type, exp_value, exp_traceback)\\n print \\\"End of custom function\\\"\",\n \"def configureTrace(self,traceString):\\n configureTrace(traceString)\",\n \"def do_read_trace(self, arg):\\n try:\\n results = self.phil.read_trace()\\n except KeyError as exc:\\n print('Could not parse argument {}'.format(exc))\\n except (TypeError, ValueError, SyntaxError) as exc:\\n print(exc)\\n else:\\n if len(results) == 0:\\n return\\n headers = ['time', 'diff', 'source_diff', 'source', 'event']\\n table_data = []\\n diffs = []\\n for event in results[\\\"data\\\"]:\\n row_data = []\\n for key_name in headers:\\n if key_name == 'diff':\\n diffs.append(event[key_name])\\n row_data.append(event[key_name])\\n table_data.append(row_data)\\n print(tabulate(table_data, headers=headers, floatfmt=\\\".9f\\\"))\\n\\n try:\\n if len(diffs) > 1:\\n diffs = diffs[1:]\\n print(\\\"\\\\nDifference Stats\\\")\\n print(\\\" min: {:.9f}\\\".format(min(diffs)))\\n print(\\\" max: {:.9f}\\\".format(max(diffs)))\\n print(\\\" mean: {:.9f}\\\".format(sta.mean(diffs)))\\n print(\\\" median: {:.9f}\\\".format(sta.median(diffs)))\\n print(\\\" stdev: {:.9f}\\\".format(sta.stdev(diffs)))\\n print(\\\"variance: {:.9f}\\\".format(sta.variance(diffs)))\\n except ValueError:\\n pass\",\n \"def trace(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def get_trace_string(self):\\n return (\\\"%s -> %s(0x%s) addr:0x%s\\\" %\\n (self.instr_str, self.rd, self.rd_val, self.addr))\",\n \"def lineno():\\n return str(' - IpAddr - line number: '+str(inspect.currentframe().f_back.f_lineno))\",\n \"def stack_trace(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:\",\n \"def showtraceback(self,exc_tuple = None):\\n\\n # Though this won't be called by syntax errors in the input line,\\n # there may be SyntaxError cases whith imported code.\\n if exc_tuple is None:\\n type, value, tb = sys.exc_info()\\n else:\\n type, value, tb = exc_tuple\\n if type is SyntaxError:\\n self.showsyntaxerror()\\n else:\\n sys.last_type = type\\n sys.last_value = value\\n sys.last_traceback = tb\\n self.InteractiveTB()\\n if self.InteractiveTB.call_pdb and self.has_readline:\\n # pdb mucks up readline, fix it back\\n self.readline.set_completer(self.Completer.complete)\",\n \"def filename_line(skip: int = 2) -> Tuple[str, int]:\\n stack = inspect.stack()\\n start = skip\\n parentframe = stack[start][0]\\n\\n filename = 'N/A'\\n module = inspect.getmodule(parentframe)\\n if module:\\n filename = os.path.basename(os.path.realpath(module.__file__))\\n\\n return filename, parentframe.f_lineno\",\n \"def _get_caller_detail(n=2):\\n if not _show_caller_details:\\n return None\\n s = inspect.stack()[:n + 1]\\n try:\\n frame = s[n]\\n try:\\n return frame[1]\\n # WARNING(dhellmann): Using frame.lineno to include the\\n # line number in the return value causes some sort of\\n # memory or stack corruption that manifests in values not\\n # being cleaned up in the cfgfilter tests.\\n # return '%s:%s' % (frame[1], frame[2])\\n finally:\\n del frame\\n finally:\\n del s\",\n \"def with_traceback(self, tb): # real signature unknown; restored from __doc__\\n pass\",\n \"def trace(msg):\\n import datetime\\n print('[{:%Y-%m-%d %H:%M:%S}]: '.format(datetime.datetime.now()) + msg)\",\n \"def instrument_fail(self, req, where):\\n\\n if where in req[\\\"file_details\\\"][\\\"backend_filename\\\"]:\\n raise Exception(\\\"Instrumented Failure: %s\\\" % where)\",\n \"def _clean_onerror(func, path, excinfo):\\n print(\\\"%s encountered error when processing %s: %s\\\" % (func, path, excinfo))\",\n \"def text(eparams, context=5):\\n import os\\n import types\\n import time\\n import traceback\\n import linecache\\n import inspect\\n import pydoc\\n\\n etype, evalue, etb = eparams\\n if isinstance(etype, types.ClassType):\\n etype = etype.__name__\\n pyver = 'Python ' + sys.version.split()[0] + ': ' + sys.executable\\n date = time.ctime(time.time())\\n head = \\\"%s\\\\n%s\\\\n%s\\\\n\\\" % (str(etype), pyver, date) + '''\\nA problem occurred in a Python script. Here is the sequence of\\nfunction calls leading up to the error, in the order they occurred.\\n'''\\n\\n frames = []\\n records = inspect.getinnerframes(etb, context)\\n for frame, file, lnum, func, lines, index in records:\\n file = file and os.path.abspath(file) or '?'\\n args, varargs, varkw, locals = inspect.getargvalues(frame)\\n call = ''\\n if func != '?':\\n call = 'in ' + func + \\\\\\n inspect.formatargvalues(args, varargs, varkw, locals,\\n formatvalue=lambda value: '=' + pydoc.text.repr(value))\\n\\n highlight = {}\\n\\n def reader(lnum=[lnum]):\\n highlight[lnum[0]] = 1\\n try:\\n return linecache.getline(file, lnum[0])\\n finally:\\n lnum[0] += 1\\n vars = scanvars(reader, frame, locals)\\n\\n rows = [' %s %s' % (file, call)]\\n if index is not None:\\n i = lnum - index\\n for line in lines:\\n num = '%5d ' % i\\n rows.append(num + line.rstrip())\\n i += 1\\n\\n done, dump = {}, []\\n for name, where, value in vars:\\n if name in done:\\n continue\\n done[name] = 1\\n if value is not __UNDEF__:\\n if where == 'global':\\n name = 'global ' + name\\n elif where == 'local':\\n name = name\\n else:\\n name = where + name.split('.')[-1]\\n dump.append('%s = %s' % (name, pydoc.text.repr(value)))\\n else:\\n dump.append(name + ' undefined')\\n\\n rows.append('\\\\n'.join(dump))\\n frames.append('\\\\n%s\\\\n' % '\\\\n'.join(rows))\\n\\n exception = ['%s: %s' % (str(etype), str(evalue))]\\n if isinstance(evalue, types.InstanceType):\\n for name in dir(evalue):\\n value = pydoc.text.repr(getattr(evalue, name))\\n exception.append('\\\\n%s%s = %s' % (\\\" \\\" * 4, name, value))\\n\\n return head + ''.join(frames) + ''.join(exception) + '''\\n\\nThe above is a description of an error in a Python program. Here is\\nthe original traceback:\\n\\n%s\\n''' % ''.join(traceback.format_exception(etype, evalue, etb))\",\n \"def parse_line_err(self, match):\\n self.line = match.group(2)\\n self.filename = match.group(1)\\n self.message = match.group(4)\\n self.keyword = match.group(3)\\n\\n self.fix_filename()\\n self.fix_namespaces()\\n self.fix_nonerrors()\\n\\n if self.message.strip() == \\\"ld returned 1 exit status\\\":\\n self.error_type = \\\"Linking Error\\\"\\n self.signal_eof = True\\n return \\\"\\\"\\n\\n return_value = \\\"\\\"\\n if self.filename is not None:\\n return_value += \\\"{}:\\\".format(self.filename)\\n if self.line is not None:\\n return_value += \\\"{}: \\\".format(self.line)\\n if self.keyword is not None:\\n return_value += \\\"{}: \\\".format(self.keyword)\\n if self.message is not None:\\n return_value += self.message\\n\\n if return_value != \\\"\\\":\\n return_value += \\\"\\\\n\\\"\\n return return_value\",\n \"def _extract_thread_stack_trace(\\n self, thread: str, lines: List[str]\\n ) -> Optional[List[str]]:\\n thread_str = f\\\"Thread {thread} \\\"\\n i: int = 0\\n while i < len(lines) and thread_str not in lines[i]:\\n i += 1\\n if i != len(lines) and thread_str in lines[i]:\\n j: int = i\\n while j < len(lines) and lines[j] != \\\"\\\\n\\\":\\n j += 1\\n start = i - 1\\n end = j\\n return lines[start:end]\\n return None\",\n \"def find_backtrace(self):\\n return [ft for ft in os.listdir(self.output_dir)\\n if os.path.isfile(ft) and ft.startswith(\\\"Backtrace.\\\")]\",\n \"def getLineInformation(line):\\n \\n pass\",\n \"def trace(msg, minLevel=1):\\n global verbose\\n if verbose >= minLevel:\\n tracePrint(msg)\",\n \"def dbtrace_show_output(trace_object, output_file):\\n\\n pass\",\n \"def handle_line(line):\\n print line,\\n\\n line_parts = log_re.match(line).groupdict()\\n action = line_parts['action']\\n attacker = line_parts['attacker']\\n\\n (cmd, status, output) = interact(line_parts, method=opts.method)\\n\\n if status > 0:\\n warnings.warn('IP %s (%s)' % (attacker, output), InteractionWarning)\\n print '\\\\t%s FAILURE' % attacker\\n else:\\n print '\\\\t%s SUCCESS' % attacker\\n \\n print\",\n \"def print_error(self, msg, line_num=False, errorFunc=SystemError):\\n if line_num is False: line_num = self.line_num\\n bad_line_ind = self.line_nums[line_num]\\n\\n err_msg = \\\"\\\\n\\\\n\\\\n############ ERROR #############\\\\n\\\"\\n err_msg += \\\"Error in input_file '%s'\\\\n\\\\n---\\\\n\\\" % self.inp_filename\\n err_msg += msg.strip(\\\"\\\\n\\\")\\n err_msg += \\\"\\\\n---\\\\n\\\\nline number: %i\\\\n\\\" % self.line_nums[line_num]\\n err_msg += f\\\"line: '{self.file_ltxt_orig[bad_line_ind]}'\\\"\\n err_msg += \\\"\\\\n\\\"\\n err_msg += f\\\"err id: {self.E_str}\\\"\\n err_msg += \\\"\\\\n#################################\\\\n\\\\n\\\"\\n raise errorFunc(err_msg)\",\n \"def traceback(self):\\r\\n clean = self.raw_traceback\\r\\n lines = ['Traceback (most recent call last):\\\\n']\\r\\n lines += traceback.format_list(clean)\\r\\n msg = str(self.error)\\r\\n lines += traceback.format_exception_only(self.exc_info[0], msg)\\r\\n return ''.join(lines)[:-1]\",\n \"def degsOutput(err, globalNameSpace):\\n lineNumber = err.lineNumber\\n columnNumber = err.columnNumber\\n err.msg = '\\\\n' + err.msg + '\\\\n'\\n print(err.msg, file=sys.stderr)\\n if not lineNumber == None:\\n positionReference = [\\\"Error caused at line %(lineNumber)i\\\" % locals()]\\n if not columnNumber == None:\\n positionReference.append(\\\", column %(columnNumber)i\\\" % locals())\\n positionReference.append(\\\":\\\\n\\\")\\n positionReference.append(globalNameSpace['inputScript'].splitlines(True)[lineNumber-1])\\n if not columnNumber == None:\\n positionReference.append(\\\" \\\"*(columnNumber-1) + \\\"^~~ here.\\\")\\n print(''.join(positionReference) + '\\\\n', file=sys.stderr)\\n if err.element:\\n print(\\\"In element: \\\" + err.element.userUnderstandableXPath(), file=sys.stderr)\\n else:\\n print(\\\"Unknown element. Please report this error to %s\\\" % globalNameSpace['bugReportAddress'], file=sys.stderr)\",\n \"def parse_stack_trace(self, it, line):\\n events = []\\n stack_traces = []\\n\\n while self.stack_trace_re.match(line):\\n event = self.parse_stack_trace_line(line)\\n if event:\\n events.append(event)\\n\\n stack_traces.append(line)\\n line = get_next(it)\\n\\n events.reverse()\\n\\n return stack_traces, events, line\",\n \"def log_line(self, line):\\n print '%s%s' % (LOG_LINE_PREFIX, line)\",\n \"def stacktrace(self):\\n stacktrace = self.StacktraceParser().Parse(\\n self._raw_stacktrace,\\n self._dependency_analyzer.regression_version_deps,\\n signature=self.signature, top_n_frames=self._top_n_frames)\\n if not stacktrace:\\n logging.warning('Failed to parse the stacktrace %s',\\n self._raw_stacktrace)\\n return stacktrace\",\n \"def ProcessLine(fn, filename, file_extension, clean_lines, line,\\n include_state, function_state, nesting_state, error,\\n extra_check_functions=[]):\\n fn(filename, file_extension, clean_lines, line,\\n include_state, function_state, nesting_state,\\n makeErrorFn(error, [], [r'(.*)should be indented \\\\+1 space inside(.*)']),\\n extra_check_functions=[])\",\n \"def settrace(function): # real signature unknown; restored from __doc__\\n pass\",\n \"def handle_awful_failure(fail_text):\\r\\n if g.debug:\\r\\n import sys\\r\\n s = sys.exc_info()\\r\\n # reraise the original error with the original stack trace\\r\\n raise s[1], None, s[2]\\r\\n try:\\r\\n # log the traceback, and flag the \\\"path\\\" as the error location\\r\\n import traceback\\r\\n g.log.error(\\\"FULLPATH: %s\\\" % fail_text)\\r\\n g.log.error(traceback.format_exc())\\r\\n return redditbroke % fail_text\\r\\n except:\\r\\n # we are doomed. Admit defeat\\r\\n return \\\"This is an error that should never occur. You win.\\\"\",\n \"def myHandleError(self, record):\\n if raiseExceptions:\\n ei = sys.exc_info()\\n try:\\n traceback.print_exception(ei[0], ei[1], ei[2], None, sys.stderr)\\n except IOError:\\n pass # see issue 5971\\n finally:\\n del ei\\n raise\",\n \"def myHandleError(self, record):\\n if raiseExceptions:\\n ei = sys.exc_info()\\n try:\\n traceback.print_exception(ei[0], ei[1], ei[2], None, sys.stderr)\\n except IOError:\\n pass # see issue 5971\\n finally:\\n del ei\\n raise\",\n \"def log_diagnostics(self, paths):\\n\\t\\tpass\",\n \"def dispatch_line(self, frame):\\n if self.stop_here(frame) or self.break_here(frame):\\n self.user_line(frame)\\n if self.quitting: raise BdbQuit\\n return self.trace_dispatch\",\n \"def error(self, value='', line_before=False):\\n self.errors += 1\\n if line_before:\\n print('\\\\n')\\n print(Fore.RED + '!!! ' + value)\",\n \"def log_error(e):\\n\\tprint(e)\",\n \"def log_error(e):\\n\\tprint(e)\",\n \"def log_error(self, fmt, *args):\\r\\n pass\\r\\n # log_error\\r\",\n \"def _show_err(self, msg, lineno, lexpos):\\n # get the entire string we just tried to parse\\n data = self.lexerObj.lexer.lexdata\\n s = data.split('\\\\n')\\n\\n col = _find_column(data, lexpos)\\n line = s[lineno-1]\\n\\n leader = 3*' '\\n print \\\"-\\\"*72\\n print \\\"cvx4py error on line %s:\\\" % lineno\\n print leader, \\\"\\\"\\\">> %s \\\"\\\"\\\" % line.strip()\\n print leader, \\\" \\\" + (\\\" \\\"*(col-1)) + \\\"^\\\"\\n print\\n print \\\"ERROR:\\\", msg\\n print \\\"-\\\"*72\",\n \"def format_debug(e):\\n _, _, tb = sys.exc_info()\\n return '1: {doc} \\\\n2: {exec_info} \\\\n3: {exec_0} \\\\n 4: {exec_1} \\\\n5: {lineno} \\\\n6: {stack}'.format(\\n doc=e.__doc__,\\n exec_info=sys.exc_info(),\\n exec_0=sys.exc_info()[0],\\n exec_1=sys.exc_info()[1],\\n lineno=traceback.tb_lineno(sys.exc_info()[2]),\\n stack=traceback.print_tb(tb))\",\n \"def get_err_source_info(original_traceback=None) -> dict:\\n try: # carefully try to get the actual place where the error happened\\n if not original_traceback:\\n original_traceback = sys.exc_info()[2] # class, exc, traceback\\n first_call = traceback.extract_tb(original_traceback)[-1]\\n return dict(\\n src_module=first_call[0],\\n src_linenr=first_call[1],\\n src_func=first_call[2],\\n src_code=first_call[3],\\n )\\n except Exception as e:\\n current_app.warning(\\n \\\"I was unable to retrieve error source information: %s.\\\" % str(e)\\n )\\n return dict(module=\\\"\\\", linenr=0, method=\\\"\\\", src_code=\\\"\\\")\",\n \"def format_h5_backtrace(self, backtrace=None): # reliably restored by inspect\\n pass\",\n \"def show_error(self):\\n logging.error('=> ', self.test_script_source.line)\\n total_len = 0\\n i = 0\\n if self.test_script_source.current_pos <= self.test_script_source.total_num_seg:\\n if i < self.test_script_source.current_pos - 1:\\n total_len = total_len + len(self.test_script_source.line_segments[i])\\n i += 1\\n else:\\n total_len = len(self.test_script_source.line)\\n\\n if self.test_script_source.current_pos > 1:\\n logging.error('=> ', (' ' * (total_len + 1)) + '^')\\n else:\\n logging.error('=> ', (' ' * total_len) + '^')\",\n \"def get_caller_context(depth=None, **kwarg):\\r\\n if TIK_ERROR_MSG.api_source_info is not None:\\r\\n return TIK_ERROR_MSG.api_source_info\\r\\n if depth is None:\\r\\n raise RuntimeError(\\\"There are two reasons for the error:\\\\n\\\"\\r\\n \\\"If it is called by the user, please register source\\\"\\r\\n \\\" info before entering decorators;\\\\n\\\"\\r\\n \\\"If it is an internal call, please specify \\\"\\r\\n \\\"the stack depth;\\\")\\r\\n additional_stack = kwarg.get('stack_depth', 0)\\r\\n depth += additional_stack\\r\\n if ERROR_MSG_LEVEL.err_msg_level == 0:\\r\\n caller = stack(depth)\\r\\n else:\\r\\n caller = current_frame(depth)\\r\\n return caller\",\n \"def get_addr2line(traceback, binfile=\\\"\\\", search_dirs=[], shlib_db=None):\\n tokens = traceback.split(\\\"+\\\")\\n afile = tokens[0]\\n thefile = \\\"\\\"\\n if not afile:\\n thefile = binfile\\n else:\\n if shlib_db and afile in shlib_db:\\n thefile = shlib_db[afile]\\n else:\\n thefile = find_shlib(g_search_dirs, afile)\\n verbose(\\\"decoding traceback: \\\" + traceback + \\\" file: \\\" + afile + \\\" => \\\" + str(thefile), LEVEL_1)\\n if not thefile or not os.path.exists(thefile):\\n verbose(\\\"Failed to decode because \\\" + afile + \\\" and \\\" + str(thefile) + \\\" do not exist!\\\", LEVEL_1)\\n return traceback + \\\"\\\\n\\\"\\n offset = tokens[1]\\n elf_type = get_elf_type(thefile)\\n verbose(thefile + \\\" elf_type: \\\" + elf_type, LEVEL_1)\\n if elf_type == \\\"EXEC\\\":\\n # Calculate absolute address for EXEC type binary, which is then fed to addr2line\\n base_addr = get_elf_load_base_addr(thefile)\\n verbose(\\\"The LOAD base address or the rounded down entry address is: \\\" + hex(base_addr), LEVEL_1)\\n offset = hex(int(offset, 0) + base_addr)\\n #print (\\\"the absolute address is: \\\" + offset)\\n addr2line_prog = get_config_value(\\\"addr2line\\\")\\n if not addr2line_prog:\\n addr2line_prog = \\\"addr2line\\\"\\n cmd = addr2line_prog + \\\" -f -i -e \\\" + cmd_quote(thefile) + \\\" \\\" + offset + \\\" || true\\\"\\n verbose(\\\"The traceback decode cmd is: \\\" + cmd, LEVEL_1)\\n output = subprocess.check_output(cmd, shell=True, universal_newlines=True, stderr=open(os.devnull, 'w'))\\n return output\",\n \"def addExceptionMessage(self, q, inst, traceback):\\n self.fail('FAIL: Exception raised: %s' % inst)\\n self.addMessage('')\\n for line in traceback.format_exc().split('\\\\n'):\\n self.addMessage(line)\",\n \"def showDebugSource(self, fn, line):\\n if not fn.startswith('<'):\\n self.openSourceFile(fn, line)\\n self.setFileLine(fn, line)\",\n \"def on_error(self, exception):\\n traceback.print_exc()\",\n \"def report_next_line_error(\\n self, context, column_number, line_number_delta=0, extra_error_information=None\\n ):\\n context.add_triggered_rule(\\n context.scan_file,\\n context.line_number + line_number_delta,\\n column_number,\\n self.get_details().plugin_id,\\n self.get_details().plugin_name,\\n self.get_details().plugin_description,\\n extra_error_information,\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7392801","0.7135186","0.6529018","0.63906014","0.6296253","0.6159555","0.6074369","0.6055162","0.6053701","0.60512197","0.60511047","0.60449284","0.6025194","0.5981327","0.5965538","0.592666","0.5902943","0.5831507","0.580618","0.5780158","0.57784814","0.57647014","0.5753568","0.5750067","0.5749855","0.5743602","0.57275677","0.57223684","0.57033956","0.57029104","0.5697544","0.5690092","0.568533","0.56794834","0.56768554","0.56722647","0.56659317","0.5658137","0.56529206","0.5645151","0.5626171","0.56129295","0.56121814","0.56075066","0.5604556","0.5601082","0.55999154","0.5582503","0.5544587","0.55318636","0.552164","0.55152524","0.5492879","0.54899037","0.54861367","0.54846215","0.5483101","0.5479823","0.5477309","0.54702896","0.54634887","0.54480475","0.54472756","0.54454714","0.544275","0.544184","0.54409266","0.5438819","0.5426612","0.54259","0.5423951","0.5410504","0.54096586","0.5409225","0.5399472","0.53978556","0.5396943","0.53968686","0.5394926","0.53930175","0.53849334","0.5378057","0.5378057","0.53736264","0.53674847","0.5367169","0.5365625","0.5365625","0.53635585","0.53543454","0.5348614","0.5345943","0.5341363","0.5340771","0.5337111","0.53295404","0.53262603","0.5325475","0.53171486","0.53160095"],"string":"[\n \"0.7392801\",\n \"0.7135186\",\n \"0.6529018\",\n \"0.63906014\",\n \"0.6296253\",\n \"0.6159555\",\n \"0.6074369\",\n \"0.6055162\",\n \"0.6053701\",\n \"0.60512197\",\n \"0.60511047\",\n \"0.60449284\",\n \"0.6025194\",\n \"0.5981327\",\n \"0.5965538\",\n \"0.592666\",\n \"0.5902943\",\n \"0.5831507\",\n \"0.580618\",\n \"0.5780158\",\n \"0.57784814\",\n \"0.57647014\",\n \"0.5753568\",\n \"0.5750067\",\n \"0.5749855\",\n \"0.5743602\",\n \"0.57275677\",\n \"0.57223684\",\n \"0.57033956\",\n \"0.57029104\",\n \"0.5697544\",\n \"0.5690092\",\n \"0.568533\",\n \"0.56794834\",\n \"0.56768554\",\n \"0.56722647\",\n \"0.56659317\",\n \"0.5658137\",\n \"0.56529206\",\n \"0.5645151\",\n \"0.5626171\",\n \"0.56129295\",\n \"0.56121814\",\n \"0.56075066\",\n \"0.5604556\",\n \"0.5601082\",\n \"0.55999154\",\n \"0.5582503\",\n \"0.5544587\",\n \"0.55318636\",\n \"0.552164\",\n \"0.55152524\",\n \"0.5492879\",\n \"0.54899037\",\n \"0.54861367\",\n \"0.54846215\",\n \"0.5483101\",\n \"0.5479823\",\n \"0.5477309\",\n \"0.54702896\",\n \"0.54634887\",\n \"0.54480475\",\n \"0.54472756\",\n \"0.54454714\",\n \"0.544275\",\n \"0.544184\",\n \"0.54409266\",\n \"0.5438819\",\n \"0.5426612\",\n \"0.54259\",\n \"0.5423951\",\n \"0.5410504\",\n \"0.54096586\",\n \"0.5409225\",\n \"0.5399472\",\n \"0.53978556\",\n \"0.5396943\",\n \"0.53968686\",\n \"0.5394926\",\n \"0.53930175\",\n \"0.53849334\",\n \"0.5378057\",\n \"0.5378057\",\n \"0.53736264\",\n \"0.53674847\",\n \"0.5367169\",\n \"0.5365625\",\n \"0.5365625\",\n \"0.53635585\",\n \"0.53543454\",\n \"0.5348614\",\n \"0.5345943\",\n \"0.5341363\",\n \"0.5340771\",\n \"0.5337111\",\n \"0.53295404\",\n \"0.53262603\",\n \"0.5325475\",\n \"0.53171486\",\n \"0.53160095\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7310826"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":3286,"cells":{"query":{"kind":"string","value":"Validates and ensures output workspace exists"},"document":{"kind":"string","value":"def validate_workspace(wrksp):\n try:\n if wrksp.lower().endswith('.gdb') and \\\n os.path.isdir(wrksp) == False:\n return arcpy.CreateFileGDB_management(out_folder_path=os.path.dirname(wrksp),\n out_name=os.path.basename(wrksp))[0]\n elif wrksp.lower().endswith('.sde') and \\\n os.path.isfile(wrksp) == False:\n raise ValueError(\"SDE workspace must exist before using it.\")\n elif os.path.isdir(wrksp) == False:\n os.makedirs(wrksp)\n return wrksp\n else:\n return wrksp\n except:\n line, filename, synerror = trace()\n raise FunctionError(\n {\n \"function\": \"validate_workspace\",\n \"line\": line,\n \"filename\": filename,\n \"synerror\": synerror,\n \"arc\" : str(arcpy.GetMessages(2))\n }\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 test_missing_output_workspace(self):\n manifest = copy.deepcopy(job_test_utils.COMPLETE_MANIFEST)\n config = copy.deepcopy(self.configuration)\n config['output_workspaces'] = {}\n json_data = {\n 'manifest': manifest,\n 'configuration': config\n }\n\n url = '/%s/job-types/validation/' % self.api\n response = self.client.generic('POST', url, json.dumps(json_data), 'application/json')\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n results = json.loads(response.content)\n self.assertFalse(results['is_valid'])\n self.assertEqual(len(results['errors']), 1)\n self.assertEqual(results['errors'][0]['name'], 'MISSING_WORKSPACE')","def check_output(self):\n directory, file = split(self.target)\n if not exists(directory):\n mkdir(directory)\n if exists(self.target):\n unlink(self.target)","def test_invalid_output_workspace(self):\n manifest = copy.deepcopy(job_test_utils.COMPLETE_MANIFEST)\n config = copy.deepcopy(self.configuration)\n config['output_workspaces'] = {\n 'default': 'bad_name'\n }\n json_data = {\n 'manifest': manifest,\n 'configuration': config\n }\n\n url = '/%s/job-types/validation/' % self.api\n response = self.client.generic('POST', url, json.dumps(json_data), 'application/json')\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n results = json.loads(response.content)\n self.assertFalse(results['is_valid'])\n self.assertEqual(len(results['errors']), 1)\n self.assertEqual(results['errors'][0]['name'], 'INVALID_WORKSPACE')","def test_create_workspace():\n\n bambi = create_test_bambi()\n bambi.create_workspace(bambi.name)\n success = check_workspace_existance(bambi)\n\n assert success","def make_sure_path_exists(out_path):\n try:\n os.makedirs(out_path)\n except OSError as exception:\n if exception.errno != errno.EEXIST:\n print \"Errors in output folder path! please change the output path or analysis name\\n\"\n exit()","def test_deprecated_output_workspace(self):\n manifest = copy.deepcopy(job_test_utils.COMPLETE_MANIFEST)\n config = copy.deepcopy(self.configuration)\n config['output_workspaces'] = {\n 'default': 'inactive'\n }\n json_data = {\n 'manifest': manifest,\n 'configuration': config\n }\n\n url = '/%s/job-types/validation/' % self.api\n response = self.client.generic('POST', url, json.dumps(json_data), 'application/json')\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n results = json.loads(response.content)\n self.assertTrue(results['is_valid'])\n self.assertEqual(len(results['warnings']), 1)\n self.assertEqual(results['warnings'][0]['name'], 'DEPRECATED_WORKSPACE')","def test_check_if_output_file_exists():\n input_file = os.path.join(os.getcwd(), 'tests', 'input_test_file.docx')\n output_file = os.path.join(os.getcwd(), 'tests', 'output_test_file.txt')\n\n questions_parser = QuestionsParser()\n questions_parser.main(argv=['-i', input_file, '-o', output_file])\n assert os.path.exists(output_file)\n os.unlink(output_file)","def test_init_does_not_create(self):\n self.logger.info(\"STEP: Initialize the workspace library.\")\n self.workspace = Workspace(Mock())\n\n self.logger.info(\n \"STEP: Verify that the workspace library did not create a workspace \"\n \"directory.\"\n )\n self.assertFalse(Path.cwd().joinpath(\"workspace\").exists())","def test_not_ready_if_insufficient_output_space(self):\n self.command.package = self.input_ovf\n\n self.command.ui.default_confirm_response = False\n # Make working directory requirements negligible but output huge\n with mock.patch.object(self.command,\n \"working_dir_disk_space_required\",\n return_value=0), \\\n mock.patch.object(self.command.vm,\n 'predicted_output_size',\n return_value=(1 << 60)):\n ready, reason = self.command.ready_to_run()\n\n self.assertFalse(ready)\n self.assertRegex(reason, \"Insufficient disk space available\"\n \" to guarantee successful output\")\n\n # User can opt to continue anyway\n self.command.ui.default_confirm_response = True\n self.command._cached_disk_requirements.clear()\n with mock.patch.object(self.command,\n \"working_dir_disk_space_required\",\n return_value=0), \\\n mock.patch.object(self.command.vm,\n 'predicted_output_size',\n return_value=(1 << 60)):\n ready, reason = self.command.ready_to_run()\n\n self.assertTrue(ready)","def check_workspace ():\n\n try:\n ex (\"cd $DOC_ROOT/ACE_TAO && git pull -p\")\n print (\"Successfully updated ACE/TAO working copy\")\n except:\n print (\"Unable to update ACE/TAO workspace at \" + doc_root)\n raise\n\n try:\n ex (\"cd $DOC_ROOT/MPC && git pull -p\")\n print (\"Successfully updated MPC working copy to revision \")\n except:\n print (\"Unable to update the MPC workspace at \" + doc_root + \"/ACE/MPC\")\n raise\n\n vprint (\"Repos root URL = \" + opts.repo_root + \"\\n\")\n vprint (\"Repos MPC root URL = \" + opts.mpc_root + \"\\n\")","def __manage_output_folder(self):\n if not os.path.exists(self.output_folder):\n os.makedirs(self.output_folder)","def test_output_exists():\n global out_dir, cor_dir\n assert(path.exists(path.join(out_dir, 'oshea_similarity.json')))","def check_for_preexisting_output_file(output_file_path):\n if path.exists(f\"{output_file_path}\"):\n print(\"Output file at specified save location file path already exists!\")\n print(\"Aborting operation!\")\n sys.exit()","def validate(cls, output_destination):\n # nothing to check :)\n pass","def validate(cls, output_destination):\n # nothing to check :)\n pass","def _check_save_directory_path(self):\n if self.save_directory_path is not None:\n if os.path.exists(self.save_directory_path):\n raise ValueError(\n 'You must provide non-existing save output directory, '\n '{} given.'.format(self.save_directory_path))\n else:\n os.makedirs(self.save_directory_path)","def validate(self):\n self.__log('Validating whether all conditions are met.')\n if not self.config['OUT_FOLDER'] or not self.config['OUTPUT_FOLDER']:\n self.__log('The path to the output folder cannot be found.', 'error')\n raise FileNotFoundError\n\n try:\n if '.' in self.output_filename:\n self.__log('The output filename should not contain an extension.', 'error')\n raise ValueError\n except TypeError:\n pass\n\n if not self.output_filename:\n self.__log('The output filename has not been specified.', 'warning')\n self.output_filename = self.hash_time()\n i = 0\n while self.output_file_exists():\n self.__log('Adding a unique identifier to current filename.', 'warning')\n self.output_filename = self.output_filename + '-' + i\n i += 1\n self.__log(f'Continuing with file: \"{self.output_filename}\"', 'success')\n\n # Iterate over options to check for required parameters, as to not waste requests\n self.__log('Starting to check if all required parameters are set')\n for key, value in self.options.items():\n if key in self.config['REQUIRED_PARAMETERS'] and not value:\n self.__log(f'Missing a required parameter: {key}', 'error')\n raise MissingRequiredParameterError(key)\n\n self.__log('All validation successful.', 'success')","def setup_molecule_output_check(exp_builder_db, mol_id, output_path):\n exp_builder_db._setup_molecules(mol_id)\n assert os.path.exists(output_path)\n assert os.path.getsize(output_path) > 0","def env_check(self):\n b_status : bool = True\n str_error : str = \"no error\"\n if not os.path.exists(self.str_inputDir):\n b_status = False\n if self.toConsole():\n error.warn(self, 'inputDirFail', exitToOS = True, drawBox = True)\n str_error = 'error captured while accessing input directory'\n return {\n 'status' : b_status,\n 'error' : str_error\n }","def check_build_exists(self):\n path = self.base_dir + \"/\" + self.app_name + \"/\" + \"build\"\n from django_swagger_utils.core.utils.check_path_exists import check_path_exists\n build_dir = check_path_exists(path)\n if build_dir:\n raise Exception(\"Build Directory Already Exist, please run update_specs_build\")","def _validate_output_file_path(file_path: str):\n file_dir = os.path.dirname(file_path)\n if not os.path.isdir(file_dir):\n try:\n os.makedirs(file_dir)\n except Exception as e:\n utils.error(f\"Failed to create parent directory {file_dir} for file {file_path}. Reason: {e}\")\n if not os.access(file_dir, os.W_OK):\n utils.error(f\"Cannot write file: {file_path}. {file_dir} is not writeable.\")","def check(self):\n super().check()\n\n # scratch directory\n if 'ORTHO' not in PATH:\n setattr(PATH, 'ORTHO', join(PATH.SCRATCH, 'ortho'))","def init(self):\n\n self.checkDirectory(self.output_dir,\"output\")\n self.checkDirectory(self.working_dir,\"working\")","def validate(self):\n variables = ['waterThickness', 'waterPressure']\n compare_variables(test_case=self, variables=variables,\n filename1='full_run/output.nc',\n filename2='restart_run/output.nc')","def _check_before_run(self):\n if not osp.exists(self.root):\n raise RuntimeError(\"'{}' is not available\".format(self.root))\n if not osp.exists(self.train_name_path):\n raise RuntimeError(\"'{}' is not available\".format(self.train_name_path))\n if not osp.exists(self.test_name_path):\n raise RuntimeError(\"'{}' is not available\".format(self.test_name_path))\n if not osp.exists(self.track_train_info_path):\n raise RuntimeError(\"'{}' is not available\".format(self.track_train_info_path))\n if not osp.exists(self.track_test_info_path):\n raise RuntimeError(\"'{}' is not available\".format(self.track_test_info_path))\n if not osp.exists(self.query_IDX_path):\n raise RuntimeError(\"'{}' is not available\".format(self.query_IDX_path))","def check_out_dir_exists(out_dir):\n if not os.path.isdir(out_dir):\n os.makedirs(out_dir)","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.data_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.data_dir))\n if not osp.exists(self.split_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.split_dir))","def check_config(outconfig):\n self.log.info(\"Checking if all the necessary files exist.\")\n\n # Perform necessary checks\n\n log.info(\"All necessary files exist for {} configuration.\".format(outconfig[\"Flavor\"]))\n\n return","def __check_exist_path(self):\n if 'path_out' not in self.params:\n raise ValueError('missing \"path_out\" among parameters')\n self.params['path_out'] = update_path(self.params.get('path_out'))\n list_names = [n for n in self.params if any(m in n.lower() for m in ['path', 'dir', 'file'])]\n for n in list_names:\n p = os.path.abspath(os.path.expanduser(self.params[n]))\n if not os.path.exists(p):\n raise FileNotFoundError('given path/file/dir \"%s\" does not exist!' % p)\n self.params[n] = p\n for n in [n for n in self.params if 'exec' in n]:\n # in case you define executable in your home\n if os.path.expanduser(self.params[n]) != self.params[n]:\n self.params[n] = os.path.expanduser(self.params[n])","def ensure_dirs_exists(self):\n os.makedirs(os.path.join(self.location, \"batches\"), exist_ok=True)\n os.makedirs(os.path.join(self.location, \"results\"), exist_ok=True)","def sanity_check(loadfile, queryfile):\n if not os.path.exists(loadfile):\n print(\"Error: The path for the load csv file does not exist\")\n return False\n\n if not os.path.exists(queryfile): \n print(\"Error: The path for the query csv file does not exist\")\n return False\n\n\n \"\"\"\n if not os.path.exists(\"/plots\"):\n os.mkdir(\"/plots\")\n \"\"\" \n return True","def check_outpath(self, outpath):\n if not os.path.isdir(outpath+str(self.ar_no)):\n ar_outpath = os.path.join(outpath,str(self.ar_no))\n ar_outpath_video = os.path.join(outpath,str(self.ar_no)+'_video')\n os.makedirs(ar_outpath)\n os.makedirs(ar_outpath_video)\n print(\"Path does not exist, create: \")\n print(ar_outpath)\n print(ar_outpath_video)","def check_filesystem():\n if FLAGS.continue_run:\n # start a new run, set flag to continue, so there is nothing\n # check if something there, if not, create, but don't delete\n if not tf.gfile.Exists(FLAGS.summaries_dir):\n tf.gfile.MakeDirs(FLAGS.summaries_dir)\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'train'))\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'validation'))\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'test'))\n if not tf.gfile.Exists(FLAGS.checkpoint_dir):\n tf.gfile.MakeDirs(FLAGS.checkpoint_dir)\n else:\n # delete checkpoints and event summaries because training restarted\n if tf.gfile.Exists(FLAGS.summaries_dir):\n tf.gfile.DeleteRecursively(FLAGS.summaries_dir)\n tf.gfile.MakeDirs(FLAGS.summaries_dir)\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'train'))\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'validation'))\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'test'))\n if tf.gfile.Exists(FLAGS.checkpoint_dir):\n tf.gfile.DeleteRecursively(FLAGS.checkpoint_dir)\n tf.gfile.MakeDirs(FLAGS.checkpoint_dir)","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.data_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.data_dir))\n if not osp.exists(self.raw_mat_path):\n raise RuntimeError(\"'{}' is not available\".format(self.raw_mat_path))\n if not osp.exists(self.split_new_det_mat_path):\n raise RuntimeError(\"'{}' is not available\".format(self.split_new_det_mat_path))\n if not osp.exists(self.split_new_lab_mat_path):\n raise RuntimeError(\"'{}' is not available\".format(self.split_new_lab_mat_path))","def check_some_assertions():\n if FLAGS.input_width is None:\n FLAGS.input_width = FLAGS.input_height\n if FLAGS.output_width is None:\n FLAGS.output_width = FLAGS.output_height\n\n if not os.path.exists(FLAGS.checkpoint_dir):\n os.makedirs(FLAGS.checkpoint_dir)\n if not os.path.exists(FLAGS.sample_dir):\n os.makedirs(FLAGS.sample_dir)","def check_some_assertions():\n if FLAGS.input_width is None:\n FLAGS.input_width = FLAGS.input_height\n if FLAGS.output_width is None:\n FLAGS.output_width = FLAGS.output_height\n\n if not os.path.exists(FLAGS.checkpoint_dir):\n os.makedirs(FLAGS.checkpoint_dir)\n if not os.path.exists(FLAGS.sample_dir):\n os.makedirs(FLAGS.sample_dir)","def test_check_process_output(self):\n workflow = self.get_workflow(\n \"\"\"file://result <- file://source\n echo test\n \"\"\")\n workflow.pre_check_processes()\n try:\n process = workflow._processes[0]\n create_tuttle_dirs()\n workflow.run_process(process)\n assert False, \"Exception has not been not raised\"\n except ResourceError:\n assert True","def flush_outputs():\n try:\n shutil.rmtree(ROOT_OUTPUT_DIR)\n print(\"Removed directory '{}'!\".format(ROOT_OUTPUT_DIR))\n return True\n except FileNotFoundError:\n print(\"Directory '{}' already removed!\".format(ROOT_OUTPUT_DIR))\n return False","def test_set_output_invalid(self):\n # Nonexistent output location, regardless of package\n with self.assertRaises(InvalidInputError):\n self.command.output = \"/foo/bar/baz\"\n\n self.command.package = self.input_ovf\n # Nonexistent output location with package set\n with self.assertRaises(InvalidInputError):\n self.command.output = \"/foo/bar/baz.ova\"\n\n # Output to directory instead of file (currently unsupported)\n with self.assertRaises(InvalidInputError):\n self.command.output = self.temp_dir\n\n # Output to \"directory\" under a file\n with self.assertRaises(InvalidInputError):\n self.command.output = os.path.join(self.input_ovf, \"foo.ova\")","def check_xshear_output(self):\n lens_nchunk=self['lens_conf']['nchunk']\n tilenames=scat.get_tilenames(self['source_conf']['scat_table'])\n\n ntile=len(tilenames)\n for lens_chunk in xrange(lens_nchunk):\n print(\" checking chunk: %d/%d\" % (lens_chunk+1, lens_nchunk))\n for i,tilename in enumerate(tilenames):\n # first check if this source catalog exists\n if self._scat_exists(tilename):\n job=XShearWQJob(self['run'],\n lens_chunk,\n tilename)\n info=job.get_info()\n if not os.path.exists(info['output_file']):\n print(\"missing output:\",info['output_file'])","def sanity_check_step(self):\n custom_paths = {\n 'files': ['bin/bazel'],\n 'dirs': [],\n }\n super(EB_Bazel, self).sanity_check_step(custom_paths=custom_paths)","def _validate_init_args(self):\n\n if self.outdir.exists() and not self.outdir.is_dir():\n raise Error(f\"path '{self.outdir}' already exists and it is not a directory\")\n\n # Ensure that results are compatible.\n rname, rver = self._refinfo[\"toolname\"], self._refinfo[\"toolver\"]\n for res in self.rsts:\n name, ver = res.info[\"toolname\"], res.info[\"toolver\"]\n if name != rname:\n raise Error(f\"the following test results are not compatible:\\n\"\n f\"1. {self._refres.dirpath}: created by '{rname}'\\n\"\n f\"2. {res.dirpath}: created by '{name}'\\n\"\n f\"Cannot put incompatible results to the same report\")\n if ver != rver:\n _LOG.warning(\"the following test results may be not compatible:\\n\"\n \"1. %s: created by '%s' version '%s'\\n\"\n \"2. %s: created by '%s' version '%s'\",\n self._refres.dirpath, rname, rver, res.dirpath, name, ver)\n\n # Ensure the report IDs are unique.\n reportids = set()\n for res in self.rsts:\n reportid = res.reportid\n if reportid in reportids:\n # Try to construct a unique report ID.\n for idx in range(1, 20):\n new_reportid = f\"{reportid}-{idx:02}\"\n if new_reportid not in reportids:\n _LOG.warning(\"duplicate reportid '%s', using '%s' instead\",\n reportid, new_reportid)\n res.reportid = new_reportid\n break\n else:\n raise Error(f\"too many duplicate report IDs, e.g., '{reportid}' is problematic\")\n\n reportids.add(res.reportid)\n\n if self.title_descr and Path(self.title_descr).is_file():\n try:\n with open(self.title_descr, \"r\") as fobj:\n self.title_descr = fobj.read()\n except OSError as err:\n raise Error(f\"failed to read the report description file {self.title_descr}: {err}\")\n\n for res in self.rsts:\n if res.dirpath.resolve() == self.outdir.resolve():\n # Don't create report in results directory, use 'html-report' subdirectory instead.\n self.outdir = self.outdir.joinpath(\"html-report\")","def validate_run_results(input_file_parameters, dir_stack):\r\n prev_command_had_output_dir = True\r\n dir_stack_index = -1\r\n command_index = 0\r\n for current_command in input_file_parameters.commands:\r\n # Skip over SPLIT commands\r\n if current_command == 'SPLIT':\r\n continue\r\n\r\n command_index += 1\r\n\r\n if prev_command_had_output_dir:\r\n dir_stack_index += 1\r\n\r\n # Keep track of number of commands created in the current workflow step\r\n number_of_successful_commands = 0\r\n\r\n # Infer command type, parameters, input and output directories\r\n command_type, command_parameters = \\\r\n utils.parse_staplefile_command_line(current_command)\r\n in_dir = dir_stack[dir_stack_index]\r\n if command_type.require_output_dir:\r\n out_dir = dir_stack[dir_stack_index+1]\r\n prev_command_had_output_dir = True\r\n else:\r\n out_dir = in_dir\r\n prev_command_had_output_dir = False\r\n\r\n # Read files until command class finds no more valid input files\r\n number_of_potential_commands = 0\r\n while True:\r\n try:\r\n # The command instance is generated without exceptions if the\r\n # command execution has failed (i.e. expected output\r\n # file does not exist). Otherwise NewFileError is raised.\r\n current_command = command_type(command_parameters, in_dir, out_dir)\r\n except STAPLERerror.NewFileExists:\r\n number_of_successful_commands += 1\r\n number_of_potential_commands += 1\r\n continue\r\n except STAPLERerror.VirtualIOError:\r\n break\r\n number_of_potential_commands += 1\r\n\r\n # Print validation results\r\n if not number_of_successful_commands:\r\n print '{0} command (step number {1}) has not been run.' \\\r\n .format(command_type.name, command_index)\r\n continue\r\n if number_of_successful_commands == number_of_potential_commands:\r\n print '{0} command (step number {1}) has been run succesfully.' \\\r\n .format(command_type.name, command_index)\r\n else:\r\n print '{0} command (step number {1}) workflows have failed {2}/{3} times' \\\r\n .format(command_type.name, command_index,\r\n number_of_potential_commands - number_of_successful_commands,\r\n number_of_potential_commands)","def ensure_out_dir(out_dir):\n if not os.path.isdir(out_dir):\n os.makedirs(out_dir)","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.train_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n if not osp.exists(self.query_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.query_dir))\n if not osp.exists(self.gallery_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.gallery_dir))","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.train_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n if not osp.exists(self.query_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.query_dir))\n if not osp.exists(self.gallery_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.gallery_dir))","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.train_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n if not osp.exists(self.query_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.query_dir))\n if not osp.exists(self.gallery_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.gallery_dir))","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.train_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n if not osp.exists(self.query_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.query_dir))\n if not osp.exists(self.gallery_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.gallery_dir))","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.train_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n if not osp.exists(self.query_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.query_dir))\n if not osp.exists(self.gallery_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.gallery_dir))","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.train_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n if not osp.exists(self.query_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.query_dir))\n if not osp.exists(self.gallery_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.gallery_dir))","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.train_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n if not osp.exists(self.query_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.query_dir))\n if not osp.exists(self.gallery_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.gallery_dir))","def __validate(self):\n self.report(self.name).receive_info_from_gui(self.tournament.get())\n msg.showinfo(title=None, message=self.message_path_to_folder)\n self.master.master.launch()\n self.master.destroy()","def current_dir_ok() :\n\n current_ok = True\n\n current_dir = str(os.environ['PWD'])\n expected_dir = str(os.path.abspath(out_dir))\n\n if not current_dir == expected_dir :\n print \"ERROR current directory (%s) is not the output directory for the ntuples (%s)\"%(current_dir, expected_dir)\n current_ok = False\n\n return current_ok","def _check_numpy_output(self, cwd):\n\n for ii, refname in enumerate(self.files):\n if self.forms[ii] == \"numpy\":\n try:\n ref_output = np.loadtxt(\n Path(cwd) / refname, usecols=self.usecol[ii]\n )\n except IOError:\n raise IOError(\n 'Please provide a reference properties output named \"{}\"'.format(\n refname\n )\n )\n except ValueError:\n raise ValueError(\n \"Please check ref_simulation.out in {}\".format(\n str((self.parent / cwd).absolute())\n )\n )\n\n fname = refname[4:]\n test_output = np.loadtxt(self.tmp_dir / fname, usecols=self.usecol[ii])\n\n try:\n np.testing.assert_allclose(\n test_output, ref_output, rtol=1.0e-7, atol=1.0e-15\n )\n # print(\"No anomaly during the regtest for {}\".format(refname))\n except AssertionError:\n raise AssertionError(\n \"ANOMALY: Disagreement between reference and {} in {}\".format(\n fname, str((self.parent / cwd).absolute())\n )\n )","def test_outputs_not_created(self):\n one_process_workflow = \"\"\"file://B <- file://A\n echo A does not produce B\n \"\"\"\n process = run_first_process(one_process_workflow)\n assert process.success is False, process.error_message\n assert process.error_message.find(\"these resources should have been created\") >= 0, process.error_message\n assert process.error_message.find(\"* file://B\") >= 0, process.error_message","def test_make_output_folder_blank_path(self):\n test_object = Maic()\n expected_result = \"\"\n self.assertEqual(expected_result,\n test_object.make_output_folder(output_folder=\"\"),\n \"Should get back an empty string for an output \"\n \"folder specified as ''\")","def sanity_check_step(self):\n custom_paths = {\n 'files':[\"%s/%s\" % (self.bindir, x) for x in [\"convert\", \"cplex\", \"cplexamp\"]],\n 'dirs':[],\n }\n super(EB_CPLEX, self).sanity_check_step(custom_paths=custom_paths)","def test_make_output_folder_undefined_path(self):\n test_object = Maic()\n expected_result = \"\"\n self.assertEqual(expected_result,\n test_object.make_output_folder(output_folder=None),\n \"Should get back an empty string for an undefined \"\n \"output folder\")","def validate(ctx):\n handler = ValidateCommandHandler(ctx.obj['qa_dir'])\n exit(0 if handler.validate() else 1)","def workspace_exists(client, workspace):\n data = {\"workspace\": workspace}\n return client._creoson_post(\"windchill\", \"workspace_exists\", data, \"exists\")","def _check_before_run(self):\n\t\tif not osp.exists(self.dataset_dir):\n\t\t\traise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n\t\tif not osp.exists(self.train_dir):\n\t\t\traise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n\t\tif not osp.exists(self.query_dir):\n\t\t\traise RuntimeError(\"'{}' is not available\".format(self.query_dir))\n\t\tif not osp.exists(self.gallery_dir):\n\t\t\traise RuntimeError(\"'{}' is not available\".format(self.gallery_dir))","def check_dest_root(self):\n dest_root = self.view.folder_line.text()\n if not os.path.isdir(dest_root):\n try:\n os.makedirs(dest_root)\n except (WindowsError, TypeError):\n self.view.message.setText('Please input a valid folder path.')\n return False\n return True","def test_invalid_workspace(self):\n self.assertFalse(\n cifuzz.build_fuzzers(\n EXAMPLE_PROJECT,\n 'oss-fuzz',\n 'not/a/dir',\n commit_sha='0b95fe1039ed7c38fea1f97078316bfc1030c523',\n ))","def test_failedCommandProvidesOutput(self):\n bookTeX = FilePath(self.mktemp() + \".tex\")\n builder = BookBuilder()\n inputState = bookTeX.parent().children()\n exc = self.assertRaises(\n CommandFailed,\n builder.buildPDF,\n bookTeX, self.howtoDir, FilePath(self.mktemp()))\n self.assertTrue(exc.output)\n newOutputState = set(bookTeX.parent().children()) - set(inputState)\n self.assertEqual(len(newOutputState), 1)\n workPath = newOutputState.pop()\n self.assertTrue(\n workPath.isdir(),\n \"Expected work path %r was not a directory.\" % (workPath.path,))","def prepare_run(input_path: str, output_path: str, tmp: str) -> None:\n input_file_exists(input_path)\n if os.path.isdir(output_path) and len(os.listdir(output_path)) != 0:\n raise AssertionError(\"output folder must be empty or non-existent.\")\n set_tempdir(tmp)\n os.makedirs(output_path, exist_ok=True)","def ensure_data_folder_existence() -> None:\n folder_name = params.DATA_FOLDER_NAME\n if not folder_name in os.listdir('.'):\n os.mkdir(folder_name)","def __init_output_folder():\n try:\n os.makedirs(Result.__json_dir)\n except OSError as e:\n if e.errno != errno.EEXIST:\n raise e","def _check_before_run(self):\r\n if not osp.exists(self.dataset_dir):\r\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\r\n if not osp.exists(self.train_dir):\r\n raise RuntimeError(\"'{}' is not available\".format(self.train_dir))","def ensure_exists(output_dir):\n try:\n makedirs(output_dir)\n except OSError:\n if not isdir(output_dir):\n raise","def santityCheckInitialization(self):\r\n\r\n for obj in self.config[\"repos\"]:\r\n if not isdir(obj[\"path\"]):\r\n print(\"ERROR : Initialization Failed missing {} at path {}\".format(obj[\"name\"], obj[\"path\"]))","def check_working_directory():\n if not os.path.exists(CUCKOO_ROOT):\n raise CuckooStartupError(\"You specified a non-existing root directory: %s\" % CUCKOO_ROOT)\n\n cwd = os.path.join(os.getcwd(), \"cuckoo.py\")\n if not os.path.exists(cwd):\n raise CuckooStartupError(\"You are not running Cuckoo from it's root directory\")","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.train_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n if not osp.exists(self.list_query_path):\n raise RuntimeError(\"'{}' is not available\".format(self.list_query_path))\n if not osp.exists(self.list_gallery_path):\n raise RuntimeError(\"'{}' is not available\".format(self.list_gallery_path))","def check_for_setup_error(self):\n if self.share2nms:\n for nfs_share in self.share2nms:\n nms = self.share2nms[nfs_share]\n volume_name, dataset = self._get_share_datasets(nfs_share)\n if not nms.volume.object_exists(volume_name):\n raise LookupError(_(\"Volume %s does not exist in Nexenta \"\n \"Store appliance\"), volume_name)\n folder = '%s/%s' % (volume_name, dataset)\n if not nms.folder.object_exists(folder):\n raise LookupError(_(\"Folder %s does not exist in Nexenta \"\n \"Store appliance\"), folder)\n if (folder not in nms.netstorsvc.get_shared_folders(\n 'svc:/network/nfs/server:default', '')):\n self._share_folder(nms, volume_name, dataset)\n self._get_capacity_info(nfs_share)","def test_raises_when_assignment_tests_directory_is_non_empty(\n self, tmp_path_factory, platform_url, workdir, rtd_path\n ):\n # arrange\n existing_assignment_dir = rtd_path / ASSIGNMENT_NAMES[0]\n existing_assignment_dir.mkdir(parents=True)\n\n # act/assert\n result = run_generate_rtd(\n base_url=platform_url, rtd=rtd_path, workdir=workdir\n )\n\n assert result.status == plug.Status.ERROR\n assert existing_assignment_dir.name in result.msg\n assert \"delete\" in result.msg","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.train_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n if not osp.exists(self.test_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.test_dir))","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n if not osp.exists(self.train_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n if not osp.exists(self.probe_gallery_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.probe_gallery_dir))","def _VerifySDKEnvironment(self):\n # If the environment wasn't set up, then the output directory wouldn't be\n # created after 'gn gen'.\n # TODO: Make this check actually look at the environment.\n if not os.path.exists(self.out_board_dir):\n raise AssertionError('%s not created!' % self.out_board_dir)\n # Log args.gn for debugging.\n logging.info('ARGS.GN=\\n%s',\n osutils.ReadFile(os.path.join(self.out_board_dir, 'args.gn')))","def initialized(self):\n return self.workspace == find_enclosing_workspace(self.workspace)","def check_working_dir(directory):\n filepath = os.path.join(directory, \"text.txt\")\n try:\n open(filepath, \"w\")\n except IOError:\n sys.exit('Unable to write to directory {0} \\n Exiting Drupdates'.format(directory))\n return False\n return True","def cleanOutputDir(output):\n if os.path.exists(output) and os.path.isdir(output):\n shutil.rmtree(output)","def test_output_directory_with_space(self):\n temp_out_dir = \"xxmotif test\"\n input_file = self.copy_and_mark_for_cleanup(\"Fasta/f002\")\n\n try:\n XXmotifCommandline(outdir=temp_out_dir, seqfile=input_file)\n except ValueError:\n pass\n else:\n self.fail(\"expected ValueError\")","def validate_full_design(self, name=None, outputdir=None, ports=None):\n if name is None:\n name = self.design_name\n if outputdir is None:\n outputdir = self.project_path\n\n self.logger.glb.info(\"#### Design Validation Checks###\")\n #\n # Routine outputs to the validation info to a log file in the project directory and also\n # returns the validation info to be used to update properties.xml file\n\n validation_ok = True\n\n #\n # Write an overall validation log file with all output from all checks\n # The design validation inside HFSS outputs to a separate log file which we merge into this overall file\n #\n val_list = []\n all_validate = outputdir + \"\\\\all_validation.log\"\n with open(all_validate, \"w\") as validation:\n\n # Desktop Messages\n msg = \"Desktop Messages:\"\n validation.writelines(msg + \"\\n\")\n val_list.append(msg)\n msgs = self._desktop.GetMessages(name, \"HFSSDesign1\", 0)\n # need to check if design name is always this default name HFSSDesign1\n for msg in msgs:\n self.logger.glb.info(msg)\n # msg = msg.replace('\"','')\n msg = msg.rstrip(\"\\r\\n\")\n val_list.append(msg)\n validation.writelines(msg + \"\\n\")\n\n # Run Design Validation and write out the lines to the logger\n\n ret = self._odesign.ValidateCircuit()\n msg = \"Design Validation Messages:\"\n validation.writelines(msg + \"\\n\")\n val_list.append(msg)\n if ret == 0:\n msg = \"**** ERRORS Present - please check and confirm\"\n self.logger.glb.error(msg)\n else:\n msg = \"**** Validation Completed Correctly\"\n self.logger.glb.info(msg)\n\n # Find the Excitations and check or list them out\n msg = \"Excitation Messages:\"\n validation.writelines(msg + \"\\n\")\n val_list.append(msg)\n numportsdefined = int(len(self.get_excitations_name))\n if ports is not None and ports != numportsdefined:\n msg = \"**** Port Number Error! - Please check model\"\n self.logger.glb.error(msg)\n validation.writelines(msg + \"\\n\")\n val_list.append(msg)\n validation_ok = False\n # need to stop the simulation athis point\n else:\n msg1 = \"Ports Requested: \" + str(ports)\n msg2 = \"Ports Defined: \" + str(numportsdefined)\n self.logger.glb.info(msg1)\n validation.writelines(msg1 + \"\\n\")\n val_list.append(msg1)\n self.logger.glb.info(msg2)\n validation.writelines(msg2 + \"\\n\")\n val_list.append(msg2)\n\n excitation_names = self.get_excitations_name\n for excitation in excitation_names:\n msg = \"Excitation name: \" + str(excitation)\n self.logger.glb.info(msg)\n validation.writelines(msg + \"\\n\")\n val_list.append(msg)\n validation.close()\n return val_list, validation_ok # return all the info in a list for use later","def test_local_validation(tmpdir):\n with tmpdir.as_cwd():\n with pytest.raises(FileNotFoundError):\n validate_nagl_model_path(\"test.pt\")\n\n with open(\"test.pt\", \"w\") as f:\n f.write(\"test\")\n model_path = validate_nagl_model_path(\"test.pt\")\n assert os.path.exists(model_path)","def prepare_supplemental_output_directory():\n output_dir = workspace_path('%s/%s' % (scenario_filename(), \"Supplemental Output Files\")) # this does not have the .db suffix\n output_args = ['--output-dir', output_dir] # to be returned and passed to adsm_simulation.exe\n if not os.path.exists(output_dir):\n os.makedirs(output_dir, exist_ok=True)\n return output_args","def check_grid(gridname,modeldirs=None):\n\n chgriddir(gridname)\n \n # guess the model directories \n modeldirs = get_modeldirs(modeldirs)\n \n for modeldir in modeldirs:\n if not os.path.isfile(modeldir+\"/finished.out\"):\n print(\"Model \"+modeldir+\" failed:\")","def check_output_dir(args, expected_items=0):\n if (\n os.path.exists(args.output_dir)\n and len(os.listdir(args.output_dir)) > expected_items\n and args.do_train\n and not args.overwrite_output_dir\n ):\n raise ValueError(\n f\"Output directory ({args.output_dir}) already exists and \"\n f\"has {len(os.listdir(args.output_dir))} items in it (expected {expected_items} items). \"\n \"Use --overwrite_output_dir to overcome.\"\n )","def test_empty_output_successful(self):\n\n manifest = copy.deepcopy(job_test_utils.COMPLETE_MANIFEST)\n manifest['job']['interface']['outputs'] = {}\n\n json_data = {\n 'manifest': manifest,\n 'configuration': self.configuration\n }\n\n url = '/%s/job-types/validation/' % self.api\n response = self.client.generic('POST', url, json.dumps(json_data), 'application/json')\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\n\n results = json.loads(response.content)\n self.assertTrue(results['is_valid'])\n self.assertDictEqual(results, {u'errors': [], u'is_valid': True, u'warnings': []})","def __checkDestination(self):\n return os.path.exists(self.__targetPath)","def sense(self):\n\n partition_folder = self.getPartitionFolder()\n log_folder = os.path.join(partition_folder, 'var/log')\n log_name = 'slapgrid-%s-error.log' % self.getConfig('partition-id')\n slapgrid_error_log_file = os.path.join(partition_folder, '.%s' % log_name)\n link_file = os.path.join(log_folder, log_name)\n monitor_url = self.getConfig('monitor-url')\n message = ''\n if os.path.exists(slapgrid_error_log_file) and \\\n os.stat(slapgrid_error_log_file).st_size:\n message = 'Buildout failed to process %s.' % self.getConfig('partition-id')\n if monitor_url:\n message += '\\nSee %s/log/%s for more information.' % (monitor_url, log_name)\n if not os.path.exists(link_file):\n os.symlink(slapgrid_error_log_file, link_file)\n else:\n if os.path.exists(link_file):\n os.unlink(link_file)\n\n if message:\n self.logger.error(message)\n else:\n self.logger.info(\"buildout is OK\")","def validate_input(self):\n inputs = self.inputs\n if 'remote_data' in inputs:\n input_ok = True\n else:\n input_ok = False\n return self.exit_codes.ERROR_NO_INPUT_REMOTE_DATA # pylint: disable=no-member\n input_remote = self.inputs.remote_data\n parents = input_remote.get_incoming(node_class=CalcJobNode)\n nparents = len(parents.all_link_labels())\n\n if nparents != 1:\n # extract parent workflow and get uuid of last calc from output node\n parent_workflow = input_remote.inputs.last_RemoteData\n if not isinstance(parent_workflow, WorkChainNode):\n return self.exit_codes.ERROR_INVALID_REMOTE_DATA_TPYE # pylint: disable=no-member\n\n parent_workflow_out = parent_workflow.outputs.output_kkr_scf_wc_ParameterResults\n uuid_last_calc = parent_workflow_out.get_dict().get('last_calc_nodeinfo').get('uuid')\n last_calc = load_node(uuid_last_calc)\n\n if not isinstance(last_calc, KkrCalculation) and not isinstance(last_calc, VoronoiCalculation):\n return self.exit_code.ERROR_INVALID_REMOTE_DATA_TPYE\n\n # overwrite remote_data node with extracted remote folder\n output_remote = last_calc.outputs.remote_folder\n\n self.inputs.remote_data = output_remote\n\n # extract structure\n struc_kkr, _ = VoronoiCalculation.find_parent_structure(self.inputs.remote_data)\n # save if structure is an alloy\n self.ctx.struc_is_alloy = struc_kkr.is_alloy\n\n # To validate for kpoints\n if 'kpoints' in inputs:\n self.ctx.BS_kpoints = inputs.kpoints\n input_ok = True\n self.ctx.structure_data = 'None (kpoints taken from input)'\n else:\n #create an auxiliary structure with unique kind_names, this leads to using the input structure in the seekpath method instead of finding the primitive one\n cell = np.array(struc_kkr.cell)\n if not struc_kkr.pbc[2]:\n # 2D structure, make sure the third bravais vector points along z\n cell[2] = np.cross(cell[0], cell[1])\n saux = StructureData(cell=cell)\n for isite, site in enumerate(struc_kkr.sites):\n kind = struc_kkr.get_kind(site.kind_name)\n saux.append_atom(\n name='atom' + str(isite) + ':' + site.kind_name,\n symbols=kind.symbols,\n weights=kind.weights,\n position=site.position\n )\n # use auxiliary structure inside k-point generator\n output = get_explicit_kpoints_path(saux)\n primitive_struc = output['primitive_structure']\n conventional_struc = output['conv_structure']\n kpoints_ok = True\n\n #check if primitive_structure and input structure are identical:\n maxdiff_cell = sum(abs(np.array(primitive_struc.cell) - np.array(saux.cell))).max()\n\n if maxdiff_cell > 3 * 10**-9:\n self.report(f'Error in cell : {maxdiff_cell}')\n self.report(\n 'WARNING : The structure data from the voronoi calc is not the primitive structure type and in come cases it is medatory'\n )\n self.report(f'prim: {primitive_struc.cell} {primitive_struc.sites}')\n self.report(f'conv: {conventional_struc.cell} {conventional_struc.sites}')\n self.ctx.structure_data = 'conventional_unit_cell '\n else:\n self.ctx.structure_data = 'primitive_unit_cell'\n\n if not kpoints_ok:\n return self.exit_codes.ERROR_INCORRECT_KPOINTS_EXTRACTED # pylint: disable=no-member\n else:\n kpts = output['explicit_kpoints']\n\n self.ctx.BS_kpoints = kpts\n if isinstance(KpointsData(), type(kpts)):\n input_ok = True\n else:\n input_ok = False\n return self.exit_codes.ERROR_NO_KPOINTS_EXTRACTED # pylint: disable=no-member\n\n # To validate for kkr\n if 'kkr' in inputs:\n try:\n test_and_get_codenode(inputs.kkr, 'kkr.kkr', use_exceptions=True)\n except ValueError:\n input_ok = False\n return self.exit_codes.ERROR_KKRCODE_NOT_CORRECT # pylint: disable=no-member\n\n # set self.ctx.input_params_KKR\n self.ctx.input_params_KKR = get_parent_paranode(self.inputs.remote_data)\n self.report(f'The validation input_ok {input_ok}')","def check_training_package(folder, ruleset, quiet, werror):\n check_training_result_files(folder, ruleset, quiet, werror)","def assert_sources_folder_exist(command: commands.FilesRelatedCommand,\n filesystem: infra.Filesystem,\n stdout: infra.STDOut) -> None:\n if filesystem.not_exists(command.sources_folder):\n stdout.red(f'Sources folder does not exist: {command.sources_folder}')\n sys.exit(1)","def ValidateOutput(self, stdout, stderr, result):\n # Store .ref and .log files in a platform-specific subdirectory\n # (avoid possible clashes if several platforms are tested)\n if \"CMTCONFIG\" in os.environ:\n try: os.mkdir( os.environ['CMTCONFIG'] )\n except OSError: pass\n stdout_log_path=os.environ['CMTCONFIG']+os.sep\n else:\n stdout_log_path=''\n # Maybe some verbosity is needed here\n if not(self.stdout_tag==''):\n strlog='the tag is ' + self.stdout_tag\n logger.debug('ExecTestBase2:ValidateOutput: '+strlog)\n if not(self.stdout_tol==0):\n strlog='the tolerance is ' + repr(self.stdout_tol) \n logger.debug('ExecTestBase2:ValidateOutput: '+strlog)\n if not(self.stdout_ref==''):\n if not(self.stdout_ref_path==''):\n self.reference_file=self.stdout_ref_path+os.sep+self.stdout_ref \n else:\n self.reference_file=self.stdout_ref \n if os.path.abspath(self.reference_file) != os.path.abspath(stdout_log_path+str(self.stdout_ref)):\n shutil.copyfile(os.path.abspath(self.reference_file),\n stdout_log_path+str(self.stdout_ref))\n ref_file_stdout=''\n for l in fileinput.input(stdout_log_path+str(self.stdout_ref)): \n ref_file_stdout=ref_file_stdout+l.strip()+'\\n'\n if not(self.excluded_lines==''):\n strlog='the excluded lines are ' + self.excluded_lines \n logger.debug('ExecTestBase2:ValidateOutput: '+strlog) \n # Copy the log for later use as ref \n f_ouput=open(stdout_log_path+self.stdout_ref.rstrip('ref')+'log', 'w')\n f_ouput.write(stdout)\n f_ouput.close()\n # Check to see if the standard output matches.\n self.causes = []\n if not(self.stdout=='*'):\n if not(self.stdout_ref==''):\n # the reference output is described in a\n # external reference file \n if not self.__CompareText1(stdout, ref_file_stdout, result):\n self.causes.append(\"standard output\") \n result[\"ExecTest.expected_stdout\"] = result.Quote(self.stdout)\n else:\n # the reference output is described in the test-case\n if not self.__CompareText1(stdout, self.stdout,result):\n self.causes.append(\"standard output\") \n result[\"ExecTest.expected_stdout\"] = result.Quote(self.stdout)\n else:\n result[\"ExecTest.expected_stdout\"] = result.Quote(self.stdout)\n \n # Check to see if the standard error matches.\n if not(self.stderr=='*'):\n if not self.__CompareText(stderr, self.stderr):\n self.causes.append(\"standard error\")\n result[\"ExecTest.expected_stderr\"] = result.Quote(self.stderr)\n else: \n result[\"ExecTest.expected_stderr\"] = result.Quote(self.stderr)\n #\n return self.causes","def _check_before_run(self):\n if not osp.exists(self.dataset_dir):\n raise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))","def checkGlobalConflicts(self):\n\t\tappionScript.AppionScript.checkGlobalConflicts(self)\n\n\t\tif self.params['runname'] is None:\n\t\t\tapDisplay.printError(\"please enter a runname, example: 'runname=run1'\")\n\t\tif self.params['runname'] == 'templates':\n\t\t\tapDisplay.printError(\"templates is a reserved runname, please use another runname\")\n\t\tif self.params['runname'] == 'models':\n\t\t\tapDisplay.printError(\"models is a reserved runname, please use another runname\")\n\t\tif self.params['rundir']is not None and self.params['runname'] != os.path.basename(self.params['rundir']):\n\t\t\tapDisplay.printError(\"runname and rundir basename are different: \"\n\t\t\t\t+self.params['runname']+\" vs. \"+os.path.basename(self.params['rundir']))\n\t\tif self.params['mrcnames'] and self.params['preset']:\n\t\t\tapDisplay.printError(\"preset can not be specified if particular images have been specified\")\n\t\tif self.params['sessionname'] is None and self.params['mrcnames'] is None:\n\t\t\tapDisplay.printError(\"please specify an mrc name or session\")\n\t\tif self.params['sessionname'] is not None and self.params['projectid'] is not None:\n\t\t\t### Check that project and tilt series are in sync\n\t\t\tseriesproject = apProject.getProjectIdFromSessionName(self.params['sessionname'])\n\t\t\tif seriesproject and seriesproject != self.params['projectid']:\n\t\t\t\tapDisplay.printError(\"project id and session do not correlate\")","def check_settings(args):\n print('')\n print('-'*80)\n print('CHECK SETTINGS:\\n')\n\n pypath= os.path.abspath(os.path.split(oxbs_qc.__file__)[0])\n checkList= []\n sys.stdout.write('Check output directory \"%s\" is writable... ' %(args.outdir))\n passed= os.access(args.outdir, os.W_OK)\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('outdir', passed))\n\n ## samtools\n ## -----------\n tg= spawn.find_executable('samtools')\n\n if tg is None:\n passed= False\n else:\n passed= os.path.isfile(tg)\n\n sys.stdout.write('Check samtools \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('samtools', passed))\n\n ## samtools\n ## -----------\n tg= spawn.find_executable('bedtools')\n\n if tg is None:\n passed= False\n else:\n passed= os.path.isfile(tg)\n\n sys.stdout.write('Check bedtools \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED (methyaltion can\\'t be called)\\n')\n checkList.append(('bedtools', passed))\n\n\n ## cutadapt\n ## trim_glore doesn't have a cutadapt path options. So it must be on the PATH\n ## -----------\n tg= spawn.find_executable('cutadapt')\n if tg is None:\n passed= False\n else:\n passed= os.path.isfile(tg)\n\n sys.stdout.write('Check cutadapt \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('cutadapt', passed))\n\n ## Trim galore\n ## -----------\n if args.trim_galore_path is None:\n tgpath= os.path.abspath(os.path.split(oxbs_qc.__file__)[0])\n else:\n tgpath= args.trim_galore_path \n tg= os.path.join(tgpath, 'trim_galore')\n passed= os.path.isfile(tg)\n\n sys.stdout.write('Check trim_galore \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('trim_galore', passed))\n\n ## bismark\n ## -------\n if args.bismark_path is None:\n tgpath= os.path.abspath(os.path.split(oxbs_qc.__file__)[0])\n else:\n tgpath= args.bismark_path \n tg= os.path.join(tgpath, 'bismark')\n passed= os.path.isfile(tg)\n\n sys.stdout.write('Check bismark \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('bismark', passed))\n\n ## clipOverlap\n ## -----------\n if args.clipoverlap_path == '':\n tg= spawn.find_executable('bam')\n else:\n tg= os.path.join(args.clipoverlap_path, 'bam')\n \n if tg is None:\n passed= False\n else:\n passed= os.path.isfile(tg)\n\n sys.stdout.write('Check bam clipOverlap \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('clipOverlap', passed))\n\n ## R\n ## -----------\n if args.rscript_path == '':\n tg= spawn.find_executable('Rscript')\n else:\n tg= os.path.join(args.rscript_path, 'Rscript')\n\n if tg is None:\n passed= False\n else:\n passed= os.path.isfile(tg)\n\n sys.stdout.write('Check R/Rscript \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('R/Rscript', passed))\n\n\n ## Custom scripts\n ## --------------\n tg= os.path.join(pypath, 'FastQC/fastqc')\n passed= os.path.isfile(tg)\n sys.stdout.write('Check fastqc \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('fastqc', passed))\n\n tg= os.path.join(pypath, 'ShortenFastq.jar')\n passed= os.path.isfile(tg)\n sys.stdout.write('Check ShortenFastq.jar \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('ShortenFastq.jar', passed))\n\n tg= os.path.join(pypath, 'MarkDuplicates.jar')\n passed= os.path.isfile(tg)\n sys.stdout.write('Check MarkDuplicates.jar \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('MarkDuplicates.jar', passed))\n\n tg= os.path.join(pypath, 'cleanReadNames.py')\n passed= os.path.isfile(tg)\n sys.stdout.write('Check cleanReadNames.py \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('cleanReadNames.py.py', passed))\n\n #tg= os.path.join(pypath, 'mpileup2methylation.py')\n #passed= os.path.isfile(tg)\n #sys.stdout.write('Check mpileup2methylation.py \"%s\"... ' %(tg))\n #if passed:\n # sys.stdout.write('OK\\n')\n #else:\n # sys.stdout.write('FAILED\\n')\n #checkList.append(('mpileup2methylation.py', passed))\n \n tg= os.path.join(pypath, 'bam2methylation.py')\n passed= os.path.isfile(tg)\n sys.stdout.write('Check bam2methylation.py \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('bam2methylation.py', passed))\n \n tg= os.path.join(pypath, 'oxbs_report.R')\n passed= os.path.isfile(tg)\n sys.stdout.write('Check oxbs_report.R \"%s\"... ' %(tg))\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('oxbs_report.R', passed))\n\n ## Reference FASTA\n sys.stdout.write('Check reference FASTA \"%s\"... ' %(args.ref))\n if args.ref is None:\n tg= None\n passed= False\n sys.stdout.write('FAILED\\n')\n elif os.path.isfile(args.ref):\n sys.stdout.write('OK\\n')\n passed= True\n else:\n sys.stdout.write('FAILED\\n')\n passed= False\n checkList.append(('Ref. FASTA', passed))\n \n ## Reference TXT\n sys.stdout.write('Check reference TXT \"%s\"... ' %(args.ref))\n if args.ref is None:\n tg= None\n passed= False\n sys.stdout.write('FAILED\\n')\n else:\n txt= os.path.splitext(args.ref)[0] + '.txt'\n if os.path.isfile(txt):\n sys.stdout.write('OK\\n')\n passed= True\n else:\n sys.stdout.write('FAILED\\n')\n passed= False\n checkList.append(('Ref. TXT', passed))\n \n ## List of BED positions:\n if args.listpos is not None:\n sys.stdout.write('Check bed file of positions \"%s\"... ' %(args.listpos))\n if os.path.isfile(args.listpos):\n sys.stdout.write('OK\\n')\n passed= True\n else:\n sys.stdout.write('FAILED\\n')\n passed= False\n checkList.append(('Bed file of positions', passed))\n \n ## Check bowtie2 indexes\n ##refbt2= os.path.split(args.ref)[0] + 'Bisulfite_Genome'\n ## ...\n \n sys.stdout.write('Check prefix \"%s\"... ' %(args.prefix))\n try:\n passed= validate_prefix(args.prefix)\n except ValidArgException:\n passed= False\n if passed:\n sys.stdout.write('OK\\n')\n else:\n sys.stdout.write('FAILED\\n')\n checkList.append(('prefix', passed))\n \n print('')\n print('-'*80)\n for x in checkList:\n if not x[1]:\n print(x[0] + ' ' + 'FAILED')\n print('')\n return(checkList)","def _assert_build_info(self):\n if not self.path.exists():\n from zensols.pybuild import SetupUtil\n self.path.parent.mkdir(parents=True, exist_ok=True)\n if not self.rel_setup_path.exists():\n raise OSError('configuration file does not ' +\n f'exist: {self.rel_setup_path}')\n su = SetupUtil.source(rel_setup_path=self.rel_setup_path)\n logger.info(f'saving build info to {self.path}')\n with open(self.path, 'w') as f:\n su.to_json(writer=f)","def validate(self):\n variables = ['bottomDepth', 'ssh', 'layerThickness', 'zMid',\n 'maxLevelCell', 'temperature', 'salinity']\n compare_variables(\n test_case=self, variables=variables,\n filename1='initial_state/initial_state.nc')\n\n variables = ['temperature', 'salinity', 'layerThickness',\n 'normalVelocity']\n compare_variables(test_case=self, variables=variables,\n filename1='full_run/output.nc',\n filename2='restart_run/output.nc')\n\n variables = ['ssh', 'landIcePressure', 'landIceDraft',\n 'landIceFraction',\n 'landIceMask', 'landIceFrictionVelocity', 'topDrag',\n 'topDragMagnitude', 'landIceFreshwaterFlux',\n 'landIceHeatFlux', 'heatFluxToLandIce',\n 'landIceBoundaryLayerTemperature',\n 'landIceBoundaryLayerSalinity',\n 'landIceHeatTransferVelocity',\n 'landIceSaltTransferVelocity',\n 'landIceInterfaceTemperature',\n 'landIceInterfaceSalinity', 'accumulatedLandIceMass',\n 'accumulatedLandIceHeat']\n compare_variables(test_case=self, variables=variables,\n filename1='full_run/land_ice_fluxes.nc',\n filename2='restart_run/land_ice_fluxes.nc')\n\n variables = ['accumulatedFrazilIceMass',\n 'accumulatedFrazilIceSalinity',\n 'seaIceEnergy', 'frazilLayerThicknessTendency',\n 'frazilTemperatureTendency', 'frazilSalinityTendency',\n 'frazilSurfacePressure',\n 'accumulatedLandIceFrazilMass']\n compare_variables(test_case=self, variables=variables,\n filename1='full_run/frazil.nc',\n filename2='restart_run/frazil.nc')","def _checkIntegrity(self):\n return (\n os.path.isfile(os.path.join(self._root, 'processed/train.pkl'))\n and os.path.isfile(os.path.join(self._root, 'processed/test.pkl')))","def check(self):\n self.init()\n self.calculate_output()\n self.compare_outputs_with_expects()"],"string":"[\n \"def test_missing_output_workspace(self):\\n manifest = copy.deepcopy(job_test_utils.COMPLETE_MANIFEST)\\n config = copy.deepcopy(self.configuration)\\n config['output_workspaces'] = {}\\n json_data = {\\n 'manifest': manifest,\\n 'configuration': config\\n }\\n\\n url = '/%s/job-types/validation/' % self.api\\n response = self.client.generic('POST', url, json.dumps(json_data), 'application/json')\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n results = json.loads(response.content)\\n self.assertFalse(results['is_valid'])\\n self.assertEqual(len(results['errors']), 1)\\n self.assertEqual(results['errors'][0]['name'], 'MISSING_WORKSPACE')\",\n \"def check_output(self):\\n directory, file = split(self.target)\\n if not exists(directory):\\n mkdir(directory)\\n if exists(self.target):\\n unlink(self.target)\",\n \"def test_invalid_output_workspace(self):\\n manifest = copy.deepcopy(job_test_utils.COMPLETE_MANIFEST)\\n config = copy.deepcopy(self.configuration)\\n config['output_workspaces'] = {\\n 'default': 'bad_name'\\n }\\n json_data = {\\n 'manifest': manifest,\\n 'configuration': config\\n }\\n\\n url = '/%s/job-types/validation/' % self.api\\n response = self.client.generic('POST', url, json.dumps(json_data), 'application/json')\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n results = json.loads(response.content)\\n self.assertFalse(results['is_valid'])\\n self.assertEqual(len(results['errors']), 1)\\n self.assertEqual(results['errors'][0]['name'], 'INVALID_WORKSPACE')\",\n \"def test_create_workspace():\\n\\n bambi = create_test_bambi()\\n bambi.create_workspace(bambi.name)\\n success = check_workspace_existance(bambi)\\n\\n assert success\",\n \"def make_sure_path_exists(out_path):\\n try:\\n os.makedirs(out_path)\\n except OSError as exception:\\n if exception.errno != errno.EEXIST:\\n print \\\"Errors in output folder path! please change the output path or analysis name\\\\n\\\"\\n exit()\",\n \"def test_deprecated_output_workspace(self):\\n manifest = copy.deepcopy(job_test_utils.COMPLETE_MANIFEST)\\n config = copy.deepcopy(self.configuration)\\n config['output_workspaces'] = {\\n 'default': 'inactive'\\n }\\n json_data = {\\n 'manifest': manifest,\\n 'configuration': config\\n }\\n\\n url = '/%s/job-types/validation/' % self.api\\n response = self.client.generic('POST', url, json.dumps(json_data), 'application/json')\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n results = json.loads(response.content)\\n self.assertTrue(results['is_valid'])\\n self.assertEqual(len(results['warnings']), 1)\\n self.assertEqual(results['warnings'][0]['name'], 'DEPRECATED_WORKSPACE')\",\n \"def test_check_if_output_file_exists():\\n input_file = os.path.join(os.getcwd(), 'tests', 'input_test_file.docx')\\n output_file = os.path.join(os.getcwd(), 'tests', 'output_test_file.txt')\\n\\n questions_parser = QuestionsParser()\\n questions_parser.main(argv=['-i', input_file, '-o', output_file])\\n assert os.path.exists(output_file)\\n os.unlink(output_file)\",\n \"def test_init_does_not_create(self):\\n self.logger.info(\\\"STEP: Initialize the workspace library.\\\")\\n self.workspace = Workspace(Mock())\\n\\n self.logger.info(\\n \\\"STEP: Verify that the workspace library did not create a workspace \\\"\\n \\\"directory.\\\"\\n )\\n self.assertFalse(Path.cwd().joinpath(\\\"workspace\\\").exists())\",\n \"def test_not_ready_if_insufficient_output_space(self):\\n self.command.package = self.input_ovf\\n\\n self.command.ui.default_confirm_response = False\\n # Make working directory requirements negligible but output huge\\n with mock.patch.object(self.command,\\n \\\"working_dir_disk_space_required\\\",\\n return_value=0), \\\\\\n mock.patch.object(self.command.vm,\\n 'predicted_output_size',\\n return_value=(1 << 60)):\\n ready, reason = self.command.ready_to_run()\\n\\n self.assertFalse(ready)\\n self.assertRegex(reason, \\\"Insufficient disk space available\\\"\\n \\\" to guarantee successful output\\\")\\n\\n # User can opt to continue anyway\\n self.command.ui.default_confirm_response = True\\n self.command._cached_disk_requirements.clear()\\n with mock.patch.object(self.command,\\n \\\"working_dir_disk_space_required\\\",\\n return_value=0), \\\\\\n mock.patch.object(self.command.vm,\\n 'predicted_output_size',\\n return_value=(1 << 60)):\\n ready, reason = self.command.ready_to_run()\\n\\n self.assertTrue(ready)\",\n \"def check_workspace ():\\n\\n try:\\n ex (\\\"cd $DOC_ROOT/ACE_TAO && git pull -p\\\")\\n print (\\\"Successfully updated ACE/TAO working copy\\\")\\n except:\\n print (\\\"Unable to update ACE/TAO workspace at \\\" + doc_root)\\n raise\\n\\n try:\\n ex (\\\"cd $DOC_ROOT/MPC && git pull -p\\\")\\n print (\\\"Successfully updated MPC working copy to revision \\\")\\n except:\\n print (\\\"Unable to update the MPC workspace at \\\" + doc_root + \\\"/ACE/MPC\\\")\\n raise\\n\\n vprint (\\\"Repos root URL = \\\" + opts.repo_root + \\\"\\\\n\\\")\\n vprint (\\\"Repos MPC root URL = \\\" + opts.mpc_root + \\\"\\\\n\\\")\",\n \"def __manage_output_folder(self):\\n if not os.path.exists(self.output_folder):\\n os.makedirs(self.output_folder)\",\n \"def test_output_exists():\\n global out_dir, cor_dir\\n assert(path.exists(path.join(out_dir, 'oshea_similarity.json')))\",\n \"def check_for_preexisting_output_file(output_file_path):\\n if path.exists(f\\\"{output_file_path}\\\"):\\n print(\\\"Output file at specified save location file path already exists!\\\")\\n print(\\\"Aborting operation!\\\")\\n sys.exit()\",\n \"def validate(cls, output_destination):\\n # nothing to check :)\\n pass\",\n \"def validate(cls, output_destination):\\n # nothing to check :)\\n pass\",\n \"def _check_save_directory_path(self):\\n if self.save_directory_path is not None:\\n if os.path.exists(self.save_directory_path):\\n raise ValueError(\\n 'You must provide non-existing save output directory, '\\n '{} given.'.format(self.save_directory_path))\\n else:\\n os.makedirs(self.save_directory_path)\",\n \"def validate(self):\\n self.__log('Validating whether all conditions are met.')\\n if not self.config['OUT_FOLDER'] or not self.config['OUTPUT_FOLDER']:\\n self.__log('The path to the output folder cannot be found.', 'error')\\n raise FileNotFoundError\\n\\n try:\\n if '.' in self.output_filename:\\n self.__log('The output filename should not contain an extension.', 'error')\\n raise ValueError\\n except TypeError:\\n pass\\n\\n if not self.output_filename:\\n self.__log('The output filename has not been specified.', 'warning')\\n self.output_filename = self.hash_time()\\n i = 0\\n while self.output_file_exists():\\n self.__log('Adding a unique identifier to current filename.', 'warning')\\n self.output_filename = self.output_filename + '-' + i\\n i += 1\\n self.__log(f'Continuing with file: \\\"{self.output_filename}\\\"', 'success')\\n\\n # Iterate over options to check for required parameters, as to not waste requests\\n self.__log('Starting to check if all required parameters are set')\\n for key, value in self.options.items():\\n if key in self.config['REQUIRED_PARAMETERS'] and not value:\\n self.__log(f'Missing a required parameter: {key}', 'error')\\n raise MissingRequiredParameterError(key)\\n\\n self.__log('All validation successful.', 'success')\",\n \"def setup_molecule_output_check(exp_builder_db, mol_id, output_path):\\n exp_builder_db._setup_molecules(mol_id)\\n assert os.path.exists(output_path)\\n assert os.path.getsize(output_path) > 0\",\n \"def env_check(self):\\n b_status : bool = True\\n str_error : str = \\\"no error\\\"\\n if not os.path.exists(self.str_inputDir):\\n b_status = False\\n if self.toConsole():\\n error.warn(self, 'inputDirFail', exitToOS = True, drawBox = True)\\n str_error = 'error captured while accessing input directory'\\n return {\\n 'status' : b_status,\\n 'error' : str_error\\n }\",\n \"def check_build_exists(self):\\n path = self.base_dir + \\\"/\\\" + self.app_name + \\\"/\\\" + \\\"build\\\"\\n from django_swagger_utils.core.utils.check_path_exists import check_path_exists\\n build_dir = check_path_exists(path)\\n if build_dir:\\n raise Exception(\\\"Build Directory Already Exist, please run update_specs_build\\\")\",\n \"def _validate_output_file_path(file_path: str):\\n file_dir = os.path.dirname(file_path)\\n if not os.path.isdir(file_dir):\\n try:\\n os.makedirs(file_dir)\\n except Exception as e:\\n utils.error(f\\\"Failed to create parent directory {file_dir} for file {file_path}. Reason: {e}\\\")\\n if not os.access(file_dir, os.W_OK):\\n utils.error(f\\\"Cannot write file: {file_path}. {file_dir} is not writeable.\\\")\",\n \"def check(self):\\n super().check()\\n\\n # scratch directory\\n if 'ORTHO' not in PATH:\\n setattr(PATH, 'ORTHO', join(PATH.SCRATCH, 'ortho'))\",\n \"def init(self):\\n\\n self.checkDirectory(self.output_dir,\\\"output\\\")\\n self.checkDirectory(self.working_dir,\\\"working\\\")\",\n \"def validate(self):\\n variables = ['waterThickness', 'waterPressure']\\n compare_variables(test_case=self, variables=variables,\\n filename1='full_run/output.nc',\\n filename2='restart_run/output.nc')\",\n \"def _check_before_run(self):\\n if not osp.exists(self.root):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.root))\\n if not osp.exists(self.train_name_path):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_name_path))\\n if not osp.exists(self.test_name_path):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.test_name_path))\\n if not osp.exists(self.track_train_info_path):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.track_train_info_path))\\n if not osp.exists(self.track_test_info_path):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.track_test_info_path))\\n if not osp.exists(self.query_IDX_path):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.query_IDX_path))\",\n \"def check_out_dir_exists(out_dir):\\n if not os.path.isdir(out_dir):\\n os.makedirs(out_dir)\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.data_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.data_dir))\\n if not osp.exists(self.split_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.split_dir))\",\n \"def check_config(outconfig):\\n self.log.info(\\\"Checking if all the necessary files exist.\\\")\\n\\n # Perform necessary checks\\n\\n log.info(\\\"All necessary files exist for {} configuration.\\\".format(outconfig[\\\"Flavor\\\"]))\\n\\n return\",\n \"def __check_exist_path(self):\\n if 'path_out' not in self.params:\\n raise ValueError('missing \\\"path_out\\\" among parameters')\\n self.params['path_out'] = update_path(self.params.get('path_out'))\\n list_names = [n for n in self.params if any(m in n.lower() for m in ['path', 'dir', 'file'])]\\n for n in list_names:\\n p = os.path.abspath(os.path.expanduser(self.params[n]))\\n if not os.path.exists(p):\\n raise FileNotFoundError('given path/file/dir \\\"%s\\\" does not exist!' % p)\\n self.params[n] = p\\n for n in [n for n in self.params if 'exec' in n]:\\n # in case you define executable in your home\\n if os.path.expanduser(self.params[n]) != self.params[n]:\\n self.params[n] = os.path.expanduser(self.params[n])\",\n \"def ensure_dirs_exists(self):\\n os.makedirs(os.path.join(self.location, \\\"batches\\\"), exist_ok=True)\\n os.makedirs(os.path.join(self.location, \\\"results\\\"), exist_ok=True)\",\n \"def sanity_check(loadfile, queryfile):\\n if not os.path.exists(loadfile):\\n print(\\\"Error: The path for the load csv file does not exist\\\")\\n return False\\n\\n if not os.path.exists(queryfile): \\n print(\\\"Error: The path for the query csv file does not exist\\\")\\n return False\\n\\n\\n \\\"\\\"\\\"\\n if not os.path.exists(\\\"/plots\\\"):\\n os.mkdir(\\\"/plots\\\")\\n \\\"\\\"\\\" \\n return True\",\n \"def check_outpath(self, outpath):\\n if not os.path.isdir(outpath+str(self.ar_no)):\\n ar_outpath = os.path.join(outpath,str(self.ar_no))\\n ar_outpath_video = os.path.join(outpath,str(self.ar_no)+'_video')\\n os.makedirs(ar_outpath)\\n os.makedirs(ar_outpath_video)\\n print(\\\"Path does not exist, create: \\\")\\n print(ar_outpath)\\n print(ar_outpath_video)\",\n \"def check_filesystem():\\n if FLAGS.continue_run:\\n # start a new run, set flag to continue, so there is nothing\\n # check if something there, if not, create, but don't delete\\n if not tf.gfile.Exists(FLAGS.summaries_dir):\\n tf.gfile.MakeDirs(FLAGS.summaries_dir)\\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'train'))\\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'validation'))\\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'test'))\\n if not tf.gfile.Exists(FLAGS.checkpoint_dir):\\n tf.gfile.MakeDirs(FLAGS.checkpoint_dir)\\n else:\\n # delete checkpoints and event summaries because training restarted\\n if tf.gfile.Exists(FLAGS.summaries_dir):\\n tf.gfile.DeleteRecursively(FLAGS.summaries_dir)\\n tf.gfile.MakeDirs(FLAGS.summaries_dir)\\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'train'))\\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'validation'))\\n tf.gfile.MakeDirs(os.path.join(FLAGS.summaries_dir, 'test'))\\n if tf.gfile.Exists(FLAGS.checkpoint_dir):\\n tf.gfile.DeleteRecursively(FLAGS.checkpoint_dir)\\n tf.gfile.MakeDirs(FLAGS.checkpoint_dir)\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.data_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.data_dir))\\n if not osp.exists(self.raw_mat_path):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.raw_mat_path))\\n if not osp.exists(self.split_new_det_mat_path):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.split_new_det_mat_path))\\n if not osp.exists(self.split_new_lab_mat_path):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.split_new_lab_mat_path))\",\n \"def check_some_assertions():\\n if FLAGS.input_width is None:\\n FLAGS.input_width = FLAGS.input_height\\n if FLAGS.output_width is None:\\n FLAGS.output_width = FLAGS.output_height\\n\\n if not os.path.exists(FLAGS.checkpoint_dir):\\n os.makedirs(FLAGS.checkpoint_dir)\\n if not os.path.exists(FLAGS.sample_dir):\\n os.makedirs(FLAGS.sample_dir)\",\n \"def check_some_assertions():\\n if FLAGS.input_width is None:\\n FLAGS.input_width = FLAGS.input_height\\n if FLAGS.output_width is None:\\n FLAGS.output_width = FLAGS.output_height\\n\\n if not os.path.exists(FLAGS.checkpoint_dir):\\n os.makedirs(FLAGS.checkpoint_dir)\\n if not os.path.exists(FLAGS.sample_dir):\\n os.makedirs(FLAGS.sample_dir)\",\n \"def test_check_process_output(self):\\n workflow = self.get_workflow(\\n \\\"\\\"\\\"file://result <- file://source\\n echo test\\n \\\"\\\"\\\")\\n workflow.pre_check_processes()\\n try:\\n process = workflow._processes[0]\\n create_tuttle_dirs()\\n workflow.run_process(process)\\n assert False, \\\"Exception has not been not raised\\\"\\n except ResourceError:\\n assert True\",\n \"def flush_outputs():\\n try:\\n shutil.rmtree(ROOT_OUTPUT_DIR)\\n print(\\\"Removed directory '{}'!\\\".format(ROOT_OUTPUT_DIR))\\n return True\\n except FileNotFoundError:\\n print(\\\"Directory '{}' already removed!\\\".format(ROOT_OUTPUT_DIR))\\n return False\",\n \"def test_set_output_invalid(self):\\n # Nonexistent output location, regardless of package\\n with self.assertRaises(InvalidInputError):\\n self.command.output = \\\"/foo/bar/baz\\\"\\n\\n self.command.package = self.input_ovf\\n # Nonexistent output location with package set\\n with self.assertRaises(InvalidInputError):\\n self.command.output = \\\"/foo/bar/baz.ova\\\"\\n\\n # Output to directory instead of file (currently unsupported)\\n with self.assertRaises(InvalidInputError):\\n self.command.output = self.temp_dir\\n\\n # Output to \\\"directory\\\" under a file\\n with self.assertRaises(InvalidInputError):\\n self.command.output = os.path.join(self.input_ovf, \\\"foo.ova\\\")\",\n \"def check_xshear_output(self):\\n lens_nchunk=self['lens_conf']['nchunk']\\n tilenames=scat.get_tilenames(self['source_conf']['scat_table'])\\n\\n ntile=len(tilenames)\\n for lens_chunk in xrange(lens_nchunk):\\n print(\\\" checking chunk: %d/%d\\\" % (lens_chunk+1, lens_nchunk))\\n for i,tilename in enumerate(tilenames):\\n # first check if this source catalog exists\\n if self._scat_exists(tilename):\\n job=XShearWQJob(self['run'],\\n lens_chunk,\\n tilename)\\n info=job.get_info()\\n if not os.path.exists(info['output_file']):\\n print(\\\"missing output:\\\",info['output_file'])\",\n \"def sanity_check_step(self):\\n custom_paths = {\\n 'files': ['bin/bazel'],\\n 'dirs': [],\\n }\\n super(EB_Bazel, self).sanity_check_step(custom_paths=custom_paths)\",\n \"def _validate_init_args(self):\\n\\n if self.outdir.exists() and not self.outdir.is_dir():\\n raise Error(f\\\"path '{self.outdir}' already exists and it is not a directory\\\")\\n\\n # Ensure that results are compatible.\\n rname, rver = self._refinfo[\\\"toolname\\\"], self._refinfo[\\\"toolver\\\"]\\n for res in self.rsts:\\n name, ver = res.info[\\\"toolname\\\"], res.info[\\\"toolver\\\"]\\n if name != rname:\\n raise Error(f\\\"the following test results are not compatible:\\\\n\\\"\\n f\\\"1. {self._refres.dirpath}: created by '{rname}'\\\\n\\\"\\n f\\\"2. {res.dirpath}: created by '{name}'\\\\n\\\"\\n f\\\"Cannot put incompatible results to the same report\\\")\\n if ver != rver:\\n _LOG.warning(\\\"the following test results may be not compatible:\\\\n\\\"\\n \\\"1. %s: created by '%s' version '%s'\\\\n\\\"\\n \\\"2. %s: created by '%s' version '%s'\\\",\\n self._refres.dirpath, rname, rver, res.dirpath, name, ver)\\n\\n # Ensure the report IDs are unique.\\n reportids = set()\\n for res in self.rsts:\\n reportid = res.reportid\\n if reportid in reportids:\\n # Try to construct a unique report ID.\\n for idx in range(1, 20):\\n new_reportid = f\\\"{reportid}-{idx:02}\\\"\\n if new_reportid not in reportids:\\n _LOG.warning(\\\"duplicate reportid '%s', using '%s' instead\\\",\\n reportid, new_reportid)\\n res.reportid = new_reportid\\n break\\n else:\\n raise Error(f\\\"too many duplicate report IDs, e.g., '{reportid}' is problematic\\\")\\n\\n reportids.add(res.reportid)\\n\\n if self.title_descr and Path(self.title_descr).is_file():\\n try:\\n with open(self.title_descr, \\\"r\\\") as fobj:\\n self.title_descr = fobj.read()\\n except OSError as err:\\n raise Error(f\\\"failed to read the report description file {self.title_descr}: {err}\\\")\\n\\n for res in self.rsts:\\n if res.dirpath.resolve() == self.outdir.resolve():\\n # Don't create report in results directory, use 'html-report' subdirectory instead.\\n self.outdir = self.outdir.joinpath(\\\"html-report\\\")\",\n \"def validate_run_results(input_file_parameters, dir_stack):\\r\\n prev_command_had_output_dir = True\\r\\n dir_stack_index = -1\\r\\n command_index = 0\\r\\n for current_command in input_file_parameters.commands:\\r\\n # Skip over SPLIT commands\\r\\n if current_command == 'SPLIT':\\r\\n continue\\r\\n\\r\\n command_index += 1\\r\\n\\r\\n if prev_command_had_output_dir:\\r\\n dir_stack_index += 1\\r\\n\\r\\n # Keep track of number of commands created in the current workflow step\\r\\n number_of_successful_commands = 0\\r\\n\\r\\n # Infer command type, parameters, input and output directories\\r\\n command_type, command_parameters = \\\\\\r\\n utils.parse_staplefile_command_line(current_command)\\r\\n in_dir = dir_stack[dir_stack_index]\\r\\n if command_type.require_output_dir:\\r\\n out_dir = dir_stack[dir_stack_index+1]\\r\\n prev_command_had_output_dir = True\\r\\n else:\\r\\n out_dir = in_dir\\r\\n prev_command_had_output_dir = False\\r\\n\\r\\n # Read files until command class finds no more valid input files\\r\\n number_of_potential_commands = 0\\r\\n while True:\\r\\n try:\\r\\n # The command instance is generated without exceptions if the\\r\\n # command execution has failed (i.e. expected output\\r\\n # file does not exist). Otherwise NewFileError is raised.\\r\\n current_command = command_type(command_parameters, in_dir, out_dir)\\r\\n except STAPLERerror.NewFileExists:\\r\\n number_of_successful_commands += 1\\r\\n number_of_potential_commands += 1\\r\\n continue\\r\\n except STAPLERerror.VirtualIOError:\\r\\n break\\r\\n number_of_potential_commands += 1\\r\\n\\r\\n # Print validation results\\r\\n if not number_of_successful_commands:\\r\\n print '{0} command (step number {1}) has not been run.' \\\\\\r\\n .format(command_type.name, command_index)\\r\\n continue\\r\\n if number_of_successful_commands == number_of_potential_commands:\\r\\n print '{0} command (step number {1}) has been run succesfully.' \\\\\\r\\n .format(command_type.name, command_index)\\r\\n else:\\r\\n print '{0} command (step number {1}) workflows have failed {2}/{3} times' \\\\\\r\\n .format(command_type.name, command_index,\\r\\n number_of_potential_commands - number_of_successful_commands,\\r\\n number_of_potential_commands)\",\n \"def ensure_out_dir(out_dir):\\n if not os.path.isdir(out_dir):\\n os.makedirs(out_dir)\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.train_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\\n if not osp.exists(self.query_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.query_dir))\\n if not osp.exists(self.gallery_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.gallery_dir))\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.train_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\\n if not osp.exists(self.query_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.query_dir))\\n if not osp.exists(self.gallery_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.gallery_dir))\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.train_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\\n if not osp.exists(self.query_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.query_dir))\\n if not osp.exists(self.gallery_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.gallery_dir))\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.train_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\\n if not osp.exists(self.query_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.query_dir))\\n if not osp.exists(self.gallery_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.gallery_dir))\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.train_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\\n if not osp.exists(self.query_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.query_dir))\\n if not osp.exists(self.gallery_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.gallery_dir))\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.train_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\\n if not osp.exists(self.query_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.query_dir))\\n if not osp.exists(self.gallery_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.gallery_dir))\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.train_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\\n if not osp.exists(self.query_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.query_dir))\\n if not osp.exists(self.gallery_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.gallery_dir))\",\n \"def __validate(self):\\n self.report(self.name).receive_info_from_gui(self.tournament.get())\\n msg.showinfo(title=None, message=self.message_path_to_folder)\\n self.master.master.launch()\\n self.master.destroy()\",\n \"def current_dir_ok() :\\n\\n current_ok = True\\n\\n current_dir = str(os.environ['PWD'])\\n expected_dir = str(os.path.abspath(out_dir))\\n\\n if not current_dir == expected_dir :\\n print \\\"ERROR current directory (%s) is not the output directory for the ntuples (%s)\\\"%(current_dir, expected_dir)\\n current_ok = False\\n\\n return current_ok\",\n \"def _check_numpy_output(self, cwd):\\n\\n for ii, refname in enumerate(self.files):\\n if self.forms[ii] == \\\"numpy\\\":\\n try:\\n ref_output = np.loadtxt(\\n Path(cwd) / refname, usecols=self.usecol[ii]\\n )\\n except IOError:\\n raise IOError(\\n 'Please provide a reference properties output named \\\"{}\\\"'.format(\\n refname\\n )\\n )\\n except ValueError:\\n raise ValueError(\\n \\\"Please check ref_simulation.out in {}\\\".format(\\n str((self.parent / cwd).absolute())\\n )\\n )\\n\\n fname = refname[4:]\\n test_output = np.loadtxt(self.tmp_dir / fname, usecols=self.usecol[ii])\\n\\n try:\\n np.testing.assert_allclose(\\n test_output, ref_output, rtol=1.0e-7, atol=1.0e-15\\n )\\n # print(\\\"No anomaly during the regtest for {}\\\".format(refname))\\n except AssertionError:\\n raise AssertionError(\\n \\\"ANOMALY: Disagreement between reference and {} in {}\\\".format(\\n fname, str((self.parent / cwd).absolute())\\n )\\n )\",\n \"def test_outputs_not_created(self):\\n one_process_workflow = \\\"\\\"\\\"file://B <- file://A\\n echo A does not produce B\\n \\\"\\\"\\\"\\n process = run_first_process(one_process_workflow)\\n assert process.success is False, process.error_message\\n assert process.error_message.find(\\\"these resources should have been created\\\") >= 0, process.error_message\\n assert process.error_message.find(\\\"* file://B\\\") >= 0, process.error_message\",\n \"def test_make_output_folder_blank_path(self):\\n test_object = Maic()\\n expected_result = \\\"\\\"\\n self.assertEqual(expected_result,\\n test_object.make_output_folder(output_folder=\\\"\\\"),\\n \\\"Should get back an empty string for an output \\\"\\n \\\"folder specified as ''\\\")\",\n \"def sanity_check_step(self):\\n custom_paths = {\\n 'files':[\\\"%s/%s\\\" % (self.bindir, x) for x in [\\\"convert\\\", \\\"cplex\\\", \\\"cplexamp\\\"]],\\n 'dirs':[],\\n }\\n super(EB_CPLEX, self).sanity_check_step(custom_paths=custom_paths)\",\n \"def test_make_output_folder_undefined_path(self):\\n test_object = Maic()\\n expected_result = \\\"\\\"\\n self.assertEqual(expected_result,\\n test_object.make_output_folder(output_folder=None),\\n \\\"Should get back an empty string for an undefined \\\"\\n \\\"output folder\\\")\",\n \"def validate(ctx):\\n handler = ValidateCommandHandler(ctx.obj['qa_dir'])\\n exit(0 if handler.validate() else 1)\",\n \"def workspace_exists(client, workspace):\\n data = {\\\"workspace\\\": workspace}\\n return client._creoson_post(\\\"windchill\\\", \\\"workspace_exists\\\", data, \\\"exists\\\")\",\n \"def _check_before_run(self):\\n\\t\\tif not osp.exists(self.dataset_dir):\\n\\t\\t\\traise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n\\t\\tif not osp.exists(self.train_dir):\\n\\t\\t\\traise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\\n\\t\\tif not osp.exists(self.query_dir):\\n\\t\\t\\traise RuntimeError(\\\"'{}' is not available\\\".format(self.query_dir))\\n\\t\\tif not osp.exists(self.gallery_dir):\\n\\t\\t\\traise RuntimeError(\\\"'{}' is not available\\\".format(self.gallery_dir))\",\n \"def check_dest_root(self):\\n dest_root = self.view.folder_line.text()\\n if not os.path.isdir(dest_root):\\n try:\\n os.makedirs(dest_root)\\n except (WindowsError, TypeError):\\n self.view.message.setText('Please input a valid folder path.')\\n return False\\n return True\",\n \"def test_invalid_workspace(self):\\n self.assertFalse(\\n cifuzz.build_fuzzers(\\n EXAMPLE_PROJECT,\\n 'oss-fuzz',\\n 'not/a/dir',\\n commit_sha='0b95fe1039ed7c38fea1f97078316bfc1030c523',\\n ))\",\n \"def test_failedCommandProvidesOutput(self):\\n bookTeX = FilePath(self.mktemp() + \\\".tex\\\")\\n builder = BookBuilder()\\n inputState = bookTeX.parent().children()\\n exc = self.assertRaises(\\n CommandFailed,\\n builder.buildPDF,\\n bookTeX, self.howtoDir, FilePath(self.mktemp()))\\n self.assertTrue(exc.output)\\n newOutputState = set(bookTeX.parent().children()) - set(inputState)\\n self.assertEqual(len(newOutputState), 1)\\n workPath = newOutputState.pop()\\n self.assertTrue(\\n workPath.isdir(),\\n \\\"Expected work path %r was not a directory.\\\" % (workPath.path,))\",\n \"def prepare_run(input_path: str, output_path: str, tmp: str) -> None:\\n input_file_exists(input_path)\\n if os.path.isdir(output_path) and len(os.listdir(output_path)) != 0:\\n raise AssertionError(\\\"output folder must be empty or non-existent.\\\")\\n set_tempdir(tmp)\\n os.makedirs(output_path, exist_ok=True)\",\n \"def ensure_data_folder_existence() -> None:\\n folder_name = params.DATA_FOLDER_NAME\\n if not folder_name in os.listdir('.'):\\n os.mkdir(folder_name)\",\n \"def __init_output_folder():\\n try:\\n os.makedirs(Result.__json_dir)\\n except OSError as e:\\n if e.errno != errno.EEXIST:\\n raise e\",\n \"def _check_before_run(self):\\r\\n if not osp.exists(self.dataset_dir):\\r\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\r\\n if not osp.exists(self.train_dir):\\r\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\",\n \"def ensure_exists(output_dir):\\n try:\\n makedirs(output_dir)\\n except OSError:\\n if not isdir(output_dir):\\n raise\",\n \"def santityCheckInitialization(self):\\r\\n\\r\\n for obj in self.config[\\\"repos\\\"]:\\r\\n if not isdir(obj[\\\"path\\\"]):\\r\\n print(\\\"ERROR : Initialization Failed missing {} at path {}\\\".format(obj[\\\"name\\\"], obj[\\\"path\\\"]))\",\n \"def check_working_directory():\\n if not os.path.exists(CUCKOO_ROOT):\\n raise CuckooStartupError(\\\"You specified a non-existing root directory: %s\\\" % CUCKOO_ROOT)\\n\\n cwd = os.path.join(os.getcwd(), \\\"cuckoo.py\\\")\\n if not os.path.exists(cwd):\\n raise CuckooStartupError(\\\"You are not running Cuckoo from it's root directory\\\")\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.train_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\\n if not osp.exists(self.list_query_path):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.list_query_path))\\n if not osp.exists(self.list_gallery_path):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.list_gallery_path))\",\n \"def check_for_setup_error(self):\\n if self.share2nms:\\n for nfs_share in self.share2nms:\\n nms = self.share2nms[nfs_share]\\n volume_name, dataset = self._get_share_datasets(nfs_share)\\n if not nms.volume.object_exists(volume_name):\\n raise LookupError(_(\\\"Volume %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), volume_name)\\n folder = '%s/%s' % (volume_name, dataset)\\n if not nms.folder.object_exists(folder):\\n raise LookupError(_(\\\"Folder %s does not exist in Nexenta \\\"\\n \\\"Store appliance\\\"), folder)\\n if (folder not in nms.netstorsvc.get_shared_folders(\\n 'svc:/network/nfs/server:default', '')):\\n self._share_folder(nms, volume_name, dataset)\\n self._get_capacity_info(nfs_share)\",\n \"def test_raises_when_assignment_tests_directory_is_non_empty(\\n self, tmp_path_factory, platform_url, workdir, rtd_path\\n ):\\n # arrange\\n existing_assignment_dir = rtd_path / ASSIGNMENT_NAMES[0]\\n existing_assignment_dir.mkdir(parents=True)\\n\\n # act/assert\\n result = run_generate_rtd(\\n base_url=platform_url, rtd=rtd_path, workdir=workdir\\n )\\n\\n assert result.status == plug.Status.ERROR\\n assert existing_assignment_dir.name in result.msg\\n assert \\\"delete\\\" in result.msg\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.train_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\\n if not osp.exists(self.test_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.test_dir))\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\\n if not osp.exists(self.train_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.train_dir))\\n if not osp.exists(self.probe_gallery_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.probe_gallery_dir))\",\n \"def _VerifySDKEnvironment(self):\\n # If the environment wasn't set up, then the output directory wouldn't be\\n # created after 'gn gen'.\\n # TODO: Make this check actually look at the environment.\\n if not os.path.exists(self.out_board_dir):\\n raise AssertionError('%s not created!' % self.out_board_dir)\\n # Log args.gn for debugging.\\n logging.info('ARGS.GN=\\\\n%s',\\n osutils.ReadFile(os.path.join(self.out_board_dir, 'args.gn')))\",\n \"def initialized(self):\\n return self.workspace == find_enclosing_workspace(self.workspace)\",\n \"def check_working_dir(directory):\\n filepath = os.path.join(directory, \\\"text.txt\\\")\\n try:\\n open(filepath, \\\"w\\\")\\n except IOError:\\n sys.exit('Unable to write to directory {0} \\\\n Exiting Drupdates'.format(directory))\\n return False\\n return True\",\n \"def cleanOutputDir(output):\\n if os.path.exists(output) and os.path.isdir(output):\\n shutil.rmtree(output)\",\n \"def test_output_directory_with_space(self):\\n temp_out_dir = \\\"xxmotif test\\\"\\n input_file = self.copy_and_mark_for_cleanup(\\\"Fasta/f002\\\")\\n\\n try:\\n XXmotifCommandline(outdir=temp_out_dir, seqfile=input_file)\\n except ValueError:\\n pass\\n else:\\n self.fail(\\\"expected ValueError\\\")\",\n \"def validate_full_design(self, name=None, outputdir=None, ports=None):\\n if name is None:\\n name = self.design_name\\n if outputdir is None:\\n outputdir = self.project_path\\n\\n self.logger.glb.info(\\\"#### Design Validation Checks###\\\")\\n #\\n # Routine outputs to the validation info to a log file in the project directory and also\\n # returns the validation info to be used to update properties.xml file\\n\\n validation_ok = True\\n\\n #\\n # Write an overall validation log file with all output from all checks\\n # The design validation inside HFSS outputs to a separate log file which we merge into this overall file\\n #\\n val_list = []\\n all_validate = outputdir + \\\"\\\\\\\\all_validation.log\\\"\\n with open(all_validate, \\\"w\\\") as validation:\\n\\n # Desktop Messages\\n msg = \\\"Desktop Messages:\\\"\\n validation.writelines(msg + \\\"\\\\n\\\")\\n val_list.append(msg)\\n msgs = self._desktop.GetMessages(name, \\\"HFSSDesign1\\\", 0)\\n # need to check if design name is always this default name HFSSDesign1\\n for msg in msgs:\\n self.logger.glb.info(msg)\\n # msg = msg.replace('\\\"','')\\n msg = msg.rstrip(\\\"\\\\r\\\\n\\\")\\n val_list.append(msg)\\n validation.writelines(msg + \\\"\\\\n\\\")\\n\\n # Run Design Validation and write out the lines to the logger\\n\\n ret = self._odesign.ValidateCircuit()\\n msg = \\\"Design Validation Messages:\\\"\\n validation.writelines(msg + \\\"\\\\n\\\")\\n val_list.append(msg)\\n if ret == 0:\\n msg = \\\"**** ERRORS Present - please check and confirm\\\"\\n self.logger.glb.error(msg)\\n else:\\n msg = \\\"**** Validation Completed Correctly\\\"\\n self.logger.glb.info(msg)\\n\\n # Find the Excitations and check or list them out\\n msg = \\\"Excitation Messages:\\\"\\n validation.writelines(msg + \\\"\\\\n\\\")\\n val_list.append(msg)\\n numportsdefined = int(len(self.get_excitations_name))\\n if ports is not None and ports != numportsdefined:\\n msg = \\\"**** Port Number Error! - Please check model\\\"\\n self.logger.glb.error(msg)\\n validation.writelines(msg + \\\"\\\\n\\\")\\n val_list.append(msg)\\n validation_ok = False\\n # need to stop the simulation athis point\\n else:\\n msg1 = \\\"Ports Requested: \\\" + str(ports)\\n msg2 = \\\"Ports Defined: \\\" + str(numportsdefined)\\n self.logger.glb.info(msg1)\\n validation.writelines(msg1 + \\\"\\\\n\\\")\\n val_list.append(msg1)\\n self.logger.glb.info(msg2)\\n validation.writelines(msg2 + \\\"\\\\n\\\")\\n val_list.append(msg2)\\n\\n excitation_names = self.get_excitations_name\\n for excitation in excitation_names:\\n msg = \\\"Excitation name: \\\" + str(excitation)\\n self.logger.glb.info(msg)\\n validation.writelines(msg + \\\"\\\\n\\\")\\n val_list.append(msg)\\n validation.close()\\n return val_list, validation_ok # return all the info in a list for use later\",\n \"def test_local_validation(tmpdir):\\n with tmpdir.as_cwd():\\n with pytest.raises(FileNotFoundError):\\n validate_nagl_model_path(\\\"test.pt\\\")\\n\\n with open(\\\"test.pt\\\", \\\"w\\\") as f:\\n f.write(\\\"test\\\")\\n model_path = validate_nagl_model_path(\\\"test.pt\\\")\\n assert os.path.exists(model_path)\",\n \"def prepare_supplemental_output_directory():\\n output_dir = workspace_path('%s/%s' % (scenario_filename(), \\\"Supplemental Output Files\\\")) # this does not have the .db suffix\\n output_args = ['--output-dir', output_dir] # to be returned and passed to adsm_simulation.exe\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir, exist_ok=True)\\n return output_args\",\n \"def check_grid(gridname,modeldirs=None):\\n\\n chgriddir(gridname)\\n \\n # guess the model directories \\n modeldirs = get_modeldirs(modeldirs)\\n \\n for modeldir in modeldirs:\\n if not os.path.isfile(modeldir+\\\"/finished.out\\\"):\\n print(\\\"Model \\\"+modeldir+\\\" failed:\\\")\",\n \"def check_output_dir(args, expected_items=0):\\n if (\\n os.path.exists(args.output_dir)\\n and len(os.listdir(args.output_dir)) > expected_items\\n and args.do_train\\n and not args.overwrite_output_dir\\n ):\\n raise ValueError(\\n f\\\"Output directory ({args.output_dir}) already exists and \\\"\\n f\\\"has {len(os.listdir(args.output_dir))} items in it (expected {expected_items} items). \\\"\\n \\\"Use --overwrite_output_dir to overcome.\\\"\\n )\",\n \"def test_empty_output_successful(self):\\n\\n manifest = copy.deepcopy(job_test_utils.COMPLETE_MANIFEST)\\n manifest['job']['interface']['outputs'] = {}\\n\\n json_data = {\\n 'manifest': manifest,\\n 'configuration': self.configuration\\n }\\n\\n url = '/%s/job-types/validation/' % self.api\\n response = self.client.generic('POST', url, json.dumps(json_data), 'application/json')\\n self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)\\n\\n results = json.loads(response.content)\\n self.assertTrue(results['is_valid'])\\n self.assertDictEqual(results, {u'errors': [], u'is_valid': True, u'warnings': []})\",\n \"def __checkDestination(self):\\n return os.path.exists(self.__targetPath)\",\n \"def sense(self):\\n\\n partition_folder = self.getPartitionFolder()\\n log_folder = os.path.join(partition_folder, 'var/log')\\n log_name = 'slapgrid-%s-error.log' % self.getConfig('partition-id')\\n slapgrid_error_log_file = os.path.join(partition_folder, '.%s' % log_name)\\n link_file = os.path.join(log_folder, log_name)\\n monitor_url = self.getConfig('monitor-url')\\n message = ''\\n if os.path.exists(slapgrid_error_log_file) and \\\\\\n os.stat(slapgrid_error_log_file).st_size:\\n message = 'Buildout failed to process %s.' % self.getConfig('partition-id')\\n if monitor_url:\\n message += '\\\\nSee %s/log/%s for more information.' % (monitor_url, log_name)\\n if not os.path.exists(link_file):\\n os.symlink(slapgrid_error_log_file, link_file)\\n else:\\n if os.path.exists(link_file):\\n os.unlink(link_file)\\n\\n if message:\\n self.logger.error(message)\\n else:\\n self.logger.info(\\\"buildout is OK\\\")\",\n \"def validate_input(self):\\n inputs = self.inputs\\n if 'remote_data' in inputs:\\n input_ok = True\\n else:\\n input_ok = False\\n return self.exit_codes.ERROR_NO_INPUT_REMOTE_DATA # pylint: disable=no-member\\n input_remote = self.inputs.remote_data\\n parents = input_remote.get_incoming(node_class=CalcJobNode)\\n nparents = len(parents.all_link_labels())\\n\\n if nparents != 1:\\n # extract parent workflow and get uuid of last calc from output node\\n parent_workflow = input_remote.inputs.last_RemoteData\\n if not isinstance(parent_workflow, WorkChainNode):\\n return self.exit_codes.ERROR_INVALID_REMOTE_DATA_TPYE # pylint: disable=no-member\\n\\n parent_workflow_out = parent_workflow.outputs.output_kkr_scf_wc_ParameterResults\\n uuid_last_calc = parent_workflow_out.get_dict().get('last_calc_nodeinfo').get('uuid')\\n last_calc = load_node(uuid_last_calc)\\n\\n if not isinstance(last_calc, KkrCalculation) and not isinstance(last_calc, VoronoiCalculation):\\n return self.exit_code.ERROR_INVALID_REMOTE_DATA_TPYE\\n\\n # overwrite remote_data node with extracted remote folder\\n output_remote = last_calc.outputs.remote_folder\\n\\n self.inputs.remote_data = output_remote\\n\\n # extract structure\\n struc_kkr, _ = VoronoiCalculation.find_parent_structure(self.inputs.remote_data)\\n # save if structure is an alloy\\n self.ctx.struc_is_alloy = struc_kkr.is_alloy\\n\\n # To validate for kpoints\\n if 'kpoints' in inputs:\\n self.ctx.BS_kpoints = inputs.kpoints\\n input_ok = True\\n self.ctx.structure_data = 'None (kpoints taken from input)'\\n else:\\n #create an auxiliary structure with unique kind_names, this leads to using the input structure in the seekpath method instead of finding the primitive one\\n cell = np.array(struc_kkr.cell)\\n if not struc_kkr.pbc[2]:\\n # 2D structure, make sure the third bravais vector points along z\\n cell[2] = np.cross(cell[0], cell[1])\\n saux = StructureData(cell=cell)\\n for isite, site in enumerate(struc_kkr.sites):\\n kind = struc_kkr.get_kind(site.kind_name)\\n saux.append_atom(\\n name='atom' + str(isite) + ':' + site.kind_name,\\n symbols=kind.symbols,\\n weights=kind.weights,\\n position=site.position\\n )\\n # use auxiliary structure inside k-point generator\\n output = get_explicit_kpoints_path(saux)\\n primitive_struc = output['primitive_structure']\\n conventional_struc = output['conv_structure']\\n kpoints_ok = True\\n\\n #check if primitive_structure and input structure are identical:\\n maxdiff_cell = sum(abs(np.array(primitive_struc.cell) - np.array(saux.cell))).max()\\n\\n if maxdiff_cell > 3 * 10**-9:\\n self.report(f'Error in cell : {maxdiff_cell}')\\n self.report(\\n 'WARNING : The structure data from the voronoi calc is not the primitive structure type and in come cases it is medatory'\\n )\\n self.report(f'prim: {primitive_struc.cell} {primitive_struc.sites}')\\n self.report(f'conv: {conventional_struc.cell} {conventional_struc.sites}')\\n self.ctx.structure_data = 'conventional_unit_cell '\\n else:\\n self.ctx.structure_data = 'primitive_unit_cell'\\n\\n if not kpoints_ok:\\n return self.exit_codes.ERROR_INCORRECT_KPOINTS_EXTRACTED # pylint: disable=no-member\\n else:\\n kpts = output['explicit_kpoints']\\n\\n self.ctx.BS_kpoints = kpts\\n if isinstance(KpointsData(), type(kpts)):\\n input_ok = True\\n else:\\n input_ok = False\\n return self.exit_codes.ERROR_NO_KPOINTS_EXTRACTED # pylint: disable=no-member\\n\\n # To validate for kkr\\n if 'kkr' in inputs:\\n try:\\n test_and_get_codenode(inputs.kkr, 'kkr.kkr', use_exceptions=True)\\n except ValueError:\\n input_ok = False\\n return self.exit_codes.ERROR_KKRCODE_NOT_CORRECT # pylint: disable=no-member\\n\\n # set self.ctx.input_params_KKR\\n self.ctx.input_params_KKR = get_parent_paranode(self.inputs.remote_data)\\n self.report(f'The validation input_ok {input_ok}')\",\n \"def check_training_package(folder, ruleset, quiet, werror):\\n check_training_result_files(folder, ruleset, quiet, werror)\",\n \"def assert_sources_folder_exist(command: commands.FilesRelatedCommand,\\n filesystem: infra.Filesystem,\\n stdout: infra.STDOut) -> None:\\n if filesystem.not_exists(command.sources_folder):\\n stdout.red(f'Sources folder does not exist: {command.sources_folder}')\\n sys.exit(1)\",\n \"def ValidateOutput(self, stdout, stderr, result):\\n # Store .ref and .log files in a platform-specific subdirectory\\n # (avoid possible clashes if several platforms are tested)\\n if \\\"CMTCONFIG\\\" in os.environ:\\n try: os.mkdir( os.environ['CMTCONFIG'] )\\n except OSError: pass\\n stdout_log_path=os.environ['CMTCONFIG']+os.sep\\n else:\\n stdout_log_path=''\\n # Maybe some verbosity is needed here\\n if not(self.stdout_tag==''):\\n strlog='the tag is ' + self.stdout_tag\\n logger.debug('ExecTestBase2:ValidateOutput: '+strlog)\\n if not(self.stdout_tol==0):\\n strlog='the tolerance is ' + repr(self.stdout_tol) \\n logger.debug('ExecTestBase2:ValidateOutput: '+strlog)\\n if not(self.stdout_ref==''):\\n if not(self.stdout_ref_path==''):\\n self.reference_file=self.stdout_ref_path+os.sep+self.stdout_ref \\n else:\\n self.reference_file=self.stdout_ref \\n if os.path.abspath(self.reference_file) != os.path.abspath(stdout_log_path+str(self.stdout_ref)):\\n shutil.copyfile(os.path.abspath(self.reference_file),\\n stdout_log_path+str(self.stdout_ref))\\n ref_file_stdout=''\\n for l in fileinput.input(stdout_log_path+str(self.stdout_ref)): \\n ref_file_stdout=ref_file_stdout+l.strip()+'\\\\n'\\n if not(self.excluded_lines==''):\\n strlog='the excluded lines are ' + self.excluded_lines \\n logger.debug('ExecTestBase2:ValidateOutput: '+strlog) \\n # Copy the log for later use as ref \\n f_ouput=open(stdout_log_path+self.stdout_ref.rstrip('ref')+'log', 'w')\\n f_ouput.write(stdout)\\n f_ouput.close()\\n # Check to see if the standard output matches.\\n self.causes = []\\n if not(self.stdout=='*'):\\n if not(self.stdout_ref==''):\\n # the reference output is described in a\\n # external reference file \\n if not self.__CompareText1(stdout, ref_file_stdout, result):\\n self.causes.append(\\\"standard output\\\") \\n result[\\\"ExecTest.expected_stdout\\\"] = result.Quote(self.stdout)\\n else:\\n # the reference output is described in the test-case\\n if not self.__CompareText1(stdout, self.stdout,result):\\n self.causes.append(\\\"standard output\\\") \\n result[\\\"ExecTest.expected_stdout\\\"] = result.Quote(self.stdout)\\n else:\\n result[\\\"ExecTest.expected_stdout\\\"] = result.Quote(self.stdout)\\n \\n # Check to see if the standard error matches.\\n if not(self.stderr=='*'):\\n if not self.__CompareText(stderr, self.stderr):\\n self.causes.append(\\\"standard error\\\")\\n result[\\\"ExecTest.expected_stderr\\\"] = result.Quote(self.stderr)\\n else: \\n result[\\\"ExecTest.expected_stderr\\\"] = result.Quote(self.stderr)\\n #\\n return self.causes\",\n \"def _check_before_run(self):\\n if not osp.exists(self.dataset_dir):\\n raise RuntimeError(\\\"'{}' is not available\\\".format(self.dataset_dir))\",\n \"def checkGlobalConflicts(self):\\n\\t\\tappionScript.AppionScript.checkGlobalConflicts(self)\\n\\n\\t\\tif self.params['runname'] is None:\\n\\t\\t\\tapDisplay.printError(\\\"please enter a runname, example: 'runname=run1'\\\")\\n\\t\\tif self.params['runname'] == 'templates':\\n\\t\\t\\tapDisplay.printError(\\\"templates is a reserved runname, please use another runname\\\")\\n\\t\\tif self.params['runname'] == 'models':\\n\\t\\t\\tapDisplay.printError(\\\"models is a reserved runname, please use another runname\\\")\\n\\t\\tif self.params['rundir']is not None and self.params['runname'] != os.path.basename(self.params['rundir']):\\n\\t\\t\\tapDisplay.printError(\\\"runname and rundir basename are different: \\\"\\n\\t\\t\\t\\t+self.params['runname']+\\\" vs. \\\"+os.path.basename(self.params['rundir']))\\n\\t\\tif self.params['mrcnames'] and self.params['preset']:\\n\\t\\t\\tapDisplay.printError(\\\"preset can not be specified if particular images have been specified\\\")\\n\\t\\tif self.params['sessionname'] is None and self.params['mrcnames'] is None:\\n\\t\\t\\tapDisplay.printError(\\\"please specify an mrc name or session\\\")\\n\\t\\tif self.params['sessionname'] is not None and self.params['projectid'] is not None:\\n\\t\\t\\t### Check that project and tilt series are in sync\\n\\t\\t\\tseriesproject = apProject.getProjectIdFromSessionName(self.params['sessionname'])\\n\\t\\t\\tif seriesproject and seriesproject != self.params['projectid']:\\n\\t\\t\\t\\tapDisplay.printError(\\\"project id and session do not correlate\\\")\",\n \"def check_settings(args):\\n print('')\\n print('-'*80)\\n print('CHECK SETTINGS:\\\\n')\\n\\n pypath= os.path.abspath(os.path.split(oxbs_qc.__file__)[0])\\n checkList= []\\n sys.stdout.write('Check output directory \\\"%s\\\" is writable... ' %(args.outdir))\\n passed= os.access(args.outdir, os.W_OK)\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('outdir', passed))\\n\\n ## samtools\\n ## -----------\\n tg= spawn.find_executable('samtools')\\n\\n if tg is None:\\n passed= False\\n else:\\n passed= os.path.isfile(tg)\\n\\n sys.stdout.write('Check samtools \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('samtools', passed))\\n\\n ## samtools\\n ## -----------\\n tg= spawn.find_executable('bedtools')\\n\\n if tg is None:\\n passed= False\\n else:\\n passed= os.path.isfile(tg)\\n\\n sys.stdout.write('Check bedtools \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED (methyaltion can\\\\'t be called)\\\\n')\\n checkList.append(('bedtools', passed))\\n\\n\\n ## cutadapt\\n ## trim_glore doesn't have a cutadapt path options. So it must be on the PATH\\n ## -----------\\n tg= spawn.find_executable('cutadapt')\\n if tg is None:\\n passed= False\\n else:\\n passed= os.path.isfile(tg)\\n\\n sys.stdout.write('Check cutadapt \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('cutadapt', passed))\\n\\n ## Trim galore\\n ## -----------\\n if args.trim_galore_path is None:\\n tgpath= os.path.abspath(os.path.split(oxbs_qc.__file__)[0])\\n else:\\n tgpath= args.trim_galore_path \\n tg= os.path.join(tgpath, 'trim_galore')\\n passed= os.path.isfile(tg)\\n\\n sys.stdout.write('Check trim_galore \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('trim_galore', passed))\\n\\n ## bismark\\n ## -------\\n if args.bismark_path is None:\\n tgpath= os.path.abspath(os.path.split(oxbs_qc.__file__)[0])\\n else:\\n tgpath= args.bismark_path \\n tg= os.path.join(tgpath, 'bismark')\\n passed= os.path.isfile(tg)\\n\\n sys.stdout.write('Check bismark \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('bismark', passed))\\n\\n ## clipOverlap\\n ## -----------\\n if args.clipoverlap_path == '':\\n tg= spawn.find_executable('bam')\\n else:\\n tg= os.path.join(args.clipoverlap_path, 'bam')\\n \\n if tg is None:\\n passed= False\\n else:\\n passed= os.path.isfile(tg)\\n\\n sys.stdout.write('Check bam clipOverlap \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('clipOverlap', passed))\\n\\n ## R\\n ## -----------\\n if args.rscript_path == '':\\n tg= spawn.find_executable('Rscript')\\n else:\\n tg= os.path.join(args.rscript_path, 'Rscript')\\n\\n if tg is None:\\n passed= False\\n else:\\n passed= os.path.isfile(tg)\\n\\n sys.stdout.write('Check R/Rscript \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('R/Rscript', passed))\\n\\n\\n ## Custom scripts\\n ## --------------\\n tg= os.path.join(pypath, 'FastQC/fastqc')\\n passed= os.path.isfile(tg)\\n sys.stdout.write('Check fastqc \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('fastqc', passed))\\n\\n tg= os.path.join(pypath, 'ShortenFastq.jar')\\n passed= os.path.isfile(tg)\\n sys.stdout.write('Check ShortenFastq.jar \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('ShortenFastq.jar', passed))\\n\\n tg= os.path.join(pypath, 'MarkDuplicates.jar')\\n passed= os.path.isfile(tg)\\n sys.stdout.write('Check MarkDuplicates.jar \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('MarkDuplicates.jar', passed))\\n\\n tg= os.path.join(pypath, 'cleanReadNames.py')\\n passed= os.path.isfile(tg)\\n sys.stdout.write('Check cleanReadNames.py \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('cleanReadNames.py.py', passed))\\n\\n #tg= os.path.join(pypath, 'mpileup2methylation.py')\\n #passed= os.path.isfile(tg)\\n #sys.stdout.write('Check mpileup2methylation.py \\\"%s\\\"... ' %(tg))\\n #if passed:\\n # sys.stdout.write('OK\\\\n')\\n #else:\\n # sys.stdout.write('FAILED\\\\n')\\n #checkList.append(('mpileup2methylation.py', passed))\\n \\n tg= os.path.join(pypath, 'bam2methylation.py')\\n passed= os.path.isfile(tg)\\n sys.stdout.write('Check bam2methylation.py \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('bam2methylation.py', passed))\\n \\n tg= os.path.join(pypath, 'oxbs_report.R')\\n passed= os.path.isfile(tg)\\n sys.stdout.write('Check oxbs_report.R \\\"%s\\\"... ' %(tg))\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('oxbs_report.R', passed))\\n\\n ## Reference FASTA\\n sys.stdout.write('Check reference FASTA \\\"%s\\\"... ' %(args.ref))\\n if args.ref is None:\\n tg= None\\n passed= False\\n sys.stdout.write('FAILED\\\\n')\\n elif os.path.isfile(args.ref):\\n sys.stdout.write('OK\\\\n')\\n passed= True\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n passed= False\\n checkList.append(('Ref. FASTA', passed))\\n \\n ## Reference TXT\\n sys.stdout.write('Check reference TXT \\\"%s\\\"... ' %(args.ref))\\n if args.ref is None:\\n tg= None\\n passed= False\\n sys.stdout.write('FAILED\\\\n')\\n else:\\n txt= os.path.splitext(args.ref)[0] + '.txt'\\n if os.path.isfile(txt):\\n sys.stdout.write('OK\\\\n')\\n passed= True\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n passed= False\\n checkList.append(('Ref. TXT', passed))\\n \\n ## List of BED positions:\\n if args.listpos is not None:\\n sys.stdout.write('Check bed file of positions \\\"%s\\\"... ' %(args.listpos))\\n if os.path.isfile(args.listpos):\\n sys.stdout.write('OK\\\\n')\\n passed= True\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n passed= False\\n checkList.append(('Bed file of positions', passed))\\n \\n ## Check bowtie2 indexes\\n ##refbt2= os.path.split(args.ref)[0] + 'Bisulfite_Genome'\\n ## ...\\n \\n sys.stdout.write('Check prefix \\\"%s\\\"... ' %(args.prefix))\\n try:\\n passed= validate_prefix(args.prefix)\\n except ValidArgException:\\n passed= False\\n if passed:\\n sys.stdout.write('OK\\\\n')\\n else:\\n sys.stdout.write('FAILED\\\\n')\\n checkList.append(('prefix', passed))\\n \\n print('')\\n print('-'*80)\\n for x in checkList:\\n if not x[1]:\\n print(x[0] + ' ' + 'FAILED')\\n print('')\\n return(checkList)\",\n \"def _assert_build_info(self):\\n if not self.path.exists():\\n from zensols.pybuild import SetupUtil\\n self.path.parent.mkdir(parents=True, exist_ok=True)\\n if not self.rel_setup_path.exists():\\n raise OSError('configuration file does not ' +\\n f'exist: {self.rel_setup_path}')\\n su = SetupUtil.source(rel_setup_path=self.rel_setup_path)\\n logger.info(f'saving build info to {self.path}')\\n with open(self.path, 'w') as f:\\n su.to_json(writer=f)\",\n \"def validate(self):\\n variables = ['bottomDepth', 'ssh', 'layerThickness', 'zMid',\\n 'maxLevelCell', 'temperature', 'salinity']\\n compare_variables(\\n test_case=self, variables=variables,\\n filename1='initial_state/initial_state.nc')\\n\\n variables = ['temperature', 'salinity', 'layerThickness',\\n 'normalVelocity']\\n compare_variables(test_case=self, variables=variables,\\n filename1='full_run/output.nc',\\n filename2='restart_run/output.nc')\\n\\n variables = ['ssh', 'landIcePressure', 'landIceDraft',\\n 'landIceFraction',\\n 'landIceMask', 'landIceFrictionVelocity', 'topDrag',\\n 'topDragMagnitude', 'landIceFreshwaterFlux',\\n 'landIceHeatFlux', 'heatFluxToLandIce',\\n 'landIceBoundaryLayerTemperature',\\n 'landIceBoundaryLayerSalinity',\\n 'landIceHeatTransferVelocity',\\n 'landIceSaltTransferVelocity',\\n 'landIceInterfaceTemperature',\\n 'landIceInterfaceSalinity', 'accumulatedLandIceMass',\\n 'accumulatedLandIceHeat']\\n compare_variables(test_case=self, variables=variables,\\n filename1='full_run/land_ice_fluxes.nc',\\n filename2='restart_run/land_ice_fluxes.nc')\\n\\n variables = ['accumulatedFrazilIceMass',\\n 'accumulatedFrazilIceSalinity',\\n 'seaIceEnergy', 'frazilLayerThicknessTendency',\\n 'frazilTemperatureTendency', 'frazilSalinityTendency',\\n 'frazilSurfacePressure',\\n 'accumulatedLandIceFrazilMass']\\n compare_variables(test_case=self, variables=variables,\\n filename1='full_run/frazil.nc',\\n filename2='restart_run/frazil.nc')\",\n \"def _checkIntegrity(self):\\n return (\\n os.path.isfile(os.path.join(self._root, 'processed/train.pkl'))\\n and os.path.isfile(os.path.join(self._root, 'processed/test.pkl')))\",\n \"def check(self):\\n self.init()\\n self.calculate_output()\\n self.compare_outputs_with_expects()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6972508","0.65746725","0.65183914","0.6397043","0.6383192","0.6307421","0.60515106","0.60397726","0.5996995","0.5954663","0.5945204","0.59358025","0.58788586","0.58496416","0.58496416","0.577803","0.572291","0.56724334","0.5628311","0.56132805","0.55874103","0.5541713","0.5536222","0.5505645","0.5494801","0.54901916","0.5467604","0.54672295","0.5461337","0.5450424","0.54499495","0.543761","0.54301184","0.54046744","0.537678","0.537678","0.53734046","0.5360128","0.53588945","0.53519976","0.5349346","0.5342365","0.5339571","0.5337366","0.5331806","0.5331806","0.5331806","0.5331806","0.5331806","0.5331806","0.5331806","0.5327412","0.53218377","0.5315302","0.5313363","0.5310116","0.5303679","0.5302499","0.5300942","0.5298201","0.5292504","0.526105","0.525253","0.52461797","0.52356625","0.5226631","0.5224625","0.5224186","0.5210588","0.5209039","0.5208011","0.52011806","0.5193056","0.5191687","0.51871824","0.5182416","0.5181366","0.5161747","0.5160764","0.5160578","0.5154812","0.51371455","0.5134891","0.51318324","0.51314414","0.5131182","0.5128631","0.51260924","0.5125647","0.5125474","0.5124305","0.5123971","0.51220125","0.5121909","0.5115323","0.5115142","0.51094776","0.5104965","0.5101601","0.5100693"],"string":"[\n \"0.6972508\",\n \"0.65746725\",\n \"0.65183914\",\n \"0.6397043\",\n \"0.6383192\",\n \"0.6307421\",\n \"0.60515106\",\n \"0.60397726\",\n \"0.5996995\",\n \"0.5954663\",\n \"0.5945204\",\n \"0.59358025\",\n \"0.58788586\",\n \"0.58496416\",\n \"0.58496416\",\n \"0.577803\",\n \"0.572291\",\n \"0.56724334\",\n \"0.5628311\",\n \"0.56132805\",\n \"0.55874103\",\n \"0.5541713\",\n \"0.5536222\",\n \"0.5505645\",\n \"0.5494801\",\n \"0.54901916\",\n \"0.5467604\",\n \"0.54672295\",\n \"0.5461337\",\n \"0.5450424\",\n \"0.54499495\",\n \"0.543761\",\n \"0.54301184\",\n \"0.54046744\",\n \"0.537678\",\n \"0.537678\",\n \"0.53734046\",\n \"0.5360128\",\n \"0.53588945\",\n \"0.53519976\",\n \"0.5349346\",\n \"0.5342365\",\n \"0.5339571\",\n \"0.5337366\",\n \"0.5331806\",\n \"0.5331806\",\n \"0.5331806\",\n \"0.5331806\",\n \"0.5331806\",\n \"0.5331806\",\n \"0.5331806\",\n \"0.5327412\",\n \"0.53218377\",\n \"0.5315302\",\n \"0.5313363\",\n \"0.5310116\",\n \"0.5303679\",\n \"0.5302499\",\n \"0.5300942\",\n \"0.5298201\",\n \"0.5292504\",\n \"0.526105\",\n \"0.525253\",\n \"0.52461797\",\n \"0.52356625\",\n \"0.5226631\",\n \"0.5224625\",\n \"0.5224186\",\n \"0.5210588\",\n \"0.5209039\",\n \"0.5208011\",\n \"0.52011806\",\n \"0.5193056\",\n \"0.5191687\",\n \"0.51871824\",\n \"0.5182416\",\n \"0.5181366\",\n \"0.5161747\",\n \"0.5160764\",\n \"0.5160578\",\n \"0.5154812\",\n \"0.51371455\",\n \"0.5134891\",\n \"0.51318324\",\n \"0.51314414\",\n \"0.5131182\",\n \"0.5128631\",\n \"0.51260924\",\n \"0.5125647\",\n \"0.5125474\",\n \"0.5124305\",\n \"0.5123971\",\n \"0.51220125\",\n \"0.5121909\",\n \"0.5115323\",\n \"0.5115142\",\n \"0.51094776\",\n \"0.5104965\",\n \"0.5101601\",\n \"0.5100693\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6396854"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":3287,"cells":{"query":{"kind":"string","value":"Adds the required columns to the table and appends new records if given."},"document":{"kind":"string","value":"def extend_table(table, rows=None):\n try:\n if rows is None:\n rows = []\n dtypes = np.dtype(\n [\n ('_ID', np.int),\n ('MEAN_DEF_CNT', np.float64),\n ('MEDIAN_DEF_CNT', np.int32),\n ('MIN_DEF_CNT', np.int32),\n ('MAX_DEF_CNT', np.int32),\n #STandard deviation\n ('PRI_NUM_DEF', np.int32),\n ('SEC_NUM_DEF', np.int32),\n ('PER_PRI', np.float64),\n ('PER_SEC', np.float64),\n (\"PRI_ATTR_DEF\", '|S20'), # pri_attr\n (\"SEC_ATTR_DEF\", '|S20'),\n ('PRI_ATTR_DEF_PER', np.float64),\n ('SEC_ATTR_DEF_PER', np.float64),\n ('FEATURE_CNT', np.int32),\n ('PRI_ATTR_DEF_CNT', np.float64),\n ('SEC_ATTR_DEF_CNT', np.float64),\n ('LC_SCORE', np.int32)\n ]\n )\n array = np.array(rows, dtypes)\n da.ExtendTable(table, \"OID@\", array, \"_ID\", False)\n return table\n except:\n line, filename, synerror = trace()\n raise FunctionError(\n {\n \"function\": \"extend_table\",\n \"line\": line,\n \"filename\": filename,\n \"synerror\": synerror,\n \"arc\" : str(arcpy.GetMessages(2))\n }\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 add_cols(self, source) :\n\n cols = source.get_cols()\n types = source.get_types()\n\n new_cols = []\n new_types = []\n for i in range(len(cols)) :\n if cols[i] not in self.cols :\n new_cols.append(cols[i])\n new_types.append(types[i])\n self.cols.extend(new_cols)\n self.types.extend(new_types)\n\n self._alter_table(new_cols, new_types)\n\n row_ids = self.get_values('__ROWID')\n \n for col in new_cols :\n new_vals = source.get_values(col)\n if len(row_ids) == 0 :\n for val in new_vals :\n self._insert_internal(['__ROWID', col], [0, val])\n\n row_ids = self.get_values('__ROWID')\n\n else :\n binds = zip(new_vals, row_ids)\n q = self._quoter(col)\n sql_base = 'UPDATE \"%s\" SET \"%s\" = %s WHERE \"__ROWID\" = %%d' % (self.name, col, q)\n cur = self.con.cursor()\n for bind in binds :\n if bind[0] :\n update_sql = sql_base % (str(bind[0]), bind[1])\n cur.execute(update_sql)\n\n self.version += 1","def add_columns(self, table, col_data, col_type):\n conn = psycopg2.connect(self.name, sslmode='require')\n c = conn.cursor()\n for data, typ in zip(col_data, col_type):\n c.execute(\"ALTER TABLE {tn} ADD COLUMN {cn} {ct}\".\n format(tn=table, cn=data, ct=typ))\n conn.commit() \n conn.close()","def add_data(self, rowdata):\n if not rowdata.keys():\n # No columns were specified\n return\n for colnam in rowdata.keys():\n # Check the the column is actually defined in\n # in the table\n try:\n self.list_columns().index(colnam)\n except ValueError:\n # The column name wasn't found\n raise ValueError(\n \"Column \" + str(colnam) + \" is not defined in the table\"\n )\n for icol in range(0, self.ncolumns()):\n # Look up whether the column has an\n # explicit value assigned\n colnam = self.table_column(icol).title()\n if colnam in rowdata:\n self.table_column(icol).append(rowdata[colnam])\n else:\n # Assign a null value\n self.table_column(icol).append(\"*\")","def AddColumns(sqlite_file, table_name):\r\n columns = ['cf_direct_parent','cf_kingdom','cf_superclass',\\\r\n 'cf_class','cf_subclass','cf_intermediate_0','cf_intermediate_1',\\\r\n 'cf_intermediate_2','cf_intermediate_3','cf_intermediate_4',\\\r\n 'cf_intermediate_5','cf_molecular_framework','cf_alternative_parents',\\\r\n 'cf_substituents', 'cf_description']\r\n column_type = 'TEXT'\r\n # Connecting to the database file\r\n conn = sqlite3.connect(sqlite_file) # Connecting to the database\r\n c = conn.cursor() # Adding a cursor to interact with the database\r\n # Adding new column, if it does not exist yet, without a row value\r\n for new_column_name in columns:\r\n try:\r\n c.execute(\"ALTER TABLE {tn} ADD COLUMN '{cn}' {ct}\"\\\r\n .format(tn=table_name, cn=new_column_name, ct=column_type))\r\n print(\"Column created: {cn}\".format(cn=new_column_name))\r\n except sqlite3.OperationalError:\r\n print(\"Column already exists: {cn}\".format(cn=new_column_name))\r\n conn.commit()\r\n conn.close()\r\n return None","def _addcolumns(self, columnname, columndata=\"\"):\n self[columnname] = columndata","def add_col(self):\r\n reader = csv.reader(open(self.in_csvfile, newline=''))\r\n rows = list(reader)\r\n rows[0].append(self.col_name)\r\n for i in range(1, len(rows)):\r\n rows[i].append(self.cell_filler(rows[i]))\r\n writer = csv.writer(open(self.out_csvfile, 'w', newline=''))\r\n writer.writerows(rows)","def __append_columns(self, new_dataframe):\n self.dataframe = pd.merge(self.dataframe, new_dataframe)","def _add_necessary_columns(args, custom_columns):\n # we need to add the variant's chrom, start and gene if \n # not already there.\n if custom_columns.find(\"gene\") < 0:\n custom_columns += \", gene\"\n if custom_columns.find(\"start\") < 0:\n custom_columns += \", start\"\n \n return custom_columns","def add_rows(self):\n for row in self.rows:\n self.table.add_row(row)","def append_data(self, table_name, df):\n\t\tself.__check_colnames(table_name, df)\n\t\tif self.__dbfile is not None:\n\t\t\tdf.to_sql(table_name, self._conn, index=False, if_exists=\"append\")","def add_columns(self, **columns):\n return self.as_dataframe(self.data.assign(**columns))","def _addColumn(self, table, column, init_data):\n\t\tcommand = \"ALTER TABLE \" + table + \" ADD COLUMN \" + str(column) + \" \" + getSQLiteType(init_data)\n\t\ttry:\n\t\t\tself._run_command(command)\n\t\texcept sqlite3.OperationalError:\n\t\t\tprint(\"Column \" + str(column) + \" already exists!\")","def append_table(self, table):\n if not table:\n return\n\n indexes = []\n for idx in table.index:\n index = self.size + idx\n indexes.append(index)\n\n self.set(indexes=indexes, columns=table.columns, values=table.data)","def addEntryToTable(self):\n self.table_view.table_model.insertRows(0, 1)","def test_append(self):\n self.table.append(['Tom', 26])","def add(table, record):\n\n table.append(record)\n\n return table","def dbcolumns(con,table,**kw):\n cur = con.cursor()\n cols = list(cur.execute(\"pragma table_info(\"+table+\")\"))\n colnames = [col[1] for col in cols]\n if colnames==[]:\n cmd = \"create table \"+table+\" (id integer primary key\"\n for k,v in kw.items():\n cmd += \", %s %s\"%(k,v)\n cmd += \")\"\n cur.execute(cmd)\n else:\n # table already exists; add any missing columns\n for k,v in kw.items():\n if not k in colnames:\n cmd = \"alter table \"+table+\" add column \"+k+\" \"+v\n cur.execute(cmd)\n con.commit()\n del cur","def test_add_new_no_dupl_w_optional(self):\n new_df = pd.DataFrame(np.eye(3) * 2, index=range(3, 6),\n columns=self.req_cols + self.opt_cols)\n self.table.add_new(new=new_df)\n self.assertEqual(len(self.table.index), 6)","def add(table):\n\n # your code\n\n \n \n\n return_inputs = ui.get_inputs(['Name', 'Year'],\"Please enter a new record.\")\n key = str(common.generate_random(table))\n table.append([key,return_inputs[FIRST_PROP] , str(return_inputs[SECOND_PROP])])\n data_manager.write_table_to_file('hr/persons.csv', table)\n\n\n return table","def add_feature_columns(self, feature_columns: typing.List[str]):\n self.feature_columns += feature_columns","def test_add_column(self):\n name_column = Varchar()\n name_column._meta.name = \"name\"\n\n genre_column = Varchar()\n genre_column._meta.name = \"genre\"\n\n schema: t.List[DiffableTable] = [\n DiffableTable(\n class_name=\"Band\",\n tablename=\"band\",\n columns=[name_column, genre_column],\n )\n ]\n schema_snapshot: t.List[DiffableTable] = [\n DiffableTable(\n class_name=\"Band\",\n tablename=\"band\",\n columns=[name_column],\n )\n ]\n\n schema_differ = SchemaDiffer(\n schema=schema, schema_snapshot=schema_snapshot, auto_input=\"y\"\n )\n\n self.assertTrue(len(schema_differ.add_columns.statements) == 1)\n self.assertEqual(\n schema_differ.add_columns.statements[0],\n \"manager.add_column(table_class_name='Band', tablename='band', column_name='genre', db_column_name='genre', column_class_name='Varchar', column_class=Varchar, params={'length': 255, 'default': '', 'null': False, 'primary_key': False, 'unique': False, 'index': False, 'index_method': IndexMethod.btree, 'choices': None, 'db_column_name': None})\", # noqa\n )","def __mag_table_append(self, table_new):\n for r in table_new[self.__mag_colnames]:\n self.__mags.add_row(r)\n self.__mags.sort(['ra','dec','MJD'])","def update(self):\n current = LazyRegister(self.db)\n current.render()\n cur = self.db.cursor()\n for table in self.tables:\n if table in current.tables:\n additions, removals = current.tables[table].migrate(self.tables[table])\n for addition in additions:\n cur.execute(\"\"\"ALTER TABLE %s ADD COLUMN %s\"\"\" % (\n table, addition[1].get_sql()\n ))\n print('Added column: ', addition[0])\n for removal in removals:\n #cur.execute(\"\"\"ALTER TABLE %s DROP COLUMN %s\"\"\" % (\n # table, removal[0]\n #))\n #print('Removed column: ', removal[0])\n print('Did not removed column: ', removal[0])\n else:\n schema = self.tables[table].get_create_table_sql()\n cur.execute(schema)\n print('Added table %s' % table)","def add_record(self, data):\n if not self._validate_columns(data):\n raise ValueError('Invalid column names')\n formatted_data = [str(data[column]) for column in self.column_names]\n utils.write_line(','.join(formatted_data) + '\\n', self.filename, 'a')","def add_blank_data_column(self):\n\n header_title, ok_pressed = QInputDialog.getText(self, \"Add Column\", \"Enter heading for the column:\",\n QLineEdit.Normal, \"\")\n if ok_pressed and header_title != '':\n # print(header_title)\n\n default_value, set_default_pressed = QInputDialog.getText(self, \"Set Default Value\",\n \"Enter default value to set for column if any:\",\n QLineEdit.Normal, \"\")\n\n row_count = self.csv_data_table.rowCount()\n last_column_count = self.csv_data_table.columnCount()\n self.csv_data_table.insertColumn(last_column_count)\n for empty_row in range(0, row_count):\n item = QTableWidgetItem(default_value)\n self.csv_data_table.setItem(empty_row, last_column_count, item)\n\n # TODO: fix untraced bug present in show/hide columns\n self.column_headers.append(header_title)\n self.column_headers_all.append(header_title)\n # print(self.column_headers)\n # print(self.column_headers_all)\n self.csv_data_table.setHorizontalHeaderLabels(self.column_headers)","def addTableColumn(self, tablename, columnname, columntype):\n\n # Check if the table exists\n if tablename in self.getTableNames():\n\n # Check that the column does not already exist\n if columnname not in self.getColumnNames(tablename):\n\n #Allow columnames with spaces\n columnname = '`'+columnname+'`'\n\n \"\"\"# Fit characters to the allowed format if necessary\n fmt = ''\n if (self.connector == 'mysql' and\n ('TEXT' in columntype or 'VARCHAR' in columntype) and\n not ('CHARACTER SET' in columntype or\n 'utf8mb4' in columntype)):\n\n # We enforze utf8mb4 for mysql\n fmt = ' CHARACTER SET utf8mb4'\n\n\n sqlcmd = ('ALTER TABLE ' + tablename + ' ADD COLUMN ' +\n columnname + ' ' + columntype + fmt)\"\"\"\n sqlcmd = ('ALTER TABLE ' + tablename + ' ADD COLUMN ' +\n columnname + ' ' + columntype) \n self._c.execute(sqlcmd)\n\n # Commit changes\n self._conn.commit()\n\n else:\n print((\"WARNING: Column {0} already exists in table {1}.\"\n ).format(columnname, tablename))\n\n else:\n print('Error adding column to table. Please, select a valid ' +\n 'table name from the list')\n print(self.getTableNames())\n\n return","def add(table):\n\n # 2\n id = common.generate_random(table)\n addnew = ui.get_inputs(\n ['name: ', 'birth_year: '],\n 'Adding entry to hr')\n addnew.insert(0, id)\n table.append(addnew)\n data_manager.write_table_to_file('hr/persons.csv', table)\n return table","def columns_setup(self):\n self.required = None\n self.addition = None\n self.deletion = None\n self.retention = None\n self.rename = None","def addCommonExtraColumn(self, req, study_id, found_extra_table, column_name, data_type, description):\n debug = False\n common_extra_table_name = None\n min_column_count = None\n quoted_column_name = '\"{0}\"'.format(column_name.upper())\n \n if 'SAMPLE' in found_extra_table:\n common_extra_table_name = 'COMMON_EXTRA_SAMPLE'\n min_column_count = 2\n elif 'PREP' in found_extra_table:\n common_extra_table_name = 'COMMON_EXTRA_PREP'\n min_column_count = 3\n \n if common_extra_table_name == None:\n raise Exception('Error: Could not determine the common extra table name. The found extra table is: %s' % found_extra_table)\n \n # Set the database data type:\n database_data_type = ''\n if data_type == 'text' or database_data_type == 'range':\n database_data_type = 'varchar2(4000)'\n elif data_type == 'numeric':\n database_data_type = 'int'\n elif data_type == 'date':\n database_data_type = 'date'\n \n if database_data_type == '':\n raise Exception('Could not determine common extra column data type.')\n\n # Create the column if it doesn't already exist\n statement = \"\"\"\n select count(*) \n from all_tab_columns \n where column_name = '{0}' \n and table_name = '{1}'\n \"\"\".format(column_name.upper(), common_extra_table_name)\n if debug:\n req.write('<pre>' + statement + '</pre><br/>')\n con = self.getMetadataDatabaseConnection()\n results = con.cursor().execute(statement).fetchone()\n if results[0] == 0:\n statement = 'alter table %s add %s %s' % (common_extra_table_name, quoted_column_name, database_data_type)\n if debug:\n req.write('<pre>' + statement + '</pre><br/>')\n con.cursor().execute(statement)\n \n # Copy the data found in the found extra_table\n if common_extra_table_name == 'COMMON_EXTRA_SAMPLE':\n statement = \"\"\"\n MERGE INTO common_extra_sample e\n USING (\n SELECT sample_id, {0}\n FROM {1}\n ) x\n ON (e.sample_id = x.sample_id)\n WHEN MATCHED THEN \n UPDATE SET e.{0} = x.{0}\n WHEN NOT MATCHED THEN \n INSERT (e.sample_id, e.{0})\n VALUES (x.sample_id, x.{0})\n \"\"\".format(quoted_column_name, found_extra_table)\n else:\n statement = \"\"\"\n MERGE INTO common_extra_prep e\n USING (\n SELECT sample_id, row_number, {0}\n FROM {1}\n ) x\n ON (e.sample_id = x.sample_id and e.row_number = x.row_number)\n WHEN MATCHED THEN \n UPDATE SET e.{0} = x.{0}\n WHEN NOT MATCHED THEN \n INSERT (e.sample_id, e.row_number, e.{0})\n VALUES (x.sample_id, x.row_number, x.{0})\n \"\"\".format(quoted_column_name, found_extra_table)\n \n if debug:\n req.write('<pre>' + statement + '</pre><br/>')\n con.cursor().execute(statement)\n statement = 'commit'\n if debug:\n req.write('<pre>' + statement + '</pre><br/>')\n con.cursor().execute(statement)\n \n # Remove the column from the found extra table. If it's the last custom column in the table, remove the table\n statement = \"select count(*) from all_tab_columns where table_name = '%s'\" % (found_extra_table)\n if debug:\n req.write('<pre>' + statement + '</pre><br/>')\n results = con.cursor().execute(statement).fetchone()\n if results[0] <= min_column_count:\n statement = 'drop table %s' % (found_extra_table)\n if debug:\n req.write('<pre>' + statement + '</pre><br/>')\n con.cursor().execute(statement)\n else:\n statement = 'alter table %s drop column %s' % (found_extra_table, quoted_column_name)\n if debug:\n req.write('<pre>' + statement + '</pre><br/>')\n con.cursor().execute(statement)\n \n # Clean up references in study_actual_columns\n extra_table_study_id = found_extra_table.split('_')[2]\n\n statement = \"\"\"\n update study_actual_columns \n set table_name = '\"{0}\"' \n where study_id = {1} \n and table_name = '\"{2}\"'\n \"\"\".format(common_extra_table_name, extra_table_study_id, found_extra_table)\n if debug:\n req.write('<pre>' + statement + '</pre><br/>')\n con.cursor().execute(statement)\n statement = 'commit'\n if debug:\n req.write('<pre>' + statement + '</pre><br/>')\n con.cursor().execute(statement)","def add_row(self, dict_with_columns_key):\n for column in self.columns:\n val = dict_with_columns_key.get(column)\n if val is None:\n val = \"\"\n self.data[column].append(val)","def add(table):\n id_storage = common.get_values_from_column(table, 0)\n id_ = common.generate_random(table)\n table = manage_data_from_user(table, id_storage, id_, False)\n\n return table","def append_row(self, row_dict):\n \n for k,v in row_dict.items():\n \n if(k not in self.table):\n # Heading does not exist yet. Fill in blanks for past items\n self.table[k] = [\"\"] * self.rowcount\n \n # clean up value\n v = v.strip()\n # try converting string to a number\n try:\n v = ast.literal_eval(v)\n except:\n pass\n \n self.table[k].append(v)\n \n self.rowcount = self.rowcount + 1\n \n # Even out any columns in DB that were not filled\n for hdr in self.table:\n if(len(self.table[hdr]) < self.rowcount):\n self.table[hdr].append(None)","def add(table, record):\n index_id = 0\n record.insert(index_id, common.generate_random(table))\n table.append(record)\n data_manager.write_table_to_file(\"model/sales/sales.csv\", table)\n\n return table","def append_columns(cls, columns, grid=None, grid_url=None):\n grid_id = parse_grid_id_args(grid, grid_url)\n\n grid_ops.ensure_uploaded(grid_id)\n\n # Verify unique column names\n column_names = [c.name for c in columns]\n if grid:\n existing_column_names = [c.name for c in grid]\n column_names.extend(existing_column_names)\n duplicate_name = utils.get_first_duplicate(column_names)\n if duplicate_name:\n err = exceptions.NON_UNIQUE_COLUMN_MESSAGE.format(duplicate_name)\n raise exceptions.InputError(err)\n\n # This is sorta gross, we need to double-encode this.\n body = {\"cols\": _json.dumps(columns, cls=PlotlyJSONEncoder)}\n fid = grid_id\n response = v2.grids.col_create(fid, body)\n parsed_content = response.json()\n\n cls._fill_in_response_column_ids(columns, parsed_content[\"cols\"], fid)\n\n if grid:\n grid.extend(columns)","def _with_columns(self, columns):\n table = Table()\n for label, column in zip(self.column_labels, columns):\n self._add_column_and_format(table, label, column)\n return table","def create_table_load_records(self, tablename, records, has_header=True):\n # Column names from header, or make up.\n if has_header:\n header = records.pop(0)\n header = [utils.name_cleaned(n) for n in header]\n if len(header) != len(set(header)):\n raise ValueError(\"non-unique header column names\")\n else:\n header = [f\"column{i+1}\" for i in range(len(records[0]))]\n\n # Infer column types and constraints.\n schema = {\"name\": tablename}\n schema[\"columns\"] = [{\"name\": name} for name in header]\n try:\n for i, column in enumerate(schema[\"columns\"]):\n type = None\n column[\"notnull\"] = True\n\n # First attempt: integer\n for n, record in enumerate(records):\n value = record[i]\n if value is None:\n column[\"notnull\"] = False\n elif isinstance(value, int):\n pass\n elif isinstance(value, str):\n try:\n int(value)\n except (ValueError, TypeError):\n break\n else:\n break\n else:\n type = constants.INTEGER\n\n # Next attempt: float\n if type is None:\n for n, record in enumerate(records):\n value = record[i]\n if value is None:\n column[\"notnull\"] = False\n elif isinstance(value, (float, int)):\n pass\n elif isinstance(value, str):\n try:\n float(value)\n except (ValueError, TypeError):\n break\n else:\n break\n else:\n type = constants.REAL\n\n # Default: text\n if type is None:\n column[\"type\"] = constants.TEXT\n if column[\"notnull\"]:\n for record in records:\n value = record[i]\n if value is None:\n column[\"notnull\"] = False\n break\n else:\n column[\"type\"] = type\n except IndexError:\n raise ValueError(f\"record {i+1} has too few items\")\n\n # Create the table.\n self.add_table(schema)\n\n # Actually convert values in records.\n for i, column in enumerate(schema[\"columns\"]):\n type = column[\"type\"]\n if type == constants.INTEGER:\n for n, record in enumerate(records):\n value = record[i]\n if value is not None:\n record[i] = int(value)\n elif type == constants.REAL:\n for n, record in enumerate(records):\n value = record[i]\n if value is not None:\n record[i] = float(value)\n\n # Insert the data.\n sql = 'INSERT INTO \"%s\" (%s) VALUES (%s)' % (\n tablename,\n \",\".join(['\"%(name)s\"' % c for c in schema[\"columns\"]]),\n \",\".join(\"?\" * len(schema[\"columns\"])),\n )\n with self.dbcnx:\n self.dbcnx.executemany(sql, records)\n self.update_table(schema)","def add(table):\n\n list_labels = [\"Name: \", \"Manufacturer: \", \"purchase_date: \", \"Durability: \"]\n data_input = ui.get_inputs(list_labels, \"Add new record\")\n\n id_ = common.generate_random(table)\n is_date_number = data_input[2].isdigit() and len(data_input) == 4\n is_durability_number = data_input[3].isdigit()\n\n if is_date_number is True and is_durability_number is True:\n data_input.insert(0, id_)\n table.append(data_input)\n\n elif is_date_number is False:\n ui.print_error_message(\"Wrong year format! Record add failed!\")\n\n elif is_durability_number is False:\n ui.print_error_message(\"Wrong durability format! Record add failed!\")\n\n return table","def test_dummydb_add_data_to_table_wrong_column_name(self):\n db = DummyDB()\n columns = {\n \"one\": int,\n \"two\": str,\n \"three\": bool,\n }\n db.create_table(\"new_table\", columns)\n result = db.select(\"new_table\", four=1)","def _alter_table(self, names, types) :\n\n cur = self.con.cursor()\n for i in range(min(len(names), len(types))) :\n alter_sql = 'ALTER TABLE \"%s\" ADD COLUMN \"%s\" %s' % (self.name, names[i], types[i])\n cur.execute(alter_sql)","def append_names(self, excludes=None, append=\", \"):\n\n if self.columns and self.q_str.startswith(\"INSERT\"):\n q_temp = []\n if excludes and isinstance(excludes, str):\n for key in self.columns.keys():\n if key != excludes:\n q_temp.append(key)\n elif excludes and isinstance(excludes, list):\n for key in self.columns.keys():\n if key not in excludes:\n q_temp.append(key)\n elif excludes is None:\n for key in self.columns.keys():\n q_temp.append(key)\n else:\n raise ValueError(\"append_names accepts lists, dict keys and pd.DataFrame indexes\")\n else:\n raise ValueError(\"append_names does not accept NULL init_objections\")\n\n q_temp = \", \".join(q_temp)\n self.q_str = append.join([self.q_str, q_temp])\n self.q_str = \"\".join([self.q_str, \") VALUES \"])","def __refmag_table_append(self, table_new): \n if not \"mag_calib_unc\" in table_new.colnames:\n table_new[\"mag_calib_unc\"] = [None for i in range(len(table_new))]\n \n for r in table_new[self.__mag_colnames]:\n self.__ref_mags.add_row(r)\n self.__ref_mags.sort(['ra','dec','MJD'])","def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\n return False","def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\n return False","def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\n return False","def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\n return False","def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\n return False","def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\n return False","def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\n return False","def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\n return False","def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\n return False","def project(self, name, cols) :\n\n ct = [v \n for v in list(zip(self.get_cols(), self.get_types()))\n if v[0] in cols]\n\n base_row = dict(zip(cols, itertools.repeat(None)))\n \n def make_new_row(r) :\n values = {}\n values.update(base_row)\n values.update(r.as_dict())\n return values\n new_rows = [make_new_row(row) for row in self]\n\n new_table = self.factory.new_table(name, ct)\n new_table.add_rows(new_rows)\n return new_table","def add_column(self, schema):\n self[schema.name] = schema.copy()","def add_table_column(\n self, table: Table, name: Optional[str] = None, values: Any = None\n ):\n self._requires_table(table)\n table.append_column(name, values)","def deferred_to_columns_cb(self, target, model, fields):\n table = model._meta.db_table\n if table not in target:\n target[table] = set()\n for field in fields:\n if not hasattr(field.column, \"columns\"):\n target[table].add(field.column)\n else:\n target[table].update(field.column.columns)","def add_row(self, *column_data):\n row = \"<tr>\"\n row += \" \".join(f\"<td>{header}</td>\" for header in column_data)\n row += \"</tr>\\n\"\n self.result += row","def AddColumn(self, column):\n self.columns.append(column)\n self.column_dict[column.column_id] = column","def add_select(self, *column):\n if not column:\n column = []\n\n self.columns += column\n\n return self","def create_table_columns(database, table, columns):\r\n in_tests.test_create_table_columns(database, table, columns)\r\n\r\n connection = sqlite3.connect(database)\r\n cursor = connection.cursor()\r\n\r\n for column in columns:\r\n query = f\"ALTER TABLE {table} ADD COLUMN {column}\"\r\n cursor.execute(query)\r\n connection.commit()\r\n cursor.close()\r\n connection.close()\r\n\r\n out_tests.test_create_table_columns(\r\n get_table_columns_names(database, table), columns)\r\n return ()","def test_query_all_new_column(self):\n session = self.prepare(user_table=True)\n\n self._insert_data(session)\n\n assert_one(\n session,\n \"SELECT * FROM users_by_state WHERE state = 'TX' AND username = 'user1'\",\n ['TX', 'user1', 1968, 'f', 'ch@ngem3a', None]\n )\n\n session.execute(\"ALTER TABLE users ADD first_name varchar;\")\n\n results = list(session.execute(\"SELECT * FROM users_by_state WHERE state = 'TX' AND username = 'user1'\"))\n assert len(results) == 1\n assert hasattr(results[0], 'first_name'), 'Column \"first_name\" not found'\n assert_one(\n session,\n \"SELECT * FROM users_by_state WHERE state = 'TX' AND username = 'user1'\",\n ['TX', 'user1', 1968, None, 'f', 'ch@ngem3a', None]\n )","def append_row(self):\r\n values = []\r\n vals_to_insert = ''\r\n\r\n for key in Output.COLUMNS:\r\n values.append(str(self[key]))\r\n\r\n # Replace any Quotes in parsed record with double quotes\r\n for i in values:\r\n vals_to_insert += i.replace('\"', '\"\"') + '\",\"'\r\n\r\n vals_to_insert = '\"' + vals_to_insert[:-3] + '\"'\r\n insert_sqlite_db(vals_to_insert)","def add_column_into_source(self, tap_type, table, new_column):\n run_query_method = getattr(self, f'run_query_tap_{tap_type}')\n run_query_method(\n f'ALTER TABLE {table} ADD {new_column[\"name\"]} int'\n )\n run_query_method(\n f'UPDATE {table} set {new_column[\"name\"]}={new_column[\"value\"]} where 1=1'\n )","def add(table):\n # 2\n id = common.generate_random(table)\n addnew = ui.get_inputs(\n ['month: ',\n 'day: ',\n 'year: ',\n 'type (in=income, out= outflow): ',\n 'amount (of transaction in USD): '],\n 'Adding item to Accounting table')\n addnew.insert(0, id)\n table.append(addnew)\n data_manager.write_table_to_file('accounting/items.csv', table)\n\n return table","def add_row(self, row):\n \n new_row = pd.DataFrame(data=[row], columns = self.table.columns) \n self.table = self.table.append(new_row, ignore_index=True)","def add(table):\n\n new_list_to_add = []\n\n new_list_to_add.append(common.generate_random(table))\n new_list_to_add.extend(ui.get_inputs([\"Please add the Name: \"],\"\"))\n new_list_to_add.extend(ui.get_inputs([\"Please add the Manufacturer: \"],\"\"))\n new_list_to_add.extend(ui.get_inputs([\"Please add the Year of Purchase: \"],\"\"))\n new_list_to_add.extend(ui.get_inputs([\"Please add the Durability Time in Year/s: \"],\"\"))\n \n table.append(new_list_to_add) # hozzáadni a csv filehoz\n data_manager.write_table_to_file(\"inventory/inventory.csv\", table)\n\n return table","def setAllColumns(self, newAllColumns):\n \n pass","def add_numeric_cols(self):\n self.create_numeric_status()\n self.create_date_integer()","def appendData(self, dataframe, tableName, truncate=False):\n if truncate:\n truncateSetting = 'replace'\n else:\n truncateSetting = 'append'\n dataframe.to_sql(name=tableName, con=self.writeConn, if_exists=truncateSetting, index=False)","def __update_feature_table_columns(self):\n self.__init_table()\n\n feature_dict_sorted_keys = feature_extractor_definition.keys()\n feature_dict_sorted_keys.sort()\n for key in feature_dict_sorted_keys:\n if not self.__has_feature_column(key):\n self.__add_feature_column(key, feature_extractor_definition[key])","def add_row(self, *column_data):\n raise NotImplementedError","def add_column(self, fieldname, column, align=..., valign=...):\n ...","def add_header(self, *column_headers):\n raise NotImplementedError","def add_rows(self, dict_with_columns_key):\n max_length = 0\n for vals in dict_with_columns_key.values():\n if len(vals) > max_length:\n max_length = len(vals)\n\n for column in self.columns:\n vals = dict_with_columns_key.get(column)\n vals.extend([\"\"] * (max_length - len(vals))) # Enforce all columns to have same length\n self.data[column].extend(vals)","def populate_dyn(self, table):\n myrow = table.row\n myrow[\"sample_time\"] = int(time.time() - glob.base_time)\n myrow[\"available_bike_stands\"] = self.available_bike_stands\n myrow[\"available_bikes\"] = self.available_bikes\n myrow[\"last_update\"] = self.last_update\n myrow[\"status\"] = self.status\n myrow.append()\n table.flush()","def add_all_lines(conn, table_values):\n\n column_list = table_values[0]\n column_row = \",\".join(column_list)\n qmark = \"?\"\n col_count = len(column_list)\n for cols in range(1, col_count):\n qmark += \", ?\"\n cols = cols\n\n cur = conn.cursor()\n cur.execute(\"DROP TABLE IF EXISTS ayasdi_table;\")\n cur.execute(\"CREATE TABLE ayasdi_table (\" + column_row + \");\")\n cur.executemany(\\\n \"INSERT INTO ayasdi_table (\" + column_row + \") VALUES (\" + qmark + \");\", \\\n table_values)","def add_column(self, tap_column):\r\n self.__columns.append(tap_column)","def append_table(self, table):\n\n self._db_manager.register_table(table)","def setcolumns(self, columns):\n\n # Store the column titles (\"raw\" format)\n # This is a list of white-space separated strings\n self.__columns = columns\n # Create table_column objects\n for col in columns.split():\n self.addcolumn(col)\n # Attempt to populate the column objects\n if self.__data:\n self.__populate_columns()\n self.__nonzero = True","def _bulk_add_rows(self, converted) :\n\n insert_sql = 'INSERT INTO \"%s\" VALUES (%s)' % (self.name, ','.join(['?'] * len(self.cols)))\n cur = self.con.cursor()\n cur.executemany(insert_sql, converted)","def add_blank_data_row(self):\n last_row_count = self.csv_data_table.rowCount()\n column_count = self.csv_data_table.columnCount()\n self.csv_data_table.insertRow(last_row_count)\n for empty_col in range(0, column_count):\n item = QTableWidgetItem('')\n self.csv_data_table.setItem(last_row_count, empty_col, item)","def select(self, keep_columns=None, additional_columns=None):\n if keep_columns is None:\n keep_columns = self.columns\n\n if additional_columns is None:\n additional_columns = {}\n\n result_table = Table(keep_columns + list(additional_columns.keys()))\n\n for row in self.rows:\n new_row = [row[column] for column in keep_columns]\n\n for column_name, calculation in additional_columns.items():\n new_row += [calculation(row)]\n\n result_table.insert(new_row)\n\n return result_table","def visit_alter_table_append_command(element, compiler, **kw):\n if element.ignore_extra:\n fill_option = 'IGNOREEXTRA'\n elif element.fill_target:\n fill_option = 'FILLTARGET'\n else:\n fill_option = ''\n\n query_text = \\\n 'ALTER TABLE {target} APPEND FROM {source} {fill_option}'.format(\n target=compiler.preparer.format_table(element.target),\n source=compiler.preparer.format_table(element.source),\n fill_option=fill_option,\n )\n return compiler.process(sa.text(query_text), **kw)","def populate_table(database, table, data):\n\n for row in data:\n database.session.add(table(row))\n database.session.commit()","def add_table_column(self, schema, column):\n if not column[\"name\"] or not constants.NAME_RX.match(column[\"name\"]):\n raise ValueError(\"invalid column name\")\n if utils.name_in_nocase(column[\"name\"], [c[\"name\"] for c in schema[\"columns\"]]):\n raise ValueError(\"non-unique column name\")\n if column[\"type\"] not in constants.COLUMN_TYPES:\n raise ValueError(\"invalid column type\")\n sql = (\n f'''ALTER TABLE \"{schema['name']}\"'''\n f\"\"\" ADD COLUMN \"{column['name']}\" {column['type']}\"\"\"\n )\n if column.get(\"notnull\"):\n notnull = [\"NOT NULL\"]\n if column[\"type\"] == constants.INTEGER:\n notnull.append(\"DEFAULT 0\")\n elif column[\"type\"] == constants.REAL:\n notnull.append(\"DEFAULT 0.0\")\n elif column[\"type\"] in (constants.TEXT, constants.BLOB):\n notnull.append(\"DEFAULT ''\")\n sql += \" \" + \" \".join(notnull)\n self.dbcnx.execute(sql)\n schema[\"columns\"].append(column)\n self.update_table(schema)","def add_transaction(table, id, store_id, hr_id, crm_id, quantity):\n record = [id, store_id, hr_id, crm_id, quantity]\n table.append(record)\n\n return table","def set_columns(self, columns):\n self.columns = columns","def addcolumn(self, column):\n if column not in self.headersindex:\n database = managers.database_manager.get_database(self.owner_id, self.database_id)\n cur = database.get_connection().cursor()\n cur.execute(\"ALTER TABLE \\'%s\\' ADD COLUMN %s\" % (self.name, column.to_declaration()))","def add_extra_column(self, prof_gas, retrieval_date, mod_data, **kwargs):\n pass","def add_column(self, name, **kwargs):\n\n import sqlalchemy.orm.session\n from dbexceptions import NotFoundError\n\n s = sqlalchemy.orm.session.Session.object_session(self)\n\n assert s, \"Can't create column with this method unless the table has a session\"\n\n name = Column.mangle_name(name)\n\n if not kwargs.get('fast', False):\n try:\n row = self.column(name)\n except NotFoundError:\n row = None\n else:\n row = None\n\n if row:\n extant = True\n\n else:\n row = Column(self, name=name, **kwargs)\n extant = False\n\n if kwargs.get('data', False):\n row.data = dict(row.data.items() + kwargs['data'].items())\n\n for key, value in kwargs.items():\n\n excludes = ['d_id', 't_id', 'name', 'schema_type', 'data']\n\n # Proto is the name of the object.\n if key == 'proto' and isinstance(value, basestring):\n key = 'proto_vid'\n\n if extant:\n excludes.append('sequence_id')\n\n if key[0] != '_' and key not in excludes:\n try:\n setattr(row, key, value)\n except AttributeError:\n raise AttributeError(\n \"Column record has no attribute {}\".format(key))\n\n if isinstance(value, basestring) and len(value) == 0:\n if key == 'is_primary_key':\n value = False\n setattr(row, key, value)\n\n # If the id column has a description and the table does not, add it to\n # the table.\n if row.name == 'id' and row.is_primary_key and not self.description:\n self.description = row.description\n s.merge(self)\n\n if extant:\n row = s.merge(row)\n else:\n s.add(row)\n\n if kwargs.get('commit', True):\n s.commit()\n\n return row","def add(table):\n\n # your code\n row = []\n row.append(common.generate_random(table))\n\n inputs = ui.get_inputs([\"TITLE: \", \"MANUFACTURER: \", \"PRICE: \", \"STOCK: \"], \"Fill the records below: \")\n for i in inputs:\n row.append(i)\n\n table.append(row)\n\n return table","def _insert_column(self, column_name, column_type, table, params=None, overwrite=False, after_col=None, verbose=True):\n \n not_null = ''\n auto_increment = ''\n \n if params != None and 'not_null' in params:\n not_null = 'NOT NULL'\n \n \n if params != None and 'auto_increment' in params:\n auto_increment = \"AUTO_INCREMENT\"\n \n \n ADD_COLUMN_COMMAND = \"ALTER TABLE {0} ADD {1} {2} {3} {4}\".format(table, column_name, column_type, not_null, auto_increment)\n \n if (after_col != None and type(after_col) is str):\n ADD_COLUMN_COMMAND += \" AFTER {0} \".format(after_col)\n \n \n self.cursor.execute(ADD_COLUMN_COMMAND)\n \n if verbose: \n print(\"Adding the column '{0}' to the table '{1}'...\".format(column_name, table))\n print(\"\\t\" + ADD_COLUMN_COMMAND) \n \n \n if params != None and 'foreign_key' in params:\n \n if 'references' not in params:\n raise InvalidParameterError\n \n referenced_table = params['references'].split('(')[0]\n referenced_column = params['references'].split('(')[1][:-1] \n \n \n if (not self.check_table(referenced_table, verbose=False)):\n raise(TableNotFoundError)\n \n \n if (not self.check_column(referenced_column, referenced_table, verbose=False)):\n raise(ColumnNotFoundError)\n \n \n ADD_FOREIGN_KEY_COMMAND = \"ALTER TABLE {0} ADD FOREIGN KEY ({1}) REFERENCES {2}({3})\".format(table, column_name, referenced_table, referenced_column)\n \n \n if verbose: \n print(\"\\t\" + ADD_FOREIGN_KEY_COMMAND) \n \n self.cursor.execute(ADD_FOREIGN_KEY_COMMAND)","def add_records(self):\n\n self.setup_progressbar(\"Loading {} records from table {}...\"\n .format(self.record_count, self.lyr.name()),\n self.record_count)\n\n provider = self.lyr.dataProvider()\n for i, row in enumerate(self.cur):\n feature = QgsFeature()\n feature.setGeometry(QgsGeometry())\n feature.setAttributes([flds for flds in row])\n provider.addFeatures([feature])\n self.update_progressbar(i)\n\n iface.messageBar().clearWidgets()\n iface.messageBar().pushMessage(\"Ready\", \"{} records added to {}\".format(str(self.record_count), self.lyr.name())\n , level=QgsMessageBar.INFO)","def add_new_cols(cat, prefix=\"\", floatcols=None, boolcols=None):\n\t\n\tif floatcols != None:\n\t\tfor col in floatcols:\n\t\t\tcat.add_column(astropy.table.MaskedColumn(name=prefix+col, dtype=float, length=len(cat)))\n\t\t\tcat[prefix+col].mask = [True] * len(cat)\n\tif boolcols != None:\n\t\tfor col in boolcols:\n\t\t\tcat.add_column(astropy.table.MaskedColumn(name=prefix+col, dtype=bool, length=len(cat)))\n\t\t\tcat[prefix+col].mask = [True] * len(cat)","def update_table_columns(self, table_name, table):\n table_definition = self._table_definitions[table_name]\n new_columns = table.columns.difference(table_definition.c.keys())\n new_column_types = {c: table.dtypes[c] for c in new_columns}\n\n allows_covariates = table_definition.name in [\"avgint\", \"data\"]\n\n good_prefixes = [\"c_\"]\n if allows_covariates:\n good_prefixes.append(\"x_\")\n bad_column_names = [c for c in new_columns if c[:2] not in good_prefixes]\n if bad_column_names:\n msg = f\"\"\"\n Table '{table_definition.name}' has these columns {list(table_definition.c.keys())}.\n It allows additional comment columns, which must start 'c_'.\"\"\"\n if allows_covariates:\n msg += \" In addition it allows covariate columns, which must start with 'x_'.\"\n msg += f\" You supplied columns that don't meet those requirements: {bad_column_names}\"\n\n raise ValueError(dedent(msg))\n\n add_columns_to_table(table_definition, new_column_types)","def _add_fields(self, fields):\n for field in fields:\n self.add(field)","def __limmag_table_append(self, table_new): \n for r in table_new[self.__limmag_colnames]:\n self.__lim_mags.add_row(r)\n self.__lim_mags.sort(['ra','dec','MJD'])","def test_add_table(self):\n name_column = Varchar()\n name_column._meta.name = \"name\"\n schema: t.List[DiffableTable] = [\n DiffableTable(\n class_name=\"Band\", tablename=\"band\", columns=[name_column]\n )\n ]\n schema_snapshot: t.List[DiffableTable] = []\n schema_differ = SchemaDiffer(\n schema=schema, schema_snapshot=schema_snapshot, auto_input=\"y\"\n )\n\n create_tables = schema_differ.create_tables\n self.assertTrue(len(create_tables.statements) == 1)\n self.assertEqual(\n create_tables.statements[0],\n \"manager.add_table('Band', tablename='band')\",\n )\n\n new_table_columns = schema_differ.new_table_columns\n self.assertTrue(len(new_table_columns.statements) == 1)\n self.assertEqual(\n new_table_columns.statements[0],\n \"manager.add_column(table_class_name='Band', tablename='band', column_name='name', db_column_name='name', column_class_name='Varchar', column_class=Varchar, params={'length': 255, 'default': '', 'null': False, 'primary_key': False, 'unique': False, 'index': False, 'index_method': IndexMethod.btree, 'choices': None, 'db_column_name': None})\", # noqa\n )","def append(self, other, ensureFilled = True):\n\t\tself.rows.extend(other.rows)\n\t\tself.headers.extend([x for x in other.headers if not x in self.headers])\n\t\tif(ensureFilled):\n\t\t\tself.ensureFilled()\n\t\treturn self","def add_column_to_staging_table(cursor,table_schema,table_name,column_name):\n if not check_if_column_exists(cursor, table_schema, table_name, column_name):\n add_column = \"ALTER TABLE \" + table_schema + \".\" + table_name + \" ADD COLUMN \" + column_name + \" text;\"\n cursor.execute(add_column)","def columns(self, *args):\n column_set = set(self._columns)\n for c in args:\n if c in column_set:\n continue\n else:\n self._columns.append(c)\n # column_set.add(c) # FIXME failing tests\n return self","def _add_cols(df: pandas.DataFrame, scope = (globals(), locals())) -> None:\n command : str = input(\"\\nAdd a column:\\n\")\n if command.lower() in ['n', 'no', 'quit()', 'exit', 'return']:\n return\n\n col_name : str = command[ \\\n re.search(r'[\\w\\.\\(\\)]+', command).start(): \\\n re.search(r'[\\w\\.\\(\\)]+', command).end() \\\n ]\n # new column's name\n\n arg : str = command[re.search(r'[=,;]', command).end():]\n # the new column's \"function\"\n ref_cols = re.findall(r'(?<=\\{)\\w[\\w\\.\\(\\)]*(?=\\})', arg)\n # df column names that are referenced to create new columns\n\n for i in range(len(ref_cols)):\n arg = re.sub(\n f'{{{ref_cols[i]}}}',\n f'df[\\'{ref_cols[i]}\\']',\n arg\n )\n # substituting references\n\n scope[0].update(globals())\n scope[1].update(locals())\n\n col_arg = eval(arg, scope[0], scope[1])\n # pandas.Series for type checking\n df[col_name] = col_arg\n # creating column\n\n more : str = input(\"\\nWould you like to add more columns?\\n\")\n if more.lower() in ['y', 'yes', 'continue', 'true']:\n return _add_cols(df)\n return","def test_dummydb_add_data_to_table(self):\n db = DummyDB()\n columns = {\n \"one\": int,\n \"two\": str,\n \"three\": bool,\n }\n db.create_table(\"new_table\", columns)\n db.insert(\"new_table\", one=1, two=\"haunted\", three=True)\n result = db.select(\"new_table\", one=1)\n self.assertEqual(result[0]['two'], \"haunted\")"],"string":"[\n \"def add_cols(self, source) :\\n\\n cols = source.get_cols()\\n types = source.get_types()\\n\\n new_cols = []\\n new_types = []\\n for i in range(len(cols)) :\\n if cols[i] not in self.cols :\\n new_cols.append(cols[i])\\n new_types.append(types[i])\\n self.cols.extend(new_cols)\\n self.types.extend(new_types)\\n\\n self._alter_table(new_cols, new_types)\\n\\n row_ids = self.get_values('__ROWID')\\n \\n for col in new_cols :\\n new_vals = source.get_values(col)\\n if len(row_ids) == 0 :\\n for val in new_vals :\\n self._insert_internal(['__ROWID', col], [0, val])\\n\\n row_ids = self.get_values('__ROWID')\\n\\n else :\\n binds = zip(new_vals, row_ids)\\n q = self._quoter(col)\\n sql_base = 'UPDATE \\\"%s\\\" SET \\\"%s\\\" = %s WHERE \\\"__ROWID\\\" = %%d' % (self.name, col, q)\\n cur = self.con.cursor()\\n for bind in binds :\\n if bind[0] :\\n update_sql = sql_base % (str(bind[0]), bind[1])\\n cur.execute(update_sql)\\n\\n self.version += 1\",\n \"def add_columns(self, table, col_data, col_type):\\n conn = psycopg2.connect(self.name, sslmode='require')\\n c = conn.cursor()\\n for data, typ in zip(col_data, col_type):\\n c.execute(\\\"ALTER TABLE {tn} ADD COLUMN {cn} {ct}\\\".\\n format(tn=table, cn=data, ct=typ))\\n conn.commit() \\n conn.close()\",\n \"def add_data(self, rowdata):\\n if not rowdata.keys():\\n # No columns were specified\\n return\\n for colnam in rowdata.keys():\\n # Check the the column is actually defined in\\n # in the table\\n try:\\n self.list_columns().index(colnam)\\n except ValueError:\\n # The column name wasn't found\\n raise ValueError(\\n \\\"Column \\\" + str(colnam) + \\\" is not defined in the table\\\"\\n )\\n for icol in range(0, self.ncolumns()):\\n # Look up whether the column has an\\n # explicit value assigned\\n colnam = self.table_column(icol).title()\\n if colnam in rowdata:\\n self.table_column(icol).append(rowdata[colnam])\\n else:\\n # Assign a null value\\n self.table_column(icol).append(\\\"*\\\")\",\n \"def AddColumns(sqlite_file, table_name):\\r\\n columns = ['cf_direct_parent','cf_kingdom','cf_superclass',\\\\\\r\\n 'cf_class','cf_subclass','cf_intermediate_0','cf_intermediate_1',\\\\\\r\\n 'cf_intermediate_2','cf_intermediate_3','cf_intermediate_4',\\\\\\r\\n 'cf_intermediate_5','cf_molecular_framework','cf_alternative_parents',\\\\\\r\\n 'cf_substituents', 'cf_description']\\r\\n column_type = 'TEXT'\\r\\n # Connecting to the database file\\r\\n conn = sqlite3.connect(sqlite_file) # Connecting to the database\\r\\n c = conn.cursor() # Adding a cursor to interact with the database\\r\\n # Adding new column, if it does not exist yet, without a row value\\r\\n for new_column_name in columns:\\r\\n try:\\r\\n c.execute(\\\"ALTER TABLE {tn} ADD COLUMN '{cn}' {ct}\\\"\\\\\\r\\n .format(tn=table_name, cn=new_column_name, ct=column_type))\\r\\n print(\\\"Column created: {cn}\\\".format(cn=new_column_name))\\r\\n except sqlite3.OperationalError:\\r\\n print(\\\"Column already exists: {cn}\\\".format(cn=new_column_name))\\r\\n conn.commit()\\r\\n conn.close()\\r\\n return None\",\n \"def _addcolumns(self, columnname, columndata=\\\"\\\"):\\n self[columnname] = columndata\",\n \"def add_col(self):\\r\\n reader = csv.reader(open(self.in_csvfile, newline=''))\\r\\n rows = list(reader)\\r\\n rows[0].append(self.col_name)\\r\\n for i in range(1, len(rows)):\\r\\n rows[i].append(self.cell_filler(rows[i]))\\r\\n writer = csv.writer(open(self.out_csvfile, 'w', newline=''))\\r\\n writer.writerows(rows)\",\n \"def __append_columns(self, new_dataframe):\\n self.dataframe = pd.merge(self.dataframe, new_dataframe)\",\n \"def _add_necessary_columns(args, custom_columns):\\n # we need to add the variant's chrom, start and gene if \\n # not already there.\\n if custom_columns.find(\\\"gene\\\") < 0:\\n custom_columns += \\\", gene\\\"\\n if custom_columns.find(\\\"start\\\") < 0:\\n custom_columns += \\\", start\\\"\\n \\n return custom_columns\",\n \"def add_rows(self):\\n for row in self.rows:\\n self.table.add_row(row)\",\n \"def append_data(self, table_name, df):\\n\\t\\tself.__check_colnames(table_name, df)\\n\\t\\tif self.__dbfile is not None:\\n\\t\\t\\tdf.to_sql(table_name, self._conn, index=False, if_exists=\\\"append\\\")\",\n \"def add_columns(self, **columns):\\n return self.as_dataframe(self.data.assign(**columns))\",\n \"def _addColumn(self, table, column, init_data):\\n\\t\\tcommand = \\\"ALTER TABLE \\\" + table + \\\" ADD COLUMN \\\" + str(column) + \\\" \\\" + getSQLiteType(init_data)\\n\\t\\ttry:\\n\\t\\t\\tself._run_command(command)\\n\\t\\texcept sqlite3.OperationalError:\\n\\t\\t\\tprint(\\\"Column \\\" + str(column) + \\\" already exists!\\\")\",\n \"def append_table(self, table):\\n if not table:\\n return\\n\\n indexes = []\\n for idx in table.index:\\n index = self.size + idx\\n indexes.append(index)\\n\\n self.set(indexes=indexes, columns=table.columns, values=table.data)\",\n \"def addEntryToTable(self):\\n self.table_view.table_model.insertRows(0, 1)\",\n \"def test_append(self):\\n self.table.append(['Tom', 26])\",\n \"def add(table, record):\\n\\n table.append(record)\\n\\n return table\",\n \"def dbcolumns(con,table,**kw):\\n cur = con.cursor()\\n cols = list(cur.execute(\\\"pragma table_info(\\\"+table+\\\")\\\"))\\n colnames = [col[1] for col in cols]\\n if colnames==[]:\\n cmd = \\\"create table \\\"+table+\\\" (id integer primary key\\\"\\n for k,v in kw.items():\\n cmd += \\\", %s %s\\\"%(k,v)\\n cmd += \\\")\\\"\\n cur.execute(cmd)\\n else:\\n # table already exists; add any missing columns\\n for k,v in kw.items():\\n if not k in colnames:\\n cmd = \\\"alter table \\\"+table+\\\" add column \\\"+k+\\\" \\\"+v\\n cur.execute(cmd)\\n con.commit()\\n del cur\",\n \"def test_add_new_no_dupl_w_optional(self):\\n new_df = pd.DataFrame(np.eye(3) * 2, index=range(3, 6),\\n columns=self.req_cols + self.opt_cols)\\n self.table.add_new(new=new_df)\\n self.assertEqual(len(self.table.index), 6)\",\n \"def add(table):\\n\\n # your code\\n\\n \\n \\n\\n return_inputs = ui.get_inputs(['Name', 'Year'],\\\"Please enter a new record.\\\")\\n key = str(common.generate_random(table))\\n table.append([key,return_inputs[FIRST_PROP] , str(return_inputs[SECOND_PROP])])\\n data_manager.write_table_to_file('hr/persons.csv', table)\\n\\n\\n return table\",\n \"def add_feature_columns(self, feature_columns: typing.List[str]):\\n self.feature_columns += feature_columns\",\n \"def test_add_column(self):\\n name_column = Varchar()\\n name_column._meta.name = \\\"name\\\"\\n\\n genre_column = Varchar()\\n genre_column._meta.name = \\\"genre\\\"\\n\\n schema: t.List[DiffableTable] = [\\n DiffableTable(\\n class_name=\\\"Band\\\",\\n tablename=\\\"band\\\",\\n columns=[name_column, genre_column],\\n )\\n ]\\n schema_snapshot: t.List[DiffableTable] = [\\n DiffableTable(\\n class_name=\\\"Band\\\",\\n tablename=\\\"band\\\",\\n columns=[name_column],\\n )\\n ]\\n\\n schema_differ = SchemaDiffer(\\n schema=schema, schema_snapshot=schema_snapshot, auto_input=\\\"y\\\"\\n )\\n\\n self.assertTrue(len(schema_differ.add_columns.statements) == 1)\\n self.assertEqual(\\n schema_differ.add_columns.statements[0],\\n \\\"manager.add_column(table_class_name='Band', tablename='band', column_name='genre', db_column_name='genre', column_class_name='Varchar', column_class=Varchar, params={'length': 255, 'default': '', 'null': False, 'primary_key': False, 'unique': False, 'index': False, 'index_method': IndexMethod.btree, 'choices': None, 'db_column_name': None})\\\", # noqa\\n )\",\n \"def __mag_table_append(self, table_new):\\n for r in table_new[self.__mag_colnames]:\\n self.__mags.add_row(r)\\n self.__mags.sort(['ra','dec','MJD'])\",\n \"def update(self):\\n current = LazyRegister(self.db)\\n current.render()\\n cur = self.db.cursor()\\n for table in self.tables:\\n if table in current.tables:\\n additions, removals = current.tables[table].migrate(self.tables[table])\\n for addition in additions:\\n cur.execute(\\\"\\\"\\\"ALTER TABLE %s ADD COLUMN %s\\\"\\\"\\\" % (\\n table, addition[1].get_sql()\\n ))\\n print('Added column: ', addition[0])\\n for removal in removals:\\n #cur.execute(\\\"\\\"\\\"ALTER TABLE %s DROP COLUMN %s\\\"\\\"\\\" % (\\n # table, removal[0]\\n #))\\n #print('Removed column: ', removal[0])\\n print('Did not removed column: ', removal[0])\\n else:\\n schema = self.tables[table].get_create_table_sql()\\n cur.execute(schema)\\n print('Added table %s' % table)\",\n \"def add_record(self, data):\\n if not self._validate_columns(data):\\n raise ValueError('Invalid column names')\\n formatted_data = [str(data[column]) for column in self.column_names]\\n utils.write_line(','.join(formatted_data) + '\\\\n', self.filename, 'a')\",\n \"def add_blank_data_column(self):\\n\\n header_title, ok_pressed = QInputDialog.getText(self, \\\"Add Column\\\", \\\"Enter heading for the column:\\\",\\n QLineEdit.Normal, \\\"\\\")\\n if ok_pressed and header_title != '':\\n # print(header_title)\\n\\n default_value, set_default_pressed = QInputDialog.getText(self, \\\"Set Default Value\\\",\\n \\\"Enter default value to set for column if any:\\\",\\n QLineEdit.Normal, \\\"\\\")\\n\\n row_count = self.csv_data_table.rowCount()\\n last_column_count = self.csv_data_table.columnCount()\\n self.csv_data_table.insertColumn(last_column_count)\\n for empty_row in range(0, row_count):\\n item = QTableWidgetItem(default_value)\\n self.csv_data_table.setItem(empty_row, last_column_count, item)\\n\\n # TODO: fix untraced bug present in show/hide columns\\n self.column_headers.append(header_title)\\n self.column_headers_all.append(header_title)\\n # print(self.column_headers)\\n # print(self.column_headers_all)\\n self.csv_data_table.setHorizontalHeaderLabels(self.column_headers)\",\n \"def addTableColumn(self, tablename, columnname, columntype):\\n\\n # Check if the table exists\\n if tablename in self.getTableNames():\\n\\n # Check that the column does not already exist\\n if columnname not in self.getColumnNames(tablename):\\n\\n #Allow columnames with spaces\\n columnname = '`'+columnname+'`'\\n\\n \\\"\\\"\\\"# Fit characters to the allowed format if necessary\\n fmt = ''\\n if (self.connector == 'mysql' and\\n ('TEXT' in columntype or 'VARCHAR' in columntype) and\\n not ('CHARACTER SET' in columntype or\\n 'utf8mb4' in columntype)):\\n\\n # We enforze utf8mb4 for mysql\\n fmt = ' CHARACTER SET utf8mb4'\\n\\n\\n sqlcmd = ('ALTER TABLE ' + tablename + ' ADD COLUMN ' +\\n columnname + ' ' + columntype + fmt)\\\"\\\"\\\"\\n sqlcmd = ('ALTER TABLE ' + tablename + ' ADD COLUMN ' +\\n columnname + ' ' + columntype) \\n self._c.execute(sqlcmd)\\n\\n # Commit changes\\n self._conn.commit()\\n\\n else:\\n print((\\\"WARNING: Column {0} already exists in table {1}.\\\"\\n ).format(columnname, tablename))\\n\\n else:\\n print('Error adding column to table. Please, select a valid ' +\\n 'table name from the list')\\n print(self.getTableNames())\\n\\n return\",\n \"def add(table):\\n\\n # 2\\n id = common.generate_random(table)\\n addnew = ui.get_inputs(\\n ['name: ', 'birth_year: '],\\n 'Adding entry to hr')\\n addnew.insert(0, id)\\n table.append(addnew)\\n data_manager.write_table_to_file('hr/persons.csv', table)\\n return table\",\n \"def columns_setup(self):\\n self.required = None\\n self.addition = None\\n self.deletion = None\\n self.retention = None\\n self.rename = None\",\n \"def addCommonExtraColumn(self, req, study_id, found_extra_table, column_name, data_type, description):\\n debug = False\\n common_extra_table_name = None\\n min_column_count = None\\n quoted_column_name = '\\\"{0}\\\"'.format(column_name.upper())\\n \\n if 'SAMPLE' in found_extra_table:\\n common_extra_table_name = 'COMMON_EXTRA_SAMPLE'\\n min_column_count = 2\\n elif 'PREP' in found_extra_table:\\n common_extra_table_name = 'COMMON_EXTRA_PREP'\\n min_column_count = 3\\n \\n if common_extra_table_name == None:\\n raise Exception('Error: Could not determine the common extra table name. The found extra table is: %s' % found_extra_table)\\n \\n # Set the database data type:\\n database_data_type = ''\\n if data_type == 'text' or database_data_type == 'range':\\n database_data_type = 'varchar2(4000)'\\n elif data_type == 'numeric':\\n database_data_type = 'int'\\n elif data_type == 'date':\\n database_data_type = 'date'\\n \\n if database_data_type == '':\\n raise Exception('Could not determine common extra column data type.')\\n\\n # Create the column if it doesn't already exist\\n statement = \\\"\\\"\\\"\\n select count(*) \\n from all_tab_columns \\n where column_name = '{0}' \\n and table_name = '{1}'\\n \\\"\\\"\\\".format(column_name.upper(), common_extra_table_name)\\n if debug:\\n req.write('<pre>' + statement + '</pre><br/>')\\n con = self.getMetadataDatabaseConnection()\\n results = con.cursor().execute(statement).fetchone()\\n if results[0] == 0:\\n statement = 'alter table %s add %s %s' % (common_extra_table_name, quoted_column_name, database_data_type)\\n if debug:\\n req.write('<pre>' + statement + '</pre><br/>')\\n con.cursor().execute(statement)\\n \\n # Copy the data found in the found extra_table\\n if common_extra_table_name == 'COMMON_EXTRA_SAMPLE':\\n statement = \\\"\\\"\\\"\\n MERGE INTO common_extra_sample e\\n USING (\\n SELECT sample_id, {0}\\n FROM {1}\\n ) x\\n ON (e.sample_id = x.sample_id)\\n WHEN MATCHED THEN \\n UPDATE SET e.{0} = x.{0}\\n WHEN NOT MATCHED THEN \\n INSERT (e.sample_id, e.{0})\\n VALUES (x.sample_id, x.{0})\\n \\\"\\\"\\\".format(quoted_column_name, found_extra_table)\\n else:\\n statement = \\\"\\\"\\\"\\n MERGE INTO common_extra_prep e\\n USING (\\n SELECT sample_id, row_number, {0}\\n FROM {1}\\n ) x\\n ON (e.sample_id = x.sample_id and e.row_number = x.row_number)\\n WHEN MATCHED THEN \\n UPDATE SET e.{0} = x.{0}\\n WHEN NOT MATCHED THEN \\n INSERT (e.sample_id, e.row_number, e.{0})\\n VALUES (x.sample_id, x.row_number, x.{0})\\n \\\"\\\"\\\".format(quoted_column_name, found_extra_table)\\n \\n if debug:\\n req.write('<pre>' + statement + '</pre><br/>')\\n con.cursor().execute(statement)\\n statement = 'commit'\\n if debug:\\n req.write('<pre>' + statement + '</pre><br/>')\\n con.cursor().execute(statement)\\n \\n # Remove the column from the found extra table. If it's the last custom column in the table, remove the table\\n statement = \\\"select count(*) from all_tab_columns where table_name = '%s'\\\" % (found_extra_table)\\n if debug:\\n req.write('<pre>' + statement + '</pre><br/>')\\n results = con.cursor().execute(statement).fetchone()\\n if results[0] <= min_column_count:\\n statement = 'drop table %s' % (found_extra_table)\\n if debug:\\n req.write('<pre>' + statement + '</pre><br/>')\\n con.cursor().execute(statement)\\n else:\\n statement = 'alter table %s drop column %s' % (found_extra_table, quoted_column_name)\\n if debug:\\n req.write('<pre>' + statement + '</pre><br/>')\\n con.cursor().execute(statement)\\n \\n # Clean up references in study_actual_columns\\n extra_table_study_id = found_extra_table.split('_')[2]\\n\\n statement = \\\"\\\"\\\"\\n update study_actual_columns \\n set table_name = '\\\"{0}\\\"' \\n where study_id = {1} \\n and table_name = '\\\"{2}\\\"'\\n \\\"\\\"\\\".format(common_extra_table_name, extra_table_study_id, found_extra_table)\\n if debug:\\n req.write('<pre>' + statement + '</pre><br/>')\\n con.cursor().execute(statement)\\n statement = 'commit'\\n if debug:\\n req.write('<pre>' + statement + '</pre><br/>')\\n con.cursor().execute(statement)\",\n \"def add_row(self, dict_with_columns_key):\\n for column in self.columns:\\n val = dict_with_columns_key.get(column)\\n if val is None:\\n val = \\\"\\\"\\n self.data[column].append(val)\",\n \"def add(table):\\n id_storage = common.get_values_from_column(table, 0)\\n id_ = common.generate_random(table)\\n table = manage_data_from_user(table, id_storage, id_, False)\\n\\n return table\",\n \"def append_row(self, row_dict):\\n \\n for k,v in row_dict.items():\\n \\n if(k not in self.table):\\n # Heading does not exist yet. Fill in blanks for past items\\n self.table[k] = [\\\"\\\"] * self.rowcount\\n \\n # clean up value\\n v = v.strip()\\n # try converting string to a number\\n try:\\n v = ast.literal_eval(v)\\n except:\\n pass\\n \\n self.table[k].append(v)\\n \\n self.rowcount = self.rowcount + 1\\n \\n # Even out any columns in DB that were not filled\\n for hdr in self.table:\\n if(len(self.table[hdr]) < self.rowcount):\\n self.table[hdr].append(None)\",\n \"def add(table, record):\\n index_id = 0\\n record.insert(index_id, common.generate_random(table))\\n table.append(record)\\n data_manager.write_table_to_file(\\\"model/sales/sales.csv\\\", table)\\n\\n return table\",\n \"def append_columns(cls, columns, grid=None, grid_url=None):\\n grid_id = parse_grid_id_args(grid, grid_url)\\n\\n grid_ops.ensure_uploaded(grid_id)\\n\\n # Verify unique column names\\n column_names = [c.name for c in columns]\\n if grid:\\n existing_column_names = [c.name for c in grid]\\n column_names.extend(existing_column_names)\\n duplicate_name = utils.get_first_duplicate(column_names)\\n if duplicate_name:\\n err = exceptions.NON_UNIQUE_COLUMN_MESSAGE.format(duplicate_name)\\n raise exceptions.InputError(err)\\n\\n # This is sorta gross, we need to double-encode this.\\n body = {\\\"cols\\\": _json.dumps(columns, cls=PlotlyJSONEncoder)}\\n fid = grid_id\\n response = v2.grids.col_create(fid, body)\\n parsed_content = response.json()\\n\\n cls._fill_in_response_column_ids(columns, parsed_content[\\\"cols\\\"], fid)\\n\\n if grid:\\n grid.extend(columns)\",\n \"def _with_columns(self, columns):\\n table = Table()\\n for label, column in zip(self.column_labels, columns):\\n self._add_column_and_format(table, label, column)\\n return table\",\n \"def create_table_load_records(self, tablename, records, has_header=True):\\n # Column names from header, or make up.\\n if has_header:\\n header = records.pop(0)\\n header = [utils.name_cleaned(n) for n in header]\\n if len(header) != len(set(header)):\\n raise ValueError(\\\"non-unique header column names\\\")\\n else:\\n header = [f\\\"column{i+1}\\\" for i in range(len(records[0]))]\\n\\n # Infer column types and constraints.\\n schema = {\\\"name\\\": tablename}\\n schema[\\\"columns\\\"] = [{\\\"name\\\": name} for name in header]\\n try:\\n for i, column in enumerate(schema[\\\"columns\\\"]):\\n type = None\\n column[\\\"notnull\\\"] = True\\n\\n # First attempt: integer\\n for n, record in enumerate(records):\\n value = record[i]\\n if value is None:\\n column[\\\"notnull\\\"] = False\\n elif isinstance(value, int):\\n pass\\n elif isinstance(value, str):\\n try:\\n int(value)\\n except (ValueError, TypeError):\\n break\\n else:\\n break\\n else:\\n type = constants.INTEGER\\n\\n # Next attempt: float\\n if type is None:\\n for n, record in enumerate(records):\\n value = record[i]\\n if value is None:\\n column[\\\"notnull\\\"] = False\\n elif isinstance(value, (float, int)):\\n pass\\n elif isinstance(value, str):\\n try:\\n float(value)\\n except (ValueError, TypeError):\\n break\\n else:\\n break\\n else:\\n type = constants.REAL\\n\\n # Default: text\\n if type is None:\\n column[\\\"type\\\"] = constants.TEXT\\n if column[\\\"notnull\\\"]:\\n for record in records:\\n value = record[i]\\n if value is None:\\n column[\\\"notnull\\\"] = False\\n break\\n else:\\n column[\\\"type\\\"] = type\\n except IndexError:\\n raise ValueError(f\\\"record {i+1} has too few items\\\")\\n\\n # Create the table.\\n self.add_table(schema)\\n\\n # Actually convert values in records.\\n for i, column in enumerate(schema[\\\"columns\\\"]):\\n type = column[\\\"type\\\"]\\n if type == constants.INTEGER:\\n for n, record in enumerate(records):\\n value = record[i]\\n if value is not None:\\n record[i] = int(value)\\n elif type == constants.REAL:\\n for n, record in enumerate(records):\\n value = record[i]\\n if value is not None:\\n record[i] = float(value)\\n\\n # Insert the data.\\n sql = 'INSERT INTO \\\"%s\\\" (%s) VALUES (%s)' % (\\n tablename,\\n \\\",\\\".join(['\\\"%(name)s\\\"' % c for c in schema[\\\"columns\\\"]]),\\n \\\",\\\".join(\\\"?\\\" * len(schema[\\\"columns\\\"])),\\n )\\n with self.dbcnx:\\n self.dbcnx.executemany(sql, records)\\n self.update_table(schema)\",\n \"def add(table):\\n\\n list_labels = [\\\"Name: \\\", \\\"Manufacturer: \\\", \\\"purchase_date: \\\", \\\"Durability: \\\"]\\n data_input = ui.get_inputs(list_labels, \\\"Add new record\\\")\\n\\n id_ = common.generate_random(table)\\n is_date_number = data_input[2].isdigit() and len(data_input) == 4\\n is_durability_number = data_input[3].isdigit()\\n\\n if is_date_number is True and is_durability_number is True:\\n data_input.insert(0, id_)\\n table.append(data_input)\\n\\n elif is_date_number is False:\\n ui.print_error_message(\\\"Wrong year format! Record add failed!\\\")\\n\\n elif is_durability_number is False:\\n ui.print_error_message(\\\"Wrong durability format! Record add failed!\\\")\\n\\n return table\",\n \"def test_dummydb_add_data_to_table_wrong_column_name(self):\\n db = DummyDB()\\n columns = {\\n \\\"one\\\": int,\\n \\\"two\\\": str,\\n \\\"three\\\": bool,\\n }\\n db.create_table(\\\"new_table\\\", columns)\\n result = db.select(\\\"new_table\\\", four=1)\",\n \"def _alter_table(self, names, types) :\\n\\n cur = self.con.cursor()\\n for i in range(min(len(names), len(types))) :\\n alter_sql = 'ALTER TABLE \\\"%s\\\" ADD COLUMN \\\"%s\\\" %s' % (self.name, names[i], types[i])\\n cur.execute(alter_sql)\",\n \"def append_names(self, excludes=None, append=\\\", \\\"):\\n\\n if self.columns and self.q_str.startswith(\\\"INSERT\\\"):\\n q_temp = []\\n if excludes and isinstance(excludes, str):\\n for key in self.columns.keys():\\n if key != excludes:\\n q_temp.append(key)\\n elif excludes and isinstance(excludes, list):\\n for key in self.columns.keys():\\n if key not in excludes:\\n q_temp.append(key)\\n elif excludes is None:\\n for key in self.columns.keys():\\n q_temp.append(key)\\n else:\\n raise ValueError(\\\"append_names accepts lists, dict keys and pd.DataFrame indexes\\\")\\n else:\\n raise ValueError(\\\"append_names does not accept NULL init_objections\\\")\\n\\n q_temp = \\\", \\\".join(q_temp)\\n self.q_str = append.join([self.q_str, q_temp])\\n self.q_str = \\\"\\\".join([self.q_str, \\\") VALUES \\\"])\",\n \"def __refmag_table_append(self, table_new): \\n if not \\\"mag_calib_unc\\\" in table_new.colnames:\\n table_new[\\\"mag_calib_unc\\\"] = [None for i in range(len(table_new))]\\n \\n for r in table_new[self.__mag_colnames]:\\n self.__ref_mags.add_row(r)\\n self.__ref_mags.sort(['ra','dec','MJD'])\",\n \"def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\\n return False\",\n \"def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\\n return False\",\n \"def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\\n return False\",\n \"def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\\n return False\",\n \"def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\\n return False\",\n \"def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\\n return False\",\n \"def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\\n return False\",\n \"def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\\n return False\",\n \"def AppendCols(self, numCols=1): # real signature unknown; restored from __doc__\\n return False\",\n \"def project(self, name, cols) :\\n\\n ct = [v \\n for v in list(zip(self.get_cols(), self.get_types()))\\n if v[0] in cols]\\n\\n base_row = dict(zip(cols, itertools.repeat(None)))\\n \\n def make_new_row(r) :\\n values = {}\\n values.update(base_row)\\n values.update(r.as_dict())\\n return values\\n new_rows = [make_new_row(row) for row in self]\\n\\n new_table = self.factory.new_table(name, ct)\\n new_table.add_rows(new_rows)\\n return new_table\",\n \"def add_column(self, schema):\\n self[schema.name] = schema.copy()\",\n \"def add_table_column(\\n self, table: Table, name: Optional[str] = None, values: Any = None\\n ):\\n self._requires_table(table)\\n table.append_column(name, values)\",\n \"def deferred_to_columns_cb(self, target, model, fields):\\n table = model._meta.db_table\\n if table not in target:\\n target[table] = set()\\n for field in fields:\\n if not hasattr(field.column, \\\"columns\\\"):\\n target[table].add(field.column)\\n else:\\n target[table].update(field.column.columns)\",\n \"def add_row(self, *column_data):\\n row = \\\"<tr>\\\"\\n row += \\\" \\\".join(f\\\"<td>{header}</td>\\\" for header in column_data)\\n row += \\\"</tr>\\\\n\\\"\\n self.result += row\",\n \"def AddColumn(self, column):\\n self.columns.append(column)\\n self.column_dict[column.column_id] = column\",\n \"def add_select(self, *column):\\n if not column:\\n column = []\\n\\n self.columns += column\\n\\n return self\",\n \"def create_table_columns(database, table, columns):\\r\\n in_tests.test_create_table_columns(database, table, columns)\\r\\n\\r\\n connection = sqlite3.connect(database)\\r\\n cursor = connection.cursor()\\r\\n\\r\\n for column in columns:\\r\\n query = f\\\"ALTER TABLE {table} ADD COLUMN {column}\\\"\\r\\n cursor.execute(query)\\r\\n connection.commit()\\r\\n cursor.close()\\r\\n connection.close()\\r\\n\\r\\n out_tests.test_create_table_columns(\\r\\n get_table_columns_names(database, table), columns)\\r\\n return ()\",\n \"def test_query_all_new_column(self):\\n session = self.prepare(user_table=True)\\n\\n self._insert_data(session)\\n\\n assert_one(\\n session,\\n \\\"SELECT * FROM users_by_state WHERE state = 'TX' AND username = 'user1'\\\",\\n ['TX', 'user1', 1968, 'f', 'ch@ngem3a', None]\\n )\\n\\n session.execute(\\\"ALTER TABLE users ADD first_name varchar;\\\")\\n\\n results = list(session.execute(\\\"SELECT * FROM users_by_state WHERE state = 'TX' AND username = 'user1'\\\"))\\n assert len(results) == 1\\n assert hasattr(results[0], 'first_name'), 'Column \\\"first_name\\\" not found'\\n assert_one(\\n session,\\n \\\"SELECT * FROM users_by_state WHERE state = 'TX' AND username = 'user1'\\\",\\n ['TX', 'user1', 1968, None, 'f', 'ch@ngem3a', None]\\n )\",\n \"def append_row(self):\\r\\n values = []\\r\\n vals_to_insert = ''\\r\\n\\r\\n for key in Output.COLUMNS:\\r\\n values.append(str(self[key]))\\r\\n\\r\\n # Replace any Quotes in parsed record with double quotes\\r\\n for i in values:\\r\\n vals_to_insert += i.replace('\\\"', '\\\"\\\"') + '\\\",\\\"'\\r\\n\\r\\n vals_to_insert = '\\\"' + vals_to_insert[:-3] + '\\\"'\\r\\n insert_sqlite_db(vals_to_insert)\",\n \"def add_column_into_source(self, tap_type, table, new_column):\\n run_query_method = getattr(self, f'run_query_tap_{tap_type}')\\n run_query_method(\\n f'ALTER TABLE {table} ADD {new_column[\\\"name\\\"]} int'\\n )\\n run_query_method(\\n f'UPDATE {table} set {new_column[\\\"name\\\"]}={new_column[\\\"value\\\"]} where 1=1'\\n )\",\n \"def add(table):\\n # 2\\n id = common.generate_random(table)\\n addnew = ui.get_inputs(\\n ['month: ',\\n 'day: ',\\n 'year: ',\\n 'type (in=income, out= outflow): ',\\n 'amount (of transaction in USD): '],\\n 'Adding item to Accounting table')\\n addnew.insert(0, id)\\n table.append(addnew)\\n data_manager.write_table_to_file('accounting/items.csv', table)\\n\\n return table\",\n \"def add_row(self, row):\\n \\n new_row = pd.DataFrame(data=[row], columns = self.table.columns) \\n self.table = self.table.append(new_row, ignore_index=True)\",\n \"def add(table):\\n\\n new_list_to_add = []\\n\\n new_list_to_add.append(common.generate_random(table))\\n new_list_to_add.extend(ui.get_inputs([\\\"Please add the Name: \\\"],\\\"\\\"))\\n new_list_to_add.extend(ui.get_inputs([\\\"Please add the Manufacturer: \\\"],\\\"\\\"))\\n new_list_to_add.extend(ui.get_inputs([\\\"Please add the Year of Purchase: \\\"],\\\"\\\"))\\n new_list_to_add.extend(ui.get_inputs([\\\"Please add the Durability Time in Year/s: \\\"],\\\"\\\"))\\n \\n table.append(new_list_to_add) # hozzáadni a csv filehoz\\n data_manager.write_table_to_file(\\\"inventory/inventory.csv\\\", table)\\n\\n return table\",\n \"def setAllColumns(self, newAllColumns):\\n \\n pass\",\n \"def add_numeric_cols(self):\\n self.create_numeric_status()\\n self.create_date_integer()\",\n \"def appendData(self, dataframe, tableName, truncate=False):\\n if truncate:\\n truncateSetting = 'replace'\\n else:\\n truncateSetting = 'append'\\n dataframe.to_sql(name=tableName, con=self.writeConn, if_exists=truncateSetting, index=False)\",\n \"def __update_feature_table_columns(self):\\n self.__init_table()\\n\\n feature_dict_sorted_keys = feature_extractor_definition.keys()\\n feature_dict_sorted_keys.sort()\\n for key in feature_dict_sorted_keys:\\n if not self.__has_feature_column(key):\\n self.__add_feature_column(key, feature_extractor_definition[key])\",\n \"def add_row(self, *column_data):\\n raise NotImplementedError\",\n \"def add_column(self, fieldname, column, align=..., valign=...):\\n ...\",\n \"def add_header(self, *column_headers):\\n raise NotImplementedError\",\n \"def add_rows(self, dict_with_columns_key):\\n max_length = 0\\n for vals in dict_with_columns_key.values():\\n if len(vals) > max_length:\\n max_length = len(vals)\\n\\n for column in self.columns:\\n vals = dict_with_columns_key.get(column)\\n vals.extend([\\\"\\\"] * (max_length - len(vals))) # Enforce all columns to have same length\\n self.data[column].extend(vals)\",\n \"def populate_dyn(self, table):\\n myrow = table.row\\n myrow[\\\"sample_time\\\"] = int(time.time() - glob.base_time)\\n myrow[\\\"available_bike_stands\\\"] = self.available_bike_stands\\n myrow[\\\"available_bikes\\\"] = self.available_bikes\\n myrow[\\\"last_update\\\"] = self.last_update\\n myrow[\\\"status\\\"] = self.status\\n myrow.append()\\n table.flush()\",\n \"def add_all_lines(conn, table_values):\\n\\n column_list = table_values[0]\\n column_row = \\\",\\\".join(column_list)\\n qmark = \\\"?\\\"\\n col_count = len(column_list)\\n for cols in range(1, col_count):\\n qmark += \\\", ?\\\"\\n cols = cols\\n\\n cur = conn.cursor()\\n cur.execute(\\\"DROP TABLE IF EXISTS ayasdi_table;\\\")\\n cur.execute(\\\"CREATE TABLE ayasdi_table (\\\" + column_row + \\\");\\\")\\n cur.executemany(\\\\\\n \\\"INSERT INTO ayasdi_table (\\\" + column_row + \\\") VALUES (\\\" + qmark + \\\");\\\", \\\\\\n table_values)\",\n \"def add_column(self, tap_column):\\r\\n self.__columns.append(tap_column)\",\n \"def append_table(self, table):\\n\\n self._db_manager.register_table(table)\",\n \"def setcolumns(self, columns):\\n\\n # Store the column titles (\\\"raw\\\" format)\\n # This is a list of white-space separated strings\\n self.__columns = columns\\n # Create table_column objects\\n for col in columns.split():\\n self.addcolumn(col)\\n # Attempt to populate the column objects\\n if self.__data:\\n self.__populate_columns()\\n self.__nonzero = True\",\n \"def _bulk_add_rows(self, converted) :\\n\\n insert_sql = 'INSERT INTO \\\"%s\\\" VALUES (%s)' % (self.name, ','.join(['?'] * len(self.cols)))\\n cur = self.con.cursor()\\n cur.executemany(insert_sql, converted)\",\n \"def add_blank_data_row(self):\\n last_row_count = self.csv_data_table.rowCount()\\n column_count = self.csv_data_table.columnCount()\\n self.csv_data_table.insertRow(last_row_count)\\n for empty_col in range(0, column_count):\\n item = QTableWidgetItem('')\\n self.csv_data_table.setItem(last_row_count, empty_col, item)\",\n \"def select(self, keep_columns=None, additional_columns=None):\\n if keep_columns is None:\\n keep_columns = self.columns\\n\\n if additional_columns is None:\\n additional_columns = {}\\n\\n result_table = Table(keep_columns + list(additional_columns.keys()))\\n\\n for row in self.rows:\\n new_row = [row[column] for column in keep_columns]\\n\\n for column_name, calculation in additional_columns.items():\\n new_row += [calculation(row)]\\n\\n result_table.insert(new_row)\\n\\n return result_table\",\n \"def visit_alter_table_append_command(element, compiler, **kw):\\n if element.ignore_extra:\\n fill_option = 'IGNOREEXTRA'\\n elif element.fill_target:\\n fill_option = 'FILLTARGET'\\n else:\\n fill_option = ''\\n\\n query_text = \\\\\\n 'ALTER TABLE {target} APPEND FROM {source} {fill_option}'.format(\\n target=compiler.preparer.format_table(element.target),\\n source=compiler.preparer.format_table(element.source),\\n fill_option=fill_option,\\n )\\n return compiler.process(sa.text(query_text), **kw)\",\n \"def populate_table(database, table, data):\\n\\n for row in data:\\n database.session.add(table(row))\\n database.session.commit()\",\n \"def add_table_column(self, schema, column):\\n if not column[\\\"name\\\"] or not constants.NAME_RX.match(column[\\\"name\\\"]):\\n raise ValueError(\\\"invalid column name\\\")\\n if utils.name_in_nocase(column[\\\"name\\\"], [c[\\\"name\\\"] for c in schema[\\\"columns\\\"]]):\\n raise ValueError(\\\"non-unique column name\\\")\\n if column[\\\"type\\\"] not in constants.COLUMN_TYPES:\\n raise ValueError(\\\"invalid column type\\\")\\n sql = (\\n f'''ALTER TABLE \\\"{schema['name']}\\\"'''\\n f\\\"\\\"\\\" ADD COLUMN \\\"{column['name']}\\\" {column['type']}\\\"\\\"\\\"\\n )\\n if column.get(\\\"notnull\\\"):\\n notnull = [\\\"NOT NULL\\\"]\\n if column[\\\"type\\\"] == constants.INTEGER:\\n notnull.append(\\\"DEFAULT 0\\\")\\n elif column[\\\"type\\\"] == constants.REAL:\\n notnull.append(\\\"DEFAULT 0.0\\\")\\n elif column[\\\"type\\\"] in (constants.TEXT, constants.BLOB):\\n notnull.append(\\\"DEFAULT ''\\\")\\n sql += \\\" \\\" + \\\" \\\".join(notnull)\\n self.dbcnx.execute(sql)\\n schema[\\\"columns\\\"].append(column)\\n self.update_table(schema)\",\n \"def add_transaction(table, id, store_id, hr_id, crm_id, quantity):\\n record = [id, store_id, hr_id, crm_id, quantity]\\n table.append(record)\\n\\n return table\",\n \"def set_columns(self, columns):\\n self.columns = columns\",\n \"def addcolumn(self, column):\\n if column not in self.headersindex:\\n database = managers.database_manager.get_database(self.owner_id, self.database_id)\\n cur = database.get_connection().cursor()\\n cur.execute(\\\"ALTER TABLE \\\\'%s\\\\' ADD COLUMN %s\\\" % (self.name, column.to_declaration()))\",\n \"def add_extra_column(self, prof_gas, retrieval_date, mod_data, **kwargs):\\n pass\",\n \"def add_column(self, name, **kwargs):\\n\\n import sqlalchemy.orm.session\\n from dbexceptions import NotFoundError\\n\\n s = sqlalchemy.orm.session.Session.object_session(self)\\n\\n assert s, \\\"Can't create column with this method unless the table has a session\\\"\\n\\n name = Column.mangle_name(name)\\n\\n if not kwargs.get('fast', False):\\n try:\\n row = self.column(name)\\n except NotFoundError:\\n row = None\\n else:\\n row = None\\n\\n if row:\\n extant = True\\n\\n else:\\n row = Column(self, name=name, **kwargs)\\n extant = False\\n\\n if kwargs.get('data', False):\\n row.data = dict(row.data.items() + kwargs['data'].items())\\n\\n for key, value in kwargs.items():\\n\\n excludes = ['d_id', 't_id', 'name', 'schema_type', 'data']\\n\\n # Proto is the name of the object.\\n if key == 'proto' and isinstance(value, basestring):\\n key = 'proto_vid'\\n\\n if extant:\\n excludes.append('sequence_id')\\n\\n if key[0] != '_' and key not in excludes:\\n try:\\n setattr(row, key, value)\\n except AttributeError:\\n raise AttributeError(\\n \\\"Column record has no attribute {}\\\".format(key))\\n\\n if isinstance(value, basestring) and len(value) == 0:\\n if key == 'is_primary_key':\\n value = False\\n setattr(row, key, value)\\n\\n # If the id column has a description and the table does not, add it to\\n # the table.\\n if row.name == 'id' and row.is_primary_key and not self.description:\\n self.description = row.description\\n s.merge(self)\\n\\n if extant:\\n row = s.merge(row)\\n else:\\n s.add(row)\\n\\n if kwargs.get('commit', True):\\n s.commit()\\n\\n return row\",\n \"def add(table):\\n\\n # your code\\n row = []\\n row.append(common.generate_random(table))\\n\\n inputs = ui.get_inputs([\\\"TITLE: \\\", \\\"MANUFACTURER: \\\", \\\"PRICE: \\\", \\\"STOCK: \\\"], \\\"Fill the records below: \\\")\\n for i in inputs:\\n row.append(i)\\n\\n table.append(row)\\n\\n return table\",\n \"def _insert_column(self, column_name, column_type, table, params=None, overwrite=False, after_col=None, verbose=True):\\n \\n not_null = ''\\n auto_increment = ''\\n \\n if params != None and 'not_null' in params:\\n not_null = 'NOT NULL'\\n \\n \\n if params != None and 'auto_increment' in params:\\n auto_increment = \\\"AUTO_INCREMENT\\\"\\n \\n \\n ADD_COLUMN_COMMAND = \\\"ALTER TABLE {0} ADD {1} {2} {3} {4}\\\".format(table, column_name, column_type, not_null, auto_increment)\\n \\n if (after_col != None and type(after_col) is str):\\n ADD_COLUMN_COMMAND += \\\" AFTER {0} \\\".format(after_col)\\n \\n \\n self.cursor.execute(ADD_COLUMN_COMMAND)\\n \\n if verbose: \\n print(\\\"Adding the column '{0}' to the table '{1}'...\\\".format(column_name, table))\\n print(\\\"\\\\t\\\" + ADD_COLUMN_COMMAND) \\n \\n \\n if params != None and 'foreign_key' in params:\\n \\n if 'references' not in params:\\n raise InvalidParameterError\\n \\n referenced_table = params['references'].split('(')[0]\\n referenced_column = params['references'].split('(')[1][:-1] \\n \\n \\n if (not self.check_table(referenced_table, verbose=False)):\\n raise(TableNotFoundError)\\n \\n \\n if (not self.check_column(referenced_column, referenced_table, verbose=False)):\\n raise(ColumnNotFoundError)\\n \\n \\n ADD_FOREIGN_KEY_COMMAND = \\\"ALTER TABLE {0} ADD FOREIGN KEY ({1}) REFERENCES {2}({3})\\\".format(table, column_name, referenced_table, referenced_column)\\n \\n \\n if verbose: \\n print(\\\"\\\\t\\\" + ADD_FOREIGN_KEY_COMMAND) \\n \\n self.cursor.execute(ADD_FOREIGN_KEY_COMMAND)\",\n \"def add_records(self):\\n\\n self.setup_progressbar(\\\"Loading {} records from table {}...\\\"\\n .format(self.record_count, self.lyr.name()),\\n self.record_count)\\n\\n provider = self.lyr.dataProvider()\\n for i, row in enumerate(self.cur):\\n feature = QgsFeature()\\n feature.setGeometry(QgsGeometry())\\n feature.setAttributes([flds for flds in row])\\n provider.addFeatures([feature])\\n self.update_progressbar(i)\\n\\n iface.messageBar().clearWidgets()\\n iface.messageBar().pushMessage(\\\"Ready\\\", \\\"{} records added to {}\\\".format(str(self.record_count), self.lyr.name())\\n , level=QgsMessageBar.INFO)\",\n \"def add_new_cols(cat, prefix=\\\"\\\", floatcols=None, boolcols=None):\\n\\t\\n\\tif floatcols != None:\\n\\t\\tfor col in floatcols:\\n\\t\\t\\tcat.add_column(astropy.table.MaskedColumn(name=prefix+col, dtype=float, length=len(cat)))\\n\\t\\t\\tcat[prefix+col].mask = [True] * len(cat)\\n\\tif boolcols != None:\\n\\t\\tfor col in boolcols:\\n\\t\\t\\tcat.add_column(astropy.table.MaskedColumn(name=prefix+col, dtype=bool, length=len(cat)))\\n\\t\\t\\tcat[prefix+col].mask = [True] * len(cat)\",\n \"def update_table_columns(self, table_name, table):\\n table_definition = self._table_definitions[table_name]\\n new_columns = table.columns.difference(table_definition.c.keys())\\n new_column_types = {c: table.dtypes[c] for c in new_columns}\\n\\n allows_covariates = table_definition.name in [\\\"avgint\\\", \\\"data\\\"]\\n\\n good_prefixes = [\\\"c_\\\"]\\n if allows_covariates:\\n good_prefixes.append(\\\"x_\\\")\\n bad_column_names = [c for c in new_columns if c[:2] not in good_prefixes]\\n if bad_column_names:\\n msg = f\\\"\\\"\\\"\\n Table '{table_definition.name}' has these columns {list(table_definition.c.keys())}.\\n It allows additional comment columns, which must start 'c_'.\\\"\\\"\\\"\\n if allows_covariates:\\n msg += \\\" In addition it allows covariate columns, which must start with 'x_'.\\\"\\n msg += f\\\" You supplied columns that don't meet those requirements: {bad_column_names}\\\"\\n\\n raise ValueError(dedent(msg))\\n\\n add_columns_to_table(table_definition, new_column_types)\",\n \"def _add_fields(self, fields):\\n for field in fields:\\n self.add(field)\",\n \"def __limmag_table_append(self, table_new): \\n for r in table_new[self.__limmag_colnames]:\\n self.__lim_mags.add_row(r)\\n self.__lim_mags.sort(['ra','dec','MJD'])\",\n \"def test_add_table(self):\\n name_column = Varchar()\\n name_column._meta.name = \\\"name\\\"\\n schema: t.List[DiffableTable] = [\\n DiffableTable(\\n class_name=\\\"Band\\\", tablename=\\\"band\\\", columns=[name_column]\\n )\\n ]\\n schema_snapshot: t.List[DiffableTable] = []\\n schema_differ = SchemaDiffer(\\n schema=schema, schema_snapshot=schema_snapshot, auto_input=\\\"y\\\"\\n )\\n\\n create_tables = schema_differ.create_tables\\n self.assertTrue(len(create_tables.statements) == 1)\\n self.assertEqual(\\n create_tables.statements[0],\\n \\\"manager.add_table('Band', tablename='band')\\\",\\n )\\n\\n new_table_columns = schema_differ.new_table_columns\\n self.assertTrue(len(new_table_columns.statements) == 1)\\n self.assertEqual(\\n new_table_columns.statements[0],\\n \\\"manager.add_column(table_class_name='Band', tablename='band', column_name='name', db_column_name='name', column_class_name='Varchar', column_class=Varchar, params={'length': 255, 'default': '', 'null': False, 'primary_key': False, 'unique': False, 'index': False, 'index_method': IndexMethod.btree, 'choices': None, 'db_column_name': None})\\\", # noqa\\n )\",\n \"def append(self, other, ensureFilled = True):\\n\\t\\tself.rows.extend(other.rows)\\n\\t\\tself.headers.extend([x for x in other.headers if not x in self.headers])\\n\\t\\tif(ensureFilled):\\n\\t\\t\\tself.ensureFilled()\\n\\t\\treturn self\",\n \"def add_column_to_staging_table(cursor,table_schema,table_name,column_name):\\n if not check_if_column_exists(cursor, table_schema, table_name, column_name):\\n add_column = \\\"ALTER TABLE \\\" + table_schema + \\\".\\\" + table_name + \\\" ADD COLUMN \\\" + column_name + \\\" text;\\\"\\n cursor.execute(add_column)\",\n \"def columns(self, *args):\\n column_set = set(self._columns)\\n for c in args:\\n if c in column_set:\\n continue\\n else:\\n self._columns.append(c)\\n # column_set.add(c) # FIXME failing tests\\n return self\",\n \"def _add_cols(df: pandas.DataFrame, scope = (globals(), locals())) -> None:\\n command : str = input(\\\"\\\\nAdd a column:\\\\n\\\")\\n if command.lower() in ['n', 'no', 'quit()', 'exit', 'return']:\\n return\\n\\n col_name : str = command[ \\\\\\n re.search(r'[\\\\w\\\\.\\\\(\\\\)]+', command).start(): \\\\\\n re.search(r'[\\\\w\\\\.\\\\(\\\\)]+', command).end() \\\\\\n ]\\n # new column's name\\n\\n arg : str = command[re.search(r'[=,;]', command).end():]\\n # the new column's \\\"function\\\"\\n ref_cols = re.findall(r'(?<=\\\\{)\\\\w[\\\\w\\\\.\\\\(\\\\)]*(?=\\\\})', arg)\\n # df column names that are referenced to create new columns\\n\\n for i in range(len(ref_cols)):\\n arg = re.sub(\\n f'{{{ref_cols[i]}}}',\\n f'df[\\\\'{ref_cols[i]}\\\\']',\\n arg\\n )\\n # substituting references\\n\\n scope[0].update(globals())\\n scope[1].update(locals())\\n\\n col_arg = eval(arg, scope[0], scope[1])\\n # pandas.Series for type checking\\n df[col_name] = col_arg\\n # creating column\\n\\n more : str = input(\\\"\\\\nWould you like to add more columns?\\\\n\\\")\\n if more.lower() in ['y', 'yes', 'continue', 'true']:\\n return _add_cols(df)\\n return\",\n \"def test_dummydb_add_data_to_table(self):\\n db = DummyDB()\\n columns = {\\n \\\"one\\\": int,\\n \\\"two\\\": str,\\n \\\"three\\\": bool,\\n }\\n db.create_table(\\\"new_table\\\", columns)\\n db.insert(\\\"new_table\\\", one=1, two=\\\"haunted\\\", three=True)\\n result = db.select(\\\"new_table\\\", one=1)\\n self.assertEqual(result[0]['two'], \\\"haunted\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6977524","0.66601425","0.6458155","0.63593054","0.6348672","0.63241756","0.63117015","0.62366897","0.62343997","0.6218119","0.61731595","0.61588264","0.60610455","0.6052164","0.6035236","0.60302246","0.5991479","0.59869546","0.5986548","0.5966985","0.58958644","0.5880533","0.5879068","0.5862508","0.58427334","0.5828609","0.58023477","0.57889324","0.57874537","0.5785345","0.57832515","0.5767601","0.57629925","0.575807","0.5742575","0.5731693","0.57316893","0.5731494","0.5723864","0.57087386","0.56923956","0.5686829","0.5686829","0.5686829","0.5686829","0.5686829","0.5686829","0.5686829","0.5686829","0.5686829","0.5684389","0.5675704","0.56706196","0.5667847","0.5666918","0.56627643","0.5660885","0.5656983","0.56354594","0.56335616","0.563104","0.56303525","0.5619057","0.56130564","0.5607931","0.5602491","0.56007135","0.5579626","0.55789834","0.55769867","0.55712295","0.55686224","0.55666274","0.5550861","0.5549117","0.5507906","0.5502468","0.5499345","0.5491019","0.5490691","0.5484255","0.5479541","0.5478231","0.54618263","0.5461425","0.54568934","0.5451791","0.54502076","0.54494864","0.54466987","0.5444382","0.5444229","0.5436978","0.54364485","0.5429888","0.54257834","0.5422738","0.54225826","0.5408795","0.5407415","0.5403843"],"string":"[\n \"0.6977524\",\n \"0.66601425\",\n \"0.6458155\",\n \"0.63593054\",\n \"0.6348672\",\n \"0.63241756\",\n \"0.63117015\",\n \"0.62366897\",\n \"0.62343997\",\n \"0.6218119\",\n \"0.61731595\",\n \"0.61588264\",\n \"0.60610455\",\n \"0.6052164\",\n \"0.6035236\",\n \"0.60302246\",\n \"0.5991479\",\n \"0.59869546\",\n \"0.5986548\",\n \"0.5966985\",\n \"0.58958644\",\n \"0.5880533\",\n \"0.5879068\",\n \"0.5862508\",\n \"0.58427334\",\n \"0.5828609\",\n \"0.58023477\",\n \"0.57889324\",\n \"0.57874537\",\n \"0.5785345\",\n \"0.57832515\",\n \"0.5767601\",\n \"0.57629925\",\n \"0.575807\",\n \"0.5742575\",\n \"0.5731693\",\n \"0.57316893\",\n \"0.5731494\",\n \"0.5723864\",\n \"0.57087386\",\n \"0.56923956\",\n \"0.5686829\",\n \"0.5686829\",\n \"0.5686829\",\n \"0.5686829\",\n \"0.5686829\",\n \"0.5686829\",\n \"0.5686829\",\n \"0.5686829\",\n \"0.5686829\",\n \"0.5684389\",\n \"0.5675704\",\n \"0.56706196\",\n \"0.5667847\",\n \"0.5666918\",\n \"0.56627643\",\n \"0.5660885\",\n \"0.5656983\",\n \"0.56354594\",\n \"0.56335616\",\n \"0.563104\",\n \"0.56303525\",\n \"0.5619057\",\n \"0.56130564\",\n \"0.5607931\",\n \"0.5602491\",\n \"0.56007135\",\n \"0.5579626\",\n \"0.55789834\",\n \"0.55769867\",\n \"0.55712295\",\n \"0.55686224\",\n \"0.55666274\",\n \"0.5550861\",\n \"0.5549117\",\n \"0.5507906\",\n \"0.5502468\",\n \"0.5499345\",\n \"0.5491019\",\n \"0.5490691\",\n \"0.5484255\",\n \"0.5479541\",\n \"0.5478231\",\n \"0.54618263\",\n \"0.5461425\",\n \"0.54568934\",\n \"0.5451791\",\n \"0.54502076\",\n \"0.54494864\",\n \"0.54466987\",\n \"0.5444382\",\n \"0.5444229\",\n \"0.5436978\",\n \"0.54364485\",\n \"0.5429888\",\n \"0.54257834\",\n \"0.5422738\",\n \"0.54225826\",\n \"0.5408795\",\n \"0.5407415\",\n \"0.5403843\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3288,"cells":{"query":{"kind":"string","value":"main driver of program"},"document":{"kind":"string","value":"def main(*argv):\n try:\n attr_features = argv[0]\n sql_clause = argv[1]\n polygon_grid = argv[2]\n error_field_count = str(argv[3]) #'NULL_COUNT'#\n error_field_def = str(argv[4]) #'NULL_COLUMNS'#\n output_fc = argv[5]\n out_fc_exists = arcpy.Exists(output_fc)\n\n # Local Variable\n #\n scratchFolder = env.scratchFolder\n scratchGDB = env.scratchGDB\n results = []\n # Logic\n #\n if not out_fc_exists:\n output_gdb = validate_workspace(os.path.dirname(output_fc))\n # Create the grid\n #\n out_grid = arcpy.CopyFeatures_management(polygon_grid, output_fc)[0]\n out_grid = extend_table(out_grid)\n where_clause=None\n else:\n arcpy.MakeFeatureLayer_management(output_fc, \"lyr\")\n arcpy.SelectLayerByLocation_management(\"lyr\", \"HAVE_THEIR_CENTER_IN\", polygon_grid)\n oids = [row[0] for row in arcpy.da.SearchCursor(\"lyr\", \"OID@\")]\n if len(oids) >1:\n oids_string = str(tuple(oids))\n else:\n oids_string = str('('+ str(oids[0]) + ')')\n\n where_clause = 'OBJECTID IN ' + oids_string\n\n error_field = (error_field_def, error_field_count)\n\n # Process the Data\n #\n\n poly_desc = arcpy.Describe(output_fc)\n fc_desc = arcpy.Describe(attr_features)\n if poly_desc.extent.within(fc_desc.extent):\n\n temp_fc = 'in_memory/clip'\n arcpy.AddMessage('Clipping features to polygon')\n arcpy.Clip_analysis(attr_features, output_fc, temp_fc)\n arcpy.AddMessage('Created in_memory fc')\n #data_sdf = geomotion.SpatialDataFrame.from_featureclass(temp_fc,\n # fields=[value_field])\n if sql_clause:\n attr_sdf = SpatialDataFrame.from_featureclass(temp_fc,\n fields=error_field,\n where_clause=sql_clause)\n else:\n attr_sdf = SpatialDataFrame.from_featureclass(temp_fc,\n fields=error_field)\n arcpy.AddMessage('features read into spatial dataframe after clipping')\n else:\n #data_sdf = geomotion.SpatialDataFrame.from_featureclass(, fields=[value_field])\n arcpy.AddMessage('features read into spatial dataframe without clipping')\n if sql_clause:\n attr_sdf = SpatialDataFrame.from_featureclass(attr_features,\n fields=error_field,\n where_clause=sql_clause)\n else:\n attr_sdf = SpatialDataFrame.from_featureclass(attr_features,\n fields=error_field)\n\n grid_sdf = SpatialDataFrame.from_featureclass(filename=output_fc,\n where_clause=where_clause)\n\n index = attr_sdf.sindex\n for idx, row in enumerate(grid_sdf.iterrows()):\n errors = []\n attrs = []\n geom = row[1].SHAPE\n oid = row[1].OBJECTID\n print(str(oid))\n ext = [geom.extent.lowerLeft.X, geom.extent.lowerLeft.Y,\n geom.extent.upperRight.X, geom.extent.upperRight.Y]\n row_oids = list(index.intersect(ext))\n df_current = attr_sdf.loc[row_oids]#.copy()\n sq = df_current.geometry.disjoint(geom) == False\n fcount = len(df_current[sq]) # Total Count\n q2 = df_current[error_field_count] > 0\n #& q2\n df_current = df_current[sq].copy() # Get the # of features with deficiency_cnt > 0\n #print(\"here\")\n if fcount>0: #len(df_current) > 0:\n errors += df_current[error_field_count].tolist()\n arcpy.AddMessage(str(errors))\n def process(x):\n print(x)\n return [va for va in x.replace(' ', '').split('|')[-1].split(',') if len(va) > 1]\n for e in df_current[error_field_def].apply(process).tolist():\n attrs += e\n del e\n row = get_answers(oid=oid,\n err=errors,\n attr=attrs,\n feature_count=fcount)\n results.append(row)\n if len(results) > 250:\n extend_table(table=output_fc, rows=results)\n results = []\n del idx\n del row\n del errors\n del attrs\n del geom\n del oid\n del ext\n del row_oids\n del df_current\n del sq\n del q2\n if len(results) > 0:\n extend_table(table=output_fc, rows=results)\n del index\n del results\n del grid_sdf\n del attr_sdf\n except arcpy.ExecuteError:\n line, filename, synerror = trace()\n arcpy.AddError(\"error on line: %s\" % line)\n arcpy.AddError(\"error in file name: %s\" % filename)\n arcpy.AddError(\"with error message: %s\" % synerror)\n arcpy.AddError(\"ArcPy Error Message: %s\" % arcpy.GetMessages(2))\n except FunctionError as f_e:\n messages = f_e.args[0]\n arcpy.AddError(\"error in function: %s\" % messages[\"function\"])\n arcpy.AddError(\"error on line: %s\" % messages[\"line\"])\n arcpy.AddError(\"error in file name: %s\" % messages[\"filename\"])\n arcpy.AddError(\"with error message: %s\" % messages[\"synerror\"])\n arcpy.AddError(\"ArcPy Error Message: %s\" % messages[\"arc\"])\n except:\n line, filename, synerror = trace()\n arcpy.AddError(\"error on line: %s\" % line)\n arcpy.AddError(\"error in file name: %s\" % filename)\n arcpy.AddError(\"with error message: %s\" % synerror)"},"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 main():\n pass","def main():\n run_program()","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():\n\tpass","def main():\n return","def main(self):\r\n pass","def main() -> None:","def main() -> None:","def main() -> None:","def main() -> None:","def main(self) -> None:\n pass","def main(self):","def run():\n main()","def main():\n Main()","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n\n BASIC.run(PROGRAM)","def main():\n\n pass","def main():\n driver = Driver()\n driver.start()","def main() -> None:\n return","def main(args):","def main(args):","def main():\n ...","def main(args=None):","def main(args=None):","def main():\n pass","def main():\n\n pass\n\n return None","def main():\n\n pass\n\n return None","def main(self):\n pass","def main(cls):\n raise NotImplementedError","def main():\n print(\"It works!!! ;-)\")\n ###TODO### do something with the various methods/functions of this file","def main(self, params):\n pass","def main():\n return 0","def main():\n return 0","def run_main():\n main(sys.argv)","def main():\n\tcli = Cli()\n\tcli.run()","def main():\n print(\"is Running!\")","def main():\n tng.api.runner()","def main():\n print(\"Call your main application code here\")","def main():\n print(\"Call your main application code here\")","def main():\n print(\"Call your main application code here\")","def run():\n main(sys.argv[1:])","def run():\n main(sys.argv[1:])","def run():\n main(sys.argv[1:])","def run():\n main(sys.argv[1:])","def run():\n main(sys.argv[1:])","def run():\n main(sys.argv[1:])","def run():\n main(sys.argv[1:])","def run():\n main(sys.argv[1:])","def main_cli():\n pass","def main(args=None):\n pass","def main():\n opt = parse_opts()\n run(opt)","def main():\n opt = parse_opts()\n run(opt)","def main(self, params):\n raise NotImplementedError('main() must be implemented.')","def run():\n # main(sys.argv[1:])\n main()","def main():\r\n print(\"JoJo\")","def main():\n pass\n\n if __name__ == \"__main)__\":\n main()","def main(self, **kwargs) -> None:\n ..."],"string":"[\n \"def main():\\n pass\",\n \"def main():\\n run_program()\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\\n\\tpass\",\n \"def main():\\n return\",\n \"def main(self):\\r\\n pass\",\n \"def main() -> None:\",\n \"def main() -> None:\",\n \"def main() -> None:\",\n \"def main() -> None:\",\n \"def main(self) -> None:\\n pass\",\n \"def main(self):\",\n \"def run():\\n main()\",\n \"def main():\\n Main()\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n\\n BASIC.run(PROGRAM)\",\n \"def main():\\n\\n pass\",\n \"def main():\\n driver = Driver()\\n driver.start()\",\n \"def main() -> None:\\n return\",\n \"def main(args):\",\n \"def main(args):\",\n \"def main():\\n ...\",\n \"def main(args=None):\",\n \"def main(args=None):\",\n \"def main():\\n pass\",\n \"def main():\\n\\n pass\\n\\n return None\",\n \"def main():\\n\\n pass\\n\\n return None\",\n \"def main(self):\\n pass\",\n \"def main(cls):\\n raise NotImplementedError\",\n \"def main():\\n print(\\\"It works!!! ;-)\\\")\\n ###TODO### do something with the various methods/functions of this file\",\n \"def main(self, params):\\n pass\",\n \"def main():\\n return 0\",\n \"def main():\\n return 0\",\n \"def run_main():\\n main(sys.argv)\",\n \"def main():\\n\\tcli = Cli()\\n\\tcli.run()\",\n \"def main():\\n print(\\\"is Running!\\\")\",\n \"def main():\\n tng.api.runner()\",\n \"def main():\\n print(\\\"Call your main application code here\\\")\",\n \"def main():\\n print(\\\"Call your main application code here\\\")\",\n \"def main():\\n print(\\\"Call your main application code here\\\")\",\n \"def run():\\n main(sys.argv[1:])\",\n \"def run():\\n main(sys.argv[1:])\",\n \"def run():\\n main(sys.argv[1:])\",\n \"def run():\\n main(sys.argv[1:])\",\n \"def run():\\n main(sys.argv[1:])\",\n \"def run():\\n main(sys.argv[1:])\",\n \"def run():\\n main(sys.argv[1:])\",\n \"def run():\\n main(sys.argv[1:])\",\n \"def main_cli():\\n pass\",\n \"def main(args=None):\\n pass\",\n \"def main():\\n opt = parse_opts()\\n run(opt)\",\n \"def main():\\n opt = parse_opts()\\n run(opt)\",\n \"def main(self, params):\\n raise NotImplementedError('main() must be implemented.')\",\n \"def run():\\n # main(sys.argv[1:])\\n main()\",\n \"def main():\\r\\n print(\\\"JoJo\\\")\",\n \"def main():\\n pass\\n\\n if __name__ == \\\"__main)__\\\":\\n main()\",\n \"def main(self, **kwargs) -> None:\\n ...\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8577987","0.85386586","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.8478492","0.838479","0.8375622","0.8302349","0.8288314","0.8288314","0.8288314","0.8288314","0.8198463","0.8155175","0.8070857","0.807074","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.8035722","0.80341285","0.803022","0.79313624","0.7917631","0.78524107","0.78524107","0.78274816","0.77894026","0.77894026","0.77853703","0.7696014","0.7696014","0.76593953","0.76228505","0.76116407","0.75854725","0.75674856","0.75674856","0.75564826","0.7547887","0.7537844","0.7523735","0.74350876","0.74350876","0.74350876","0.7414662","0.7414662","0.7414662","0.7414662","0.7414662","0.7414662","0.7414662","0.7414662","0.74079156","0.7369287","0.735195","0.735195","0.730511","0.7289348","0.72711736","0.72628343","0.7253919"],"string":"[\n \"0.8577987\",\n \"0.85386586\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.8478492\",\n \"0.838479\",\n \"0.8375622\",\n \"0.8302349\",\n \"0.8288314\",\n \"0.8288314\",\n \"0.8288314\",\n \"0.8288314\",\n \"0.8198463\",\n \"0.8155175\",\n \"0.8070857\",\n \"0.807074\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.8035722\",\n \"0.80341285\",\n \"0.803022\",\n \"0.79313624\",\n \"0.7917631\",\n \"0.78524107\",\n \"0.78524107\",\n \"0.78274816\",\n \"0.77894026\",\n \"0.77894026\",\n \"0.77853703\",\n \"0.7696014\",\n \"0.7696014\",\n \"0.76593953\",\n \"0.76228505\",\n \"0.76116407\",\n \"0.75854725\",\n \"0.75674856\",\n \"0.75674856\",\n \"0.75564826\",\n \"0.7547887\",\n \"0.7537844\",\n \"0.7523735\",\n \"0.74350876\",\n \"0.74350876\",\n \"0.74350876\",\n \"0.7414662\",\n \"0.7414662\",\n \"0.7414662\",\n \"0.7414662\",\n \"0.7414662\",\n \"0.7414662\",\n \"0.7414662\",\n \"0.7414662\",\n \"0.74079156\",\n \"0.7369287\",\n \"0.735195\",\n \"0.735195\",\n \"0.730511\",\n \"0.7289348\",\n \"0.72711736\",\n \"0.72628343\",\n \"0.7253919\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3289,"cells":{"query":{"kind":"string","value":"The constructor of the class. Here you will need to create the attributes (\"instance variables\") that were described in the docstring. Note that some of the attributes are defined by parameters passed to this constructor method, but others are not."},"document":{"kind":"string","value":"def __init__(self, name, full_name, team, eye_color, hair_color, base):\n\n self.name = name\n self.full_name = full_name\n self.team = team\n self.eye_color = eye_color\n self.hair_color = hair_color\n self.base = base\n\n self.powers = []\n self.nemeses = []"},"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, **kwds):\n raise NotImplementedError","def __init__(self) -> None:\n # TODO: Provide the complete constructor for this object","def __init__(self, *args, **kwargs) -> None:\n pass","def __init__(self, *args, **kwargs) -> None:\n pass","def __init__(self, *args, **kwargs):\n raise NotImplementedError","def __init__(self, **kwargs):\n raise NotImplementedError","def __init__(self, *args, **kwargs):\n pass","def __init__(self, *args, **kwargs):\n pass","def __init__(self, *args, **kwargs):\n pass","def __init__(self, *args, **kwargs):\n pass","def __init__(self, **kwargs):\n pass","def __init__(self, **kwargs):\n pass","def __init__(self, **kwargs):\n pass","def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass","def __init__ (self, *args, **kw):\n self.__args = args\n self.__kw = kw","def __init__(self, *args, **kwargs):\n raise NotImplementedError()","def __init__(self, *args, **kwargs):\n self.args = args\n self.kwargs = kwargs","def __init__(self, *args, **kwargs): # real signature unknown\n pass","def __init__(self, *args, **kwargs): # real signature unknown\n pass","def __init__(self, *args, **kwargs): # real signature unknown\n pass","def __init__(self, *args, **kwargs):\n self._args = args\n self._kwargs = kwargs","def __init__(name, title=\"\", description=\"\"):","def __init__ (self):\n pass","def __init__(self, **kwargs):\n self.__kwargs = kwargs","def __init__(self, name, price, publisher):\n\n\t\t# passes self which means itself. only defines name, price, and publisher\n\t\tself.name = name\n\t\tself.price = price\n\t\tself.publisher = publisher\n\t\t# any of these variables are available with the instances below.\n\t\t# called attributes","def __init__(self, **kwargs):\n self.swagger_types = {\n 'key': 'str',\n 'display_name': 'str',\n 'description': 'str',\n 'catalog_id': 'str',\n 'uri': 'str',\n 'job_type': 'str',\n 'lifecycle_state': 'str',\n 'is_sample_data_extracted': 'bool',\n 'time_created': 'datetime'\n }\n\n self.attribute_map = {\n 'key': 'key',\n 'display_name': 'displayName',\n 'description': 'description',\n 'catalog_id': 'catalogId',\n 'uri': 'uri',\n 'job_type': 'jobType',\n 'lifecycle_state': 'lifecycleState',\n 'is_sample_data_extracted': 'isSampleDataExtracted',\n 'time_created': 'timeCreated'\n }\n\n self._key = None\n self._display_name = None\n self._description = None\n self._catalog_id = None\n self._uri = None\n self._job_type = None\n self._lifecycle_state = None\n self._is_sample_data_extracted = None\n self._time_created = None","def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.__args = args\n self.__kwargs = kwargs","def __init__(self, *args):\n pass","def __init__(self, **kwargs):\n _declarative_constructor(self, **kwargs)","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self, *args):\r\n pass","def __init__(self,*args):\n pass","def __init__(self, name, typing, reflection, year):#Taking in parameters\n self.n = name#Assigning variables\n self.t = typing\n self.r = reflection\n self.y = year","def __init__(self, make, model, year): # 定义类的默认方法\n self.make = make # 传入变量赋值给可供类中其他方法调用或实例调用的变量\n self.model = model\n self.year = year","def __init__(self, **kwargs):\n pass","def __init__(self):\n raise NotImplementedError(\"This class cannot be instantiated!\")","def __init__(self, name, age):\r\n self.name = name\r\n self.age = age","def __init__(self, first_name, last_name, age):\n\n self.first_name = first_name\n self.last_name = last_name\n self.age = age","def __init__(self, name, age):\n self.name = name\n self.age = age","def __init__(self, name, age):\n self.name = name\n self.age = age","def __init__(self, name, age):\n self.name = name\n self.age = age","def __init__(self, name, age):\n self.name = name\n self.age = age","def __init__(self, name, age):\n\t\tself.name = name\n\t\tself.age = age","def __init__(self, name, age):\n\t\tself.name = name\n\t\tself.age = age","def __init__(self, name, age):\n\t\tself.name = name\n\t\tself.age = age","def __init__(self, a, b, c):\r\n self.a = a\r\n self.b = b\r\n self.c = c","def __init__(self, attrs: Dict[str, Any]) -> None:\n self.attrs = attrs","def __init__(self, *args):\n\n self.args = args","def __init__(self, *args):\n\n self.args = args","def __init__(self, **parameters):\n self.parameters = parameters","def __init__(self):\n self.swagger_types = {\n 'id': 'str',\n 'name': 'str',\n 'channel_id': 'str',\n 'channel_secret': 'str',\n 'switcher_secret': 'str',\n 'service_code': 'str',\n 'self_uri': 'str'\n }\n\n self.attribute_map = {\n 'id': 'id',\n 'name': 'name',\n 'channel_id': 'channelId',\n 'channel_secret': 'channelSecret',\n 'switcher_secret': 'switcherSecret',\n 'service_code': 'serviceCode',\n 'self_uri': 'selfUri'\n }\n\n self._id = None\n self._name = None\n self._channel_id = None\n self._channel_secret = None\n self._switcher_secret = None\n self._service_code = None\n self._self_uri = None","def __init__(self, *args, **kwargs):","def __init__(self, *args, **kwargs):","def __init__(self, *args, **kwargs):","def __init__(self, *args, **kwargs):","def __init__(self, first_name, last_name, age):\n self.first_name = first_name\n self.last_name = last_name\n self.age = age","def __init__(self, first_name, last_name, age):\n self.first_name = first_name\n self.last_name = last_name\n self.age = age","def __init__(self, first_name, last_name, age):\n self.first_name = first_name\n self.last_name = last_name\n self.age = age","def __init__(self, first_name, last_name, age):\n self.first_name = first_name\n self.last_name = last_name\n self.age = age","def __init__(self, first_name, last_name, age):\n self.first_name = first_name\n self.last_name = last_name\n self.age = age","def __init__(self, first_name, last_name, age):\n self.first_name = first_name\n self.last_name = last_name\n self.age = age","def __init__(self, first_name, last_name, age):\n self.first_name = first_name\n self.last_name = last_name\n self.age = age","def __init__(self, first_name, last_name, age):\n self.first_name = first_name\n self.last_name = last_name\n self.age = age","def __init__(self,\n id=None,\n name=None,\n mtype=None,\n usage_bytes=None,\n ):\n\n # Initialize members of the class\n self.id = id\n self.name = name\n self.mtype = mtype\n self.usage_bytes = usage_bytes","def __init__(self,title,description):\n self.title = title\n self.description = description\n \n\t#concept = Concept('title','description) = calls constructor \"__init__\" & pass func\n\t#concept.title = 'title'\n\t#concept.description = description","def __init__(self,\n height=None,\n length=None,\n weight=None,\n width=None):\n\n # Initialize members of the class\n self.height = height\n self.length = length\n self.weight = weight\n self.width = width","def __init__ (self) :","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def init(self, *args, **kwds):\n pass","def __init__(self, **kw_args):\n self._isoFmt = \"%Y%m%dT%H%M%S%z\"\n\n self._init_client_id(kw_args)\n self._init_shared_secret(kw_args)\n self._init_counter_from_time(kw_args)\n self._init_last_count(kw_args)\n self._init_last_count_update_time(kw_args)\n self._init_period(kw_args)\n self._init_password_length(kw_args)\n self._init_tags(kw_args)\n self._init_note(kw_args)","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass"],"string":"[\n \"def __init__(self, **kwds):\\n raise NotImplementedError\",\n \"def __init__(self) -> None:\\n # TODO: Provide the complete constructor for this object\",\n \"def __init__(self, *args, **kwargs) -> None:\\n pass\",\n \"def __init__(self, *args, **kwargs) -> None:\\n pass\",\n \"def __init__(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def __init__(self, **kwargs):\\n raise NotImplementedError\",\n \"def __init__(self, *args, **kwargs):\\n pass\",\n \"def __init__(self, *args, **kwargs):\\n pass\",\n \"def __init__(self, *args, **kwargs):\\n pass\",\n \"def __init__(self, *args, **kwargs):\\n pass\",\n \"def __init__(self, **kwargs):\\n pass\",\n \"def __init__(self, **kwargs):\\n pass\",\n \"def __init__(self, **kwargs):\\n pass\",\n \"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\\n pass\",\n \"def __init__ (self, *args, **kw):\\n self.__args = args\\n self.__kw = kw\",\n \"def __init__(self, *args, **kwargs):\\n raise NotImplementedError()\",\n \"def __init__(self, *args, **kwargs):\\n self.args = args\\n self.kwargs = kwargs\",\n \"def __init__(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def __init__(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def __init__(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def __init__(self, *args, **kwargs):\\n self._args = args\\n self._kwargs = kwargs\",\n \"def __init__(name, title=\\\"\\\", description=\\\"\\\"):\",\n \"def __init__ (self):\\n pass\",\n \"def __init__(self, **kwargs):\\n self.__kwargs = kwargs\",\n \"def __init__(self, name, price, publisher):\\n\\n\\t\\t# passes self which means itself. only defines name, price, and publisher\\n\\t\\tself.name = name\\n\\t\\tself.price = price\\n\\t\\tself.publisher = publisher\\n\\t\\t# any of these variables are available with the instances below.\\n\\t\\t# called attributes\",\n \"def __init__(self, **kwargs):\\n self.swagger_types = {\\n 'key': 'str',\\n 'display_name': 'str',\\n 'description': 'str',\\n 'catalog_id': 'str',\\n 'uri': 'str',\\n 'job_type': 'str',\\n 'lifecycle_state': 'str',\\n 'is_sample_data_extracted': 'bool',\\n 'time_created': 'datetime'\\n }\\n\\n self.attribute_map = {\\n 'key': 'key',\\n 'display_name': 'displayName',\\n 'description': 'description',\\n 'catalog_id': 'catalogId',\\n 'uri': 'uri',\\n 'job_type': 'jobType',\\n 'lifecycle_state': 'lifecycleState',\\n 'is_sample_data_extracted': 'isSampleDataExtracted',\\n 'time_created': 'timeCreated'\\n }\\n\\n self._key = None\\n self._display_name = None\\n self._description = None\\n self._catalog_id = None\\n self._uri = None\\n self._job_type = None\\n self._lifecycle_state = None\\n self._is_sample_data_extracted = None\\n self._time_created = None\",\n \"def __init__(self, *args, **kwargs):\\n super().__init__(*args, **kwargs)\\n self.__args = args\\n self.__kwargs = kwargs\",\n \"def __init__(self, *args):\\n pass\",\n \"def __init__(self, **kwargs):\\n _declarative_constructor(self, **kwargs)\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self, *args):\\r\\n pass\",\n \"def __init__(self,*args):\\n pass\",\n \"def __init__(self, name, typing, reflection, year):#Taking in parameters\\n self.n = name#Assigning variables\\n self.t = typing\\n self.r = reflection\\n self.y = year\",\n \"def __init__(self, make, model, year): # 定义类的默认方法\\n self.make = make # 传入变量赋值给可供类中其他方法调用或实例调用的变量\\n self.model = model\\n self.year = year\",\n \"def __init__(self, **kwargs):\\n pass\",\n \"def __init__(self):\\n raise NotImplementedError(\\\"This class cannot be instantiated!\\\")\",\n \"def __init__(self, name, age):\\r\\n self.name = name\\r\\n self.age = age\",\n \"def __init__(self, first_name, last_name, age):\\n\\n self.first_name = first_name\\n self.last_name = last_name\\n self.age = age\",\n \"def __init__(self, name, age):\\n self.name = name\\n self.age = age\",\n \"def __init__(self, name, age):\\n self.name = name\\n self.age = age\",\n \"def __init__(self, name, age):\\n self.name = name\\n self.age = age\",\n \"def __init__(self, name, age):\\n self.name = name\\n self.age = age\",\n \"def __init__(self, name, age):\\n\\t\\tself.name = name\\n\\t\\tself.age = age\",\n \"def __init__(self, name, age):\\n\\t\\tself.name = name\\n\\t\\tself.age = age\",\n \"def __init__(self, name, age):\\n\\t\\tself.name = name\\n\\t\\tself.age = age\",\n \"def __init__(self, a, b, c):\\r\\n self.a = a\\r\\n self.b = b\\r\\n self.c = c\",\n \"def __init__(self, attrs: Dict[str, Any]) -> None:\\n self.attrs = attrs\",\n \"def __init__(self, *args):\\n\\n self.args = args\",\n \"def __init__(self, *args):\\n\\n self.args = args\",\n \"def __init__(self, **parameters):\\n self.parameters = parameters\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'id': 'str',\\n 'name': 'str',\\n 'channel_id': 'str',\\n 'channel_secret': 'str',\\n 'switcher_secret': 'str',\\n 'service_code': 'str',\\n 'self_uri': 'str'\\n }\\n\\n self.attribute_map = {\\n 'id': 'id',\\n 'name': 'name',\\n 'channel_id': 'channelId',\\n 'channel_secret': 'channelSecret',\\n 'switcher_secret': 'switcherSecret',\\n 'service_code': 'serviceCode',\\n 'self_uri': 'selfUri'\\n }\\n\\n self._id = None\\n self._name = None\\n self._channel_id = None\\n self._channel_secret = None\\n self._switcher_secret = None\\n self._service_code = None\\n self._self_uri = None\",\n \"def __init__(self, *args, **kwargs):\",\n \"def __init__(self, *args, **kwargs):\",\n \"def __init__(self, *args, **kwargs):\",\n \"def __init__(self, *args, **kwargs):\",\n \"def __init__(self, first_name, last_name, age):\\n self.first_name = first_name\\n self.last_name = last_name\\n self.age = age\",\n \"def __init__(self, first_name, last_name, age):\\n self.first_name = first_name\\n self.last_name = last_name\\n self.age = age\",\n \"def __init__(self, first_name, last_name, age):\\n self.first_name = first_name\\n self.last_name = last_name\\n self.age = age\",\n \"def __init__(self, first_name, last_name, age):\\n self.first_name = first_name\\n self.last_name = last_name\\n self.age = age\",\n \"def __init__(self, first_name, last_name, age):\\n self.first_name = first_name\\n self.last_name = last_name\\n self.age = age\",\n \"def __init__(self, first_name, last_name, age):\\n self.first_name = first_name\\n self.last_name = last_name\\n self.age = age\",\n \"def __init__(self, first_name, last_name, age):\\n self.first_name = first_name\\n self.last_name = last_name\\n self.age = age\",\n \"def __init__(self, first_name, last_name, age):\\n self.first_name = first_name\\n self.last_name = last_name\\n self.age = age\",\n \"def __init__(self,\\n id=None,\\n name=None,\\n mtype=None,\\n usage_bytes=None,\\n ):\\n\\n # Initialize members of the class\\n self.id = id\\n self.name = name\\n self.mtype = mtype\\n self.usage_bytes = usage_bytes\",\n \"def __init__(self,title,description):\\n self.title = title\\n self.description = description\\n \\n\\t#concept = Concept('title','description) = calls constructor \\\"__init__\\\" & pass func\\n\\t#concept.title = 'title'\\n\\t#concept.description = description\",\n \"def __init__(self,\\n height=None,\\n length=None,\\n weight=None,\\n width=None):\\n\\n # Initialize members of the class\\n self.height = height\\n self.length = length\\n self.weight = weight\\n self.width = width\",\n \"def __init__ (self) :\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def init(self, *args, **kwds):\\n pass\",\n \"def __init__(self, **kw_args):\\n self._isoFmt = \\\"%Y%m%dT%H%M%S%z\\\"\\n\\n self._init_client_id(kw_args)\\n self._init_shared_secret(kw_args)\\n self._init_counter_from_time(kw_args)\\n self._init_last_count(kw_args)\\n self._init_last_count_update_time(kw_args)\\n self._init_period(kw_args)\\n self._init_password_length(kw_args)\\n self._init_tags(kw_args)\\n self._init_note(kw_args)\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.795267","0.78457487","0.7731138","0.7731138","0.7643051","0.76117766","0.7513325","0.7513325","0.7513325","0.7513325","0.7501279","0.7501279","0.7501279","0.7375516","0.73525584","0.7352199","0.73369604","0.7306995","0.7306995","0.7306995","0.7300619","0.7215287","0.7207899","0.7166026","0.7156388","0.7152725","0.7147736","0.7131461","0.7119932","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71170795","0.71053123","0.7101743","0.7096952","0.70938784","0.7075368","0.707356","0.7067816","0.70607895","0.70607895","0.70607895","0.70607895","0.7060403","0.7060403","0.7060403","0.7053699","0.7051492","0.70451486","0.70451486","0.7043424","0.70339364","0.701632","0.701632","0.701632","0.701632","0.7008673","0.7008673","0.7008673","0.7008673","0.7008673","0.7008673","0.7008673","0.7008673","0.7004986","0.7004972","0.6996012","0.69900286","0.69865","0.69865","0.69865","0.69865","0.6976645","0.6968906","0.69596195","0.69596195","0.69596195","0.69596195","0.69596195","0.69596195","0.69596195"],"string":"[\n \"0.795267\",\n \"0.78457487\",\n \"0.7731138\",\n \"0.7731138\",\n \"0.7643051\",\n \"0.76117766\",\n \"0.7513325\",\n \"0.7513325\",\n \"0.7513325\",\n \"0.7513325\",\n \"0.7501279\",\n \"0.7501279\",\n \"0.7501279\",\n \"0.7375516\",\n \"0.73525584\",\n \"0.7352199\",\n \"0.73369604\",\n \"0.7306995\",\n \"0.7306995\",\n \"0.7306995\",\n \"0.7300619\",\n \"0.7215287\",\n \"0.7207899\",\n \"0.7166026\",\n \"0.7156388\",\n \"0.7152725\",\n \"0.7147736\",\n \"0.7131461\",\n \"0.7119932\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71170795\",\n \"0.71053123\",\n \"0.7101743\",\n \"0.7096952\",\n \"0.70938784\",\n \"0.7075368\",\n \"0.707356\",\n \"0.7067816\",\n \"0.70607895\",\n \"0.70607895\",\n \"0.70607895\",\n \"0.70607895\",\n \"0.7060403\",\n \"0.7060403\",\n \"0.7060403\",\n \"0.7053699\",\n \"0.7051492\",\n \"0.70451486\",\n \"0.70451486\",\n \"0.7043424\",\n \"0.70339364\",\n \"0.701632\",\n \"0.701632\",\n \"0.701632\",\n \"0.701632\",\n \"0.7008673\",\n \"0.7008673\",\n \"0.7008673\",\n \"0.7008673\",\n \"0.7008673\",\n \"0.7008673\",\n \"0.7008673\",\n \"0.7008673\",\n \"0.7004986\",\n \"0.7004972\",\n \"0.6996012\",\n \"0.69900286\",\n \"0.69865\",\n \"0.69865\",\n \"0.69865\",\n \"0.69865\",\n \"0.6976645\",\n \"0.6968906\",\n \"0.69596195\",\n \"0.69596195\",\n \"0.69596195\",\n \"0.69596195\",\n \"0.69596195\",\n \"0.69596195\",\n \"0.69596195\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3290,"cells":{"query":{"kind":"string","value":"This is the string method for the class. Whenever an instance of is passed to the str() or print() functions, the return string from this method will be returned. Fill in the instance attributes that are outlined by the characters in the variable."},"document":{"kind":"string","value":"def __str__(self):\n\n description = f\"{self.name} is a member of the {self.team} and possesses the following powers:\\n{self.powers}\"\n return description"},"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 __str__(self):\n # print(self.get_string())\n return self.get_string()","def __str__(self):\n # print(self.get_string())\n return self.get_string()","def __str__(self):\n return self.printable()","def __str__(self):\n if self.f_has_range():\n lenstr = \"len:%d\" % self.f_get_range_length()\n else:\n lenstr = \"\"\n\n if self.v_comment:\n commentstr = \"`%s`\" % self.v_comment\n else:\n commentstr = \"\"\n\n if commentstr or lenstr:\n if commentstr and lenstr:\n combined_str = \"%s, %s\" % (lenstr, commentstr)\n elif commentstr:\n combined_str = commentstr\n elif lenstr:\n combined_str = lenstr\n else:\n raise RuntimeError(\"You shall not pass!\")\n\n infostr = \" (%s)\" % combined_str\n\n else:\n infostr = \"\"\n\n return_string = \"%s %s%s\" % (self.f_get_class_name(), self.v_full_name, infostr)\n\n if not self.f_is_empty():\n return_string += \": \" + self.f_val_to_str()\n\n return return_string","def __str__(self):\n raise NotImplementedError('Subclasses must define how to layout Character printing')","def __str__(self):\n return self.string","def __str__(self):\r\n return repr(self)","def __str__(self):\n bold = \"*\" if self.bold else ''\n italic = \"/\" if self.italic else ''\n underline = \"_\" if self.underline else ''\n return bold + italic + underline + self.character","def __str__(self):\r\n to_print = (\"Name: \" + self.name + \", Age: \" +\r\n str(self.age) + \", Hobbys: \" + str(self.hobbys))\r\n return to_print","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self): # pragma: no cover\n return self.display()","def __str__(self):\n return str(self.__s)","def __str__(self):\n return_string = self.name + \"\\n\" + str(self.traits)\n\n return return_string","def __str__(self):\n return repr(self)","def __str__(self):\r\n myname = None\r\n for i in dir():\r\n if isinstance(eval(i), School):\r\n myname = i\r\n# printstring = \"%s\\n\" % self.__class__.__name__\r\n #wanted a way of finding out the name of the instance of the class, but couldn't figure out a way to do it...\r\n if myname == \"self\":\r\n myname = self.name_full\r\n printstring = \"%s (%s)\" % (myname, self.__class__.__name__)\r\n vars = self.__dict__.keys()\r\n vars.sort()\r\n for x in vars:\r\n z = x.ljust(20)\r\n try:\r\n printable_var = self.__dict__[x].encode(\"ASCII\")\r\n #printstring = \"%s\\n\\t%s: %s\" % (printstring, z, self.__dict__[x])\r\n printstring = \"%s\\n\\t%s: %s\" % (printstring, z, printable_var)\r\n except:\r\n printstring = \"%s\\n\\t%s: \" % (printstring, z)\r\n #print \"x\", x\r\n #print \"self.__dict__[x]\", self.__dict__[x]\r\n for dodgy_character in str(self.__dict__[x]):\r\n try:\r\n printable_char = dodgy_character.encode(\"ASCII\")\r\n printstring = \"%s%s\" % (printstring, printable_char)\r\n except:\r\n printstring = \"%s%s\" % (printstring, \"?\")\r\n return \"%s\\n\" % printstring","def __str__(self):\n return self.get_string()","def __str__(self):\n print_info = f\"\\nStudent ID: {self._id}, Name: {self._name}, \" \\\n f\"Year: {self._year} \\nPhone: {str(self._phone)}, \" \\\n f\"Address: {str(self._address)} \" \\\n f\"\\nClasses: {str(self._classes)}\" \\\n f\"\\nBirth Date: {self._date}\"\n return print_info","def __str__(self):\n datastr = self.f_val_to_str()\n return_string = \"%s %s\" % (self.f_get_class_name(), self.v_full_name)\n if self.v_comment:\n return_string += \" (`%s`)\" % self.v_comment\n if datastr:\n return_string += \": \" + datastr\n\n return return_string","def __str__(self) -> str:\r\n return self.process(self.string)","def __str__(self):\n\n # This appears at the end of the fed method line\n strme = \"{} {} {} {}\"\\\n .format(self.n_itr, self.i_beg, self.i_end, self.omega)\n\n return strme","def __repr__(self) -> str:\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())","def __repr__(self) -> str:\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())","def __repr__(self) -> str:\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())","def __str__(self) -> str:\n return str(self.getvalue())","def __str__(self) -> str:\n return str(self.getvalue())","def __str__(self) -> str:\n return str(self.getvalue())","def __str__(self):\n return self.format()","def __str__(self):\n string = super().__str__()\n string += \"\\n\" + str(self.get_dict())\n return string","def __repr__(self) -> str:\n\t\treturn \"\"","def __repr__(self):\n\n # Sometimes, to avoid messy concatenation, it's ok to have your string\n # go past the 80-charcter line limit\n return f'<Animal animal_id={self.animal_id} name={self.name}> animal_species={self.animal_species}'","def __str__(self):\n return self.get_str()","def __repr__(self) -> str:\n\t\treturn \"- {}\\n{}\\n\".format(self.name, self.__str__())","def __str__(self):\n class_name_str = str(self.__class__.__name__) + \": (\"\n head_str = str(self.head_vertex) + \", \"\n tail_str = str(self.tail_vertex) + \", \"\n weight_str = str(self.weight) + \")\"\n attributes_str = head_str + tail_str + weight_str\n str_rep = class_name_str + attributes_str\n return str_rep","def __str__(self):\n class_name_str = str(self.__class__.__name__) + \": (\"\n head_str = str(self.head_vertex) + \", \"\n tail_str = str(self.tail_vertex) + \", \"\n weight_str = str(self.weight) + \")\"\n attributes_str = head_str + tail_str + weight_str\n str_rep = class_name_str + attributes_str\n return str_rep","def __str__(self):\n # Notice the use of self to get the class method\n return self.__repr__()","def __repr__(self):\r\n return str(self)","def __str__(self):\n raise NotImplementedError(\"__str__ not implemented for \"+str(type(self)))","def __str__(self) -> str:\n pass","def __str__(self):\n temp = super().__str__()\n return temp + '\\nB:\\n' + str(self.B)","def __repr__(self):\n args = []\n if self.name != \"alpha\":\n args.append(repr(self.name))\n if self.propertiesstr:\n args.append(repr(self.propertiesstr))\n elif self.propertiesstr:\n args.append(\"attr=%r\" % self.propertiesstr)\n return \"%s(%s)\" % (type(self).__name__, \", \".join(args))","def __str__(self):\r\n return self.__repr__()","def __str__(self):\n return str(self.GetString())","def __str__(self):\n astr = '[\\n name: [ ' + self.name + ' ]\\n'\n astr += ' variables: [ '\n for var, init in self.variables:\n astr += '(' + var + ' := ' + init + '), '\n astr = astr[:-2] + ' ]\\n assumptions: [ '\n for assumption in self.assumptions:\n astr += assumption + ', '\n astr = astr[:-2] + ' ]\\n guarantees: [ '\n for guarantee in self.guarantees:\n astr += guarantee + ', '\n return astr[:-2] + ' ]\\n]'","def __repr__(self):\r\n\t\treturn str(self)","def __str__(self):\n # newline-delimited values of all the attributes\n return \">%s\\n%s\" % (self.Label, self.Sequence)","def __repr__(self) -> str:\n return self.__str__()","def __repr__(self) -> str:\n return self.__str__()","def __repr__(self) -> str:\n return self.__str__()","def __repr__(self) -> str:\n return self.__str__()","def __str__(self) -> str:\n result = \"\"\n for attr in self.ATTRS:\n if len(result) != 0:\n result += \"\\n\"\n result += f\"{attr}: {getattr(self, attr)}\"\n\n return result","def toString():","def __str__(self):\n _str = indent(self.name, color = self.color)\n _str += indent(\"-\"*len(self.name))\n _str += indent(\"( \" + self.movemement + \" - \"+ self.symbole + \" )\")\n _str += indent(\"Awareness: \" + str(self.awareness))\n for _iel in self.abilities:\n _str += indent(_iel)\n if self.description is not None:\n _str += indent(\"-\"*45 + \"\\n\")\n _str += indent(self.description)\n _str += indent(\"-\"*45 + \"\\n\")\n _str += indent(BOLD_BLACK + \" \"*15 + \"Combat Stats\" + RESET)\n _str += indent(\"-\"*45 + \"\\n\")\n _str += indent(BLUE + \" Horror\" + RESET + \" Toughness\"\\\n + RED + \" Combat\" + RESET)\n _str += indent(BLUE + \"Rating Damage \"\\\n + RED + \"Rating Damage\")\n _str += indent(BLUE + \" \" + str(self.horror_rating)\\\n + \" \"*8 + str(self.horror_damage) + RESET\\\n + \" \"*8 + str(self.toughness) + RED\\\n + \" \"*8 + str(self.combat_rating)\\\n + \" \"*8 + str(self.combat_damage) + RESET)\n _str += indent(\"-\"*45 + \"\\n\")\n return _str","def __repr__(self) -> str:\n return f\"{self.text}\"","def __repr__(self) -> str:\n return str(self)","def __repr__(self):\n return \"\\'{}\\'\".format(self.__str__())","def __repr__(self) -> str:\n return f\"<Class[{self.name}](line:{self.line})>\"","def __repr__(self):\n\t\treturn str(self)","def __repr__(self):\n\t\treturn str(self)","def __str__(self):\n print_string = 'key: {} | value: {}'.format(\n str(self.key), str(self.value)\n )\n return print_string","def __str__(self):\n class_name_str = str(self.__class__.__name__) + \": (\"\n attributes_str = str(self.head_vertex) + \", \" + \\\n str(self.tail_vertex) + \")\"\n str_rep = class_name_str + attributes_str\n return str_rep","def __repr__(self):\n str(self)","def __str__(self):\n return self._str","def __str__(self): # reliably restored by inspect\n pass","def __repr__(self) -> str:\n return f\"{self.title} that starts at {self.start} and ends at {self.end} and is taught by {self.instructor}\"","def __str__(self):\n # add a dagger symbol to the class name if needed\n temp = super().__str__()\n if self.dagger:\n temp += \".H\"\n return temp","def __str__(self):\n if self.__description:\n return self.__description\n return repr(self)","def basestr(cls: Any) -> str:\n return baserepr(cls)","def __repr__(self):\r\n return self.__str__()","def __str__(self) -> str:\n\t\treturn \"\"","def __str__(self) :\n raise NotImplementedError","def __repr__(self) -> str:\n ...","def __repr__(self) -> str:\n ...","def __repr__(self) -> str:\n ...","def __repr__(self) -> str:\n ...","def __repr__(self) -> str:\n ...","def __str__(self):\n return self.toString()","def __str__(self):\n raise NotImplementedError(\"Implemented in a subclass\")","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __repr__(self):\n return str(self)","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return f'''\n {super().__str__()}\n Brand: {self._breand}\n Pover: {self._power} (W)\n Nozzle: {self._nozzle} (pieces)\n '''","def __str__(self):\n raise NotImplementedError(\"Should be implemented by subclass\")","def __repr__(self):\n string_representation = self.__str__().replace(\"{\", \"(\").replace(\n \"}\", \")\").replace(\":\", \"=\")\n return f\"{type(self).__name__}{string_representation}\""],"string":"[\n \"def __str__(self):\\n # print(self.get_string())\\n return self.get_string()\",\n \"def __str__(self):\\n # print(self.get_string())\\n return self.get_string()\",\n \"def __str__(self):\\n return self.printable()\",\n \"def __str__(self):\\n if self.f_has_range():\\n lenstr = \\\"len:%d\\\" % self.f_get_range_length()\\n else:\\n lenstr = \\\"\\\"\\n\\n if self.v_comment:\\n commentstr = \\\"`%s`\\\" % self.v_comment\\n else:\\n commentstr = \\\"\\\"\\n\\n if commentstr or lenstr:\\n if commentstr and lenstr:\\n combined_str = \\\"%s, %s\\\" % (lenstr, commentstr)\\n elif commentstr:\\n combined_str = commentstr\\n elif lenstr:\\n combined_str = lenstr\\n else:\\n raise RuntimeError(\\\"You shall not pass!\\\")\\n\\n infostr = \\\" (%s)\\\" % combined_str\\n\\n else:\\n infostr = \\\"\\\"\\n\\n return_string = \\\"%s %s%s\\\" % (self.f_get_class_name(), self.v_full_name, infostr)\\n\\n if not self.f_is_empty():\\n return_string += \\\": \\\" + self.f_val_to_str()\\n\\n return return_string\",\n \"def __str__(self):\\n raise NotImplementedError('Subclasses must define how to layout Character printing')\",\n \"def __str__(self):\\n return self.string\",\n \"def __str__(self):\\r\\n return repr(self)\",\n \"def __str__(self):\\n bold = \\\"*\\\" if self.bold else ''\\n italic = \\\"/\\\" if self.italic else ''\\n underline = \\\"_\\\" if self.underline else ''\\n return bold + italic + underline + self.character\",\n \"def __str__(self):\\r\\n to_print = (\\\"Name: \\\" + self.name + \\\", Age: \\\" +\\r\\n str(self.age) + \\\", Hobbys: \\\" + str(self.hobbys))\\r\\n return to_print\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self): # pragma: no cover\\n return self.display()\",\n \"def __str__(self):\\n return str(self.__s)\",\n \"def __str__(self):\\n return_string = self.name + \\\"\\\\n\\\" + str(self.traits)\\n\\n return return_string\",\n \"def __str__(self):\\n return repr(self)\",\n \"def __str__(self):\\r\\n myname = None\\r\\n for i in dir():\\r\\n if isinstance(eval(i), School):\\r\\n myname = i\\r\\n# printstring = \\\"%s\\\\n\\\" % self.__class__.__name__\\r\\n #wanted a way of finding out the name of the instance of the class, but couldn't figure out a way to do it...\\r\\n if myname == \\\"self\\\":\\r\\n myname = self.name_full\\r\\n printstring = \\\"%s (%s)\\\" % (myname, self.__class__.__name__)\\r\\n vars = self.__dict__.keys()\\r\\n vars.sort()\\r\\n for x in vars:\\r\\n z = x.ljust(20)\\r\\n try:\\r\\n printable_var = self.__dict__[x].encode(\\\"ASCII\\\")\\r\\n #printstring = \\\"%s\\\\n\\\\t%s: %s\\\" % (printstring, z, self.__dict__[x])\\r\\n printstring = \\\"%s\\\\n\\\\t%s: %s\\\" % (printstring, z, printable_var)\\r\\n except:\\r\\n printstring = \\\"%s\\\\n\\\\t%s: \\\" % (printstring, z)\\r\\n #print \\\"x\\\", x\\r\\n #print \\\"self.__dict__[x]\\\", self.__dict__[x]\\r\\n for dodgy_character in str(self.__dict__[x]):\\r\\n try:\\r\\n printable_char = dodgy_character.encode(\\\"ASCII\\\")\\r\\n printstring = \\\"%s%s\\\" % (printstring, printable_char)\\r\\n except:\\r\\n printstring = \\\"%s%s\\\" % (printstring, \\\"?\\\")\\r\\n return \\\"%s\\\\n\\\" % printstring\",\n \"def __str__(self):\\n return self.get_string()\",\n \"def __str__(self):\\n print_info = f\\\"\\\\nStudent ID: {self._id}, Name: {self._name}, \\\" \\\\\\n f\\\"Year: {self._year} \\\\nPhone: {str(self._phone)}, \\\" \\\\\\n f\\\"Address: {str(self._address)} \\\" \\\\\\n f\\\"\\\\nClasses: {str(self._classes)}\\\" \\\\\\n f\\\"\\\\nBirth Date: {self._date}\\\"\\n return print_info\",\n \"def __str__(self):\\n datastr = self.f_val_to_str()\\n return_string = \\\"%s %s\\\" % (self.f_get_class_name(), self.v_full_name)\\n if self.v_comment:\\n return_string += \\\" (`%s`)\\\" % self.v_comment\\n if datastr:\\n return_string += \\\": \\\" + datastr\\n\\n return return_string\",\n \"def __str__(self) -> str:\\r\\n return self.process(self.string)\",\n \"def __str__(self):\\n\\n # This appears at the end of the fed method line\\n strme = \\\"{} {} {} {}\\\"\\\\\\n .format(self.n_itr, self.i_beg, self.i_end, self.omega)\\n\\n return strme\",\n \"def __repr__(self) -> str:\\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())\",\n \"def __repr__(self) -> str:\\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())\",\n \"def __repr__(self) -> str:\\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())\",\n \"def __str__(self) -> str:\\n return str(self.getvalue())\",\n \"def __str__(self) -> str:\\n return str(self.getvalue())\",\n \"def __str__(self) -> str:\\n return str(self.getvalue())\",\n \"def __str__(self):\\n return self.format()\",\n \"def __str__(self):\\n string = super().__str__()\\n string += \\\"\\\\n\\\" + str(self.get_dict())\\n return string\",\n \"def __repr__(self) -> str:\\n\\t\\treturn \\\"\\\"\",\n \"def __repr__(self):\\n\\n # Sometimes, to avoid messy concatenation, it's ok to have your string\\n # go past the 80-charcter line limit\\n return f'<Animal animal_id={self.animal_id} name={self.name}> animal_species={self.animal_species}'\",\n \"def __str__(self):\\n return self.get_str()\",\n \"def __repr__(self) -> str:\\n\\t\\treturn \\\"- {}\\\\n{}\\\\n\\\".format(self.name, self.__str__())\",\n \"def __str__(self):\\n class_name_str = str(self.__class__.__name__) + \\\": (\\\"\\n head_str = str(self.head_vertex) + \\\", \\\"\\n tail_str = str(self.tail_vertex) + \\\", \\\"\\n weight_str = str(self.weight) + \\\")\\\"\\n attributes_str = head_str + tail_str + weight_str\\n str_rep = class_name_str + attributes_str\\n return str_rep\",\n \"def __str__(self):\\n class_name_str = str(self.__class__.__name__) + \\\": (\\\"\\n head_str = str(self.head_vertex) + \\\", \\\"\\n tail_str = str(self.tail_vertex) + \\\", \\\"\\n weight_str = str(self.weight) + \\\")\\\"\\n attributes_str = head_str + tail_str + weight_str\\n str_rep = class_name_str + attributes_str\\n return str_rep\",\n \"def __str__(self):\\n # Notice the use of self to get the class method\\n return self.__repr__()\",\n \"def __repr__(self):\\r\\n return str(self)\",\n \"def __str__(self):\\n raise NotImplementedError(\\\"__str__ not implemented for \\\"+str(type(self)))\",\n \"def __str__(self) -> str:\\n pass\",\n \"def __str__(self):\\n temp = super().__str__()\\n return temp + '\\\\nB:\\\\n' + str(self.B)\",\n \"def __repr__(self):\\n args = []\\n if self.name != \\\"alpha\\\":\\n args.append(repr(self.name))\\n if self.propertiesstr:\\n args.append(repr(self.propertiesstr))\\n elif self.propertiesstr:\\n args.append(\\\"attr=%r\\\" % self.propertiesstr)\\n return \\\"%s(%s)\\\" % (type(self).__name__, \\\", \\\".join(args))\",\n \"def __str__(self):\\r\\n return self.__repr__()\",\n \"def __str__(self):\\n return str(self.GetString())\",\n \"def __str__(self):\\n astr = '[\\\\n name: [ ' + self.name + ' ]\\\\n'\\n astr += ' variables: [ '\\n for var, init in self.variables:\\n astr += '(' + var + ' := ' + init + '), '\\n astr = astr[:-2] + ' ]\\\\n assumptions: [ '\\n for assumption in self.assumptions:\\n astr += assumption + ', '\\n astr = astr[:-2] + ' ]\\\\n guarantees: [ '\\n for guarantee in self.guarantees:\\n astr += guarantee + ', '\\n return astr[:-2] + ' ]\\\\n]'\",\n \"def __repr__(self):\\r\\n\\t\\treturn str(self)\",\n \"def __str__(self):\\n # newline-delimited values of all the attributes\\n return \\\">%s\\\\n%s\\\" % (self.Label, self.Sequence)\",\n \"def __repr__(self) -> str:\\n return self.__str__()\",\n \"def __repr__(self) -> str:\\n return self.__str__()\",\n \"def __repr__(self) -> str:\\n return self.__str__()\",\n \"def __repr__(self) -> str:\\n return self.__str__()\",\n \"def __str__(self) -> str:\\n result = \\\"\\\"\\n for attr in self.ATTRS:\\n if len(result) != 0:\\n result += \\\"\\\\n\\\"\\n result += f\\\"{attr}: {getattr(self, attr)}\\\"\\n\\n return result\",\n \"def toString():\",\n \"def __str__(self):\\n _str = indent(self.name, color = self.color)\\n _str += indent(\\\"-\\\"*len(self.name))\\n _str += indent(\\\"( \\\" + self.movemement + \\\" - \\\"+ self.symbole + \\\" )\\\")\\n _str += indent(\\\"Awareness: \\\" + str(self.awareness))\\n for _iel in self.abilities:\\n _str += indent(_iel)\\n if self.description is not None:\\n _str += indent(\\\"-\\\"*45 + \\\"\\\\n\\\")\\n _str += indent(self.description)\\n _str += indent(\\\"-\\\"*45 + \\\"\\\\n\\\")\\n _str += indent(BOLD_BLACK + \\\" \\\"*15 + \\\"Combat Stats\\\" + RESET)\\n _str += indent(\\\"-\\\"*45 + \\\"\\\\n\\\")\\n _str += indent(BLUE + \\\" Horror\\\" + RESET + \\\" Toughness\\\"\\\\\\n + RED + \\\" Combat\\\" + RESET)\\n _str += indent(BLUE + \\\"Rating Damage \\\"\\\\\\n + RED + \\\"Rating Damage\\\")\\n _str += indent(BLUE + \\\" \\\" + str(self.horror_rating)\\\\\\n + \\\" \\\"*8 + str(self.horror_damage) + RESET\\\\\\n + \\\" \\\"*8 + str(self.toughness) + RED\\\\\\n + \\\" \\\"*8 + str(self.combat_rating)\\\\\\n + \\\" \\\"*8 + str(self.combat_damage) + RESET)\\n _str += indent(\\\"-\\\"*45 + \\\"\\\\n\\\")\\n return _str\",\n \"def __repr__(self) -> str:\\n return f\\\"{self.text}\\\"\",\n \"def __repr__(self) -> str:\\n return str(self)\",\n \"def __repr__(self):\\n return \\\"\\\\'{}\\\\'\\\".format(self.__str__())\",\n \"def __repr__(self) -> str:\\n return f\\\"<Class[{self.name}](line:{self.line})>\\\"\",\n \"def __repr__(self):\\n\\t\\treturn str(self)\",\n \"def __repr__(self):\\n\\t\\treturn str(self)\",\n \"def __str__(self):\\n print_string = 'key: {} | value: {}'.format(\\n str(self.key), str(self.value)\\n )\\n return print_string\",\n \"def __str__(self):\\n class_name_str = str(self.__class__.__name__) + \\\": (\\\"\\n attributes_str = str(self.head_vertex) + \\\", \\\" + \\\\\\n str(self.tail_vertex) + \\\")\\\"\\n str_rep = class_name_str + attributes_str\\n return str_rep\",\n \"def __repr__(self):\\n str(self)\",\n \"def __str__(self):\\n return self._str\",\n \"def __str__(self): # reliably restored by inspect\\n pass\",\n \"def __repr__(self) -> str:\\n return f\\\"{self.title} that starts at {self.start} and ends at {self.end} and is taught by {self.instructor}\\\"\",\n \"def __str__(self):\\n # add a dagger symbol to the class name if needed\\n temp = super().__str__()\\n if self.dagger:\\n temp += \\\".H\\\"\\n return temp\",\n \"def __str__(self):\\n if self.__description:\\n return self.__description\\n return repr(self)\",\n \"def basestr(cls: Any) -> str:\\n return baserepr(cls)\",\n \"def __repr__(self):\\r\\n return self.__str__()\",\n \"def __str__(self) -> str:\\n\\t\\treturn \\\"\\\"\",\n \"def __str__(self) :\\n raise NotImplementedError\",\n \"def __repr__(self) -> str:\\n ...\",\n \"def __repr__(self) -> str:\\n ...\",\n \"def __repr__(self) -> str:\\n ...\",\n \"def __repr__(self) -> str:\\n ...\",\n \"def __repr__(self) -> str:\\n ...\",\n \"def __str__(self):\\n return self.toString()\",\n \"def __str__(self):\\n raise NotImplementedError(\\\"Implemented in a subclass\\\")\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __repr__(self):\\n return str(self)\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return f'''\\n {super().__str__()}\\n Brand: {self._breand}\\n Pover: {self._power} (W)\\n Nozzle: {self._nozzle} (pieces)\\n '''\",\n \"def __str__(self):\\n raise NotImplementedError(\\\"Should be implemented by subclass\\\")\",\n \"def __repr__(self):\\n string_representation = self.__str__().replace(\\\"{\\\", \\\"(\\\").replace(\\n \\\"}\\\", \\\")\\\").replace(\\\":\\\", \\\"=\\\")\\n return f\\\"{type(self).__name__}{string_representation}\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77815866","0.77815866","0.7584849","0.74873406","0.7468666","0.74566126","0.7438483","0.7398238","0.73615706","0.7347233","0.7347233","0.7347233","0.7347233","0.7336336","0.7325533","0.7299921","0.7297643","0.7283104","0.72561014","0.72357535","0.7232867","0.72177285","0.7196232","0.71950704","0.71950704","0.71950704","0.71894294","0.71894294","0.71894294","0.71689457","0.71684647","0.71235204","0.7115328","0.7101173","0.70946443","0.709321","0.709321","0.7079545","0.7062991","0.70546013","0.7052219","0.70382094","0.70352745","0.70332736","0.70305324","0.7030146","0.7020428","0.7016177","0.70133907","0.70133907","0.70133907","0.70133907","0.70132935","0.7010538","0.7005002","0.69987684","0.69918585","0.698798","0.69864964","0.6980585","0.6980585","0.69736636","0.6973032","0.69651556","0.6962518","0.69617313","0.6960051","0.69469965","0.69440514","0.6940224","0.69296855","0.69295424","0.6919902","0.6916447","0.6916447","0.6916447","0.6916447","0.6916447","0.69087756","0.69085747","0.69037735","0.69037735","0.69037735","0.69037735","0.69037735","0.69037735","0.69037735","0.69037735","0.69037735","0.69037735","0.69037735","0.69037735","0.69037735","0.6880875","0.6880875","0.6880875","0.6880875","0.6880875","0.6871453","0.6869943","0.6867495"],"string":"[\n \"0.77815866\",\n \"0.77815866\",\n \"0.7584849\",\n \"0.74873406\",\n \"0.7468666\",\n \"0.74566126\",\n \"0.7438483\",\n \"0.7398238\",\n \"0.73615706\",\n \"0.7347233\",\n \"0.7347233\",\n \"0.7347233\",\n \"0.7347233\",\n \"0.7336336\",\n \"0.7325533\",\n \"0.7299921\",\n \"0.7297643\",\n \"0.7283104\",\n \"0.72561014\",\n \"0.72357535\",\n \"0.7232867\",\n \"0.72177285\",\n \"0.7196232\",\n \"0.71950704\",\n \"0.71950704\",\n \"0.71950704\",\n \"0.71894294\",\n \"0.71894294\",\n \"0.71894294\",\n \"0.71689457\",\n \"0.71684647\",\n \"0.71235204\",\n \"0.7115328\",\n \"0.7101173\",\n \"0.70946443\",\n \"0.709321\",\n \"0.709321\",\n \"0.7079545\",\n \"0.7062991\",\n \"0.70546013\",\n \"0.7052219\",\n \"0.70382094\",\n \"0.70352745\",\n \"0.70332736\",\n \"0.70305324\",\n \"0.7030146\",\n \"0.7020428\",\n \"0.7016177\",\n \"0.70133907\",\n \"0.70133907\",\n \"0.70133907\",\n \"0.70133907\",\n \"0.70132935\",\n \"0.7010538\",\n \"0.7005002\",\n \"0.69987684\",\n \"0.69918585\",\n \"0.698798\",\n \"0.69864964\",\n \"0.6980585\",\n \"0.6980585\",\n \"0.69736636\",\n \"0.6973032\",\n \"0.69651556\",\n \"0.6962518\",\n \"0.69617313\",\n \"0.6960051\",\n \"0.69469965\",\n \"0.69440514\",\n \"0.6940224\",\n \"0.69296855\",\n \"0.69295424\",\n \"0.6919902\",\n \"0.6916447\",\n \"0.6916447\",\n \"0.6916447\",\n \"0.6916447\",\n \"0.6916447\",\n \"0.69087756\",\n \"0.69085747\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.69037735\",\n \"0.6880875\",\n \"0.6880875\",\n \"0.6880875\",\n \"0.6880875\",\n \"0.6880875\",\n \"0.6871453\",\n \"0.6869943\",\n \"0.6867495\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3291,"cells":{"query":{"kind":"string","value":"This method will modify the attribute by appending the parameter to it."},"document":{"kind":"string","value":"def add_power(self, power):\n\n self.powers.append(power)"},"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 __setattr__(self, name, value):\n if name in ['parameters', 'program_name']: # Allowed attributes\n self.__dict__[name] = value\n else:\n self.set_parameter(name, value) # treat as a parameter","def put_param(self, attr_name, val):\n self._params[attr_name] = val","def add_attribute(self, attr):\n self.add(attr)","def __setattr__(self,attributeName,attributeValue):\n if (attributeName in StackParameterNames):\n StackParameters[attributeName] = attributeValue\n else:\n object.__setattr__(self, attributeName, attributeValue)\n #endIf","def add_attribute(self, attr):\n self.attrs.add_attribute(attr)","def __setitem__(self, name: str, value):\n super(Parameter, self).__setitem__(name, value)","def append_attribute(myobj, attrib_k, val):\n vals = getattr(myobj, attrib_k, [])\n if val not in vals:\n vals.append(val)\n setattr(myobj, attrib_k, vals)","def add_attribute(self, attr):\n self.attrs.add(attr)","def set_attribute(self, attr, value):\n super().set_attribute(attr, value) # Keep this line, it triggers the parent class method.\n setattr(self, attr, value)","def __setattr__(self, attr, value):\n super().__setattr__(attr, value)","def set_attr(self, asset_key, attr, value=True):\r\n self.set_attrs(asset_key, {attr: value})","def set_attribute(self, name, value):\n\n pass","def __setitem__(self, attribute_name, value):\n pass # pragma: no cover","def addAttr(self, *args):\n return _libsbml.XMLToken_addAttr(self, *args)","def add_attribute(self, attr: ResourceAttributeDescriptor) -> None:\n self._attributes[assert_not_none(attr.name)] = attr.bind(self)","def add_attribute(self, name, value):\n\t\tif name in self.__attr_hash:\n#\t\t\tattribue already exists\n\t\t\ta = self.__attr_hash[name]\n\t\t\tif name == 'class':\n#\t\t\t\t'class' is a magic attribute\n\t\t\t\tif a['value']:\n\t\t\t\t\tvalue = ' ' + value\n\t\t\t\ta['value'] += value\n\t\t\telse:\n\t\t\t\ta['value'] = value\n\t\telse:\n\t\t\ta = {'name': name, 'value': value}\n\t\t\tself.__attr_hash[name] = a\n\t\t\tself.attributes.append(a)","def setParameter(self, name, value):","def add_attribute(self, attribute_key, attribute_value):\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair","def add_attribute(self, attribute_key, attribute_value):\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair","def add_attribute(self, attribute_key, attribute_value):\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair","def add_attribute(node_proto, name, value):\n node_proto.attribute.extend([make_attribute(name, value)])","def __setitem__(self, name, value):\n self.gattrs[name] = value","def _setAttribute(self, attribute, value):\n\n # if multiple values found\n if hasattr(self, attribute):\n\n # make sure attribute is a list\n values = getattr(self, attribute)\n if not isinstance(values, list):\n setattr(self, attribute, [values])\n\n # append value to list\n getattr(self, attribute).append(value)\n\n # single value found\n else:\n setattr(self, attribute, value)","def write_parameter(self, path, value, attr=None):\n if path.startswith('sample'):\n entry = self.entry.nxroot['entry']\n else:\n entry = self.entry\n if value is not None:\n if attr and path in entry:\n entry[path].attrs[attr] = value\n elif path in entry:\n if isinstance(entry[path], NXgroup):\n del entry[path]\n entry[path] = value\n else:\n entry[path].replace(value)\n elif attr is None:\n entry[path] = value","def __setattr__(self, attribute, value):\n\t\tassert ltrace_func(TRACE_BASE)\n\n\t\tif attribute[0] == '_' or callable(value) \\\n\t\t\t\t\t\tor attribute in self.__class__._licorn_protected_attrs:\n\t\t\tdict.__setattr__(self, attribute, value)\n\n\t\telse:\n\t\t\tdict.__setitem__(self, attribute, value)","def addattribute(self, uid, field, value):\n\n raise NotImplementedError","def __setattr__(self, attr, value):\n self[attr] = value","def add_attribute(self, attribute_name, attribute_value):\n self.attributes[attribute_name] = attribute_value","def _add_argument(hparams, key, value, update=True):\n if hasattr(hparams, key):\n if update:\n setattr(hparams, key, value)\n else:\n hparams.add_hparam(key, value)","def __setitem__(self, key, item):\n self.attrib[key] = item","def __setitem__(self, key, item):\n self.attrib[key] = item","def add_attribute(self, subject_id, id=None, value=None):","def add_attribute(self, subject_id, id=None, value=None):","def add_attribute(self, subject_id, id=None, value=None):","def add_attribute(self, subject_id, id=None, value=None):","def add_attribute(self, subject_id, id=None, value=None):","def modify_argument(parser, arg_name, attribute, new_value):\n for action in parser._actions:\n if action.dest == arg_name:\n setattr(action, attribute, new_value)\n return","def __setitem__(self, key, value):\n if key not in self.attribute_dict.keys():\n raise KeyError(\"Object does not have parameter: {}.\".format(key))\n self.attribute_dict[key] = value","def addParameter(cTag, name, value): #@NoSelf","def __setattr__(self, name, value):\n raise AttributeError(\"You cannot modify attributes on a %s\" % self.__class__.__name__)","def add_attribute(self, key, value):\n self.attributes[key] = value","def setAttributeValue(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\n pass","def __setattr__ (self, attr, value):\n self.set_value (attr, value)","def set_attribute(self, attr, value):\n logger.debug(\"SET ATTRIBUTE {} to {}\".format(attr, value))","def __setattr__(self, attr, value):","def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\n pass","def add_param(element):\n nonlocal params\n name = element.attrib.get(\"name\", None)\n value = element.attrib.get(\"value\", \"\")\n if name:\n params[name] = value","def _insert_parametric_attribute(self,attr_name,attr_def_str):\n self._check_for_definition_correctness(attr_name,attr_def_str)\n self._attrs_def.update([(attr_name,attr_def_str)])\n for attr_def in attr_def_str.split():\n if '$' in attr_def:\n self._params_in_attrs.setdefault(attr_def,set()).add(attr_name)","def __setitem__(self, key, value) :\n attributeslist = getattr(self.request, \"_%s_attributes\" % self.name)\n for i in range(len(attributeslist)) :\n attribute = attributeslist[i]\n for j in range(len(attribute)) :\n (attrname, attrvalue) = attribute[j]\n if attrname == key :\n attribute[j][1].append(value)\n return\n attribute.append((key, [value]))","def __setitem__(self, arg, value):\n setattr(self.args, arg, value)","def nma_attribute(self, stmt, p_elem, pset=None):\n att = \"nma:\" + stmt.keyword\n if att not in p_elem.attr:\n p_elem.attr[att] = stmt.arg","def add_attribute(a, name, other):\n raise TypeError(\"can't add new attribute\")","def add_attribute(self, attr_type, name, components):\n self.attributes[attr_type] = {\"name\": name, \"components\": components}","def __setattr__(self, name, value):\n if hasattr(self, name):\n super(JobSubmission, self).__setattr__(name, value)\n\n else:\n self.params[str(name)] = str(value) #TODO: resolve parameter cases","def propagate_attribute(self, attr, val):\n self.activities.propagate_attribute(attr, val)","def add_attr(self, attr, value, position=None, extra=None):\n # pylint: disable=eval-used\n if attr.startswith(\"*\"):\n attr = attr[1:]\n if attr not in self._attributes:\n self._attributes[attr] = []\n if len(self._attributes[attr]) != position:\n raise TypeError(\"AST Node lost in conversion!\")\n self._attributes[attr].append(value)\n elif extra is not None:\n self._attributes[attr] = eval(extra)\n else:\n self._attributes[attr] = value","def set(self, attr, val):\r\n self.__dict__[attr] = val","def set(self, attribute: str, value: Any):\n return setattr(self, attribute, value)","def add_attribute(self, key, value):\n if key == \"process_step\":\n self.process_step = value\n elif key == \"source\":\n self.source = value\n else:\n self.attributes[key] = value","def __setattr__(self,name,value):\n\n if name == '_dont_touch':\n super.__setattr__(self,name,value) \n elif name in self._dont_touch:\n raise ValueError(\"Parameter %s is protected, please don't touch!\"%name)\n else:\n super.__setattr__(self,name,value)\n self._dont_touch.append(name)","def __setattr__(self,name,value):\n\n if name == '_dont_touch':\n super.__setattr__(self,name,value) \n elif name in self._dont_touch:\n raise ValueError(\"Parameter %s is protected, please don't touch!\"%name)\n else:\n super.__setattr__(self,name,value)\n self._dont_touch.append(name)","def __setattr__(self,name,val):\n # use dir() not hasattr() because hasattr uses __getattribute__\n if name in dir(self):\n\n if name in self.params():\n self.set_parameter_value(name,val,self)\n else:\n object.__setattr__(self,name,val)\n\n elif name in dir(self._extraPO):\n\n if name in self._extraPO.params():\n self.set_parameter_value(name,val,self._extraPO)\n else:\n object.__setattr__(self._extraPO,name,val)\n\n else:\n\n # name not found, so set on this object\n object.__setattr__(self,name,val)","def __setattr__(self, attr: str, _value: t.Any) -> t.NoReturn:\n raise AttributeError(attr)","def _wrap_attr(attr):\n return '={0},'.format(attr)","def addParameter(self, *args):\n return _libsbml.Model_addParameter(self, *args)","def setAttribute(self, username, attribute, value=''):\n if username in self.contents:\n self.contents[username][attribute] = value\n else:\n self.contents.__setitem__(username, {attribute: value})","def __setattr__ (self, name, value):\n\t\ttry:\n\t\t\tself.__dict__[name] # Do not delete this line (it verifies the existence of an attribute)\n\t\t\t# Positioning of the existing attribute\n\t\t\tself.__dict__[name] = value\n\t\texcept KeyError:\n\t\t\t# The attribute does not exist is probably value of the structure\n\t\t\tself.__dict__[\"value\"][name] = value","def add_param(self, param):\n self.params.append(param)\n return self","def add_attribute(self, key: str, value: Union[str, int]) -> None:\n self.span_instance.add_attribute(key, value)","def __setattr__(self, name, value):\n try:\n self[self.sig.argpos(name)] = value\n return value\n except:\n pass\n list.__setattr__(self, name, value)","def regattr(self, attr):\n\n return super().regattr(attr=attr)","def set_attr(self, name, value):\n setattr(self, name, value)","def set_param(self, name, value, *, distrib=None, ref=None):\n raise NotImplementedError","def add_attribute(obj, attribute, value):\n if not hasattr(obj, \"__dict__\"):\n raise TypeError(\"can't add new attribute\")\n setattr(obj, attribute, value)","def __setattr__(self, attribute: str, value: Any) -> None:\n if hasattr(self, attribute) or self.contents is None:\n object.__setattr__(self, attribute, value)\n else:\n object.__setattr__(self.contents, attribute, value)","def __setattr__(self, name: str, value: Any) -> None:\n super().__setattr__(name, value)","def set(self, attribute, value):\n self.__setattr__(attribute, value)","def addParameter(self, *args):\n return _libsbml.KineticLaw_addParameter(self, *args)","def add_attribute(self, name, value):\n\n self._attributes[name] = value","def add_attribute(self, name, value):\n\n self._attributes[name] = value","def add_attribute(self, name, value):\n\n self._attributes[name] = value","def add_parameter(self, parameter):\n self._pkey += 1\n self.parameters[self._pkey] = parameter","def __setattr__(self, name, value):\n self.set(**{name: value})","def add_attrib(self, key, func, func_args):\n if key in self.aux_attrib:\n raise KeyError(\"Attribute '{0}' already exists, please use 'set_attrib'.\".format(key))\n else:\n self.set_attrib(key, func, func_args)","def add_param(self, param):\n self._params.append(param)\n self.add_decompostion(param)","def SetAttribute(self, attr, val):\n attrs = self.GetAttributes()\n attrs[attr] = val\n return self.SetAttributes(attr, attrs)","def update(self, attribute: str, result: ProcessorResult) -> None:\n pass","def setParameter(self,arg,value):\n self._params[arg] = value\n return self._params","def add(self, param):\n self._data.add(param)","def __setitem__(self, key, value):\n self.params[key].value = value","def __setitem__(self, feature, value):\n setattr(self, feature, value)","def add_attribute(obj, attr, val):\n if not hasattr(obj, \"__dict__\"):\n raise TypeError(\"can't add new attribute\")\n setattr(obj, attr, val)","def __setattr__(self, key, value):\n resp = f'Attribute {key} can not be '\n if key in self.__dict__:\n resp += 'changed'\n else:\n resp += 'added'\n raise AttributeError(resp)","def setattr(self, node, attr, value):\n node.set(attr, value)","def __setattr__(self, name, value, overwrite=False):\n\n if \"attributes\" in dir(self):\n if name not in self.attributes:\n raise ImplementationError(name)\n elif \"_init_attrs\" in dir(self) and name in self._init_attrs and name != \"_init_attrs\" and not overwrite:\n message = f'\"{name}\" was used for two different argument names. Make sure each argument is unique.'\n message += f\"Current value is {getattr(self, name)}, proposed value is {value}\"\n raise ImplementationError(name, message)\n\n super().__setattr__(name, value)","def add_attr(self, key: str, value):\n if key in self._attr_names():\n raise ValueError(\"Already have an attribute called '{}'\".format(key))\n self._attributes.append((key, value))","def _paramUpdate(self):\n\n # Update the database attributes accordingly.\n dt.utilities.DB_attrs_save(self.Database, self.newParam)","def add_attribute(obj, attribute, value):\n if hasattr(obj, \"__dict__\"):\n setattr(obj, attribute, value)\n else:\n raise TypeError(\"can't add new attribute\")","def set_attrib(self, key, func, func_args):\n self.aux_attrib[key] = func\n self.aux_attrib_args[key] = func_args","def addParam(self, var: IRVariable):\n self.params[var.name] = var","def add_attribute(self, name, value, modify=False, sources=None, published_at=None):\n\n # Find attributes and remove if matches\n if modify:\n if not self.current_attributes:\n res = self.tq.get('{}/attributes'.format(self._get_api_endpoint()))\n self.current_attributes = res.get('data', [])\n\n for attr in self.current_attributes:\n if attr['name'] == name and attr['value'].lower() != value.lower():\n attribute_id = attr['id']\n self.tq.delete(\n '{}/attributes/{}'.format(self._get_api_endpoint(), attribute_id))\n # break\n\n data = {'name': name, 'value': value}\n if sources and isinstance(sources, str):\n data['sources'] = [{'name': sources}]\n elif sources and isinstance(sources, dict):\n data['sources'] = [sources]\n elif sources and isinstance(sources, list):\n data['sources'] = sources\n if published_at:\n data['published_at'] = published_at\n\n res = self.tq.post('{}/attributes'.format(self._get_api_endpoint()), data=data)\n\n # Add the newly added indicator to the cache\n if res.get('total', 0) > 0:\n self.current_attributes.append(res['data'][0])"],"string":"[\n \"def __setattr__(self, name, value):\\n if name in ['parameters', 'program_name']: # Allowed attributes\\n self.__dict__[name] = value\\n else:\\n self.set_parameter(name, value) # treat as a parameter\",\n \"def put_param(self, attr_name, val):\\n self._params[attr_name] = val\",\n \"def add_attribute(self, attr):\\n self.add(attr)\",\n \"def __setattr__(self,attributeName,attributeValue):\\n if (attributeName in StackParameterNames):\\n StackParameters[attributeName] = attributeValue\\n else:\\n object.__setattr__(self, attributeName, attributeValue)\\n #endIf\",\n \"def add_attribute(self, attr):\\n self.attrs.add_attribute(attr)\",\n \"def __setitem__(self, name: str, value):\\n super(Parameter, self).__setitem__(name, value)\",\n \"def append_attribute(myobj, attrib_k, val):\\n vals = getattr(myobj, attrib_k, [])\\n if val not in vals:\\n vals.append(val)\\n setattr(myobj, attrib_k, vals)\",\n \"def add_attribute(self, attr):\\n self.attrs.add(attr)\",\n \"def set_attribute(self, attr, value):\\n super().set_attribute(attr, value) # Keep this line, it triggers the parent class method.\\n setattr(self, attr, value)\",\n \"def __setattr__(self, attr, value):\\n super().__setattr__(attr, value)\",\n \"def set_attr(self, asset_key, attr, value=True):\\r\\n self.set_attrs(asset_key, {attr: value})\",\n \"def set_attribute(self, name, value):\\n\\n pass\",\n \"def __setitem__(self, attribute_name, value):\\n pass # pragma: no cover\",\n \"def addAttr(self, *args):\\n return _libsbml.XMLToken_addAttr(self, *args)\",\n \"def add_attribute(self, attr: ResourceAttributeDescriptor) -> None:\\n self._attributes[assert_not_none(attr.name)] = attr.bind(self)\",\n \"def add_attribute(self, name, value):\\n\\t\\tif name in self.__attr_hash:\\n#\\t\\t\\tattribue already exists\\n\\t\\t\\ta = self.__attr_hash[name]\\n\\t\\t\\tif name == 'class':\\n#\\t\\t\\t\\t'class' is a magic attribute\\n\\t\\t\\t\\tif a['value']:\\n\\t\\t\\t\\t\\tvalue = ' ' + value\\n\\t\\t\\t\\ta['value'] += value\\n\\t\\t\\telse:\\n\\t\\t\\t\\ta['value'] = value\\n\\t\\telse:\\n\\t\\t\\ta = {'name': name, 'value': value}\\n\\t\\t\\tself.__attr_hash[name] = a\\n\\t\\t\\tself.attributes.append(a)\",\n \"def setParameter(self, name, value):\",\n \"def add_attribute(self, attribute_key, attribute_value):\\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair\",\n \"def add_attribute(self, attribute_key, attribute_value):\\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair\",\n \"def add_attribute(self, attribute_key, attribute_value):\\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair\",\n \"def add_attribute(node_proto, name, value):\\n node_proto.attribute.extend([make_attribute(name, value)])\",\n \"def __setitem__(self, name, value):\\n self.gattrs[name] = value\",\n \"def _setAttribute(self, attribute, value):\\n\\n # if multiple values found\\n if hasattr(self, attribute):\\n\\n # make sure attribute is a list\\n values = getattr(self, attribute)\\n if not isinstance(values, list):\\n setattr(self, attribute, [values])\\n\\n # append value to list\\n getattr(self, attribute).append(value)\\n\\n # single value found\\n else:\\n setattr(self, attribute, value)\",\n \"def write_parameter(self, path, value, attr=None):\\n if path.startswith('sample'):\\n entry = self.entry.nxroot['entry']\\n else:\\n entry = self.entry\\n if value is not None:\\n if attr and path in entry:\\n entry[path].attrs[attr] = value\\n elif path in entry:\\n if isinstance(entry[path], NXgroup):\\n del entry[path]\\n entry[path] = value\\n else:\\n entry[path].replace(value)\\n elif attr is None:\\n entry[path] = value\",\n \"def __setattr__(self, attribute, value):\\n\\t\\tassert ltrace_func(TRACE_BASE)\\n\\n\\t\\tif attribute[0] == '_' or callable(value) \\\\\\n\\t\\t\\t\\t\\t\\tor attribute in self.__class__._licorn_protected_attrs:\\n\\t\\t\\tdict.__setattr__(self, attribute, value)\\n\\n\\t\\telse:\\n\\t\\t\\tdict.__setitem__(self, attribute, value)\",\n \"def addattribute(self, uid, field, value):\\n\\n raise NotImplementedError\",\n \"def __setattr__(self, attr, value):\\n self[attr] = value\",\n \"def add_attribute(self, attribute_name, attribute_value):\\n self.attributes[attribute_name] = attribute_value\",\n \"def _add_argument(hparams, key, value, update=True):\\n if hasattr(hparams, key):\\n if update:\\n setattr(hparams, key, value)\\n else:\\n hparams.add_hparam(key, value)\",\n \"def __setitem__(self, key, item):\\n self.attrib[key] = item\",\n \"def __setitem__(self, key, item):\\n self.attrib[key] = item\",\n \"def add_attribute(self, subject_id, id=None, value=None):\",\n \"def add_attribute(self, subject_id, id=None, value=None):\",\n \"def add_attribute(self, subject_id, id=None, value=None):\",\n \"def add_attribute(self, subject_id, id=None, value=None):\",\n \"def add_attribute(self, subject_id, id=None, value=None):\",\n \"def modify_argument(parser, arg_name, attribute, new_value):\\n for action in parser._actions:\\n if action.dest == arg_name:\\n setattr(action, attribute, new_value)\\n return\",\n \"def __setitem__(self, key, value):\\n if key not in self.attribute_dict.keys():\\n raise KeyError(\\\"Object does not have parameter: {}.\\\".format(key))\\n self.attribute_dict[key] = value\",\n \"def addParameter(cTag, name, value): #@NoSelf\",\n \"def __setattr__(self, name, value):\\n raise AttributeError(\\\"You cannot modify attributes on a %s\\\" % self.__class__.__name__)\",\n \"def add_attribute(self, key, value):\\n self.attributes[key] = value\",\n \"def setAttributeValue(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\\n pass\",\n \"def __setattr__ (self, attr, value):\\n self.set_value (attr, value)\",\n \"def set_attribute(self, attr, value):\\n logger.debug(\\\"SET ATTRIBUTE {} to {}\\\".format(attr, value))\",\n \"def __setattr__(self, attr, value):\",\n \"def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\\n pass\",\n \"def add_param(element):\\n nonlocal params\\n name = element.attrib.get(\\\"name\\\", None)\\n value = element.attrib.get(\\\"value\\\", \\\"\\\")\\n if name:\\n params[name] = value\",\n \"def _insert_parametric_attribute(self,attr_name,attr_def_str):\\n self._check_for_definition_correctness(attr_name,attr_def_str)\\n self._attrs_def.update([(attr_name,attr_def_str)])\\n for attr_def in attr_def_str.split():\\n if '$' in attr_def:\\n self._params_in_attrs.setdefault(attr_def,set()).add(attr_name)\",\n \"def __setitem__(self, key, value) :\\n attributeslist = getattr(self.request, \\\"_%s_attributes\\\" % self.name)\\n for i in range(len(attributeslist)) :\\n attribute = attributeslist[i]\\n for j in range(len(attribute)) :\\n (attrname, attrvalue) = attribute[j]\\n if attrname == key :\\n attribute[j][1].append(value)\\n return\\n attribute.append((key, [value]))\",\n \"def __setitem__(self, arg, value):\\n setattr(self.args, arg, value)\",\n \"def nma_attribute(self, stmt, p_elem, pset=None):\\n att = \\\"nma:\\\" + stmt.keyword\\n if att not in p_elem.attr:\\n p_elem.attr[att] = stmt.arg\",\n \"def add_attribute(a, name, other):\\n raise TypeError(\\\"can't add new attribute\\\")\",\n \"def add_attribute(self, attr_type, name, components):\\n self.attributes[attr_type] = {\\\"name\\\": name, \\\"components\\\": components}\",\n \"def __setattr__(self, name, value):\\n if hasattr(self, name):\\n super(JobSubmission, self).__setattr__(name, value)\\n\\n else:\\n self.params[str(name)] = str(value) #TODO: resolve parameter cases\",\n \"def propagate_attribute(self, attr, val):\\n self.activities.propagate_attribute(attr, val)\",\n \"def add_attr(self, attr, value, position=None, extra=None):\\n # pylint: disable=eval-used\\n if attr.startswith(\\\"*\\\"):\\n attr = attr[1:]\\n if attr not in self._attributes:\\n self._attributes[attr] = []\\n if len(self._attributes[attr]) != position:\\n raise TypeError(\\\"AST Node lost in conversion!\\\")\\n self._attributes[attr].append(value)\\n elif extra is not None:\\n self._attributes[attr] = eval(extra)\\n else:\\n self._attributes[attr] = value\",\n \"def set(self, attr, val):\\r\\n self.__dict__[attr] = val\",\n \"def set(self, attribute: str, value: Any):\\n return setattr(self, attribute, value)\",\n \"def add_attribute(self, key, value):\\n if key == \\\"process_step\\\":\\n self.process_step = value\\n elif key == \\\"source\\\":\\n self.source = value\\n else:\\n self.attributes[key] = value\",\n \"def __setattr__(self,name,value):\\n\\n if name == '_dont_touch':\\n super.__setattr__(self,name,value) \\n elif name in self._dont_touch:\\n raise ValueError(\\\"Parameter %s is protected, please don't touch!\\\"%name)\\n else:\\n super.__setattr__(self,name,value)\\n self._dont_touch.append(name)\",\n \"def __setattr__(self,name,value):\\n\\n if name == '_dont_touch':\\n super.__setattr__(self,name,value) \\n elif name in self._dont_touch:\\n raise ValueError(\\\"Parameter %s is protected, please don't touch!\\\"%name)\\n else:\\n super.__setattr__(self,name,value)\\n self._dont_touch.append(name)\",\n \"def __setattr__(self,name,val):\\n # use dir() not hasattr() because hasattr uses __getattribute__\\n if name in dir(self):\\n\\n if name in self.params():\\n self.set_parameter_value(name,val,self)\\n else:\\n object.__setattr__(self,name,val)\\n\\n elif name in dir(self._extraPO):\\n\\n if name in self._extraPO.params():\\n self.set_parameter_value(name,val,self._extraPO)\\n else:\\n object.__setattr__(self._extraPO,name,val)\\n\\n else:\\n\\n # name not found, so set on this object\\n object.__setattr__(self,name,val)\",\n \"def __setattr__(self, attr: str, _value: t.Any) -> t.NoReturn:\\n raise AttributeError(attr)\",\n \"def _wrap_attr(attr):\\n return '={0},'.format(attr)\",\n \"def addParameter(self, *args):\\n return _libsbml.Model_addParameter(self, *args)\",\n \"def setAttribute(self, username, attribute, value=''):\\n if username in self.contents:\\n self.contents[username][attribute] = value\\n else:\\n self.contents.__setitem__(username, {attribute: value})\",\n \"def __setattr__ (self, name, value):\\n\\t\\ttry:\\n\\t\\t\\tself.__dict__[name] # Do not delete this line (it verifies the existence of an attribute)\\n\\t\\t\\t# Positioning of the existing attribute\\n\\t\\t\\tself.__dict__[name] = value\\n\\t\\texcept KeyError:\\n\\t\\t\\t# The attribute does not exist is probably value of the structure\\n\\t\\t\\tself.__dict__[\\\"value\\\"][name] = value\",\n \"def add_param(self, param):\\n self.params.append(param)\\n return self\",\n \"def add_attribute(self, key: str, value: Union[str, int]) -> None:\\n self.span_instance.add_attribute(key, value)\",\n \"def __setattr__(self, name, value):\\n try:\\n self[self.sig.argpos(name)] = value\\n return value\\n except:\\n pass\\n list.__setattr__(self, name, value)\",\n \"def regattr(self, attr):\\n\\n return super().regattr(attr=attr)\",\n \"def set_attr(self, name, value):\\n setattr(self, name, value)\",\n \"def set_param(self, name, value, *, distrib=None, ref=None):\\n raise NotImplementedError\",\n \"def add_attribute(obj, attribute, value):\\n if not hasattr(obj, \\\"__dict__\\\"):\\n raise TypeError(\\\"can't add new attribute\\\")\\n setattr(obj, attribute, value)\",\n \"def __setattr__(self, attribute: str, value: Any) -> None:\\n if hasattr(self, attribute) or self.contents is None:\\n object.__setattr__(self, attribute, value)\\n else:\\n object.__setattr__(self.contents, attribute, value)\",\n \"def __setattr__(self, name: str, value: Any) -> None:\\n super().__setattr__(name, value)\",\n \"def set(self, attribute, value):\\n self.__setattr__(attribute, value)\",\n \"def addParameter(self, *args):\\n return _libsbml.KineticLaw_addParameter(self, *args)\",\n \"def add_attribute(self, name, value):\\n\\n self._attributes[name] = value\",\n \"def add_attribute(self, name, value):\\n\\n self._attributes[name] = value\",\n \"def add_attribute(self, name, value):\\n\\n self._attributes[name] = value\",\n \"def add_parameter(self, parameter):\\n self._pkey += 1\\n self.parameters[self._pkey] = parameter\",\n \"def __setattr__(self, name, value):\\n self.set(**{name: value})\",\n \"def add_attrib(self, key, func, func_args):\\n if key in self.aux_attrib:\\n raise KeyError(\\\"Attribute '{0}' already exists, please use 'set_attrib'.\\\".format(key))\\n else:\\n self.set_attrib(key, func, func_args)\",\n \"def add_param(self, param):\\n self._params.append(param)\\n self.add_decompostion(param)\",\n \"def SetAttribute(self, attr, val):\\n attrs = self.GetAttributes()\\n attrs[attr] = val\\n return self.SetAttributes(attr, attrs)\",\n \"def update(self, attribute: str, result: ProcessorResult) -> None:\\n pass\",\n \"def setParameter(self,arg,value):\\n self._params[arg] = value\\n return self._params\",\n \"def add(self, param):\\n self._data.add(param)\",\n \"def __setitem__(self, key, value):\\n self.params[key].value = value\",\n \"def __setitem__(self, feature, value):\\n setattr(self, feature, value)\",\n \"def add_attribute(obj, attr, val):\\n if not hasattr(obj, \\\"__dict__\\\"):\\n raise TypeError(\\\"can't add new attribute\\\")\\n setattr(obj, attr, val)\",\n \"def __setattr__(self, key, value):\\n resp = f'Attribute {key} can not be '\\n if key in self.__dict__:\\n resp += 'changed'\\n else:\\n resp += 'added'\\n raise AttributeError(resp)\",\n \"def setattr(self, node, attr, value):\\n node.set(attr, value)\",\n \"def __setattr__(self, name, value, overwrite=False):\\n\\n if \\\"attributes\\\" in dir(self):\\n if name not in self.attributes:\\n raise ImplementationError(name)\\n elif \\\"_init_attrs\\\" in dir(self) and name in self._init_attrs and name != \\\"_init_attrs\\\" and not overwrite:\\n message = f'\\\"{name}\\\" was used for two different argument names. Make sure each argument is unique.'\\n message += f\\\"Current value is {getattr(self, name)}, proposed value is {value}\\\"\\n raise ImplementationError(name, message)\\n\\n super().__setattr__(name, value)\",\n \"def add_attr(self, key: str, value):\\n if key in self._attr_names():\\n raise ValueError(\\\"Already have an attribute called '{}'\\\".format(key))\\n self._attributes.append((key, value))\",\n \"def _paramUpdate(self):\\n\\n # Update the database attributes accordingly.\\n dt.utilities.DB_attrs_save(self.Database, self.newParam)\",\n \"def add_attribute(obj, attribute, value):\\n if hasattr(obj, \\\"__dict__\\\"):\\n setattr(obj, attribute, value)\\n else:\\n raise TypeError(\\\"can't add new attribute\\\")\",\n \"def set_attrib(self, key, func, func_args):\\n self.aux_attrib[key] = func\\n self.aux_attrib_args[key] = func_args\",\n \"def addParam(self, var: IRVariable):\\n self.params[var.name] = var\",\n \"def add_attribute(self, name, value, modify=False, sources=None, published_at=None):\\n\\n # Find attributes and remove if matches\\n if modify:\\n if not self.current_attributes:\\n res = self.tq.get('{}/attributes'.format(self._get_api_endpoint()))\\n self.current_attributes = res.get('data', [])\\n\\n for attr in self.current_attributes:\\n if attr['name'] == name and attr['value'].lower() != value.lower():\\n attribute_id = attr['id']\\n self.tq.delete(\\n '{}/attributes/{}'.format(self._get_api_endpoint(), attribute_id))\\n # break\\n\\n data = {'name': name, 'value': value}\\n if sources and isinstance(sources, str):\\n data['sources'] = [{'name': sources}]\\n elif sources and isinstance(sources, dict):\\n data['sources'] = [sources]\\n elif sources and isinstance(sources, list):\\n data['sources'] = sources\\n if published_at:\\n data['published_at'] = published_at\\n\\n res = self.tq.post('{}/attributes'.format(self._get_api_endpoint()), data=data)\\n\\n # Add the newly added indicator to the cache\\n if res.get('total', 0) > 0:\\n self.current_attributes.append(res['data'][0])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6987088","0.6885637","0.6829756","0.6731595","0.67283607","0.67017716","0.66079473","0.6570364","0.6501009","0.64624107","0.6447641","0.64455295","0.64400303","0.64285815","0.6388802","0.6383218","0.637725","0.63599354","0.63599354","0.63599354","0.6348706","0.6334282","0.6324778","0.63077027","0.63015425","0.6297457","0.62894857","0.62894225","0.6288043","0.62850267","0.62850267","0.6283991","0.6283991","0.6283991","0.6283991","0.6283991","0.6267434","0.62598014","0.6241654","0.62307155","0.62281984","0.6200556","0.6194948","0.6185698","0.6171319","0.6165554","0.6161077","0.61583555","0.61568445","0.6156378","0.6144151","0.6138369","0.61282396","0.6119409","0.6116306","0.6105505","0.61039174","0.60875696","0.6080773","0.6075971","0.6075971","0.6074163","0.6074056","0.6062446","0.6061021","0.6060032","0.60585636","0.6052972","0.6050929","0.6047986","0.6036571","0.6022522","0.60196245","0.5996791","0.599197","0.5986874","0.59852153","0.59834486","0.59749854","0.59749854","0.59749854","0.59730667","0.59730536","0.59728646","0.5972033","0.5961318","0.5957416","0.5957364","0.5946024","0.5942907","0.5933817","0.5932546","0.59298784","0.5922056","0.592187","0.59217393","0.59162265","0.5913795","0.59058076","0.5891436","0.58882475"],"string":"[\n \"0.6987088\",\n \"0.6885637\",\n \"0.6829756\",\n \"0.6731595\",\n \"0.67283607\",\n \"0.67017716\",\n \"0.66079473\",\n \"0.6570364\",\n \"0.6501009\",\n \"0.64624107\",\n \"0.6447641\",\n \"0.64455295\",\n \"0.64400303\",\n \"0.64285815\",\n \"0.6388802\",\n \"0.6383218\",\n \"0.637725\",\n \"0.63599354\",\n \"0.63599354\",\n \"0.63599354\",\n \"0.6348706\",\n \"0.6334282\",\n \"0.6324778\",\n \"0.63077027\",\n \"0.63015425\",\n \"0.6297457\",\n \"0.62894857\",\n \"0.62894225\",\n \"0.6288043\",\n \"0.62850267\",\n \"0.62850267\",\n \"0.6283991\",\n \"0.6283991\",\n \"0.6283991\",\n \"0.6283991\",\n \"0.6283991\",\n \"0.6267434\",\n \"0.62598014\",\n \"0.6241654\",\n \"0.62307155\",\n \"0.62281984\",\n \"0.6200556\",\n \"0.6194948\",\n \"0.6185698\",\n \"0.6171319\",\n \"0.6165554\",\n \"0.6161077\",\n \"0.61583555\",\n \"0.61568445\",\n \"0.6156378\",\n \"0.6144151\",\n \"0.6138369\",\n \"0.61282396\",\n \"0.6119409\",\n \"0.6116306\",\n \"0.6105505\",\n \"0.61039174\",\n \"0.60875696\",\n \"0.6080773\",\n \"0.6075971\",\n \"0.6075971\",\n \"0.6074163\",\n \"0.6074056\",\n \"0.6062446\",\n \"0.6061021\",\n \"0.6060032\",\n \"0.60585636\",\n \"0.6052972\",\n \"0.6050929\",\n \"0.6047986\",\n \"0.6036571\",\n \"0.6022522\",\n \"0.60196245\",\n \"0.5996791\",\n \"0.599197\",\n \"0.5986874\",\n \"0.59852153\",\n \"0.59834486\",\n \"0.59749854\",\n \"0.59749854\",\n \"0.59749854\",\n \"0.59730667\",\n \"0.59730536\",\n \"0.59728646\",\n \"0.5972033\",\n \"0.5961318\",\n \"0.5957416\",\n \"0.5957364\",\n \"0.5946024\",\n \"0.5942907\",\n \"0.5933817\",\n \"0.5932546\",\n \"0.59298784\",\n \"0.5922056\",\n \"0.592187\",\n \"0.59217393\",\n \"0.59162265\",\n \"0.5913795\",\n \"0.59058076\",\n \"0.5891436\",\n \"0.58882475\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3292,"cells":{"query":{"kind":"string","value":"This method will modify the attribute by appending the parameter to it."},"document":{"kind":"string","value":"def add_nemesis(self, nemesis):\n\n self.nemeses.append(nemesis)"},"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 __setattr__(self, name, value):\n if name in ['parameters', 'program_name']: # Allowed attributes\n self.__dict__[name] = value\n else:\n self.set_parameter(name, value) # treat as a parameter","def put_param(self, attr_name, val):\n self._params[attr_name] = val","def add_attribute(self, attr):\n self.add(attr)","def __setattr__(self,attributeName,attributeValue):\n if (attributeName in StackParameterNames):\n StackParameters[attributeName] = attributeValue\n else:\n object.__setattr__(self, attributeName, attributeValue)\n #endIf","def add_attribute(self, attr):\n self.attrs.add_attribute(attr)","def __setitem__(self, name: str, value):\n super(Parameter, self).__setitem__(name, value)","def append_attribute(myobj, attrib_k, val):\n vals = getattr(myobj, attrib_k, [])\n if val not in vals:\n vals.append(val)\n setattr(myobj, attrib_k, vals)","def add_attribute(self, attr):\n self.attrs.add(attr)","def set_attribute(self, attr, value):\n super().set_attribute(attr, value) # Keep this line, it triggers the parent class method.\n setattr(self, attr, value)","def __setattr__(self, attr, value):\n super().__setattr__(attr, value)","def set_attr(self, asset_key, attr, value=True):\r\n self.set_attrs(asset_key, {attr: value})","def set_attribute(self, name, value):\n\n pass","def __setitem__(self, attribute_name, value):\n pass # pragma: no cover","def addAttr(self, *args):\n return _libsbml.XMLToken_addAttr(self, *args)","def add_attribute(self, attr: ResourceAttributeDescriptor) -> None:\n self._attributes[assert_not_none(attr.name)] = attr.bind(self)","def add_attribute(self, name, value):\n\t\tif name in self.__attr_hash:\n#\t\t\tattribue already exists\n\t\t\ta = self.__attr_hash[name]\n\t\t\tif name == 'class':\n#\t\t\t\t'class' is a magic attribute\n\t\t\t\tif a['value']:\n\t\t\t\t\tvalue = ' ' + value\n\t\t\t\ta['value'] += value\n\t\t\telse:\n\t\t\t\ta['value'] = value\n\t\telse:\n\t\t\ta = {'name': name, 'value': value}\n\t\t\tself.__attr_hash[name] = a\n\t\t\tself.attributes.append(a)","def setParameter(self, name, value):","def add_attribute(self, attribute_key, attribute_value):\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair","def add_attribute(self, attribute_key, attribute_value):\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair","def add_attribute(self, attribute_key, attribute_value):\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair","def add_attribute(node_proto, name, value):\n node_proto.attribute.extend([make_attribute(name, value)])","def __setitem__(self, name, value):\n self.gattrs[name] = value","def _setAttribute(self, attribute, value):\n\n # if multiple values found\n if hasattr(self, attribute):\n\n # make sure attribute is a list\n values = getattr(self, attribute)\n if not isinstance(values, list):\n setattr(self, attribute, [values])\n\n # append value to list\n getattr(self, attribute).append(value)\n\n # single value found\n else:\n setattr(self, attribute, value)","def write_parameter(self, path, value, attr=None):\n if path.startswith('sample'):\n entry = self.entry.nxroot['entry']\n else:\n entry = self.entry\n if value is not None:\n if attr and path in entry:\n entry[path].attrs[attr] = value\n elif path in entry:\n if isinstance(entry[path], NXgroup):\n del entry[path]\n entry[path] = value\n else:\n entry[path].replace(value)\n elif attr is None:\n entry[path] = value","def __setattr__(self, attribute, value):\n\t\tassert ltrace_func(TRACE_BASE)\n\n\t\tif attribute[0] == '_' or callable(value) \\\n\t\t\t\t\t\tor attribute in self.__class__._licorn_protected_attrs:\n\t\t\tdict.__setattr__(self, attribute, value)\n\n\t\telse:\n\t\t\tdict.__setitem__(self, attribute, value)","def addattribute(self, uid, field, value):\n\n raise NotImplementedError","def __setattr__(self, attr, value):\n self[attr] = value","def add_attribute(self, attribute_name, attribute_value):\n self.attributes[attribute_name] = attribute_value","def _add_argument(hparams, key, value, update=True):\n if hasattr(hparams, key):\n if update:\n setattr(hparams, key, value)\n else:\n hparams.add_hparam(key, value)","def __setitem__(self, key, item):\n self.attrib[key] = item","def __setitem__(self, key, item):\n self.attrib[key] = item","def add_attribute(self, subject_id, id=None, value=None):","def add_attribute(self, subject_id, id=None, value=None):","def add_attribute(self, subject_id, id=None, value=None):","def add_attribute(self, subject_id, id=None, value=None):","def add_attribute(self, subject_id, id=None, value=None):","def modify_argument(parser, arg_name, attribute, new_value):\n for action in parser._actions:\n if action.dest == arg_name:\n setattr(action, attribute, new_value)\n return","def __setitem__(self, key, value):\n if key not in self.attribute_dict.keys():\n raise KeyError(\"Object does not have parameter: {}.\".format(key))\n self.attribute_dict[key] = value","def addParameter(cTag, name, value): #@NoSelf","def __setattr__(self, name, value):\n raise AttributeError(\"You cannot modify attributes on a %s\" % self.__class__.__name__)","def add_attribute(self, key, value):\n self.attributes[key] = value","def setAttributeValue(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\n pass","def __setattr__ (self, attr, value):\n self.set_value (attr, value)","def set_attribute(self, attr, value):\n logger.debug(\"SET ATTRIBUTE {} to {}\".format(attr, value))","def __setattr__(self, attr, value):","def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\n pass","def add_param(element):\n nonlocal params\n name = element.attrib.get(\"name\", None)\n value = element.attrib.get(\"value\", \"\")\n if name:\n params[name] = value","def _insert_parametric_attribute(self,attr_name,attr_def_str):\n self._check_for_definition_correctness(attr_name,attr_def_str)\n self._attrs_def.update([(attr_name,attr_def_str)])\n for attr_def in attr_def_str.split():\n if '$' in attr_def:\n self._params_in_attrs.setdefault(attr_def,set()).add(attr_name)","def __setitem__(self, key, value) :\n attributeslist = getattr(self.request, \"_%s_attributes\" % self.name)\n for i in range(len(attributeslist)) :\n attribute = attributeslist[i]\n for j in range(len(attribute)) :\n (attrname, attrvalue) = attribute[j]\n if attrname == key :\n attribute[j][1].append(value)\n return\n attribute.append((key, [value]))","def __setitem__(self, arg, value):\n setattr(self.args, arg, value)","def nma_attribute(self, stmt, p_elem, pset=None):\n att = \"nma:\" + stmt.keyword\n if att not in p_elem.attr:\n p_elem.attr[att] = stmt.arg","def add_attribute(a, name, other):\n raise TypeError(\"can't add new attribute\")","def add_attribute(self, attr_type, name, components):\n self.attributes[attr_type] = {\"name\": name, \"components\": components}","def __setattr__(self, name, value):\n if hasattr(self, name):\n super(JobSubmission, self).__setattr__(name, value)\n\n else:\n self.params[str(name)] = str(value) #TODO: resolve parameter cases","def propagate_attribute(self, attr, val):\n self.activities.propagate_attribute(attr, val)","def add_attr(self, attr, value, position=None, extra=None):\n # pylint: disable=eval-used\n if attr.startswith(\"*\"):\n attr = attr[1:]\n if attr not in self._attributes:\n self._attributes[attr] = []\n if len(self._attributes[attr]) != position:\n raise TypeError(\"AST Node lost in conversion!\")\n self._attributes[attr].append(value)\n elif extra is not None:\n self._attributes[attr] = eval(extra)\n else:\n self._attributes[attr] = value","def set(self, attr, val):\r\n self.__dict__[attr] = val","def set(self, attribute: str, value: Any):\n return setattr(self, attribute, value)","def add_attribute(self, key, value):\n if key == \"process_step\":\n self.process_step = value\n elif key == \"source\":\n self.source = value\n else:\n self.attributes[key] = value","def __setattr__(self,name,value):\n\n if name == '_dont_touch':\n super.__setattr__(self,name,value) \n elif name in self._dont_touch:\n raise ValueError(\"Parameter %s is protected, please don't touch!\"%name)\n else:\n super.__setattr__(self,name,value)\n self._dont_touch.append(name)","def __setattr__(self,name,value):\n\n if name == '_dont_touch':\n super.__setattr__(self,name,value) \n elif name in self._dont_touch:\n raise ValueError(\"Parameter %s is protected, please don't touch!\"%name)\n else:\n super.__setattr__(self,name,value)\n self._dont_touch.append(name)","def __setattr__(self,name,val):\n # use dir() not hasattr() because hasattr uses __getattribute__\n if name in dir(self):\n\n if name in self.params():\n self.set_parameter_value(name,val,self)\n else:\n object.__setattr__(self,name,val)\n\n elif name in dir(self._extraPO):\n\n if name in self._extraPO.params():\n self.set_parameter_value(name,val,self._extraPO)\n else:\n object.__setattr__(self._extraPO,name,val)\n\n else:\n\n # name not found, so set on this object\n object.__setattr__(self,name,val)","def __setattr__(self, attr: str, _value: t.Any) -> t.NoReturn:\n raise AttributeError(attr)","def _wrap_attr(attr):\n return '={0},'.format(attr)","def addParameter(self, *args):\n return _libsbml.Model_addParameter(self, *args)","def setAttribute(self, username, attribute, value=''):\n if username in self.contents:\n self.contents[username][attribute] = value\n else:\n self.contents.__setitem__(username, {attribute: value})","def __setattr__ (self, name, value):\n\t\ttry:\n\t\t\tself.__dict__[name] # Do not delete this line (it verifies the existence of an attribute)\n\t\t\t# Positioning of the existing attribute\n\t\t\tself.__dict__[name] = value\n\t\texcept KeyError:\n\t\t\t# The attribute does not exist is probably value of the structure\n\t\t\tself.__dict__[\"value\"][name] = value","def add_param(self, param):\n self.params.append(param)\n return self","def add_attribute(self, key: str, value: Union[str, int]) -> None:\n self.span_instance.add_attribute(key, value)","def __setattr__(self, name, value):\n try:\n self[self.sig.argpos(name)] = value\n return value\n except:\n pass\n list.__setattr__(self, name, value)","def regattr(self, attr):\n\n return super().regattr(attr=attr)","def set_attr(self, name, value):\n setattr(self, name, value)","def set_param(self, name, value, *, distrib=None, ref=None):\n raise NotImplementedError","def add_attribute(obj, attribute, value):\n if not hasattr(obj, \"__dict__\"):\n raise TypeError(\"can't add new attribute\")\n setattr(obj, attribute, value)","def __setattr__(self, attribute: str, value: Any) -> None:\n if hasattr(self, attribute) or self.contents is None:\n object.__setattr__(self, attribute, value)\n else:\n object.__setattr__(self.contents, attribute, value)","def __setattr__(self, name: str, value: Any) -> None:\n super().__setattr__(name, value)","def set(self, attribute, value):\n self.__setattr__(attribute, value)","def addParameter(self, *args):\n return _libsbml.KineticLaw_addParameter(self, *args)","def add_attribute(self, name, value):\n\n self._attributes[name] = value","def add_attribute(self, name, value):\n\n self._attributes[name] = value","def add_attribute(self, name, value):\n\n self._attributes[name] = value","def add_parameter(self, parameter):\n self._pkey += 1\n self.parameters[self._pkey] = parameter","def __setattr__(self, name, value):\n self.set(**{name: value})","def add_attrib(self, key, func, func_args):\n if key in self.aux_attrib:\n raise KeyError(\"Attribute '{0}' already exists, please use 'set_attrib'.\".format(key))\n else:\n self.set_attrib(key, func, func_args)","def add_param(self, param):\n self._params.append(param)\n self.add_decompostion(param)","def SetAttribute(self, attr, val):\n attrs = self.GetAttributes()\n attrs[attr] = val\n return self.SetAttributes(attr, attrs)","def update(self, attribute: str, result: ProcessorResult) -> None:\n pass","def setParameter(self,arg,value):\n self._params[arg] = value\n return self._params","def add(self, param):\n self._data.add(param)","def __setitem__(self, key, value):\n self.params[key].value = value","def __setitem__(self, feature, value):\n setattr(self, feature, value)","def add_attribute(obj, attr, val):\n if not hasattr(obj, \"__dict__\"):\n raise TypeError(\"can't add new attribute\")\n setattr(obj, attr, val)","def __setattr__(self, key, value):\n resp = f'Attribute {key} can not be '\n if key in self.__dict__:\n resp += 'changed'\n else:\n resp += 'added'\n raise AttributeError(resp)","def setattr(self, node, attr, value):\n node.set(attr, value)","def __setattr__(self, name, value, overwrite=False):\n\n if \"attributes\" in dir(self):\n if name not in self.attributes:\n raise ImplementationError(name)\n elif \"_init_attrs\" in dir(self) and name in self._init_attrs and name != \"_init_attrs\" and not overwrite:\n message = f'\"{name}\" was used for two different argument names. Make sure each argument is unique.'\n message += f\"Current value is {getattr(self, name)}, proposed value is {value}\"\n raise ImplementationError(name, message)\n\n super().__setattr__(name, value)","def add_attr(self, key: str, value):\n if key in self._attr_names():\n raise ValueError(\"Already have an attribute called '{}'\".format(key))\n self._attributes.append((key, value))","def _paramUpdate(self):\n\n # Update the database attributes accordingly.\n dt.utilities.DB_attrs_save(self.Database, self.newParam)","def add_attribute(obj, attribute, value):\n if hasattr(obj, \"__dict__\"):\n setattr(obj, attribute, value)\n else:\n raise TypeError(\"can't add new attribute\")","def set_attrib(self, key, func, func_args):\n self.aux_attrib[key] = func\n self.aux_attrib_args[key] = func_args","def addParam(self, var: IRVariable):\n self.params[var.name] = var","def add_attribute(self, name, value, modify=False, sources=None, published_at=None):\n\n # Find attributes and remove if matches\n if modify:\n if not self.current_attributes:\n res = self.tq.get('{}/attributes'.format(self._get_api_endpoint()))\n self.current_attributes = res.get('data', [])\n\n for attr in self.current_attributes:\n if attr['name'] == name and attr['value'].lower() != value.lower():\n attribute_id = attr['id']\n self.tq.delete(\n '{}/attributes/{}'.format(self._get_api_endpoint(), attribute_id))\n # break\n\n data = {'name': name, 'value': value}\n if sources and isinstance(sources, str):\n data['sources'] = [{'name': sources}]\n elif sources and isinstance(sources, dict):\n data['sources'] = [sources]\n elif sources and isinstance(sources, list):\n data['sources'] = sources\n if published_at:\n data['published_at'] = published_at\n\n res = self.tq.post('{}/attributes'.format(self._get_api_endpoint()), data=data)\n\n # Add the newly added indicator to the cache\n if res.get('total', 0) > 0:\n self.current_attributes.append(res['data'][0])"],"string":"[\n \"def __setattr__(self, name, value):\\n if name in ['parameters', 'program_name']: # Allowed attributes\\n self.__dict__[name] = value\\n else:\\n self.set_parameter(name, value) # treat as a parameter\",\n \"def put_param(self, attr_name, val):\\n self._params[attr_name] = val\",\n \"def add_attribute(self, attr):\\n self.add(attr)\",\n \"def __setattr__(self,attributeName,attributeValue):\\n if (attributeName in StackParameterNames):\\n StackParameters[attributeName] = attributeValue\\n else:\\n object.__setattr__(self, attributeName, attributeValue)\\n #endIf\",\n \"def add_attribute(self, attr):\\n self.attrs.add_attribute(attr)\",\n \"def __setitem__(self, name: str, value):\\n super(Parameter, self).__setitem__(name, value)\",\n \"def append_attribute(myobj, attrib_k, val):\\n vals = getattr(myobj, attrib_k, [])\\n if val not in vals:\\n vals.append(val)\\n setattr(myobj, attrib_k, vals)\",\n \"def add_attribute(self, attr):\\n self.attrs.add(attr)\",\n \"def set_attribute(self, attr, value):\\n super().set_attribute(attr, value) # Keep this line, it triggers the parent class method.\\n setattr(self, attr, value)\",\n \"def __setattr__(self, attr, value):\\n super().__setattr__(attr, value)\",\n \"def set_attr(self, asset_key, attr, value=True):\\r\\n self.set_attrs(asset_key, {attr: value})\",\n \"def set_attribute(self, name, value):\\n\\n pass\",\n \"def __setitem__(self, attribute_name, value):\\n pass # pragma: no cover\",\n \"def addAttr(self, *args):\\n return _libsbml.XMLToken_addAttr(self, *args)\",\n \"def add_attribute(self, attr: ResourceAttributeDescriptor) -> None:\\n self._attributes[assert_not_none(attr.name)] = attr.bind(self)\",\n \"def add_attribute(self, name, value):\\n\\t\\tif name in self.__attr_hash:\\n#\\t\\t\\tattribue already exists\\n\\t\\t\\ta = self.__attr_hash[name]\\n\\t\\t\\tif name == 'class':\\n#\\t\\t\\t\\t'class' is a magic attribute\\n\\t\\t\\t\\tif a['value']:\\n\\t\\t\\t\\t\\tvalue = ' ' + value\\n\\t\\t\\t\\ta['value'] += value\\n\\t\\t\\telse:\\n\\t\\t\\t\\ta['value'] = value\\n\\t\\telse:\\n\\t\\t\\ta = {'name': name, 'value': value}\\n\\t\\t\\tself.__attr_hash[name] = a\\n\\t\\t\\tself.attributes.append(a)\",\n \"def setParameter(self, name, value):\",\n \"def add_attribute(self, attribute_key, attribute_value):\\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair\",\n \"def add_attribute(self, attribute_key, attribute_value):\\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair\",\n \"def add_attribute(self, attribute_key, attribute_value):\\n self.set_attribute_value(attribute_key, attribute_value) # record the input key-value pair\",\n \"def add_attribute(node_proto, name, value):\\n node_proto.attribute.extend([make_attribute(name, value)])\",\n \"def __setitem__(self, name, value):\\n self.gattrs[name] = value\",\n \"def _setAttribute(self, attribute, value):\\n\\n # if multiple values found\\n if hasattr(self, attribute):\\n\\n # make sure attribute is a list\\n values = getattr(self, attribute)\\n if not isinstance(values, list):\\n setattr(self, attribute, [values])\\n\\n # append value to list\\n getattr(self, attribute).append(value)\\n\\n # single value found\\n else:\\n setattr(self, attribute, value)\",\n \"def write_parameter(self, path, value, attr=None):\\n if path.startswith('sample'):\\n entry = self.entry.nxroot['entry']\\n else:\\n entry = self.entry\\n if value is not None:\\n if attr and path in entry:\\n entry[path].attrs[attr] = value\\n elif path in entry:\\n if isinstance(entry[path], NXgroup):\\n del entry[path]\\n entry[path] = value\\n else:\\n entry[path].replace(value)\\n elif attr is None:\\n entry[path] = value\",\n \"def __setattr__(self, attribute, value):\\n\\t\\tassert ltrace_func(TRACE_BASE)\\n\\n\\t\\tif attribute[0] == '_' or callable(value) \\\\\\n\\t\\t\\t\\t\\t\\tor attribute in self.__class__._licorn_protected_attrs:\\n\\t\\t\\tdict.__setattr__(self, attribute, value)\\n\\n\\t\\telse:\\n\\t\\t\\tdict.__setitem__(self, attribute, value)\",\n \"def addattribute(self, uid, field, value):\\n\\n raise NotImplementedError\",\n \"def __setattr__(self, attr, value):\\n self[attr] = value\",\n \"def add_attribute(self, attribute_name, attribute_value):\\n self.attributes[attribute_name] = attribute_value\",\n \"def _add_argument(hparams, key, value, update=True):\\n if hasattr(hparams, key):\\n if update:\\n setattr(hparams, key, value)\\n else:\\n hparams.add_hparam(key, value)\",\n \"def __setitem__(self, key, item):\\n self.attrib[key] = item\",\n \"def __setitem__(self, key, item):\\n self.attrib[key] = item\",\n \"def add_attribute(self, subject_id, id=None, value=None):\",\n \"def add_attribute(self, subject_id, id=None, value=None):\",\n \"def add_attribute(self, subject_id, id=None, value=None):\",\n \"def add_attribute(self, subject_id, id=None, value=None):\",\n \"def add_attribute(self, subject_id, id=None, value=None):\",\n \"def modify_argument(parser, arg_name, attribute, new_value):\\n for action in parser._actions:\\n if action.dest == arg_name:\\n setattr(action, attribute, new_value)\\n return\",\n \"def __setitem__(self, key, value):\\n if key not in self.attribute_dict.keys():\\n raise KeyError(\\\"Object does not have parameter: {}.\\\".format(key))\\n self.attribute_dict[key] = value\",\n \"def addParameter(cTag, name, value): #@NoSelf\",\n \"def __setattr__(self, name, value):\\n raise AttributeError(\\\"You cannot modify attributes on a %s\\\" % self.__class__.__name__)\",\n \"def add_attribute(self, key, value):\\n self.attributes[key] = value\",\n \"def setAttributeValue(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\\n pass\",\n \"def __setattr__ (self, attr, value):\\n self.set_value (attr, value)\",\n \"def set_attribute(self, attr, value):\\n logger.debug(\\\"SET ATTRIBUTE {} to {}\\\".format(attr, value))\",\n \"def __setattr__(self, attr, value):\",\n \"def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\\n pass\",\n \"def add_param(element):\\n nonlocal params\\n name = element.attrib.get(\\\"name\\\", None)\\n value = element.attrib.get(\\\"value\\\", \\\"\\\")\\n if name:\\n params[name] = value\",\n \"def _insert_parametric_attribute(self,attr_name,attr_def_str):\\n self._check_for_definition_correctness(attr_name,attr_def_str)\\n self._attrs_def.update([(attr_name,attr_def_str)])\\n for attr_def in attr_def_str.split():\\n if '$' in attr_def:\\n self._params_in_attrs.setdefault(attr_def,set()).add(attr_name)\",\n \"def __setitem__(self, key, value) :\\n attributeslist = getattr(self.request, \\\"_%s_attributes\\\" % self.name)\\n for i in range(len(attributeslist)) :\\n attribute = attributeslist[i]\\n for j in range(len(attribute)) :\\n (attrname, attrvalue) = attribute[j]\\n if attrname == key :\\n attribute[j][1].append(value)\\n return\\n attribute.append((key, [value]))\",\n \"def __setitem__(self, arg, value):\\n setattr(self.args, arg, value)\",\n \"def nma_attribute(self, stmt, p_elem, pset=None):\\n att = \\\"nma:\\\" + stmt.keyword\\n if att not in p_elem.attr:\\n p_elem.attr[att] = stmt.arg\",\n \"def add_attribute(a, name, other):\\n raise TypeError(\\\"can't add new attribute\\\")\",\n \"def add_attribute(self, attr_type, name, components):\\n self.attributes[attr_type] = {\\\"name\\\": name, \\\"components\\\": components}\",\n \"def __setattr__(self, name, value):\\n if hasattr(self, name):\\n super(JobSubmission, self).__setattr__(name, value)\\n\\n else:\\n self.params[str(name)] = str(value) #TODO: resolve parameter cases\",\n \"def propagate_attribute(self, attr, val):\\n self.activities.propagate_attribute(attr, val)\",\n \"def add_attr(self, attr, value, position=None, extra=None):\\n # pylint: disable=eval-used\\n if attr.startswith(\\\"*\\\"):\\n attr = attr[1:]\\n if attr not in self._attributes:\\n self._attributes[attr] = []\\n if len(self._attributes[attr]) != position:\\n raise TypeError(\\\"AST Node lost in conversion!\\\")\\n self._attributes[attr].append(value)\\n elif extra is not None:\\n self._attributes[attr] = eval(extra)\\n else:\\n self._attributes[attr] = value\",\n \"def set(self, attr, val):\\r\\n self.__dict__[attr] = val\",\n \"def set(self, attribute: str, value: Any):\\n return setattr(self, attribute, value)\",\n \"def add_attribute(self, key, value):\\n if key == \\\"process_step\\\":\\n self.process_step = value\\n elif key == \\\"source\\\":\\n self.source = value\\n else:\\n self.attributes[key] = value\",\n \"def __setattr__(self,name,value):\\n\\n if name == '_dont_touch':\\n super.__setattr__(self,name,value) \\n elif name in self._dont_touch:\\n raise ValueError(\\\"Parameter %s is protected, please don't touch!\\\"%name)\\n else:\\n super.__setattr__(self,name,value)\\n self._dont_touch.append(name)\",\n \"def __setattr__(self,name,value):\\n\\n if name == '_dont_touch':\\n super.__setattr__(self,name,value) \\n elif name in self._dont_touch:\\n raise ValueError(\\\"Parameter %s is protected, please don't touch!\\\"%name)\\n else:\\n super.__setattr__(self,name,value)\\n self._dont_touch.append(name)\",\n \"def __setattr__(self,name,val):\\n # use dir() not hasattr() because hasattr uses __getattribute__\\n if name in dir(self):\\n\\n if name in self.params():\\n self.set_parameter_value(name,val,self)\\n else:\\n object.__setattr__(self,name,val)\\n\\n elif name in dir(self._extraPO):\\n\\n if name in self._extraPO.params():\\n self.set_parameter_value(name,val,self._extraPO)\\n else:\\n object.__setattr__(self._extraPO,name,val)\\n\\n else:\\n\\n # name not found, so set on this object\\n object.__setattr__(self,name,val)\",\n \"def __setattr__(self, attr: str, _value: t.Any) -> t.NoReturn:\\n raise AttributeError(attr)\",\n \"def _wrap_attr(attr):\\n return '={0},'.format(attr)\",\n \"def addParameter(self, *args):\\n return _libsbml.Model_addParameter(self, *args)\",\n \"def setAttribute(self, username, attribute, value=''):\\n if username in self.contents:\\n self.contents[username][attribute] = value\\n else:\\n self.contents.__setitem__(username, {attribute: value})\",\n \"def __setattr__ (self, name, value):\\n\\t\\ttry:\\n\\t\\t\\tself.__dict__[name] # Do not delete this line (it verifies the existence of an attribute)\\n\\t\\t\\t# Positioning of the existing attribute\\n\\t\\t\\tself.__dict__[name] = value\\n\\t\\texcept KeyError:\\n\\t\\t\\t# The attribute does not exist is probably value of the structure\\n\\t\\t\\tself.__dict__[\\\"value\\\"][name] = value\",\n \"def add_param(self, param):\\n self.params.append(param)\\n return self\",\n \"def add_attribute(self, key: str, value: Union[str, int]) -> None:\\n self.span_instance.add_attribute(key, value)\",\n \"def __setattr__(self, name, value):\\n try:\\n self[self.sig.argpos(name)] = value\\n return value\\n except:\\n pass\\n list.__setattr__(self, name, value)\",\n \"def regattr(self, attr):\\n\\n return super().regattr(attr=attr)\",\n \"def set_attr(self, name, value):\\n setattr(self, name, value)\",\n \"def set_param(self, name, value, *, distrib=None, ref=None):\\n raise NotImplementedError\",\n \"def add_attribute(obj, attribute, value):\\n if not hasattr(obj, \\\"__dict__\\\"):\\n raise TypeError(\\\"can't add new attribute\\\")\\n setattr(obj, attribute, value)\",\n \"def __setattr__(self, attribute: str, value: Any) -> None:\\n if hasattr(self, attribute) or self.contents is None:\\n object.__setattr__(self, attribute, value)\\n else:\\n object.__setattr__(self.contents, attribute, value)\",\n \"def __setattr__(self, name: str, value: Any) -> None:\\n super().__setattr__(name, value)\",\n \"def set(self, attribute, value):\\n self.__setattr__(attribute, value)\",\n \"def addParameter(self, *args):\\n return _libsbml.KineticLaw_addParameter(self, *args)\",\n \"def add_attribute(self, name, value):\\n\\n self._attributes[name] = value\",\n \"def add_attribute(self, name, value):\\n\\n self._attributes[name] = value\",\n \"def add_attribute(self, name, value):\\n\\n self._attributes[name] = value\",\n \"def add_parameter(self, parameter):\\n self._pkey += 1\\n self.parameters[self._pkey] = parameter\",\n \"def __setattr__(self, name, value):\\n self.set(**{name: value})\",\n \"def add_attrib(self, key, func, func_args):\\n if key in self.aux_attrib:\\n raise KeyError(\\\"Attribute '{0}' already exists, please use 'set_attrib'.\\\".format(key))\\n else:\\n self.set_attrib(key, func, func_args)\",\n \"def add_param(self, param):\\n self._params.append(param)\\n self.add_decompostion(param)\",\n \"def SetAttribute(self, attr, val):\\n attrs = self.GetAttributes()\\n attrs[attr] = val\\n return self.SetAttributes(attr, attrs)\",\n \"def update(self, attribute: str, result: ProcessorResult) -> None:\\n pass\",\n \"def setParameter(self,arg,value):\\n self._params[arg] = value\\n return self._params\",\n \"def add(self, param):\\n self._data.add(param)\",\n \"def __setitem__(self, key, value):\\n self.params[key].value = value\",\n \"def __setitem__(self, feature, value):\\n setattr(self, feature, value)\",\n \"def add_attribute(obj, attr, val):\\n if not hasattr(obj, \\\"__dict__\\\"):\\n raise TypeError(\\\"can't add new attribute\\\")\\n setattr(obj, attr, val)\",\n \"def __setattr__(self, key, value):\\n resp = f'Attribute {key} can not be '\\n if key in self.__dict__:\\n resp += 'changed'\\n else:\\n resp += 'added'\\n raise AttributeError(resp)\",\n \"def setattr(self, node, attr, value):\\n node.set(attr, value)\",\n \"def __setattr__(self, name, value, overwrite=False):\\n\\n if \\\"attributes\\\" in dir(self):\\n if name not in self.attributes:\\n raise ImplementationError(name)\\n elif \\\"_init_attrs\\\" in dir(self) and name in self._init_attrs and name != \\\"_init_attrs\\\" and not overwrite:\\n message = f'\\\"{name}\\\" was used for two different argument names. Make sure each argument is unique.'\\n message += f\\\"Current value is {getattr(self, name)}, proposed value is {value}\\\"\\n raise ImplementationError(name, message)\\n\\n super().__setattr__(name, value)\",\n \"def add_attr(self, key: str, value):\\n if key in self._attr_names():\\n raise ValueError(\\\"Already have an attribute called '{}'\\\".format(key))\\n self._attributes.append((key, value))\",\n \"def _paramUpdate(self):\\n\\n # Update the database attributes accordingly.\\n dt.utilities.DB_attrs_save(self.Database, self.newParam)\",\n \"def add_attribute(obj, attribute, value):\\n if hasattr(obj, \\\"__dict__\\\"):\\n setattr(obj, attribute, value)\\n else:\\n raise TypeError(\\\"can't add new attribute\\\")\",\n \"def set_attrib(self, key, func, func_args):\\n self.aux_attrib[key] = func\\n self.aux_attrib_args[key] = func_args\",\n \"def addParam(self, var: IRVariable):\\n self.params[var.name] = var\",\n \"def add_attribute(self, name, value, modify=False, sources=None, published_at=None):\\n\\n # Find attributes and remove if matches\\n if modify:\\n if not self.current_attributes:\\n res = self.tq.get('{}/attributes'.format(self._get_api_endpoint()))\\n self.current_attributes = res.get('data', [])\\n\\n for attr in self.current_attributes:\\n if attr['name'] == name and attr['value'].lower() != value.lower():\\n attribute_id = attr['id']\\n self.tq.delete(\\n '{}/attributes/{}'.format(self._get_api_endpoint(), attribute_id))\\n # break\\n\\n data = {'name': name, 'value': value}\\n if sources and isinstance(sources, str):\\n data['sources'] = [{'name': sources}]\\n elif sources and isinstance(sources, dict):\\n data['sources'] = [sources]\\n elif sources and isinstance(sources, list):\\n data['sources'] = sources\\n if published_at:\\n data['published_at'] = published_at\\n\\n res = self.tq.post('{}/attributes'.format(self._get_api_endpoint()), data=data)\\n\\n # Add the newly added indicator to the cache\\n if res.get('total', 0) > 0:\\n self.current_attributes.append(res['data'][0])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6987088","0.6885637","0.6829756","0.6731595","0.67283607","0.67017716","0.66079473","0.6570364","0.6501009","0.64624107","0.6447641","0.64455295","0.64400303","0.64285815","0.6388802","0.6383218","0.637725","0.63599354","0.63599354","0.63599354","0.6348706","0.6334282","0.6324778","0.63077027","0.63015425","0.6297457","0.62894857","0.62894225","0.6288043","0.62850267","0.62850267","0.6283991","0.6283991","0.6283991","0.6283991","0.6283991","0.6267434","0.62598014","0.6241654","0.62307155","0.62281984","0.6200556","0.6194948","0.6185698","0.6171319","0.6165554","0.6161077","0.61583555","0.61568445","0.6156378","0.6144151","0.6138369","0.61282396","0.6119409","0.6116306","0.6105505","0.61039174","0.60875696","0.6080773","0.6075971","0.6075971","0.6074163","0.6074056","0.6062446","0.6061021","0.6060032","0.60585636","0.6052972","0.6050929","0.6047986","0.6036571","0.6022522","0.60196245","0.5996791","0.599197","0.5986874","0.59852153","0.59834486","0.59749854","0.59749854","0.59749854","0.59730667","0.59730536","0.59728646","0.5972033","0.5961318","0.5957416","0.5957364","0.5946024","0.5942907","0.5933817","0.5932546","0.59298784","0.5922056","0.592187","0.59217393","0.59162265","0.5913795","0.59058076","0.5891436","0.58882475"],"string":"[\n \"0.6987088\",\n \"0.6885637\",\n \"0.6829756\",\n \"0.6731595\",\n \"0.67283607\",\n \"0.67017716\",\n \"0.66079473\",\n \"0.6570364\",\n \"0.6501009\",\n \"0.64624107\",\n \"0.6447641\",\n \"0.64455295\",\n \"0.64400303\",\n \"0.64285815\",\n \"0.6388802\",\n \"0.6383218\",\n \"0.637725\",\n \"0.63599354\",\n \"0.63599354\",\n \"0.63599354\",\n \"0.6348706\",\n \"0.6334282\",\n \"0.6324778\",\n \"0.63077027\",\n \"0.63015425\",\n \"0.6297457\",\n \"0.62894857\",\n \"0.62894225\",\n \"0.6288043\",\n \"0.62850267\",\n \"0.62850267\",\n \"0.6283991\",\n \"0.6283991\",\n \"0.6283991\",\n \"0.6283991\",\n \"0.6283991\",\n \"0.6267434\",\n \"0.62598014\",\n \"0.6241654\",\n \"0.62307155\",\n \"0.62281984\",\n \"0.6200556\",\n \"0.6194948\",\n \"0.6185698\",\n \"0.6171319\",\n \"0.6165554\",\n \"0.6161077\",\n \"0.61583555\",\n \"0.61568445\",\n \"0.6156378\",\n \"0.6144151\",\n \"0.6138369\",\n \"0.61282396\",\n \"0.6119409\",\n \"0.6116306\",\n \"0.6105505\",\n \"0.61039174\",\n \"0.60875696\",\n \"0.6080773\",\n \"0.6075971\",\n \"0.6075971\",\n \"0.6074163\",\n \"0.6074056\",\n \"0.6062446\",\n \"0.6061021\",\n \"0.6060032\",\n \"0.60585636\",\n \"0.6052972\",\n \"0.6050929\",\n \"0.6047986\",\n \"0.6036571\",\n \"0.6022522\",\n \"0.60196245\",\n \"0.5996791\",\n \"0.599197\",\n \"0.5986874\",\n \"0.59852153\",\n \"0.59834486\",\n \"0.59749854\",\n \"0.59749854\",\n \"0.59749854\",\n \"0.59730667\",\n \"0.59730536\",\n \"0.59728646\",\n \"0.5972033\",\n \"0.5961318\",\n \"0.5957416\",\n \"0.5957364\",\n \"0.5946024\",\n \"0.5942907\",\n \"0.5933817\",\n \"0.5932546\",\n \"0.59298784\",\n \"0.5922056\",\n \"0.592187\",\n \"0.59217393\",\n \"0.59162265\",\n \"0.5913795\",\n \"0.59058076\",\n \"0.5891436\",\n \"0.58882475\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3293,"cells":{"query":{"kind":"string","value":"THIS SHOULD LOOK FAMILIAR, SO WE PROVIDED IT FOR YOU. This function reads a .csv file and parses it into a list of dictionaries, where each dictionary is formed from the data on one line of the .csv file. This function takes one argument , which is the path of the file to be read. You will need to use the \"csv\" module in this function."},"document":{"kind":"string","value":"def read_csv_file(input_filepath):\n\n out_list = []\n\n with open(input_filepath, 'r', encoding = 'utf-8') as f:\n reader = csv.reader(f)\n for i,row in enumerate(reader):\n if i == 0:\n labels = row\n else:\n new_dict = {}\n for j,value in enumerate(row):\n new_dict[labels[j]] = value\n out_list.append(new_dict)\n\n return out_list"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def read_csv_as_dicts(csv_input_file_name):\n input_table = read_csv_as_table(csv_input_file_name, skip_first_line=False)\n\n # first line should contain headers\n header = input_table[0]\n # rest lines would contain actual data\n data = input_table[1:]\n\n output = []\n # process all lines with data\n for input_line in data:\n record = {}\n for i in range(len(header)):\n record[header[i]] = input_line[i]\n output.append(record)\n return output","def read_from_csv(self, csv_file):\n data = []\n with codecs.open(csv_file, 'r', encoding='utf-8') as csvfile:\n header = None\n for i, line in enumerate(csvfile):\n line_split = [x.strip() for x in line.split(\"|\")]\n line_data = [x for x in line_split if len(x) > 0]\n if i == 0:\n header = line_data\n else:\n entry = {}\n for i,datum in enumerate(line_data):\n entry[header[i]] = datum\n data.append(entry)\n print \"Loaded %d entries from %s\" % (len(data), csv_file)\n return data","def csv2dicts(csvfile, names=None):\n data = []\n for row_index, row in enumerate(csvfile):\n if row_index == 0:\n if names:\n keys = names\n else:\n keys = row\n print(keys)\n continue\n data.append({key: value for key, value in zip(keys, row)})\n return data","def csv_dict_reader(file_path):\r\n with open(file_path, 'r') as file_obj:\r\n\r\n reader = csv.DictReader(file_obj, delimiter=',')\r\n for line in reader:\r\n #print(line[\"variable_name \"]),\r\n print(line[\"dataset\"])","def read_file(file):\n \n dictionary = {}\n csv_fp = csv.reader(file)\n #L[46] = manufacturer, L[63] = year\n #L[4]= city mileage, L[34]=highway mileage\n for line in csv_fp:\n #Skip the headings and the year 2017\n if (not (line[46] == 'make')) and (not (line[63] == '2017')):\n if line[46] in dictionary:\n #Add the city and highway mileage if the year has been made\n if line[63] in dictionary[line[46]]:\n dictionary[line[46]][line[63]][0] += [int(line[4])]\n dictionary[line[46]][line[63]][1] += [int(line[34])]\n #Add the year and data if it was not made previously\n else:\n dictionary[line[46]][line[63]] = [[int(line[4])],\\\n [int(line[34])]]\n #Adds a new manufacturer\n else:\n dictionary[line[46]] = {line[63]:[[int(line[4])],\\\n [int(line[34])]]}\n return dictionary","def _read_csv_to_dictionary_list(file_name):\n catalog_list = []\n with open(file_name) as csvfile:\n reader = csv.DictReader(csvfile)\n for item in reader:\n catalog_list.append(item)\n return catalog_list","def parse_csv_input_file(input_file):\n with open(input_file) as csvfile:\n reader = csv.DictReader(csvfile)\n for item in reader:\n dict = {i: x for i, x in item.items()}\n yield(dict)","def csv_to_dict(filename):\n data_list = []\n \n with open(filename, 'rb') as datafile:\n data_reader = csv.DictReader(datafile, delimiter = ',')\n for row in data_reader:\n data_list.append(row)\n\n return data_list","def csv_dict_reader(file_obj):\n #import re\n #file = open(file_obj)\n\n # reader = csv.DictReader(file_obj)\n # for line in reader:\n # print(line[\"Name\"])","def dictparse(csvfilename, keyfield):\n table = {}\n with open(csvfilename, \"rt\", newline='') as csvfile:\n csvreader = csv.DictReader(csvfile,\n skipinitialspace=True)\n for row in csvreader:\n table[row[keyfield]] = row\n return table","def read_csv(path: str) -> list[dict[str, str]]:\n with open(path, 'r') as f:\n return list(csv.DictReader(f))","def load_csv(file):\n with open(file) as csvfile:\n reader = csv.DictReader(csvfile)\n return [dict(row) for row in reader]","def read_list():\n import glob\n import csv\n\n slist = {}\n csvfile = glob.glob(_path + '/*.csv').pop()\n if csvfile is None:\n return slist\n _logger.info(\"Found file '%s'\" % csvfile)\n\n hcsv = csv.reader(open(csvfile), delimiter=';')\n # Skip header\n next(hcsv)\n # Work on every line\n for line in hcsv:\n if len(line) < 2:\n continue\n # print(line)\n slist[line[0]] = {'name': line[2], 'surname': line[1]}\n\n # print(slist)\n # print(\"LEN\", len(slist))\n # exit(1)\n return slist","def parse_csvfile(self, csvfile):\n\n logging.info(\"Parseing csvfile: %s\" % basename(csvfile))\n fields = []\n data = {}\n try:\n with open(csvfile) as f:\n for line in f:\n line = line.strip()\n # Skip empty or commented line\n if not line or line[0] == \"#\":\n continue\n if not fields:\n # The first valid line defines fields.\n fields = [x.strip() for x in line.split(\",\")]\n for f in self.REQUIRED_FIELDS:\n if f not in fields:\n logging.error(\"Failed to find %s field. \"\n \"Aborted.\" % f)\n sys.exit(1)\n else:\n # The rest lines are data\n values = [x.strip() for x in line.split(\",\")]\n record = {}\n for k, v in zip(fields, values):\n record[k] = v\n # Convert date time string to epoch seconds\n record[\"time_h\"] = self.parse_timestr(record[\"time_h\"])\n node = record[\"name\"]\n if data.get(node, None):\n data[node].append(record)\n else:\n data[node] = [record]\n except Exception as e:\n logging.exception(\"Failed to parsing the csvfile. \"\n \"See stack trace below:\")\n sys.exit(1)\n\n # While it didn't occur often, I observed that data in CSV files\n # generated by cbtool monextrac command were not in time order.\n # So sort them.\n logging.debug(\"Sorting the data\")\n for node in data.keys():\n data[node].sort(lambda x, y: cmp(int(x[\"time\"]), int(y[\"time\"])))\n\n return data, fields","def _read_csv(file_name):\n with open(file_name) as boards:\n rows = csv.DictReader(boards, delimiter=',', quotechar='\"')\n formatted_data = []\n for row in rows:\n formatted_data.append(dict(row))\n return formatted_data","def dictparse(csvfilename, keyfield, separator, quote, quotestrategy):\n table = {}\n with open(csvfilename, \"rt\", newline='') as csvfile:\n csvreader = csv.DictReader(csvfile,\n skipinitialspace=True,\n delimiter=separator,\n quotechar=quote,\n quoting=quotestrategy)\n for row in csvreader:\n table[row[keyfield]] = row\n return table, csvreader.fieldnames","def dictparse(csvfilename, keyfield, separator, quote, quotestrategy):\n table = {}\n with open(csvfilename, \"rt\", newline='') as csvfile:\n csvreader = csv.DictReader(csvfile,\n skipinitialspace=True,\n delimiter=separator,\n quotechar=quote,\n quoting=quotestrategy)\n for row in csvreader:\n table[row[keyfield]] = row\n return table, csvreader.fieldnames","def parse(raw_file):\n parsed_data = []\n with open(raw_file, 'r') as r:\n rows = csv.reader(r)\n fields = rows.next()\n counter = 0\n for r in rows:\n parsed_data.append(dict(zip(fields, r)))\n\n return parsed_data","def read_data_from_csv(csv_file, header=None, **kwargs):\n if os.path.isabs(csv_file) == False:\n path_to_csv = os.path.join(csv_file)\n else:\n path_to_csv = csv_file\n row_list = []\n if \"field_sep\" not in kwargs.keys():\n field_sep = ','\n else:\n field_sep = kwargs.get(\"field_sep\")\n with open(path_to_csv, mode='r') as csv_file:\n csv_reader = csv.DictReader(csv_file, delimiter=field_sep, fieldnames=header)\n for record in csv_reader:\n if list(record.values())[0].startswith(\"#\") is not True:\n # IT'S A COMMENT IF IT STARTS WITH \"#\" \n # IF THIS IS YOUR HEADER ROW, SUPPLY A LIST OF COLUMN NAMES WHEN CALLING THE FUNCTION\n row_list.append(record)\n return row_list","def csv_dict_reader(file_obj):\n reader = csv.DictReader(file_obj, delimiter=',')\n for line in reader:\n print(line[\"first_name\"]),\n print(line[\"last_name\"])","def parse_csv_input(input_file): # {{{\n parsed_infile = []\n try:\n with open(input_file) as infile:\n for line in csv.reader(infile):\n parsed_infile.append(line)\n\n temp_object_storage = []\n\n for line_index, line in enumerate(parsed_infile[1:]):\n temp_object_storage.append({})\n for category_index, category in enumerate(parsed_infile[0]):\n if category_index == 0:\n category = category[3:]\n temp_object_storage[line_index][category] = line[category_index]\n\n return temp_object_storage\n except FileNotFoundError as excep:\n LOGGER.info(\"error parsing csv file: %s\", excep) # }}}","def read_csv_rows(path: str) -> list[dict[str, str]]:\n file_handle = open(\"survey\", encoding=\"utf8\")\n csv_reader = DictReader(file_handle)\n rows: list[dict[str, str]] = []\n for row in csv_reader:\n rows.append(row)\n file_handle.close()\n return rows","def parse(raw_file, delimiter):\n\t#open csv file\n\topened_file = open(raw_file)\n\t\n\t#read csv file\n\tcsv_data = csv.reader(opened_file,delimiter=delimiter)\n\t\n\t#build parsed data\n\tparsed_data = []\n\t\n\t#define headers\n\tfields = csv_data.next()\n\t\n\t#Iterate over each row of the csv file, zip together field->value pairs\n\tfor row in csv_data:\n\t\tparsed_data.append(dict(zip(fields, row)))\n\t\n\t#close csv file\n\topened_file.close()\n\t\n\treturn parsed_data","def read_csv(path):\r\n data = []\r\n csv_file = open(path)\r\n for row in csv.DictReader(csv_file):\r\n data.append(row)\r\n csv_file.close() \r\n return data","def read_strong_csv(strong_meta_csv_path):\n with open(strong_meta_csv_path, 'r') as fr:\n reader = csv.reader(fr, delimiter='\\t')\n lines = list(reader)\n \n meta_dict = {}\n for line in lines:\n [audio_name, begin_time, end_time, label] = line\n meta = {'begin_time': begin_time, 'end_time': end_time, 'label': label}\n if audio_name in meta_dict:\n meta_dict[audio_name].append(meta)\n else:\n meta_dict[audio_name] = [meta]\n \n return meta_dict","def csv_to_dict_list(file_path, char_sep=\"|\"):\n with open(file_path, mode='r') as f:\n d = [{k: v for k, v in row.items()} for row in csv.DictReader(f, skipinitialspace=True, delimiter=char_sep)]\n return d","def load_csv(filename):\n # Open csvfile\n with open(filename) as csvfile:\n reader = csv.DictReader(csvfile)\n\n # Put data in gloabal list\n for row in reader:\n # Get data of subject with either or both milk and peanut allergy\n if row[\"MILK_ALG_START\"] != \"NA\" or row[\"PEANUT_ALG_START\"] != \"NA\":\n sub_list = list()\n for key in DATA_KEYS:\n sub_list.append(row[key])\n\n # Add data of subject to all data \n data_list.append(sub_list)","def read_risposte_from_csv(csv_risposte):\n import os\n try:\n csv_in = open(os.path.join(os.path.dirname(__file__), csv_risposte), 'rb')\n r_reader = csv.DictReader(csv_in, delimiter=',')\n except IOError:\n print \"It was impossible to open file %s\" % csv_risposte\n exit(1)\n\n risposte_partiti = {}\n for row in r_reader:\n partito_id = int(row['partito_id'])\n domanda_id = int(row['domanda_id'])\n risposta = int(row['risposta_int'])\n if not partito_id in risposte_partiti:\n risposte_partiti[partito_id] = {}\n risposte_partiti[partito_id][domanda_id] = risposta\n\n return risposte_partiti","def parse_csv_file(file_path):\n\n complete_data_list = []\n\n try:\n import_file = open(file_path, \"rb\")\n\n except IOError:\n print 'An error occured trying to read the file.'\n\n else:\n reader_file = csv.DictReader(import_file)\n complete_data_list = get_file_data(reader_file)\n import_file.close()\n\n return complete_data_list","def read_dictionary(filename):\r\n dictionaryoutput = {}\r\n with open(filename) as file:\r\n entries = csv.reader(file)\r\n for item in entries:\r\n dictionaryoutput[item[0]] = item[1]\r\n return dictionaryoutput","def read_csv(csv_file):\r\n with open(csv_file, \"r\") as files:\r\n data = csv.reader(files)\r\n return list(data)","def get_dictionary_from_csv(file):\n csv_file = file[:-4] # avoid .txt extension\n csv_file += \"_dico.csv\"\n dic = pd.read_csv(csv_file, delimiter=',')\n return list(dic.columns)","def _csv_to_dict(name):\n csv_path = _get_csv_path(name)\n result = []\n with open(csv_path) as csvfile:\n reader = csv.DictReader(csvfile)\n for row in reader:\n result.append(row)\n return result","def load_from_file_csv(cls):\n fields = []\n rows = []\n new_dict = {}\n new_list = []\n key = \"\"\n filename = cls.__name__ + \".csv\"\n with open(filename) as fp:\n reader = csv.reader(fp)\n fields = next(reader)\n for row in reader:\n rows.append(row)\n for row in rows:\n i = 0\n new_dict = new_dict.fromkeys(fields)\n for attr in fields:\n key = fields[i]\n value = row[i]\n new_dict[key] = value\n i += 1\n new_list.append(cls.create(**new_dict))\n return new_list","def read_csv_rows(filename: str) -> list[dict[str, str]]:\n result: list[dict[str, str]] = []\n \n \"\"\"Open a handle to the data file.\"\"\"\n file_handle = open(filename, \"r\", encoding=\"utf8\")\n\n \"\"\"Prepare to read the data in the file as CSV instead of just strings.\"\"\"\n csv_reader = DictReader(file_handle)\n\n \"\"\"Read each row of the CSV line by line.\"\"\"\n for row in csv_reader:\n result.append(row)\n\n \"\"\"Close file.\"\"\"\n file_handle.close()\n\n return result","def csvToDict(filepath):\n data = []\n with open(getcwd() + filepath, 'r') as dataset:\n assert csv.Sniffer().has_header(dataset.read(9999)), 'No headers'\n dataset.seek(0)\n dialect = csv.Sniffer().sniff(dataset.read(99999))\n dataset.seek(0)\n reader = csv.DictReader(dataset, dialect=dialect)\n headers = reader.fieldnames\n for row in reader:\n data.append(row)\n\n data = assert_data_format(data)[0]\n\n return data, headers","def parse_trick_ascii(csv_file):\n data_file = csv.DictReader(open(csv_file))\n single_run_data_dict = {'altitude' : [0.0],\n 'latitude' : [0.0],\n 'longitude' : [0.0]}\n # Your code here\n # ...\n # return the dict\n return single_run_data_dict","def read_csv(filename, delimiter=','):\n data = []\n try:\n with open(filename, 'r') as csvfile:\n reader = csv.DictReader(csvfile, delimiter=delimiter)\n try:\n keys = reader.fieldnames\n for row in reader:\n data.append(row)\n except csv.Error as e:\n sys.exit('file %s, line %d: %s' % (filename, reader.line_num, e))\n except IOError as e:\n sys.exit('%s does not exist' % e) \n return data","def main3():\r\n #open the file\r\n with open('csvfile1.csv', 'r') as csvfile1:\r\n #use DictReader method from csv module\r\n csv_reader = csv.DictReader(csvfile1)\r\n #read the lines\r\n for line in csv_reader:\r\n print(line['email'])","def read_csv(csv_file):\r\n reader = csv.DictReader(csv_file)\r\n if 'PERSON_ID' in reader.fieldnames:\r\n key = 'PERSON_ID'\r\n elif 'LogonName' in reader.fieldnames:\r\n key = 'LogonName'\r\n else:\r\n raise 'no username field specified in the file'\r\n user_list = []\r\n for item in reader:\r\n try:\r\n uid = item[key]\r\n assert uid\r\n user_list.append(uid)\r\n except:\r\n warning('empty username')\r\n if not user_list:\r\n raise 'empty list of users'\r\n return user_list","def load_data(filepath):\n with open(filepath) as csvfile:\n reader = csv.DictReader(csvfile)\n for row in reader:\n yield row","def load_data_from_csv(csv_file, users_to_i = {}, items_to_i = {}):\n raw_data = []\n with open(csv_file) as f:\n csvreader = csv.reader(f)\n # skipping first row (header)\n next(csvreader)\n for user, item in csvreader:\n raw_data.append((user, item))\n return load_data_from_array(raw_data, users_to_i, items_to_i)","def get_csv_data(file_name: str) -> Iterator[list]:\n with open(file_name) as f:\n # creating a reader instance that can iterate over rows of file.\n reader = DictReader(f)\n\n # iterating over rows:\n for row in reader:\n yield dict(row) # returning the dicts for each row in the dataset.","def creating_dict_from_csv(self) -> dict:\n dictionary = {}\n for row in self.__read_csv():\n if dictionary.get(row[0]):\n dictionary[row[0]].append((row[1], row[2]))\n else:\n dictionary[row[0]] = [(row[1], row[2])]\n\n for key, value in dictionary.items():\n dictionary[key] = sorted(value, key=lambda x: x[1], reverse=True)\n\n return dictionary","def save_csv_into_dictionary(csv_file):\n\n dictionary = OrderedDict()\n with open(csv_file, newline='') as file:\n reader = csv.reader(file)\n for row in reader:\n dictionary[row[0]] = row[1]\n return dictionary","def csv_to_dict(filename):\n\twith open(filename, 'r') as in_hndl:\n\t\tindict = [i for i in csv.DictReader(in_hndl)]\n\treturn indict[0]","def load_csv(input):\n with open(input['csv'], 'r', encoding=input['encoding']) as f:\n invoice_dict = dict()\n reader = csv.reader(f, delimiter=';')\n\n for row in reader:\n invoice_id = row[0]\n\n if invoice_id in invoice_dict:\n invoice_dict[invoice_id].add_entry(row[1:])\n else:\n invoice_dict[invoice_id] = Invoice(row)\n\n return invoice_dict","def read_csv():","def readcsv(csvfile):\n logger = log.getLogger('obslog.readcsv')\n\n if not os.path.exists(csvfile):\n logger.error('Cannot access %s', csvfile)\n raise SystemExit\n\n data = {}\n with open(csvfile, mode='r') as csv_file:\n reader = csv.DictReader(csv_file)\n for row in reader:\n data[row['FITSFILE']] = row\n logger.debug('Data: %s', data)\n return data","def read_file(filename):\n with open(filename) as fp:\n reader = csv.DictReader(fp)\n return list(reader)","def csv_to_dict(csvfile, delimiter=\",\", quotechar='\"'):\n reader = csv.DictReader(csvfile, delimiter=delimiter, quotechar=quotechar)\n\n data = {each: [] for each in reader.fieldnames}\n for i, row in enumerate(reader):\n for key, value in row.items():\n data[key].append(value)\n return data","def read_name_map( name_map_path) :\n with open( name_map_path, newline=\"\") as csvfile:\n table = { }\n reader = csv.reader(csvfile)\n for row in reader:\n if len(row) < 2:\n continue\n if row[key_col] == key_header:\n continue\n key = row[key_col]\n val = row[val_col]\n table[key] = val\n return table","def parse(raw_file, delimiter):\n\n opened_file = open(raw_file, 'rU')\n csv_data = csv.reader(opened_file, delimiter=delimiter)\n\n parsed_data = []\n\n fields = csv_data.next()\n\n for row in csv_data:\n parsed_data.append(dict(zip(fields,row)))\n\n opened_file.close()\n\n return parsed_data","def csv2dict(filename):\n dis_dict = {}\n with open(filename) as csvfile:\n reader = csv.DictReader(csvfile)\n for row in reader:\n el_a = row[\"Element Name\"]\n dis_dict[el_a] = {}\n for entry in row:\n if entry != \"Element Name\":\n dis_dict[el_a][entry] = float(row[entry])\n csvfile.close()\n return dis_dict","def get_rows(csv):\n\n labels = csv[0][2:].split(',')\n\n # Convert each row into a hash of label: value\n return [dict(zip(labels, row.split(','))) for row in csv[1:]]","def parse(file, delimiter):\n\n\t# Open CSV\n\topened_file = open(file)\n\n\t# Read CSV\n\tdata = csv.reader(opened_file, delimiter=delimiter)\n\n\t# Build data structure\n\tparsed_data = []\n\tfields = next(data)\n\tfor row in data:\n\t\tparsed_data.append(dict(zip(fields, row)))\n\n\t# Close CSV\n\topened_file.close()\n\n\treturn parsed_data","def read_file(filename):\n\n data = {}\n with open(filename, encoding=\"utf8\") as file:\n reader = csv.DictReader(file)\n for line in reader:\n data[line['id']] = line\n return data","def read_csv(csv_file_path):\n res = [] #list\n # f = open(csv_file_path) #read file\n with open(csv_file_path,\"r\") as f:","def _process_csv_data(csv_file, user_data_map):\n with open(csv_file, 'r') as csvfile:\n rows = csv.reader(csvfile)\n for row in rows:\n if len(row) < 2:\n print('The CSV file is not in expected format.')\n raise Exception\n user_data_map[row[1].lower()] = row[0]","def make_json(csvfile):\n\n data = []\n with open(csvfile, encoding='utf-8') as csvf:\n csvreader = csv.DictReader(csvf)\n for rows in csvreader:\n data.append(rows)\n\n return data","def parse(csvfilename):\n table = []\n with open(csvfilename, \"r\") as csvfile:\n for line in csvfile:\n line = line.rstrip()\n columns = line.split(',')\n table.append(columns)\n return table","def read_names_into_dict():\n d = dict()\n with open(\"SP_500_firms.csv\") as csvfile:\n input_file = csv.DictReader(csvfile)\n for row in input_file:\n #print(row)\n d[row['Symbol']] = [row['Name'],row['Sector']]\n return d","def read_from_csvfile(fname, types, header=True):\n num_columns = len(types)\n parsed = []\n with open(fname) as f:\n reader = csv.reader(f)\n if header:\n columns = next(reader)\n else:\n columns = ['col '+str(i) for i in range(num_columns)]\n\n for row in reader:\n parsed.append([types[i](row[i]) if row[i] else None for i in range(num_columns)])\n\n return [{k:v for k,v in zip(columns, row)} for row in parsed]","def read_csv_file(in_file):\n out_list = []\n with open(in_file, 'r', newline='') as p_file:\n file_list = csv.DictReader(p_file, delimiter=',')\n for row in file_list:\n out_list.append(row)\n return out_list\n #thequeue.put(out_list)","def load_data(filename='KSI.csv'):\r\n d = []\r\n with open(filename) as csv_file:\r\n # csv_reader = csv.reader(csv_file, delimiter=',')\r\n csv_reader = csv.DictReader(csv_file, delimiter=',')\r\n for line_count, row in enumerate(csv_reader):\r\n if line_count == 0:\r\n print(f'Column names are \\n{\", \".join(row)}')\r\n # column_names = row\r\n else:\r\n d.append(row)\r\n # print(f'Processed {line_count} lines.')\r\n return d","def parse_csv_from_file(file):\n csvFileReader = None\n employee_data = []\n\n # if FileStorage object (which has a save() method)\n if hasattr(file, 'save'):\n csvFileReader = csv.reader(codecs.iterdecode(file, 'utf-8'))\n # else if File object (which does not have a save() method)\n else:\n csvFileReader = csv.reader(file)\n\n for row in csvFileReader:\n employee_data.append({\n 'first_name': row[0],\n 'last_name': row[1],\n 'annual_salary': int(row[2]),\n 'super_rate': convert_to_float(row[3]),\n 'payment_period': row[4]\n })\n\n return employee_data","def csv_dict_reader(file_obj, data = [], cost = []):\n reader = csv.DictReader(file_obj, delimiter=',')\n for line in reader:\n data.append(line[\"Дата\"]),\n cost.append(line[\"Расход\"])","def read_tags(csv_path):\n tags = {}\n with open(csv_path, 'r') as csv_file:\n reader = csv.DictReader(csv_file)\n for row in reader:\n tags[row['image_name']] = row['tags'].split()\n return tags","def load_data_from_csv(csv_file):\n list=[]\n\n with open(csv_file) as csv_1:\n csv_out = csv.reader(csv_1) \n next(csv_out)\n for rows in csv_out: \n if len(rows) != 0:\n list.append([rows[0],int(rows[1]),int(rows[2])])\n \n return (list)","def get_data_from_csv(csv_file):\n # create customer list form csv file\n with open(csv_file, encoding='utf-8', errors='ignore') as people:\n customer_reader = csv.reader(people)\n customers = [row for row in customer_reader]\n\n return customers","def read_csv(path):\r\n output = []\r\n for row in csv.DictReader(open(path)):\r\n output.append(row)\r\n return output","def load_csv(path: Path) -> Any:\n with open(path, newline='') as csvfile:\n reader = csv.DictReader(csvfile)\n items = list(reader)\n return items","def read_csv(path):\n output = []\n for row in csv.DictReader(open(path)):\n output.append(row)\n return output","def read_csv_file(csv_file_path):\n file_names = []\n file_labels = []\n with open(csv_file_path, 'r') as files_path:\n path_list = csv.DictReader(files_path)\n fieldnames = path_list.fieldnames\n for path in path_list:\n file_names.append(path[fieldnames[0]])\n file_labels.append(path[fieldnames[1]])\n return file_names, file_labels","def process_csv(csv_file=None):\n if csv_file:\n _process_csv_data(csv_file, USER_DATA_MAP)\n else:\n csv_files_list = [os.path.join(DATA_DIR, f) for f in os.listdir(DATA_DIR) if f.endswith('.csv')]\n for fl in csv_files_list:\n _process_csv_data(fl, USER_DATA_MAP)\n return USER_DATA_MAP","def dictionary_formation():\r\n sales_data = {}\r\n with open('beer_data.csv', \"r\") as data_file:\r\n file_contents = csv.reader(data_file, delimiter=',')\r\n #Value of lines_read used as key value for each dictionary\r\n #in sales_data\r\n lines_read = 1\r\n for line in file_contents:\r\n if lines_read == 1:\r\n lines_read = lines_read + 1\r\n else:\r\n #Stores each column in row as key value in dictionary\r\n sales_data[str(lines_read)] = {\r\n \"invoice_number\": line[0],\r\n \"customer\": line[1],\r\n \"date_required\": line[2],\r\n \"recipe\": line[3],\r\n \"gyle_number\": line[4],\r\n \"quantity_ordered\": int(line[5])\r\n }\r\n lines_read = lines_read + 1\r\n data_file.close()\r\n return sales_data","def load(filename):\n with open(filename,'r') as fd:\n csv_in = csv.reader(fd, delimiter=',', quotechar='\"')\n keys = csv_in.next()\n data = {k:[] for k in keys}\n for row in csv_in:\n for k,v in zip(keys,row):\n data[k].append(float(v))\n return data","def parse_prefeaturized_csv_data(features_file_path):\n objects = []\n with open(features_file_path) as f:\n # First line contains column titles\n keys = f.readline().strip().split(',')\n for line in f:\n vals = line.strip().split(\",\")\n if len(vals) != len(keys):\n continue\n else:\n objects.append({})\n for i in range(len(keys)):\n objects[-1][keys[i]] = vals[i]\n return objects","def read_sailor_data(filename):\n\td=OrderedDict()\n\twith open(filename) as csvfile:\n\t\trdr = csv.reader(csvfile)\t\n\t\tfor i in rdr:\n\t\t\t#This except is so that if the line trying to be inputted into the dictionary is a string\n\t\t\t#It will ignore it and go to the next line\n\t\t\ttry: d[i[0]]=(float(i[1]),float(i[2]))\n\t\t\texcept: None\n\treturn d","def load_csv(filepath):\n log.debug('Loading csv')\n with open(filepath) as csvfile:\n reader = csv.DictReader(csvfile)\n return reader.fieldnames, list(reader)","def load_csv_to_dict(filename):\n row_len = list()\n result = dict()\n with open(filename, 'r') as csvfile:\n reader = csv.reader(csvfile)\n for row in reader:\n key = row[0].strip()\n values = [v.strip() for v in row[1:]]\n result[key] = values\n row_len.append(len(values))\n return result, max(row_len)","def load_csv(filename):\n results = defaultdict(list)\n with open(filename, 'r') as f:\n reader = csv.DictReader(f)\n for line in reader:\n results[line['sid']].append(line)\n return results","def readCSV(filename, separator):\n \n filetoread = open(filename, \"r\")\n lines = []\n for line in filetoread:\n line = line.replace(\"\\n\", \"\").split(separator)\n lines.append(line)\n keys, values = lines[0], lines[1]\n dictionary = {}\n for i in range(0,len(keys)):\n try:\n dictionary[keys[i]] = int(values[i])\n except:\n dictionary[keys[i]] = values[i]\n return dictionary","def read_csv(filename):\n with open(filename, 'rb') as f:\n reader = unicodecsv.DictReader(f)\n return list(reader)","def populate_table_from_csv(csv_file, csv_encoding='iso-8859-15'):\n try:\n with open(file=csv_file, mode='r', encoding=csv_encoding) as input_file:\n # Could find a good place to add iterators/generators/comprehensions elsewhere, so made a new function\n # Also, yet another pylint false positive. The below line isn't supposed to be assigned to anything.\n [add_customer(*l.split(',')) for l in input_file if 'Id,Name,Last_name,' not in l] # pylint: disable=W0106\n except Exception as e:\n logger.error(\"Failed to load records from csv file %s into database %s: %s\", csv_file, customer_db.database, e)","def read_data(options):\n reader = csv.reader(open(options.datafile, \"U\"))\n raw_rows = list(reader)\n fieldnames = raw_rows[0]\n rows = []\n for raw_row in raw_rows[1:]:\n row = {}\n try:\n for i in range(len(fieldnames)):\n row[fieldnames[i]] = raw_row[i]\n rows.append(row)\n except IndexError:\n print \"SHORT ROW:\", raw_row\n print \"Read %d rows\" % len(rows)\n return rows","def parse_csv(csv_file):\n if os.path.isfile(csv_file) == True:\n num_lines = sum(1 for line in open(csv_file))\n if num_lines > 1:\n try:\n data = pd.read_csv(csv_file, index_col=False)\n data.insert(0, 'id', range(1, 1 + len(data)))\n return(data)\n except pd.parser.CParserError, err:\n message = \"Can't parse REDCap data. Check CSV file: \" + csv_file\n print(message)\n logging.critical(message)\n exit(3)\n else:\n message = \"CSV file does not contain data: \" + csv_file\n print(message)\n logging.warning(message)\n return(None)\n else:\n message = \"Can't read CSV file: \" + csv_file\n print(message)\n logging.critical(message)\n exit(4)","def load_csv(file):\n import csv\n reader = csv.reader(open(file, 'r'))\n columns = reader.next()\n c2i = dict((columns[i], i) for i in range(len(columns)))\n data = {}\n excluded = set([REP_CSV_HED_TIM, REP_CSV_HED_HER])\n for row in reader:\n \n # get relevant info from the line\n time = float(row[c2i[REP_CSV_HED_TIM]])\n hero = row[c2i[REP_CSV_HED_HER]]\n other = dict((c, REP_CSV_HANDLERS.get(c, REP_CSV_DEFHANDLER)(row[c2i[c]])) for c in columns if c not in excluded)\n \n # add to the data dictionary\n if hero not in data: data[hero] = []\n data[hero].append([time] + [other])\n \n return data","def read_csv(filename):\n\twith open(filename, newline = '') as filehandle:\n\t\t\n\t\t# create DictReader objects for inputs and read into memory\n\t\treader = csv.DictReader(filehandle, delimiter = '\\t')\n\t\tdata = []\n\t\tfor row in reader:\n\t\t\tdata.append(row)\n\t\t\t\n\treturn data","def _convert_csv_column_to_dict(csv_data, column):\n results = dict()\n\n for row in csv_data:\n key = row[0]\n data = row[1:][column]\n\n if data:\n if key not in results:\n results[key] = data.strip() if data else \"\"\n else:\n # append multiple choice questions\n results[key] += \"|{0}\".format(data.strip())\n\n return results","def csvfileUsage(self):\n with open(self.csv_path, \"rb+\") as file_obj:\n reader = csv.DictReader(file_obj, delimiter=',') # CSV DictReader object\n \"\"\" reader.fieldnames returns header , slicing intial 'Month' and\n 'Year' header from list\n \"\"\"\n for com_names in reader.fieldnames[2:]:\n self.company_data[com_names] = {}\n # iterating each row\n for row in reader:\n month, year = self.parse_my(row) # parsing the year and month from row\n # pop the `Month` and `Year` Key to minimize iteration below\n row.pop('Month'), row.pop('Year')\n \"\"\" saving and updating the data at same point of time\n each iteration time, checking the max value and updating \n `Month` `Year` and `Value`\n \"\"\"\n self.prepare_company_data(month, year, row, self.company_data)\n file_obj.close() # close file\n return self.company_data","def read_file(filepath: str) -> dict:\n if not filepath.endswith(\".csv\"):\n raise RuntimeError(\"File extension must be .csv\")\n\n people = {}\n with open(filepath) as csv:\n for line in csv:\n email, person = Parser.parse_line(line.rstrip(\"\\n\"))\n if email not in people:\n people[email] = person\n else:\n print(\"Ignoring person with duplicate email {}\".format(email))\n return people","def get_field_list(filename):\n with open(filename) as csvfile:\n reader = csv.reader(csvfile, delimiter=',', quotechar='|')\n field_mapping = {}\n for row in reader:\n field_mapping[row[0]] = row[1]\n return field_mapping","def read(path):\n \n file = open(path, 'r', encoding = 'utf-8')\n reader = csv.reader(file, delimiter = '\\t', quotechar = '', quoting = csv.QUOTE_NONE)\n result = []\n header = reader.__next__()\n for values in reader:\n entry = {}\n for i in range(len(header)):\n entry[header[i]] = values[i]\n result.append(entry)\n file.close()\n return result","def read_csv_file(file, delimiter=None):\n if delimiter is None: # try delimiters ; and ,\n delimiter = [';', ',']\n else:\n delimiter = [delimiter]\n\n for delim in delimiter:\n with open(file, encoding=\"utf8\") as fh:\n rd = csv.DictReader(fh, delimiter=delim)\n runs = [dict(row) for row in rd]\n if len(runs[0].keys()) > 1:\n logging.debug('Read csv data:')\n logging.debug(runs)\n return runs","def load_data(filename):\n data = dict()\n with open(filename) as f:\n reader = csv.DictReader(f)\n for row in reader:\n name = row[\"name\"]\n data[name] = {\n \"name\": name,\n \"mother\": row[\"mother\"] or None,\n \"father\": row[\"father\"] or None,\n \"trait\": (True if row[\"trait\"] == \"1\" else\n False if row[\"trait\"] == \"0\" else None)\n }\n return data","def load_csv(csvpath):\n with open(csvpath, \"r\") as csvfile:\n data = []\n csvreader = csv.reader(csvfile, delimiter=\",\")\n\n # Skip the CSV Header\n next(csvreader)\n\n # Read the CSV data\n for row in csvreader:\n data.append(row)\n return data","def read_movies_from_csv(filename, header):\n try:\n with open(filename, \"r\") as csvfile:\n movies = []\n reader = csv.DictReader(csvfile, header)\n for row in reader:\n movie = media.Movie(row[\"title\"],\n row[\"storyline\"],\n row[\"poster_image\"],\n row[\"trailer_youtube\"])\n movies.append(movie)\n except IOError:\n print(\"\\\"{}\\\" not found. Exiting\".format(filename))\n exit()\n else:\n if not csvfile.closed:\n csvfile.close()\n return movies","def csv_dict_reader(file_obj):\r\n with open('heatmap_data_10_200_out.csv','wb') as file:\r\n\t reader = csv.DictReader(file_obj, delimiter=',')\r\n\t for line in reader:\r\n\t \t# data = \"{location: new google.maps.LatLng(\" + str(line[\"latitude\"]) + \", \" + str(line[\"longitude\"]) + \") , weight: \" + str(float(line[\"predicted_price\"])/1000) + \" }, \"\r\n\t \tdata = line[\"predicted_price\"] + \";\" + str(line[\"latitude\"]) + \"; \" + str(line[\"longitude\"]) \r\n\t \t# data = \"new google.maps.LatLng(\" + str(line[\"latitude\"]) + \", \" + str(line[\"longitude\"]) + \"),\"\r\n\t \tprint data\r\n\t # print(line[\"latitude\"]),\r\n\t # print(line[\"longitude\"])\r\n\r\n\t \r\n\t \tfile.write(data)\r\n\t \tfile.write('\\n')","def parse_csv(csv_path):\n song_list = []\n\n try:\n with open(csv_path, encoding='utf-8') as playlist:\n print(\"Parsing \" + csv_path)\n reader = csv.reader(playlist, delimiter=',')\n next(reader) # skip csv header\n for row in reader:\n song_list.append(row[2] + \" - \" + row[1])\n # todo: parse CSV, then check to see which songs already exist in current dir\n # move non-existent results to new list and return that\n except IndexError as error:\n # consider validating playlists when parsing\n # from API on web server instead\n print(str(error))\n \n return song_list"],"string":"[\n \"def read_csv_as_dicts(csv_input_file_name):\\n input_table = read_csv_as_table(csv_input_file_name, skip_first_line=False)\\n\\n # first line should contain headers\\n header = input_table[0]\\n # rest lines would contain actual data\\n data = input_table[1:]\\n\\n output = []\\n # process all lines with data\\n for input_line in data:\\n record = {}\\n for i in range(len(header)):\\n record[header[i]] = input_line[i]\\n output.append(record)\\n return output\",\n \"def read_from_csv(self, csv_file):\\n data = []\\n with codecs.open(csv_file, 'r', encoding='utf-8') as csvfile:\\n header = None\\n for i, line in enumerate(csvfile):\\n line_split = [x.strip() for x in line.split(\\\"|\\\")]\\n line_data = [x for x in line_split if len(x) > 0]\\n if i == 0:\\n header = line_data\\n else:\\n entry = {}\\n for i,datum in enumerate(line_data):\\n entry[header[i]] = datum\\n data.append(entry)\\n print \\\"Loaded %d entries from %s\\\" % (len(data), csv_file)\\n return data\",\n \"def csv2dicts(csvfile, names=None):\\n data = []\\n for row_index, row in enumerate(csvfile):\\n if row_index == 0:\\n if names:\\n keys = names\\n else:\\n keys = row\\n print(keys)\\n continue\\n data.append({key: value for key, value in zip(keys, row)})\\n return data\",\n \"def csv_dict_reader(file_path):\\r\\n with open(file_path, 'r') as file_obj:\\r\\n\\r\\n reader = csv.DictReader(file_obj, delimiter=',')\\r\\n for line in reader:\\r\\n #print(line[\\\"variable_name \\\"]),\\r\\n print(line[\\\"dataset\\\"])\",\n \"def read_file(file):\\n \\n dictionary = {}\\n csv_fp = csv.reader(file)\\n #L[46] = manufacturer, L[63] = year\\n #L[4]= city mileage, L[34]=highway mileage\\n for line in csv_fp:\\n #Skip the headings and the year 2017\\n if (not (line[46] == 'make')) and (not (line[63] == '2017')):\\n if line[46] in dictionary:\\n #Add the city and highway mileage if the year has been made\\n if line[63] in dictionary[line[46]]:\\n dictionary[line[46]][line[63]][0] += [int(line[4])]\\n dictionary[line[46]][line[63]][1] += [int(line[34])]\\n #Add the year and data if it was not made previously\\n else:\\n dictionary[line[46]][line[63]] = [[int(line[4])],\\\\\\n [int(line[34])]]\\n #Adds a new manufacturer\\n else:\\n dictionary[line[46]] = {line[63]:[[int(line[4])],\\\\\\n [int(line[34])]]}\\n return dictionary\",\n \"def _read_csv_to_dictionary_list(file_name):\\n catalog_list = []\\n with open(file_name) as csvfile:\\n reader = csv.DictReader(csvfile)\\n for item in reader:\\n catalog_list.append(item)\\n return catalog_list\",\n \"def parse_csv_input_file(input_file):\\n with open(input_file) as csvfile:\\n reader = csv.DictReader(csvfile)\\n for item in reader:\\n dict = {i: x for i, x in item.items()}\\n yield(dict)\",\n \"def csv_to_dict(filename):\\n data_list = []\\n \\n with open(filename, 'rb') as datafile:\\n data_reader = csv.DictReader(datafile, delimiter = ',')\\n for row in data_reader:\\n data_list.append(row)\\n\\n return data_list\",\n \"def csv_dict_reader(file_obj):\\n #import re\\n #file = open(file_obj)\\n\\n # reader = csv.DictReader(file_obj)\\n # for line in reader:\\n # print(line[\\\"Name\\\"])\",\n \"def dictparse(csvfilename, keyfield):\\n table = {}\\n with open(csvfilename, \\\"rt\\\", newline='') as csvfile:\\n csvreader = csv.DictReader(csvfile,\\n skipinitialspace=True)\\n for row in csvreader:\\n table[row[keyfield]] = row\\n return table\",\n \"def read_csv(path: str) -> list[dict[str, str]]:\\n with open(path, 'r') as f:\\n return list(csv.DictReader(f))\",\n \"def load_csv(file):\\n with open(file) as csvfile:\\n reader = csv.DictReader(csvfile)\\n return [dict(row) for row in reader]\",\n \"def read_list():\\n import glob\\n import csv\\n\\n slist = {}\\n csvfile = glob.glob(_path + '/*.csv').pop()\\n if csvfile is None:\\n return slist\\n _logger.info(\\\"Found file '%s'\\\" % csvfile)\\n\\n hcsv = csv.reader(open(csvfile), delimiter=';')\\n # Skip header\\n next(hcsv)\\n # Work on every line\\n for line in hcsv:\\n if len(line) < 2:\\n continue\\n # print(line)\\n slist[line[0]] = {'name': line[2], 'surname': line[1]}\\n\\n # print(slist)\\n # print(\\\"LEN\\\", len(slist))\\n # exit(1)\\n return slist\",\n \"def parse_csvfile(self, csvfile):\\n\\n logging.info(\\\"Parseing csvfile: %s\\\" % basename(csvfile))\\n fields = []\\n data = {}\\n try:\\n with open(csvfile) as f:\\n for line in f:\\n line = line.strip()\\n # Skip empty or commented line\\n if not line or line[0] == \\\"#\\\":\\n continue\\n if not fields:\\n # The first valid line defines fields.\\n fields = [x.strip() for x in line.split(\\\",\\\")]\\n for f in self.REQUIRED_FIELDS:\\n if f not in fields:\\n logging.error(\\\"Failed to find %s field. \\\"\\n \\\"Aborted.\\\" % f)\\n sys.exit(1)\\n else:\\n # The rest lines are data\\n values = [x.strip() for x in line.split(\\\",\\\")]\\n record = {}\\n for k, v in zip(fields, values):\\n record[k] = v\\n # Convert date time string to epoch seconds\\n record[\\\"time_h\\\"] = self.parse_timestr(record[\\\"time_h\\\"])\\n node = record[\\\"name\\\"]\\n if data.get(node, None):\\n data[node].append(record)\\n else:\\n data[node] = [record]\\n except Exception as e:\\n logging.exception(\\\"Failed to parsing the csvfile. \\\"\\n \\\"See stack trace below:\\\")\\n sys.exit(1)\\n\\n # While it didn't occur often, I observed that data in CSV files\\n # generated by cbtool monextrac command were not in time order.\\n # So sort them.\\n logging.debug(\\\"Sorting the data\\\")\\n for node in data.keys():\\n data[node].sort(lambda x, y: cmp(int(x[\\\"time\\\"]), int(y[\\\"time\\\"])))\\n\\n return data, fields\",\n \"def _read_csv(file_name):\\n with open(file_name) as boards:\\n rows = csv.DictReader(boards, delimiter=',', quotechar='\\\"')\\n formatted_data = []\\n for row in rows:\\n formatted_data.append(dict(row))\\n return formatted_data\",\n \"def dictparse(csvfilename, keyfield, separator, quote, quotestrategy):\\n table = {}\\n with open(csvfilename, \\\"rt\\\", newline='') as csvfile:\\n csvreader = csv.DictReader(csvfile,\\n skipinitialspace=True,\\n delimiter=separator,\\n quotechar=quote,\\n quoting=quotestrategy)\\n for row in csvreader:\\n table[row[keyfield]] = row\\n return table, csvreader.fieldnames\",\n \"def dictparse(csvfilename, keyfield, separator, quote, quotestrategy):\\n table = {}\\n with open(csvfilename, \\\"rt\\\", newline='') as csvfile:\\n csvreader = csv.DictReader(csvfile,\\n skipinitialspace=True,\\n delimiter=separator,\\n quotechar=quote,\\n quoting=quotestrategy)\\n for row in csvreader:\\n table[row[keyfield]] = row\\n return table, csvreader.fieldnames\",\n \"def parse(raw_file):\\n parsed_data = []\\n with open(raw_file, 'r') as r:\\n rows = csv.reader(r)\\n fields = rows.next()\\n counter = 0\\n for r in rows:\\n parsed_data.append(dict(zip(fields, r)))\\n\\n return parsed_data\",\n \"def read_data_from_csv(csv_file, header=None, **kwargs):\\n if os.path.isabs(csv_file) == False:\\n path_to_csv = os.path.join(csv_file)\\n else:\\n path_to_csv = csv_file\\n row_list = []\\n if \\\"field_sep\\\" not in kwargs.keys():\\n field_sep = ','\\n else:\\n field_sep = kwargs.get(\\\"field_sep\\\")\\n with open(path_to_csv, mode='r') as csv_file:\\n csv_reader = csv.DictReader(csv_file, delimiter=field_sep, fieldnames=header)\\n for record in csv_reader:\\n if list(record.values())[0].startswith(\\\"#\\\") is not True:\\n # IT'S A COMMENT IF IT STARTS WITH \\\"#\\\" \\n # IF THIS IS YOUR HEADER ROW, SUPPLY A LIST OF COLUMN NAMES WHEN CALLING THE FUNCTION\\n row_list.append(record)\\n return row_list\",\n \"def csv_dict_reader(file_obj):\\n reader = csv.DictReader(file_obj, delimiter=',')\\n for line in reader:\\n print(line[\\\"first_name\\\"]),\\n print(line[\\\"last_name\\\"])\",\n \"def parse_csv_input(input_file): # {{{\\n parsed_infile = []\\n try:\\n with open(input_file) as infile:\\n for line in csv.reader(infile):\\n parsed_infile.append(line)\\n\\n temp_object_storage = []\\n\\n for line_index, line in enumerate(parsed_infile[1:]):\\n temp_object_storage.append({})\\n for category_index, category in enumerate(parsed_infile[0]):\\n if category_index == 0:\\n category = category[3:]\\n temp_object_storage[line_index][category] = line[category_index]\\n\\n return temp_object_storage\\n except FileNotFoundError as excep:\\n LOGGER.info(\\\"error parsing csv file: %s\\\", excep) # }}}\",\n \"def read_csv_rows(path: str) -> list[dict[str, str]]:\\n file_handle = open(\\\"survey\\\", encoding=\\\"utf8\\\")\\n csv_reader = DictReader(file_handle)\\n rows: list[dict[str, str]] = []\\n for row in csv_reader:\\n rows.append(row)\\n file_handle.close()\\n return rows\",\n \"def parse(raw_file, delimiter):\\n\\t#open csv file\\n\\topened_file = open(raw_file)\\n\\t\\n\\t#read csv file\\n\\tcsv_data = csv.reader(opened_file,delimiter=delimiter)\\n\\t\\n\\t#build parsed data\\n\\tparsed_data = []\\n\\t\\n\\t#define headers\\n\\tfields = csv_data.next()\\n\\t\\n\\t#Iterate over each row of the csv file, zip together field->value pairs\\n\\tfor row in csv_data:\\n\\t\\tparsed_data.append(dict(zip(fields, row)))\\n\\t\\n\\t#close csv file\\n\\topened_file.close()\\n\\t\\n\\treturn parsed_data\",\n \"def read_csv(path):\\r\\n data = []\\r\\n csv_file = open(path)\\r\\n for row in csv.DictReader(csv_file):\\r\\n data.append(row)\\r\\n csv_file.close() \\r\\n return data\",\n \"def read_strong_csv(strong_meta_csv_path):\\n with open(strong_meta_csv_path, 'r') as fr:\\n reader = csv.reader(fr, delimiter='\\\\t')\\n lines = list(reader)\\n \\n meta_dict = {}\\n for line in lines:\\n [audio_name, begin_time, end_time, label] = line\\n meta = {'begin_time': begin_time, 'end_time': end_time, 'label': label}\\n if audio_name in meta_dict:\\n meta_dict[audio_name].append(meta)\\n else:\\n meta_dict[audio_name] = [meta]\\n \\n return meta_dict\",\n \"def csv_to_dict_list(file_path, char_sep=\\\"|\\\"):\\n with open(file_path, mode='r') as f:\\n d = [{k: v for k, v in row.items()} for row in csv.DictReader(f, skipinitialspace=True, delimiter=char_sep)]\\n return d\",\n \"def load_csv(filename):\\n # Open csvfile\\n with open(filename) as csvfile:\\n reader = csv.DictReader(csvfile)\\n\\n # Put data in gloabal list\\n for row in reader:\\n # Get data of subject with either or both milk and peanut allergy\\n if row[\\\"MILK_ALG_START\\\"] != \\\"NA\\\" or row[\\\"PEANUT_ALG_START\\\"] != \\\"NA\\\":\\n sub_list = list()\\n for key in DATA_KEYS:\\n sub_list.append(row[key])\\n\\n # Add data of subject to all data \\n data_list.append(sub_list)\",\n \"def read_risposte_from_csv(csv_risposte):\\n import os\\n try:\\n csv_in = open(os.path.join(os.path.dirname(__file__), csv_risposte), 'rb')\\n r_reader = csv.DictReader(csv_in, delimiter=',')\\n except IOError:\\n print \\\"It was impossible to open file %s\\\" % csv_risposte\\n exit(1)\\n\\n risposte_partiti = {}\\n for row in r_reader:\\n partito_id = int(row['partito_id'])\\n domanda_id = int(row['domanda_id'])\\n risposta = int(row['risposta_int'])\\n if not partito_id in risposte_partiti:\\n risposte_partiti[partito_id] = {}\\n risposte_partiti[partito_id][domanda_id] = risposta\\n\\n return risposte_partiti\",\n \"def parse_csv_file(file_path):\\n\\n complete_data_list = []\\n\\n try:\\n import_file = open(file_path, \\\"rb\\\")\\n\\n except IOError:\\n print 'An error occured trying to read the file.'\\n\\n else:\\n reader_file = csv.DictReader(import_file)\\n complete_data_list = get_file_data(reader_file)\\n import_file.close()\\n\\n return complete_data_list\",\n \"def read_dictionary(filename):\\r\\n dictionaryoutput = {}\\r\\n with open(filename) as file:\\r\\n entries = csv.reader(file)\\r\\n for item in entries:\\r\\n dictionaryoutput[item[0]] = item[1]\\r\\n return dictionaryoutput\",\n \"def read_csv(csv_file):\\r\\n with open(csv_file, \\\"r\\\") as files:\\r\\n data = csv.reader(files)\\r\\n return list(data)\",\n \"def get_dictionary_from_csv(file):\\n csv_file = file[:-4] # avoid .txt extension\\n csv_file += \\\"_dico.csv\\\"\\n dic = pd.read_csv(csv_file, delimiter=',')\\n return list(dic.columns)\",\n \"def _csv_to_dict(name):\\n csv_path = _get_csv_path(name)\\n result = []\\n with open(csv_path) as csvfile:\\n reader = csv.DictReader(csvfile)\\n for row in reader:\\n result.append(row)\\n return result\",\n \"def load_from_file_csv(cls):\\n fields = []\\n rows = []\\n new_dict = {}\\n new_list = []\\n key = \\\"\\\"\\n filename = cls.__name__ + \\\".csv\\\"\\n with open(filename) as fp:\\n reader = csv.reader(fp)\\n fields = next(reader)\\n for row in reader:\\n rows.append(row)\\n for row in rows:\\n i = 0\\n new_dict = new_dict.fromkeys(fields)\\n for attr in fields:\\n key = fields[i]\\n value = row[i]\\n new_dict[key] = value\\n i += 1\\n new_list.append(cls.create(**new_dict))\\n return new_list\",\n \"def read_csv_rows(filename: str) -> list[dict[str, str]]:\\n result: list[dict[str, str]] = []\\n \\n \\\"\\\"\\\"Open a handle to the data file.\\\"\\\"\\\"\\n file_handle = open(filename, \\\"r\\\", encoding=\\\"utf8\\\")\\n\\n \\\"\\\"\\\"Prepare to read the data in the file as CSV instead of just strings.\\\"\\\"\\\"\\n csv_reader = DictReader(file_handle)\\n\\n \\\"\\\"\\\"Read each row of the CSV line by line.\\\"\\\"\\\"\\n for row in csv_reader:\\n result.append(row)\\n\\n \\\"\\\"\\\"Close file.\\\"\\\"\\\"\\n file_handle.close()\\n\\n return result\",\n \"def csvToDict(filepath):\\n data = []\\n with open(getcwd() + filepath, 'r') as dataset:\\n assert csv.Sniffer().has_header(dataset.read(9999)), 'No headers'\\n dataset.seek(0)\\n dialect = csv.Sniffer().sniff(dataset.read(99999))\\n dataset.seek(0)\\n reader = csv.DictReader(dataset, dialect=dialect)\\n headers = reader.fieldnames\\n for row in reader:\\n data.append(row)\\n\\n data = assert_data_format(data)[0]\\n\\n return data, headers\",\n \"def parse_trick_ascii(csv_file):\\n data_file = csv.DictReader(open(csv_file))\\n single_run_data_dict = {'altitude' : [0.0],\\n 'latitude' : [0.0],\\n 'longitude' : [0.0]}\\n # Your code here\\n # ...\\n # return the dict\\n return single_run_data_dict\",\n \"def read_csv(filename, delimiter=','):\\n data = []\\n try:\\n with open(filename, 'r') as csvfile:\\n reader = csv.DictReader(csvfile, delimiter=delimiter)\\n try:\\n keys = reader.fieldnames\\n for row in reader:\\n data.append(row)\\n except csv.Error as e:\\n sys.exit('file %s, line %d: %s' % (filename, reader.line_num, e))\\n except IOError as e:\\n sys.exit('%s does not exist' % e) \\n return data\",\n \"def main3():\\r\\n #open the file\\r\\n with open('csvfile1.csv', 'r') as csvfile1:\\r\\n #use DictReader method from csv module\\r\\n csv_reader = csv.DictReader(csvfile1)\\r\\n #read the lines\\r\\n for line in csv_reader:\\r\\n print(line['email'])\",\n \"def read_csv(csv_file):\\r\\n reader = csv.DictReader(csv_file)\\r\\n if 'PERSON_ID' in reader.fieldnames:\\r\\n key = 'PERSON_ID'\\r\\n elif 'LogonName' in reader.fieldnames:\\r\\n key = 'LogonName'\\r\\n else:\\r\\n raise 'no username field specified in the file'\\r\\n user_list = []\\r\\n for item in reader:\\r\\n try:\\r\\n uid = item[key]\\r\\n assert uid\\r\\n user_list.append(uid)\\r\\n except:\\r\\n warning('empty username')\\r\\n if not user_list:\\r\\n raise 'empty list of users'\\r\\n return user_list\",\n \"def load_data(filepath):\\n with open(filepath) as csvfile:\\n reader = csv.DictReader(csvfile)\\n for row in reader:\\n yield row\",\n \"def load_data_from_csv(csv_file, users_to_i = {}, items_to_i = {}):\\n raw_data = []\\n with open(csv_file) as f:\\n csvreader = csv.reader(f)\\n # skipping first row (header)\\n next(csvreader)\\n for user, item in csvreader:\\n raw_data.append((user, item))\\n return load_data_from_array(raw_data, users_to_i, items_to_i)\",\n \"def get_csv_data(file_name: str) -> Iterator[list]:\\n with open(file_name) as f:\\n # creating a reader instance that can iterate over rows of file.\\n reader = DictReader(f)\\n\\n # iterating over rows:\\n for row in reader:\\n yield dict(row) # returning the dicts for each row in the dataset.\",\n \"def creating_dict_from_csv(self) -> dict:\\n dictionary = {}\\n for row in self.__read_csv():\\n if dictionary.get(row[0]):\\n dictionary[row[0]].append((row[1], row[2]))\\n else:\\n dictionary[row[0]] = [(row[1], row[2])]\\n\\n for key, value in dictionary.items():\\n dictionary[key] = sorted(value, key=lambda x: x[1], reverse=True)\\n\\n return dictionary\",\n \"def save_csv_into_dictionary(csv_file):\\n\\n dictionary = OrderedDict()\\n with open(csv_file, newline='') as file:\\n reader = csv.reader(file)\\n for row in reader:\\n dictionary[row[0]] = row[1]\\n return dictionary\",\n \"def csv_to_dict(filename):\\n\\twith open(filename, 'r') as in_hndl:\\n\\t\\tindict = [i for i in csv.DictReader(in_hndl)]\\n\\treturn indict[0]\",\n \"def load_csv(input):\\n with open(input['csv'], 'r', encoding=input['encoding']) as f:\\n invoice_dict = dict()\\n reader = csv.reader(f, delimiter=';')\\n\\n for row in reader:\\n invoice_id = row[0]\\n\\n if invoice_id in invoice_dict:\\n invoice_dict[invoice_id].add_entry(row[1:])\\n else:\\n invoice_dict[invoice_id] = Invoice(row)\\n\\n return invoice_dict\",\n \"def read_csv():\",\n \"def readcsv(csvfile):\\n logger = log.getLogger('obslog.readcsv')\\n\\n if not os.path.exists(csvfile):\\n logger.error('Cannot access %s', csvfile)\\n raise SystemExit\\n\\n data = {}\\n with open(csvfile, mode='r') as csv_file:\\n reader = csv.DictReader(csv_file)\\n for row in reader:\\n data[row['FITSFILE']] = row\\n logger.debug('Data: %s', data)\\n return data\",\n \"def read_file(filename):\\n with open(filename) as fp:\\n reader = csv.DictReader(fp)\\n return list(reader)\",\n \"def csv_to_dict(csvfile, delimiter=\\\",\\\", quotechar='\\\"'):\\n reader = csv.DictReader(csvfile, delimiter=delimiter, quotechar=quotechar)\\n\\n data = {each: [] for each in reader.fieldnames}\\n for i, row in enumerate(reader):\\n for key, value in row.items():\\n data[key].append(value)\\n return data\",\n \"def read_name_map( name_map_path) :\\n with open( name_map_path, newline=\\\"\\\") as csvfile:\\n table = { }\\n reader = csv.reader(csvfile)\\n for row in reader:\\n if len(row) < 2:\\n continue\\n if row[key_col] == key_header:\\n continue\\n key = row[key_col]\\n val = row[val_col]\\n table[key] = val\\n return table\",\n \"def parse(raw_file, delimiter):\\n\\n opened_file = open(raw_file, 'rU')\\n csv_data = csv.reader(opened_file, delimiter=delimiter)\\n\\n parsed_data = []\\n\\n fields = csv_data.next()\\n\\n for row in csv_data:\\n parsed_data.append(dict(zip(fields,row)))\\n\\n opened_file.close()\\n\\n return parsed_data\",\n \"def csv2dict(filename):\\n dis_dict = {}\\n with open(filename) as csvfile:\\n reader = csv.DictReader(csvfile)\\n for row in reader:\\n el_a = row[\\\"Element Name\\\"]\\n dis_dict[el_a] = {}\\n for entry in row:\\n if entry != \\\"Element Name\\\":\\n dis_dict[el_a][entry] = float(row[entry])\\n csvfile.close()\\n return dis_dict\",\n \"def get_rows(csv):\\n\\n labels = csv[0][2:].split(',')\\n\\n # Convert each row into a hash of label: value\\n return [dict(zip(labels, row.split(','))) for row in csv[1:]]\",\n \"def parse(file, delimiter):\\n\\n\\t# Open CSV\\n\\topened_file = open(file)\\n\\n\\t# Read CSV\\n\\tdata = csv.reader(opened_file, delimiter=delimiter)\\n\\n\\t# Build data structure\\n\\tparsed_data = []\\n\\tfields = next(data)\\n\\tfor row in data:\\n\\t\\tparsed_data.append(dict(zip(fields, row)))\\n\\n\\t# Close CSV\\n\\topened_file.close()\\n\\n\\treturn parsed_data\",\n \"def read_file(filename):\\n\\n data = {}\\n with open(filename, encoding=\\\"utf8\\\") as file:\\n reader = csv.DictReader(file)\\n for line in reader:\\n data[line['id']] = line\\n return data\",\n \"def read_csv(csv_file_path):\\n res = [] #list\\n # f = open(csv_file_path) #read file\\n with open(csv_file_path,\\\"r\\\") as f:\",\n \"def _process_csv_data(csv_file, user_data_map):\\n with open(csv_file, 'r') as csvfile:\\n rows = csv.reader(csvfile)\\n for row in rows:\\n if len(row) < 2:\\n print('The CSV file is not in expected format.')\\n raise Exception\\n user_data_map[row[1].lower()] = row[0]\",\n \"def make_json(csvfile):\\n\\n data = []\\n with open(csvfile, encoding='utf-8') as csvf:\\n csvreader = csv.DictReader(csvf)\\n for rows in csvreader:\\n data.append(rows)\\n\\n return data\",\n \"def parse(csvfilename):\\n table = []\\n with open(csvfilename, \\\"r\\\") as csvfile:\\n for line in csvfile:\\n line = line.rstrip()\\n columns = line.split(',')\\n table.append(columns)\\n return table\",\n \"def read_names_into_dict():\\n d = dict()\\n with open(\\\"SP_500_firms.csv\\\") as csvfile:\\n input_file = csv.DictReader(csvfile)\\n for row in input_file:\\n #print(row)\\n d[row['Symbol']] = [row['Name'],row['Sector']]\\n return d\",\n \"def read_from_csvfile(fname, types, header=True):\\n num_columns = len(types)\\n parsed = []\\n with open(fname) as f:\\n reader = csv.reader(f)\\n if header:\\n columns = next(reader)\\n else:\\n columns = ['col '+str(i) for i in range(num_columns)]\\n\\n for row in reader:\\n parsed.append([types[i](row[i]) if row[i] else None for i in range(num_columns)])\\n\\n return [{k:v for k,v in zip(columns, row)} for row in parsed]\",\n \"def read_csv_file(in_file):\\n out_list = []\\n with open(in_file, 'r', newline='') as p_file:\\n file_list = csv.DictReader(p_file, delimiter=',')\\n for row in file_list:\\n out_list.append(row)\\n return out_list\\n #thequeue.put(out_list)\",\n \"def load_data(filename='KSI.csv'):\\r\\n d = []\\r\\n with open(filename) as csv_file:\\r\\n # csv_reader = csv.reader(csv_file, delimiter=',')\\r\\n csv_reader = csv.DictReader(csv_file, delimiter=',')\\r\\n for line_count, row in enumerate(csv_reader):\\r\\n if line_count == 0:\\r\\n print(f'Column names are \\\\n{\\\", \\\".join(row)}')\\r\\n # column_names = row\\r\\n else:\\r\\n d.append(row)\\r\\n # print(f'Processed {line_count} lines.')\\r\\n return d\",\n \"def parse_csv_from_file(file):\\n csvFileReader = None\\n employee_data = []\\n\\n # if FileStorage object (which has a save() method)\\n if hasattr(file, 'save'):\\n csvFileReader = csv.reader(codecs.iterdecode(file, 'utf-8'))\\n # else if File object (which does not have a save() method)\\n else:\\n csvFileReader = csv.reader(file)\\n\\n for row in csvFileReader:\\n employee_data.append({\\n 'first_name': row[0],\\n 'last_name': row[1],\\n 'annual_salary': int(row[2]),\\n 'super_rate': convert_to_float(row[3]),\\n 'payment_period': row[4]\\n })\\n\\n return employee_data\",\n \"def csv_dict_reader(file_obj, data = [], cost = []):\\n reader = csv.DictReader(file_obj, delimiter=',')\\n for line in reader:\\n data.append(line[\\\"Дата\\\"]),\\n cost.append(line[\\\"Расход\\\"])\",\n \"def read_tags(csv_path):\\n tags = {}\\n with open(csv_path, 'r') as csv_file:\\n reader = csv.DictReader(csv_file)\\n for row in reader:\\n tags[row['image_name']] = row['tags'].split()\\n return tags\",\n \"def load_data_from_csv(csv_file):\\n list=[]\\n\\n with open(csv_file) as csv_1:\\n csv_out = csv.reader(csv_1) \\n next(csv_out)\\n for rows in csv_out: \\n if len(rows) != 0:\\n list.append([rows[0],int(rows[1]),int(rows[2])])\\n \\n return (list)\",\n \"def get_data_from_csv(csv_file):\\n # create customer list form csv file\\n with open(csv_file, encoding='utf-8', errors='ignore') as people:\\n customer_reader = csv.reader(people)\\n customers = [row for row in customer_reader]\\n\\n return customers\",\n \"def read_csv(path):\\r\\n output = []\\r\\n for row in csv.DictReader(open(path)):\\r\\n output.append(row)\\r\\n return output\",\n \"def load_csv(path: Path) -> Any:\\n with open(path, newline='') as csvfile:\\n reader = csv.DictReader(csvfile)\\n items = list(reader)\\n return items\",\n \"def read_csv(path):\\n output = []\\n for row in csv.DictReader(open(path)):\\n output.append(row)\\n return output\",\n \"def read_csv_file(csv_file_path):\\n file_names = []\\n file_labels = []\\n with open(csv_file_path, 'r') as files_path:\\n path_list = csv.DictReader(files_path)\\n fieldnames = path_list.fieldnames\\n for path in path_list:\\n file_names.append(path[fieldnames[0]])\\n file_labels.append(path[fieldnames[1]])\\n return file_names, file_labels\",\n \"def process_csv(csv_file=None):\\n if csv_file:\\n _process_csv_data(csv_file, USER_DATA_MAP)\\n else:\\n csv_files_list = [os.path.join(DATA_DIR, f) for f in os.listdir(DATA_DIR) if f.endswith('.csv')]\\n for fl in csv_files_list:\\n _process_csv_data(fl, USER_DATA_MAP)\\n return USER_DATA_MAP\",\n \"def dictionary_formation():\\r\\n sales_data = {}\\r\\n with open('beer_data.csv', \\\"r\\\") as data_file:\\r\\n file_contents = csv.reader(data_file, delimiter=',')\\r\\n #Value of lines_read used as key value for each dictionary\\r\\n #in sales_data\\r\\n lines_read = 1\\r\\n for line in file_contents:\\r\\n if lines_read == 1:\\r\\n lines_read = lines_read + 1\\r\\n else:\\r\\n #Stores each column in row as key value in dictionary\\r\\n sales_data[str(lines_read)] = {\\r\\n \\\"invoice_number\\\": line[0],\\r\\n \\\"customer\\\": line[1],\\r\\n \\\"date_required\\\": line[2],\\r\\n \\\"recipe\\\": line[3],\\r\\n \\\"gyle_number\\\": line[4],\\r\\n \\\"quantity_ordered\\\": int(line[5])\\r\\n }\\r\\n lines_read = lines_read + 1\\r\\n data_file.close()\\r\\n return sales_data\",\n \"def load(filename):\\n with open(filename,'r') as fd:\\n csv_in = csv.reader(fd, delimiter=',', quotechar='\\\"')\\n keys = csv_in.next()\\n data = {k:[] for k in keys}\\n for row in csv_in:\\n for k,v in zip(keys,row):\\n data[k].append(float(v))\\n return data\",\n \"def parse_prefeaturized_csv_data(features_file_path):\\n objects = []\\n with open(features_file_path) as f:\\n # First line contains column titles\\n keys = f.readline().strip().split(',')\\n for line in f:\\n vals = line.strip().split(\\\",\\\")\\n if len(vals) != len(keys):\\n continue\\n else:\\n objects.append({})\\n for i in range(len(keys)):\\n objects[-1][keys[i]] = vals[i]\\n return objects\",\n \"def read_sailor_data(filename):\\n\\td=OrderedDict()\\n\\twith open(filename) as csvfile:\\n\\t\\trdr = csv.reader(csvfile)\\t\\n\\t\\tfor i in rdr:\\n\\t\\t\\t#This except is so that if the line trying to be inputted into the dictionary is a string\\n\\t\\t\\t#It will ignore it and go to the next line\\n\\t\\t\\ttry: d[i[0]]=(float(i[1]),float(i[2]))\\n\\t\\t\\texcept: None\\n\\treturn d\",\n \"def load_csv(filepath):\\n log.debug('Loading csv')\\n with open(filepath) as csvfile:\\n reader = csv.DictReader(csvfile)\\n return reader.fieldnames, list(reader)\",\n \"def load_csv_to_dict(filename):\\n row_len = list()\\n result = dict()\\n with open(filename, 'r') as csvfile:\\n reader = csv.reader(csvfile)\\n for row in reader:\\n key = row[0].strip()\\n values = [v.strip() for v in row[1:]]\\n result[key] = values\\n row_len.append(len(values))\\n return result, max(row_len)\",\n \"def load_csv(filename):\\n results = defaultdict(list)\\n with open(filename, 'r') as f:\\n reader = csv.DictReader(f)\\n for line in reader:\\n results[line['sid']].append(line)\\n return results\",\n \"def readCSV(filename, separator):\\n \\n filetoread = open(filename, \\\"r\\\")\\n lines = []\\n for line in filetoread:\\n line = line.replace(\\\"\\\\n\\\", \\\"\\\").split(separator)\\n lines.append(line)\\n keys, values = lines[0], lines[1]\\n dictionary = {}\\n for i in range(0,len(keys)):\\n try:\\n dictionary[keys[i]] = int(values[i])\\n except:\\n dictionary[keys[i]] = values[i]\\n return dictionary\",\n \"def read_csv(filename):\\n with open(filename, 'rb') as f:\\n reader = unicodecsv.DictReader(f)\\n return list(reader)\",\n \"def populate_table_from_csv(csv_file, csv_encoding='iso-8859-15'):\\n try:\\n with open(file=csv_file, mode='r', encoding=csv_encoding) as input_file:\\n # Could find a good place to add iterators/generators/comprehensions elsewhere, so made a new function\\n # Also, yet another pylint false positive. The below line isn't supposed to be assigned to anything.\\n [add_customer(*l.split(',')) for l in input_file if 'Id,Name,Last_name,' not in l] # pylint: disable=W0106\\n except Exception as e:\\n logger.error(\\\"Failed to load records from csv file %s into database %s: %s\\\", csv_file, customer_db.database, e)\",\n \"def read_data(options):\\n reader = csv.reader(open(options.datafile, \\\"U\\\"))\\n raw_rows = list(reader)\\n fieldnames = raw_rows[0]\\n rows = []\\n for raw_row in raw_rows[1:]:\\n row = {}\\n try:\\n for i in range(len(fieldnames)):\\n row[fieldnames[i]] = raw_row[i]\\n rows.append(row)\\n except IndexError:\\n print \\\"SHORT ROW:\\\", raw_row\\n print \\\"Read %d rows\\\" % len(rows)\\n return rows\",\n \"def parse_csv(csv_file):\\n if os.path.isfile(csv_file) == True:\\n num_lines = sum(1 for line in open(csv_file))\\n if num_lines > 1:\\n try:\\n data = pd.read_csv(csv_file, index_col=False)\\n data.insert(0, 'id', range(1, 1 + len(data)))\\n return(data)\\n except pd.parser.CParserError, err:\\n message = \\\"Can't parse REDCap data. Check CSV file: \\\" + csv_file\\n print(message)\\n logging.critical(message)\\n exit(3)\\n else:\\n message = \\\"CSV file does not contain data: \\\" + csv_file\\n print(message)\\n logging.warning(message)\\n return(None)\\n else:\\n message = \\\"Can't read CSV file: \\\" + csv_file\\n print(message)\\n logging.critical(message)\\n exit(4)\",\n \"def load_csv(file):\\n import csv\\n reader = csv.reader(open(file, 'r'))\\n columns = reader.next()\\n c2i = dict((columns[i], i) for i in range(len(columns)))\\n data = {}\\n excluded = set([REP_CSV_HED_TIM, REP_CSV_HED_HER])\\n for row in reader:\\n \\n # get relevant info from the line\\n time = float(row[c2i[REP_CSV_HED_TIM]])\\n hero = row[c2i[REP_CSV_HED_HER]]\\n other = dict((c, REP_CSV_HANDLERS.get(c, REP_CSV_DEFHANDLER)(row[c2i[c]])) for c in columns if c not in excluded)\\n \\n # add to the data dictionary\\n if hero not in data: data[hero] = []\\n data[hero].append([time] + [other])\\n \\n return data\",\n \"def read_csv(filename):\\n\\twith open(filename, newline = '') as filehandle:\\n\\t\\t\\n\\t\\t# create DictReader objects for inputs and read into memory\\n\\t\\treader = csv.DictReader(filehandle, delimiter = '\\\\t')\\n\\t\\tdata = []\\n\\t\\tfor row in reader:\\n\\t\\t\\tdata.append(row)\\n\\t\\t\\t\\n\\treturn data\",\n \"def _convert_csv_column_to_dict(csv_data, column):\\n results = dict()\\n\\n for row in csv_data:\\n key = row[0]\\n data = row[1:][column]\\n\\n if data:\\n if key not in results:\\n results[key] = data.strip() if data else \\\"\\\"\\n else:\\n # append multiple choice questions\\n results[key] += \\\"|{0}\\\".format(data.strip())\\n\\n return results\",\n \"def csvfileUsage(self):\\n with open(self.csv_path, \\\"rb+\\\") as file_obj:\\n reader = csv.DictReader(file_obj, delimiter=',') # CSV DictReader object\\n \\\"\\\"\\\" reader.fieldnames returns header , slicing intial 'Month' and\\n 'Year' header from list\\n \\\"\\\"\\\"\\n for com_names in reader.fieldnames[2:]:\\n self.company_data[com_names] = {}\\n # iterating each row\\n for row in reader:\\n month, year = self.parse_my(row) # parsing the year and month from row\\n # pop the `Month` and `Year` Key to minimize iteration below\\n row.pop('Month'), row.pop('Year')\\n \\\"\\\"\\\" saving and updating the data at same point of time\\n each iteration time, checking the max value and updating \\n `Month` `Year` and `Value`\\n \\\"\\\"\\\"\\n self.prepare_company_data(month, year, row, self.company_data)\\n file_obj.close() # close file\\n return self.company_data\",\n \"def read_file(filepath: str) -> dict:\\n if not filepath.endswith(\\\".csv\\\"):\\n raise RuntimeError(\\\"File extension must be .csv\\\")\\n\\n people = {}\\n with open(filepath) as csv:\\n for line in csv:\\n email, person = Parser.parse_line(line.rstrip(\\\"\\\\n\\\"))\\n if email not in people:\\n people[email] = person\\n else:\\n print(\\\"Ignoring person with duplicate email {}\\\".format(email))\\n return people\",\n \"def get_field_list(filename):\\n with open(filename) as csvfile:\\n reader = csv.reader(csvfile, delimiter=',', quotechar='|')\\n field_mapping = {}\\n for row in reader:\\n field_mapping[row[0]] = row[1]\\n return field_mapping\",\n \"def read(path):\\n \\n file = open(path, 'r', encoding = 'utf-8')\\n reader = csv.reader(file, delimiter = '\\\\t', quotechar = '', quoting = csv.QUOTE_NONE)\\n result = []\\n header = reader.__next__()\\n for values in reader:\\n entry = {}\\n for i in range(len(header)):\\n entry[header[i]] = values[i]\\n result.append(entry)\\n file.close()\\n return result\",\n \"def read_csv_file(file, delimiter=None):\\n if delimiter is None: # try delimiters ; and ,\\n delimiter = [';', ',']\\n else:\\n delimiter = [delimiter]\\n\\n for delim in delimiter:\\n with open(file, encoding=\\\"utf8\\\") as fh:\\n rd = csv.DictReader(fh, delimiter=delim)\\n runs = [dict(row) for row in rd]\\n if len(runs[0].keys()) > 1:\\n logging.debug('Read csv data:')\\n logging.debug(runs)\\n return runs\",\n \"def load_data(filename):\\n data = dict()\\n with open(filename) as f:\\n reader = csv.DictReader(f)\\n for row in reader:\\n name = row[\\\"name\\\"]\\n data[name] = {\\n \\\"name\\\": name,\\n \\\"mother\\\": row[\\\"mother\\\"] or None,\\n \\\"father\\\": row[\\\"father\\\"] or None,\\n \\\"trait\\\": (True if row[\\\"trait\\\"] == \\\"1\\\" else\\n False if row[\\\"trait\\\"] == \\\"0\\\" else None)\\n }\\n return data\",\n \"def load_csv(csvpath):\\n with open(csvpath, \\\"r\\\") as csvfile:\\n data = []\\n csvreader = csv.reader(csvfile, delimiter=\\\",\\\")\\n\\n # Skip the CSV Header\\n next(csvreader)\\n\\n # Read the CSV data\\n for row in csvreader:\\n data.append(row)\\n return data\",\n \"def read_movies_from_csv(filename, header):\\n try:\\n with open(filename, \\\"r\\\") as csvfile:\\n movies = []\\n reader = csv.DictReader(csvfile, header)\\n for row in reader:\\n movie = media.Movie(row[\\\"title\\\"],\\n row[\\\"storyline\\\"],\\n row[\\\"poster_image\\\"],\\n row[\\\"trailer_youtube\\\"])\\n movies.append(movie)\\n except IOError:\\n print(\\\"\\\\\\\"{}\\\\\\\" not found. Exiting\\\".format(filename))\\n exit()\\n else:\\n if not csvfile.closed:\\n csvfile.close()\\n return movies\",\n \"def csv_dict_reader(file_obj):\\r\\n with open('heatmap_data_10_200_out.csv','wb') as file:\\r\\n\\t reader = csv.DictReader(file_obj, delimiter=',')\\r\\n\\t for line in reader:\\r\\n\\t \\t# data = \\\"{location: new google.maps.LatLng(\\\" + str(line[\\\"latitude\\\"]) + \\\", \\\" + str(line[\\\"longitude\\\"]) + \\\") , weight: \\\" + str(float(line[\\\"predicted_price\\\"])/1000) + \\\" }, \\\"\\r\\n\\t \\tdata = line[\\\"predicted_price\\\"] + \\\";\\\" + str(line[\\\"latitude\\\"]) + \\\"; \\\" + str(line[\\\"longitude\\\"]) \\r\\n\\t \\t# data = \\\"new google.maps.LatLng(\\\" + str(line[\\\"latitude\\\"]) + \\\", \\\" + str(line[\\\"longitude\\\"]) + \\\"),\\\"\\r\\n\\t \\tprint data\\r\\n\\t # print(line[\\\"latitude\\\"]),\\r\\n\\t # print(line[\\\"longitude\\\"])\\r\\n\\r\\n\\t \\r\\n\\t \\tfile.write(data)\\r\\n\\t \\tfile.write('\\\\n')\",\n \"def parse_csv(csv_path):\\n song_list = []\\n\\n try:\\n with open(csv_path, encoding='utf-8') as playlist:\\n print(\\\"Parsing \\\" + csv_path)\\n reader = csv.reader(playlist, delimiter=',')\\n next(reader) # skip csv header\\n for row in reader:\\n song_list.append(row[2] + \\\" - \\\" + row[1])\\n # todo: parse CSV, then check to see which songs already exist in current dir\\n # move non-existent results to new list and return that\\n except IndexError as error:\\n # consider validating playlists when parsing\\n # from API on web server instead\\n print(str(error))\\n \\n return song_list\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7621891","0.7575346","0.74887645","0.7393947","0.7317759","0.73076624","0.7262524","0.72616434","0.71987087","0.71802855","0.71753365","0.7114956","0.7059726","0.70039433","0.6988675","0.6970228","0.6970228","0.6946911","0.694326","0.6926613","0.690651","0.689248","0.6891468","0.68752813","0.68582946","0.6845266","0.682375","0.680928","0.68076706","0.6799992","0.6798913","0.6792443","0.67892015","0.67817336","0.67814535","0.67610663","0.6760703","0.6754578","0.6748893","0.6739559","0.6733602","0.6727984","0.67212546","0.67172897","0.6715123","0.67090803","0.6677984","0.6676487","0.6668265","0.66385156","0.66217774","0.66193056","0.6617197","0.6610454","0.6607548","0.6586532","0.6567929","0.65585387","0.6542254","0.65390015","0.6530461","0.6529214","0.6516734","0.6508187","0.65004575","0.64837337","0.6477936","0.6477437","0.647474","0.64746004","0.6468874","0.64616925","0.6459871","0.6440052","0.64377576","0.64360845","0.64360154","0.6420435","0.6412988","0.63936245","0.63892347","0.6389114","0.63858503","0.638074","0.6377633","0.6368581","0.63598144","0.6359184","0.635599","0.6355695","0.6348888","0.6347076","0.6326281","0.6316668","0.630983","0.63057953","0.63043934","0.62968916","0.6295421","0.62950504"],"string":"[\n \"0.7621891\",\n \"0.7575346\",\n \"0.74887645\",\n \"0.7393947\",\n \"0.7317759\",\n \"0.73076624\",\n \"0.7262524\",\n \"0.72616434\",\n \"0.71987087\",\n \"0.71802855\",\n \"0.71753365\",\n \"0.7114956\",\n \"0.7059726\",\n \"0.70039433\",\n \"0.6988675\",\n \"0.6970228\",\n \"0.6970228\",\n \"0.6946911\",\n \"0.694326\",\n \"0.6926613\",\n \"0.690651\",\n \"0.689248\",\n \"0.6891468\",\n \"0.68752813\",\n \"0.68582946\",\n \"0.6845266\",\n \"0.682375\",\n \"0.680928\",\n \"0.68076706\",\n \"0.6799992\",\n \"0.6798913\",\n \"0.6792443\",\n \"0.67892015\",\n \"0.67817336\",\n \"0.67814535\",\n \"0.67610663\",\n \"0.6760703\",\n \"0.6754578\",\n \"0.6748893\",\n \"0.6739559\",\n \"0.6733602\",\n \"0.6727984\",\n \"0.67212546\",\n \"0.67172897\",\n \"0.6715123\",\n \"0.67090803\",\n \"0.6677984\",\n \"0.6676487\",\n \"0.6668265\",\n \"0.66385156\",\n \"0.66217774\",\n \"0.66193056\",\n \"0.6617197\",\n \"0.6610454\",\n \"0.6607548\",\n \"0.6586532\",\n \"0.6567929\",\n \"0.65585387\",\n \"0.6542254\",\n \"0.65390015\",\n \"0.6530461\",\n \"0.6529214\",\n \"0.6516734\",\n \"0.6508187\",\n \"0.65004575\",\n \"0.64837337\",\n \"0.6477936\",\n \"0.6477437\",\n \"0.647474\",\n \"0.64746004\",\n \"0.6468874\",\n \"0.64616925\",\n \"0.6459871\",\n \"0.6440052\",\n \"0.64377576\",\n \"0.64360845\",\n \"0.64360154\",\n \"0.6420435\",\n \"0.6412988\",\n \"0.63936245\",\n \"0.63892347\",\n \"0.6389114\",\n \"0.63858503\",\n \"0.638074\",\n \"0.6377633\",\n \"0.6368581\",\n \"0.63598144\",\n \"0.6359184\",\n \"0.635599\",\n \"0.6355695\",\n \"0.6348888\",\n \"0.6347076\",\n \"0.6326281\",\n \"0.6316668\",\n \"0.630983\",\n \"0.63057953\",\n \"0.63043934\",\n \"0.62968916\",\n \"0.6295421\",\n \"0.62950504\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67380226"},"document_rank":{"kind":"string","value":"40"}}},{"rowIdx":3294,"cells":{"query":{"kind":"string","value":"This function takes any , converts it into a string via the str() function (if possible), and then writes it to a file located at . Note that this function is a general writing function. It should not use the .csv module, but rather the python write() function. This is because we want this function to write ANYTHING we give it as the parameter (in the case of this assignement, you will actually use it to write string representations of the class instances you create)."},"document":{"kind":"string","value":"def write_to_file(filepath, data):\n\n with open(filepath, 'w') as f:\n f.write(str(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 writeToCSV(self, filepath):\r\n\t\twith open(filepath, 'w') as outputFile:\r\n\t\t\toutputFile.write(str(self))","def export_to_file(data, filename='class_data.txt', mode='a'):\n with open (filename, mode) as f:\n if mode == \"w\":\n for record in data:\n line = \",\".join(record)\n f.write(line + \"\\n\")\n elif mode == \"a\":\n line = \",\".join(data)\n f.write(line + \"\\n\")\n else:\n raise ValueError('Wrong write mode')","def writeToFile(self, output):\n f = open(output, 'w')\n data = [self.columns, self.chars, self.pwdLength, self.func.__name__]\n data = [str(x) for x in data]\n f.write(\" \".join(data))\n f.write(\"\\n\")\n f.write(repr(self))\n f.close()","def CSVWriter (iterable, outLoc, header=\"\", ):\n if not iterable:\n print (\"nothing to write\")\n return 0\n\n out = open(outLoc, 'w')\n\n if header:\n out.write(header+'\\n')\n\n #Only works if iterable is a nested list\n for member in iterable:\n for item in member:\n out.write(str(item)+',')\n out.write('\\n')\n\n print(\"write to \"+outLoc+\" successful.\")\n return 1","def create_writer():\n # python 2 and 3 handle writing files differently\n if sys.version_info[0] <= 2:\n output = io.BytesIO()\n else:\n output = io.StringIO()\n writer = csv.writer(output)\n return writer, output","def write(self, str: str, /) -> None:","def writeCSV(filename, separator, data):\n \n filetowrite = open(filename, \"w\")\n values = []\n i = 0 #Count the number of objects already written\n for item in data:\n filetowrite.write(item)\n i += 1\n if i < len(data.keys()):\n filetowrite.write(separator)\n values.append(data[item])\n filetowrite.write(\"\\n\")\n i = 0\n for value in values:\n filetowrite.write(str(value))\n i += 1\n if i < len(values):\n filetowrite.write(separator)\n \n filetowrite.close()","def save_data(self, data, weight_class, output_path=None):\n if not output_path:\n output_path = self.output_path\n if not os.path.exists(output_path):\n os.makedirs(output_path)\n \n print(\"saving data for \" + weight_class)\n data.to_csv(output_path + weight_class + \".txt\", sep=\"|\", index=False)","def write_to_file(self, filename: str) -> None:","def _simple_write(filename, obj, fmt=None):\n string = str(obj) if fmt is None else ('{' + fmt + '}').format(obj)\n with open(filename, 'w+') as file:\n file.write(string)","def test_to_file(self):\n with TemporaryDirectory() as tmp:\n df_test = make_simple_dataframe()\n Base = BaseDataClass.from_object(df_test)\n fp_save = os.path.join(tmp, \"test_save.csv\")\n Base.to_file(fp_save)\n assert os.path.exists(fp_save)","def export_to_file(self, fp, *args, **kwargs):\n with open(fp, 'w') as fh:\n self._to_str(fh)","def save(self, path, separator=\",\", encoder=lambda j,v: v):\n # csv.writer will handle str, int, float and bool:\n s = StringIO()\n w = csv.writer(s, delimiter=separator)\n w.writerows([[encode_utf8(encoder(j,v)) for j,v in enumerate(row)] for row in self])\n f = open(path, \"wb\")\n f.write(BOM_UTF8)\n f.write(s.getvalue())\n f.close()","def csv_writer(data, path):\n\n with open(path, \"a\") as csv_file:\n\n writer = csv.writer(csv_file,delimiter=',')\n\n \n\n writer.writerow(data)","def csvWriter(data, out_file):\n print '[+] Writing CSV output.'\n logging.info('Writing CSV to ' + out_file + '.')\n headers = ['ID', 'Name', 'Path', 'Session ID', 'Count', 'Last Used Date (UTC)', 'Focus Time (ms)', 'Focus Count']\n\n with open(out_file, 'wb') as csvfile:\n writer = csv.DictWriter(csvfile, fieldnames=headers, extrasaction='ignore')\n # Writes the header from list supplied to fieldnames keyword argument\n writer.writeheader()\n\n for i, dictionary in enumerate(data):\n # Insert the 'ID' value to each dictionary in the list. Add 1 to start ID at 1 instead of 0.\n dictionary['ID'] = i + 1\n # Convert the FILETIME object in the fourth index to human readable value\n dictionary['Last Used Date (UTC)'] = fileTime(dictionary['Last Used Date (UTC)'])\n writer.writerow(dictionary)\n\n csvfile.flush()\n csvfile.close()\n msg = 'Completed writing CSV file. Program exiting successfully.'\n print '[*]', msg\n logging.info(msg)","def write_to_file(data, method, delimiter):\r\n output_file = 'data.csv'\r\n with open(output_file, method, newline='', encoding='utf-8') as file:\r\n writer = csv.writer(file, delimiter=delimiter)\r\n writer.writerows([data])","def save_data(csv_text, file_name=None, station_id=None, period=None,\n debug=False):\n if file_name is None and station_id is not None:\n if period is None:\n period = \"000000-000000\"\n file_name = f\"jma-{station_id}-{period}.csv\"\n elif file_name is None:\n raise ValueError(\n \"ERROR: both file_name and station_id are not specified.\")\n if debug:\n print(\"saved:\", file_name)\n with open(file_name, \"w\") as fd:\n fd.write(csv_text)","def writeFile( str_, *args ):\n filePath = path.join( *args )\n with open( filePath, 'w' ) as fd:\n fd.write(str_)","def writeToFile(self):\n self.dto.writeToCsv()\n print(\"File written.\")","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 to_csv_file_obj(self, rows):\n output = StringIO.StringIO()\n writer = csv.writer(output)\n writer.writerows(rows)\n return output","def csv_writer(data, path):\n\twith open(path, \"wb\") as csv_file:\n\t\twriter= csv.writer(csv_file, delimiter=',')\n\t\twriter.writerows(data)","def save_to_file_csv(cls, list_objs):\n list_dictionaries = []\n if list_objs is None or list_objs == []:\n string_dictionary = \"[]\"\n else:\n for _obj_dict in list_objs:\n list_dictionaries.append(_obj_dict.to_dictionary())\n string_dictionary = Base.to_json_string(list_dictionaries)\n with open(cls.__name__ + \".csv\", \"w\") as _file:\n _file.write(string_dictionary)\n _file.close()","def write_csv(data, arg2, arg3):\n\n with open(\"data.csv\", newline='') as csvfile:\n # csv writer object\n writer = csv.writer(csvfile)\n\n # to write to file: writer.writerow([thing1, thing2, ...])","def save_data_to_file(file_name, list_of_product_objects):\r\n try:\r\n objF = open(file_name, \"w\")\r\n for row in list_of_product_objects:\r\n objF.write(str(row[0]) + \",\" + str(row[1]) + \"\\n\")\r\n objF.close()\r\n except IOError:\r\n print(\"Unable to locate file\")","def write(self, args):\n\t\tnewcsvfile = self.filename[:len(self.filename)-4] + \"NEW.csv\" #clever naming MIGHT NEED TO CHANGE THIS LATER/OVERWRITE OLD FILE?\n\t\twith open(newcsvfile, 'wb') as f:\n\t\t\twriter = csv.writer(f)\n\t\t\twriter.writerows(self.all_likes)","def save_to_file_csv(cls, list_objs):\n with open(cls.__name__ + \".csv\", \"w\", newline='') as f:\n if cls.__name__ == \"Rectangle\":\n fieldnames = ['id', 'width', 'height', 'x', 'y']\n elif cls.__name__ == \"Square\":\n fieldnames = ['id', 'size', 'x', 'y']\n writer = csv.DictWriter(f, fieldnames=fieldnames)\n writer.writeheader()\n if list_objs is not None:\n for model in list_objs:\n writer.writerow(model.to_dictionary())","def save_csv(data): \n bank_data = data\n\n #Creating headers for the csv file\n header = [\"Lender\", \"Max Loan Amount\", \"Max LTV\", \"Max DTI\", \"Max Credit Score\", \"Interest Rate\"]\n\n #Creating output path of the CSV file\n csvpath = Path(\"save_file.csv\")\n\n #Opening the csv file in csvpath by using the open() method\n with open(csvpath, \"w\", newline='') as csvfile:\n\n csvwriter = csv.writer(csvfile, delimiter = \",\")\n csvwriter.writerow(header)\n for row in bank_data:\n csvwriter.writerow(row)\n\n return data","def write(obj, filename):\n with open(filename, 'w') as f:\n print(*obj, sep='\\n', file=f)","def write_to_file(self, results):\n with open(self.outputFilename, \"w\") as csvFile:\n csvWriter = csv.writer(csvFile, delimiter=',') \n title_row = ('asset_id', 'component_id', 'latitude', 'longitude', 'installation_date', 'commissioning_date', 'street_name', 'cabinet_id', 'nominal_wattage', 'current_time', 'current_LogValue', 'current_IsLogValueOff') \n csvWriter.writerow(title_row)\n for record in results:\n csvWriter.writerow(record)","def save_class_list():\r\n try:\r\n classStringList.clear() #clear the classString List\r\n for i in range(0,len(classes)):\r\n classStringList.append(classes[i].csvRow()) #enter classes to the classStringList from the classes\r\n f = open(\"mySchedule.csv\", 'w', newline ='')\r\n csv.writer(f).writerow([\"Day\", \"Class\", \"Start Time\", \"End Time\"])\r\n for classCSVString in classStringList:\r\n csv.writer(f).writerow(classCSVString)\r\n f.close()\r\n except Exception as e:\r\n print(\"Exception found:\" + e)","def _toFile(self):\n pass","def write(self, file: IO) -> None:\n serializer = self.serializer_class(self.get_queryset(), many=True)\n\n writer = csv.DictWriter(file, self.serializer_class.Meta.fields)\n writer.writeheader()\n\n # Write serializer data and replace None/'' with 'NA'\n writer.writerows(\n OrderedDict(\n (\n field_name,\n \"NA\" if (field_value is None or field_value == \"\") else field_value,\n )\n for field_name, field_value in row.items()\n )\n for row in serializer.data\n )\n\n file.seek(0)","def write_to_file(info: List[str]) -> None:\n return","def write_CLASS_txtfile(input_file_name, data):\n output_file = open(input_file_name, 'w')\n output_file.write('Human Metabolome CLASS database')\n output_file.write('\\n\\n')\n\n for line in data:\n output_file.write(str(line) +'\\n')","def write(self, values, file_obj, format=None):\n pass","def save_to_file_csv(cls, list_objs):\n f_name = cls.__name__ + \".csv\"\n with open(f_name, 'w', newline='') as f:\n if list_objs is None or list_objs == []:\n f.write(\"[]\")\n\n else:\n if cls.__name__ == 'Rectangle':\n h = ['id', 'width', 'height', 'x', 'y']\n else:\n h = ['id', 'size', 'x', 'y']\n ncsv = csv.DictWriter(f, fieldnames=h)\n for obj in list_objs:\n ncsv.writerow(obj.to_dictionary())","def write_to_files(section, csv_path, srt_path):\n write_to_csv(section, csv_path)\n write_to_srt(section, srt_path)","def write(data):","def save(self,file):\n\n with open(file,\"w\") as f:\n f.write(self.to_string())","def csv_writer(data, path):\r\n with open(path, \"w\") as csv_file:\r\n writer = csv.writer(csv_file, delimiter=',')\r\n for line in data:\r\n writer.writerow(line)","def write_out(message, fp):\n with open(fp, 'wb') as csvfile:\n writer = csv.writer(csvfile, delimiter=',', quotechar='\"')\n writer.writerow([message])","def csv_writer(data, path):\n with open(path, \"w\") as csv_file:\n writer = csv.writer(csv_file, delimiter=',')\n for line in data:\n writer.writerow(line)","def csv_writer(data, path):\n with open(path, \"w\", newline='') as csv_file:\n writer = csv.writer(csv_file, delimiter=',')\n for line in data:\n writer.writerow(line)","def write(file, string, codec='utf8'):\n if isinstance(string, str):\n file.write(string)\n elif isinstance(string, unicode):\n file.write(string.encode(codec))","def write(self): \n # Open csv file\n with open(self.file_name, 'w', newline='') as file:\n self._writer = csv.writer(file)\n \n # Write header rows\n# self.write_sim_header_data(self.trace.sim.get_data())\n \n # Write trace table\n self._writer.writerow(['Record #', 'Rep', 'Time',\n 'Priority', 'Record Type', 'Name'])\n for trace_record in self.trace._record_list:\n self._writer.writerow(trace_record.get_row())\n file.close()","def write_data_files(self):\n # build our strings\n header_string = \"\"\n data_string = \"\"\n for value in self.data.values():\n header_string += value[2] + \",\"\n if value[0] != None:\n data_string += value[1].format(value[0])\n else:\n data_string += \",\"\n # remove the extra comma and replace with a newline\n header_string = header_string[:-1]\n header_string += \"\\n\"\n data_string = data_string[:-1]\n data_string += \"\\n\"\n \n # show what we built\n #print(header_string)\n #print(data_string)\n \n # open a temp file\n with open(\"{:s}\\\\VWSInput\\\\temp_data.csv\".format(self.path), \"w\") as temp_file:\n #temp_file.write(header_string)\n temp_file.write(data_string)\n \n # move to the input file\n filetools.mv(\"{:s}\\\\VWSInput\\\\temp_data.csv\".format(self.path), \"{:s}\\\\VWSInput\\\\data.csv\".format(self.path))\n \n return","def write(self, s):\n ...","def csv_writer(data, path):\n with open(path, \"wb\") as csv_file:\n writer = csv.writer(csv_file, delimiter=',')\n for line in data:\n writer.writerow(line)","def csvWriter(asin, price, name):\n # NOT USED\n date = arrow.now().format('YYYY/MM/DD')\n headers = ['Date', 'ASIN', 'Price', 'Name']\n with open('CSVs/' + asin + '.csv', 'w') as newWrite:\n writer = csv.writer(newWrite)","def write_the_contents_to_the_same_file(self):\n if not len(self.student_list):\n print('There is no contents to write')\n return\n\n if self._filename is None:\n self._filename = self.input_filename()\n\n with open(self._filename, 'w') as OUT:\n OUT.write(self.student_list.to_csv(date_format='%Y-%m-%d',\n sep='\\t', header=False, columns=self.columns_to_save))\n print(f'Data are saved into {self._filename!r}')","def write(self, file_variable):\n file_variable.write(\",\".join(map(str, [self.code, self.title, self.credit, self.term])))","def save(self, data, outpath):\n data.to_csv(outpath)","def csv_writer(filepath, seqs):\n with open(filepath, 'w') as f:\n f.write('\\n'.join([','.join(\n ['\"{}\"'.format(r) \n if (' ' in r) or (',' in r) else r\n for r in s])\n for s in seqs]))","def save_csv(net, wires, net_id, chip_id, chip):\n with open('output/output.csv', 'w') as file:\n # Write first line\n output = csv.writer(file)\n output.writerow([\"net\", \"wires\"])\n\n # Index and fill the body\n for step in range(len(wires)):\n output.writerow([net[step],wires[step]])\n\n # End of file\n output.writerow([f\"chip_{chip_id}_net_{net_id}\", chip.cost])","def save_to_file_csv(cls, list_objs):\n ld = []\n with open(cls.__name__ + \".csv\", \"w\", encoding=\"utf-8\") as f:\n if list_objs:\n for obj in list_objs:\n if cls.__name__ == 'Rectangle':\n ld.append([\n obj.id, obj.width, obj.height, obj.x, obj.y])\n if cls.__name__ == 'Square':\n ld.append([obj.id, obj.size, obj.x, obj.y])\n writer = csv.writer(f)\n for row in ld:\n writer.writerow(row)","def dataSave():\n # NR5G = gui_reader()\n try: #Python3\n f = open(__file__ + \".csv\",'wt', encoding='utf-8')\n except:\n f = open(__file__ + \".csv\",'wb')\n f.write('%s,'%(entryCol.entry0.get()))\n f.write('%s,'%(entryCol.entry1.get()))\n f.write('%s,'%(entryCol.entry2.get()))\n f.write('%s,'%(entryCol.entry3.get()))\n f.close()\n print(\"DataSave: File Saved\")","def save_data_to_file(file_name, list_of_product_objects):\r\n objfile = open(file_name, 'w')\r\n for row in list_of_product_objects:\r\n objfile.write(row.product_name + \",\" + str(row.product_price) + \"\\n\")\r\n objfile.close()","def csv_writer(file_path, data):\n with open(file_path, \"a+\") as f:\n #writer = csv.writer(f, delimiter=',')\n writer = csv.writer(f, lineterminator='\\n')\n writer.writerows(data)\n f.close()","def csv_writer(data, path, arr):\n with open(path, \"w\", newline='') as csv_file:\n writer = csv.DictWriter(csv_file, fieldnames = arr)\n for line in data:\n writer.writerow(line)","def writeToFile(ruleset, className, classValue, fp):\n size = len(ruleset)\n if (size != 0):\n for i in range(size):\n j=0\n while(j<len(ruleset[i])-1):\n fp.write(str(ruleset[i][j]).replace(\"'\", \"\")+' & ')\n j = j+1\n fp.write(str(ruleset[i][j]).replace(\"'\", \"\")+\" -> (\"+className+\", \"+classValue+\") \\n\")\n fp.close()","def writeTypedClassadAttrToFile(fd, attr_name, attr_value):\n if isinstance(attr_value, (int, long, float)):\n # don't quote numeric values\n fd.write('%s = %s\\n' % (attr_name, attr_value))\n else:\n escaped_value = string.replace(string.replace(str(attr_value), '\"', '\\\\\"'), '\\n', '\\\\n')\n fd.write('%s = \"%s\"\\n' % (attr_name, escaped_value))","def fs_write(obj, file_path):\n try:\n with open(str(file_path), 'w') as f:\n f.write(obj)\n return obj\n except TypeError as e:\n raise e","def to_file(self, filename=None):\n name = None\n if filename is not None:\n name = filename\n elif self.name:\n name = self.name\n\n if name:\n #f = open(self.name, 'w')\n f = codecs.open(name, 'w', encoding='utf-8')\n self.seek(0)\n f.write(self.read())\n f.close()\n else:\n print \"No log_name for this log\"","def _write_to_file(self, string):\n with open(self.p.base_dir + '/' + self.p.filename, 'w') as f:\n f.write(string)","def outputFunc(filename, parks,roading,private):\n #assert len(parks) == 3\n \n f = open(filename, 'wt')\n \n try:\n writer = csv.writer(f)\n writer.writerow(days)\n writer.writerow(parks)\n writer.writerow(roading)\n writer.writerow(private)\n finally:\n f.close()","def write(self, file_obj, file_format):\n if ( file_format.upper() == 'FASTA' ):\n write_func = write_fasta\n #elif ( file_format.upper() == 'NEXUS' ):\n # write_func = write_nexus\n #elif ( file_format.upper() == 'PHYLIP' ):\n # write_func = write_phylip\n #elif ( file_format.upper() == 'COMPACT' ):\n # write_func = write_compact \n #elif ( file_format.upper() == 'COMPACT2' ):\n # write_func = write_compact2 \n #elif ( file_format.upper() == 'COMPACT3' ):\n # write_func = write_compact3\n else:\n write_func = write_fasta\n write_func(self, file_obj)","def create_csvWriter(csvFile):\n csvWriter = csv.writer(csvFile)\n csvWriter.writerow(['College Name',\n 'City',\n 'State',\n 'ZipCode',\n 'Selectivity',\n 'file_name'])\n return csvWriter","def _file_writer(file, extension, output_data, headers):\n if extension == 'csv':\n separator = ','\n else:\n separator = ' '\n writer = csv.writer(file, delimiter=separator, quotechar='|')\n if headers is True:\n writer.writerow(['Login', 'P/N', 'Password', 'P/N'])\n writer.writerows(output_data)","def write (self, path):\n\t\ts=[]; add=s.append\n\t\tadd ('\\t'.join (self.schema))\n\t\tfor record in self.data:\n\t\t\tadd (record.asTabDelimitedRecord())\n\t\t\n\t\t# f = open (path, 'w')\n\t\tf = codecs.open(path, 'w', 'utf-8')\n\t\tf.write (self.linesep.join (s))\n\t\tf.close()\n\t\tprint (\"data written to \" + path)","def _CsvFunc(self, obj=None, verbose=False, use_pager=None, to_file=None):\n if obj is not None:\n self._printed_variables.append(obj)\n lines = describe.GenerateLines(obj, verbose=verbose, recursive=False,\n format_name='csv')\n _WriteToStream(lines, use_pager=use_pager, to_file=to_file)","def object_export_save(simulation, object_name, dir):\n query = get_query(object_name, simulation)\n # To avoid conflict if two users export a file at the same time, we\n # generate a random name for the export file.\n filename = dir + '/' + object_name + 's.tsv'\n\n with codecs.open(filename, 'w', encoding='utf8') as f:\n if object_name == 'centroid':\n filename = dir + '/zones.tsv'\n fields = ['id', 'name', 'x', 'y', 'db_id']\n elif object_name == 'crossing':\n filename = dir + '/Intersections.tsv'\n fields = ['id', 'name', 'x', 'y', 'db_id']\n elif object_name == 'link':\n filename = dir + '/links.tsv'\n fields = ['id', 'name', 'origin', 'destination', 'lanes', 'length',\n 'speed', 'capacity', 'vdf']\n elif object_name == 'function':\n filename = dir + '/functions.tsv'\n fields = ['id', 'expression']\n writer = csv.writer(f, delimiter='\\t')\n if object_name in ('centroid', 'crossing'):\n writer.writerow(['id', 'name', 'x', 'y', 'db_id'])\n values = query.values_list('user_id', 'name', 'x', 'y', 'id')\n elif object_name == 'function':\n writer.writerow(['id', 'name', 'expression'])\n values = query.values_list('user_id', 'name', 'expression')\n elif object_name == 'link':\n writer.writerow(['id', 'name', 'lanes', 'length', 'speed',\n 'capacity', 'function', 'origin', 'destination'])\n values = query.values_list('user_id', 'name', 'lanes', 'length',\n 'speed', 'capacity', 'vdf__user_id')\n # Origin and destination id must be converted to user_id.\n centroids = get_query('centroid', simulation)\n crossings = get_query('crossing', simulation)\n ids = list(centroids.values_list('id', 'user_id'))\n ids += list(crossings.values_list('id', 'user_id'))\n # Map id of nodes to their user_id.\n id_mapping = dict(ids)\n origins = query.values_list('origin', flat=True)\n origins = np.array([id_mapping[n] for n in origins])\n destinations = query.values_list('destination', flat=True)\n destinations = np.array([id_mapping[n] for n in destinations])\n # Add origin and destination user ids to the values array.\n origins = np.transpose([origins])\n destinations = np.transpose([destinations])\n if values:\n values = np.hstack([values, origins, destinations])\n writer.writerows(values)\n\n return filename","def write(self, filename, data):\n raise NotImplementedError","def string_to_file(path_to_file, string_to_write):\n\t\twith open(path_to_file, 'w+') as f:\n\t\t\tf.write(string_to_write)","def save_to_file_csv(cls, list_objs):\n l = []\n if list_objs is not None:\n for item in list_objs:\n l.append(item.to_dictionary())\n with open(\"%s.csv\" % cls.__name__, mode='w') as f:\n f.write(Base.to_json_string(l))","def write(self, object, content_type, to_file):\n return to_file","def save_as_csv(time_series, data, path_and_file_name):\n\n parent_name = \"test\"\n parent_uqid = uuid.uuid4()\n\n file_obj = open(path_and_file_name, 'w')\n file_obj.write('version,'+str(2)+'\\n')\n file_obj.write('numOfCH,'+str(1)+'\\n')\n file_obj.write('type, scan\\n')\n file_obj.write('ch_type,'+str(0)+'\\n')\n\n file_obj.write('carpet pos,'+str(0)+'\\n')\n file_obj.write('parent_name,'+str(parent_name)+'\\n')\n file_obj.write('parent_uqid,'+str(parent_uqid)+'\\n')\n file_obj.write('parent_filename,'+str(path_and_file_name)+'\\n')\n\n file_obj.write('pc, 0\\n')\n file_obj.write('Time (ns), CH0 Auto-Correlation\\n')\n for time_step in range(0, time_series.shape[0]):\n file_obj.write(str(float(time_series[time_step]))+','+str(data[time_step])+ '\\n')\n file_obj.write('end\\n')\n\n file_obj.close()","def apple_search_csv_writer(file: IO, data: str) -> callable:\n file_writer = csv.writer(file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n file_writer.writerows(data)\n return None","def csvWrite(self, data, csvFileName):\n\twith open(csvFileName, 'w') as csv_file:\n\t\twriter = csv.writer(csv_file)\n\t\t\tfor key, value in data.items():\n\t\t\t\twriter.writerow([key,value])","def save_csv(filename, rows):\n with open(filename, 'w', newline='', encoding='utf-8') as f:\n writer = csv.writer(f)\n writer.writerow([\n 'title', 'runtime', 'genre(s)', 'director(s)', 'writer(s)',\n 'actor(s)', 'rating(s)', 'number of rating(s)'\n ])\n\n writer.writerows(rows)","def to_file(self, outfile):\n\n with open(outfile, \"w\") as outf:\n outf.write(self.to_string())","def _writeRecord(self, path, name, data):\n file_path = os.path.join(path, name)\n with open(file_path, 'w') as f:\n for item in data:\n f.write(str(item)+'\\t')\n f.write('\\n')","def write(self, filename):\n pass","def write(self, filename):\n pass","def write_table_to_file(table):\n with open(\"story.csv\", \"w\") as file:\n for record in table:\n row = ';'.join(record)\n file.write(row + \"\\n\")","def save(string, file):\n\n save_file = open(file, 'w')\n save_file.write(string)\n save_file.close()","def save_to_file_csv(cls, list_objs):\n r_fields = ['id', 'width', 'height', 'x', 'y']\n s_fields = ['id', 'size', 'x', 'y']\n filename = cls.__name__ + \".csv\"\n new_list = []\n with open(filename, \"w\") as fp:\n if cls.__name__ == \"Rectangle\":\n dict_writer = csv.DictWriter(fp, fieldnames=r_fields)\n elif cls.__name__ == \"Square\":\n dict_writer = csv.DictWriter(fp, fieldnames=s_fields)\n dict_writer.writeheader()\n for objs in list_objs:\n dict_writer.writerow(objs.to_dictionary())","def write(self, out):","def write(self):","def write(self):","def save_to_csv(today, task, description, hours, start_time, end_time):\n fee = '$5'\n with open('timeTracker.csv', 'a', newline='') as file:\n fieldnames = ['Date', 'Task Name', 'Description', 'Start Time',\n 'End Time', 'Number of hours', 'Price per hour', 'Fee Charged']\n writer = csv.DictWriter(file, fieldnames=fieldnames)\n writer.writeheader()\n writer.writerow({'Date': today, 'Task Name': task, 'Description': description, 'Start Time': start_time, 'End Time': end_time,\n 'Number of hours': hours, 'Price per hour': fee, 'Fee Charged': price})","def write( data ):","def write_into_csv(self, loc_details=[], itype='atm', mode='w'): \n \n if itype==\"brc\":\n csvfile_name = self.branch_file\n headers = self.branch_headers\n else:\n csvfile_name = self.atm_file\n headers = self.atm_headers\n\n with open(csvfile_name, mode, newline='') as csvfile:\n locwriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_ALL)\n if mode=='w':\n locwriter.writerow(headers) \n\n for loc in loc_details:\n locwriter.writerow(loc)","def __create_csv(self):\n with open(self.__csv_file_name, 'w', newline='', encoding='utf-8') as csv_file:\n writer = csv.DictWriter(csv_file, fieldnames=self.__csv_fields, delimiter=';')\n writer.writeheader()","def setup_writer(fileid, postfix):\n # we dump episode num, step, total reward, and \n # number of episodes solved in a csv file for analysis\n csvfilename = \"%s.csv\" % fileid\n csvfilename = os.path.join(postfix, csvfilename)\n csvfile = open(csvfilename, 'w', 1)\n writer = csv.writer(csvfile,\n delimiter=',',\n quoting=csv.QUOTE_NONNUMERIC)\n writer.writerow(['Episode',\n 'Step',\n 'Total Reward',\n 'Number of Episodes Solved'])\n\n return csvfile, writer","def write(self, fname):\n pass","def write_data():","def write_file(data,file_name):\r\n\twith open(file_name,'wb') as new_csv_file:\r\n\t\twrtr = writer(new_csv_file)\r\n\t\tfor row in data:\r\n\t\t\twrtr.writerow(row)","def write_csv(reviewer_data, file_obj):\n writer = csv.writer(file_obj)\n writer.writerow(\n ('Reviewer', 'Reviews', '-2', '-1', '+1', '+2', '+A', '+/- %',\n 'Disagreements', 'Disagreement%'))\n for (name, r_data, d_data) in reviewer_data:\n row = (name,) + r_data + d_data\n writer.writerow(row)","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)"],"string":"[\n \"def writeToCSV(self, filepath):\\r\\n\\t\\twith open(filepath, 'w') as outputFile:\\r\\n\\t\\t\\toutputFile.write(str(self))\",\n \"def export_to_file(data, filename='class_data.txt', mode='a'):\\n with open (filename, mode) as f:\\n if mode == \\\"w\\\":\\n for record in data:\\n line = \\\",\\\".join(record)\\n f.write(line + \\\"\\\\n\\\")\\n elif mode == \\\"a\\\":\\n line = \\\",\\\".join(data)\\n f.write(line + \\\"\\\\n\\\")\\n else:\\n raise ValueError('Wrong write mode')\",\n \"def writeToFile(self, output):\\n f = open(output, 'w')\\n data = [self.columns, self.chars, self.pwdLength, self.func.__name__]\\n data = [str(x) for x in data]\\n f.write(\\\" \\\".join(data))\\n f.write(\\\"\\\\n\\\")\\n f.write(repr(self))\\n f.close()\",\n \"def CSVWriter (iterable, outLoc, header=\\\"\\\", ):\\n if not iterable:\\n print (\\\"nothing to write\\\")\\n return 0\\n\\n out = open(outLoc, 'w')\\n\\n if header:\\n out.write(header+'\\\\n')\\n\\n #Only works if iterable is a nested list\\n for member in iterable:\\n for item in member:\\n out.write(str(item)+',')\\n out.write('\\\\n')\\n\\n print(\\\"write to \\\"+outLoc+\\\" successful.\\\")\\n return 1\",\n \"def create_writer():\\n # python 2 and 3 handle writing files differently\\n if sys.version_info[0] <= 2:\\n output = io.BytesIO()\\n else:\\n output = io.StringIO()\\n writer = csv.writer(output)\\n return writer, output\",\n \"def write(self, str: str, /) -> None:\",\n \"def writeCSV(filename, separator, data):\\n \\n filetowrite = open(filename, \\\"w\\\")\\n values = []\\n i = 0 #Count the number of objects already written\\n for item in data:\\n filetowrite.write(item)\\n i += 1\\n if i < len(data.keys()):\\n filetowrite.write(separator)\\n values.append(data[item])\\n filetowrite.write(\\\"\\\\n\\\")\\n i = 0\\n for value in values:\\n filetowrite.write(str(value))\\n i += 1\\n if i < len(values):\\n filetowrite.write(separator)\\n \\n filetowrite.close()\",\n \"def save_data(self, data, weight_class, output_path=None):\\n if not output_path:\\n output_path = self.output_path\\n if not os.path.exists(output_path):\\n os.makedirs(output_path)\\n \\n print(\\\"saving data for \\\" + weight_class)\\n data.to_csv(output_path + weight_class + \\\".txt\\\", sep=\\\"|\\\", index=False)\",\n \"def write_to_file(self, filename: str) -> None:\",\n \"def _simple_write(filename, obj, fmt=None):\\n string = str(obj) if fmt is None else ('{' + fmt + '}').format(obj)\\n with open(filename, 'w+') as file:\\n file.write(string)\",\n \"def test_to_file(self):\\n with TemporaryDirectory() as tmp:\\n df_test = make_simple_dataframe()\\n Base = BaseDataClass.from_object(df_test)\\n fp_save = os.path.join(tmp, \\\"test_save.csv\\\")\\n Base.to_file(fp_save)\\n assert os.path.exists(fp_save)\",\n \"def export_to_file(self, fp, *args, **kwargs):\\n with open(fp, 'w') as fh:\\n self._to_str(fh)\",\n \"def save(self, path, separator=\\\",\\\", encoder=lambda j,v: v):\\n # csv.writer will handle str, int, float and bool:\\n s = StringIO()\\n w = csv.writer(s, delimiter=separator)\\n w.writerows([[encode_utf8(encoder(j,v)) for j,v in enumerate(row)] for row in self])\\n f = open(path, \\\"wb\\\")\\n f.write(BOM_UTF8)\\n f.write(s.getvalue())\\n f.close()\",\n \"def csv_writer(data, path):\\n\\n with open(path, \\\"a\\\") as csv_file:\\n\\n writer = csv.writer(csv_file,delimiter=',')\\n\\n \\n\\n writer.writerow(data)\",\n \"def csvWriter(data, out_file):\\n print '[+] Writing CSV output.'\\n logging.info('Writing CSV to ' + out_file + '.')\\n headers = ['ID', 'Name', 'Path', 'Session ID', 'Count', 'Last Used Date (UTC)', 'Focus Time (ms)', 'Focus Count']\\n\\n with open(out_file, 'wb') as csvfile:\\n writer = csv.DictWriter(csvfile, fieldnames=headers, extrasaction='ignore')\\n # Writes the header from list supplied to fieldnames keyword argument\\n writer.writeheader()\\n\\n for i, dictionary in enumerate(data):\\n # Insert the 'ID' value to each dictionary in the list. Add 1 to start ID at 1 instead of 0.\\n dictionary['ID'] = i + 1\\n # Convert the FILETIME object in the fourth index to human readable value\\n dictionary['Last Used Date (UTC)'] = fileTime(dictionary['Last Used Date (UTC)'])\\n writer.writerow(dictionary)\\n\\n csvfile.flush()\\n csvfile.close()\\n msg = 'Completed writing CSV file. Program exiting successfully.'\\n print '[*]', msg\\n logging.info(msg)\",\n \"def write_to_file(data, method, delimiter):\\r\\n output_file = 'data.csv'\\r\\n with open(output_file, method, newline='', encoding='utf-8') as file:\\r\\n writer = csv.writer(file, delimiter=delimiter)\\r\\n writer.writerows([data])\",\n \"def save_data(csv_text, file_name=None, station_id=None, period=None,\\n debug=False):\\n if file_name is None and station_id is not None:\\n if period is None:\\n period = \\\"000000-000000\\\"\\n file_name = f\\\"jma-{station_id}-{period}.csv\\\"\\n elif file_name is None:\\n raise ValueError(\\n \\\"ERROR: both file_name and station_id are not specified.\\\")\\n if debug:\\n print(\\\"saved:\\\", file_name)\\n with open(file_name, \\\"w\\\") as fd:\\n fd.write(csv_text)\",\n \"def writeFile( str_, *args ):\\n filePath = path.join( *args )\\n with open( filePath, 'w' ) as fd:\\n fd.write(str_)\",\n \"def writeToFile(self):\\n self.dto.writeToCsv()\\n print(\\\"File written.\\\")\",\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 to_csv_file_obj(self, rows):\\n output = StringIO.StringIO()\\n writer = csv.writer(output)\\n writer.writerows(rows)\\n return output\",\n \"def csv_writer(data, path):\\n\\twith open(path, \\\"wb\\\") as csv_file:\\n\\t\\twriter= csv.writer(csv_file, delimiter=',')\\n\\t\\twriter.writerows(data)\",\n \"def save_to_file_csv(cls, list_objs):\\n list_dictionaries = []\\n if list_objs is None or list_objs == []:\\n string_dictionary = \\\"[]\\\"\\n else:\\n for _obj_dict in list_objs:\\n list_dictionaries.append(_obj_dict.to_dictionary())\\n string_dictionary = Base.to_json_string(list_dictionaries)\\n with open(cls.__name__ + \\\".csv\\\", \\\"w\\\") as _file:\\n _file.write(string_dictionary)\\n _file.close()\",\n \"def write_csv(data, arg2, arg3):\\n\\n with open(\\\"data.csv\\\", newline='') as csvfile:\\n # csv writer object\\n writer = csv.writer(csvfile)\\n\\n # to write to file: writer.writerow([thing1, thing2, ...])\",\n \"def save_data_to_file(file_name, list_of_product_objects):\\r\\n try:\\r\\n objF = open(file_name, \\\"w\\\")\\r\\n for row in list_of_product_objects:\\r\\n objF.write(str(row[0]) + \\\",\\\" + str(row[1]) + \\\"\\\\n\\\")\\r\\n objF.close()\\r\\n except IOError:\\r\\n print(\\\"Unable to locate file\\\")\",\n \"def write(self, args):\\n\\t\\tnewcsvfile = self.filename[:len(self.filename)-4] + \\\"NEW.csv\\\" #clever naming MIGHT NEED TO CHANGE THIS LATER/OVERWRITE OLD FILE?\\n\\t\\twith open(newcsvfile, 'wb') as f:\\n\\t\\t\\twriter = csv.writer(f)\\n\\t\\t\\twriter.writerows(self.all_likes)\",\n \"def save_to_file_csv(cls, list_objs):\\n with open(cls.__name__ + \\\".csv\\\", \\\"w\\\", newline='') as f:\\n if cls.__name__ == \\\"Rectangle\\\":\\n fieldnames = ['id', 'width', 'height', 'x', 'y']\\n elif cls.__name__ == \\\"Square\\\":\\n fieldnames = ['id', 'size', 'x', 'y']\\n writer = csv.DictWriter(f, fieldnames=fieldnames)\\n writer.writeheader()\\n if list_objs is not None:\\n for model in list_objs:\\n writer.writerow(model.to_dictionary())\",\n \"def save_csv(data): \\n bank_data = data\\n\\n #Creating headers for the csv file\\n header = [\\\"Lender\\\", \\\"Max Loan Amount\\\", \\\"Max LTV\\\", \\\"Max DTI\\\", \\\"Max Credit Score\\\", \\\"Interest Rate\\\"]\\n\\n #Creating output path of the CSV file\\n csvpath = Path(\\\"save_file.csv\\\")\\n\\n #Opening the csv file in csvpath by using the open() method\\n with open(csvpath, \\\"w\\\", newline='') as csvfile:\\n\\n csvwriter = csv.writer(csvfile, delimiter = \\\",\\\")\\n csvwriter.writerow(header)\\n for row in bank_data:\\n csvwriter.writerow(row)\\n\\n return data\",\n \"def write(obj, filename):\\n with open(filename, 'w') as f:\\n print(*obj, sep='\\\\n', file=f)\",\n \"def write_to_file(self, results):\\n with open(self.outputFilename, \\\"w\\\") as csvFile:\\n csvWriter = csv.writer(csvFile, delimiter=',') \\n title_row = ('asset_id', 'component_id', 'latitude', 'longitude', 'installation_date', 'commissioning_date', 'street_name', 'cabinet_id', 'nominal_wattage', 'current_time', 'current_LogValue', 'current_IsLogValueOff') \\n csvWriter.writerow(title_row)\\n for record in results:\\n csvWriter.writerow(record)\",\n \"def save_class_list():\\r\\n try:\\r\\n classStringList.clear() #clear the classString List\\r\\n for i in range(0,len(classes)):\\r\\n classStringList.append(classes[i].csvRow()) #enter classes to the classStringList from the classes\\r\\n f = open(\\\"mySchedule.csv\\\", 'w', newline ='')\\r\\n csv.writer(f).writerow([\\\"Day\\\", \\\"Class\\\", \\\"Start Time\\\", \\\"End Time\\\"])\\r\\n for classCSVString in classStringList:\\r\\n csv.writer(f).writerow(classCSVString)\\r\\n f.close()\\r\\n except Exception as e:\\r\\n print(\\\"Exception found:\\\" + e)\",\n \"def _toFile(self):\\n pass\",\n \"def write(self, file: IO) -> None:\\n serializer = self.serializer_class(self.get_queryset(), many=True)\\n\\n writer = csv.DictWriter(file, self.serializer_class.Meta.fields)\\n writer.writeheader()\\n\\n # Write serializer data and replace None/'' with 'NA'\\n writer.writerows(\\n OrderedDict(\\n (\\n field_name,\\n \\\"NA\\\" if (field_value is None or field_value == \\\"\\\") else field_value,\\n )\\n for field_name, field_value in row.items()\\n )\\n for row in serializer.data\\n )\\n\\n file.seek(0)\",\n \"def write_to_file(info: List[str]) -> None:\\n return\",\n \"def write_CLASS_txtfile(input_file_name, data):\\n output_file = open(input_file_name, 'w')\\n output_file.write('Human Metabolome CLASS database')\\n output_file.write('\\\\n\\\\n')\\n\\n for line in data:\\n output_file.write(str(line) +'\\\\n')\",\n \"def write(self, values, file_obj, format=None):\\n pass\",\n \"def save_to_file_csv(cls, list_objs):\\n f_name = cls.__name__ + \\\".csv\\\"\\n with open(f_name, 'w', newline='') as f:\\n if list_objs is None or list_objs == []:\\n f.write(\\\"[]\\\")\\n\\n else:\\n if cls.__name__ == 'Rectangle':\\n h = ['id', 'width', 'height', 'x', 'y']\\n else:\\n h = ['id', 'size', 'x', 'y']\\n ncsv = csv.DictWriter(f, fieldnames=h)\\n for obj in list_objs:\\n ncsv.writerow(obj.to_dictionary())\",\n \"def write_to_files(section, csv_path, srt_path):\\n write_to_csv(section, csv_path)\\n write_to_srt(section, srt_path)\",\n \"def write(data):\",\n \"def save(self,file):\\n\\n with open(file,\\\"w\\\") as f:\\n f.write(self.to_string())\",\n \"def csv_writer(data, path):\\r\\n with open(path, \\\"w\\\") as csv_file:\\r\\n writer = csv.writer(csv_file, delimiter=',')\\r\\n for line in data:\\r\\n writer.writerow(line)\",\n \"def write_out(message, fp):\\n with open(fp, 'wb') as csvfile:\\n writer = csv.writer(csvfile, delimiter=',', quotechar='\\\"')\\n writer.writerow([message])\",\n \"def csv_writer(data, path):\\n with open(path, \\\"w\\\") as csv_file:\\n writer = csv.writer(csv_file, delimiter=',')\\n for line in data:\\n writer.writerow(line)\",\n \"def csv_writer(data, path):\\n with open(path, \\\"w\\\", newline='') as csv_file:\\n writer = csv.writer(csv_file, delimiter=',')\\n for line in data:\\n writer.writerow(line)\",\n \"def write(file, string, codec='utf8'):\\n if isinstance(string, str):\\n file.write(string)\\n elif isinstance(string, unicode):\\n file.write(string.encode(codec))\",\n \"def write(self): \\n # Open csv file\\n with open(self.file_name, 'w', newline='') as file:\\n self._writer = csv.writer(file)\\n \\n # Write header rows\\n# self.write_sim_header_data(self.trace.sim.get_data())\\n \\n # Write trace table\\n self._writer.writerow(['Record #', 'Rep', 'Time',\\n 'Priority', 'Record Type', 'Name'])\\n for trace_record in self.trace._record_list:\\n self._writer.writerow(trace_record.get_row())\\n file.close()\",\n \"def write_data_files(self):\\n # build our strings\\n header_string = \\\"\\\"\\n data_string = \\\"\\\"\\n for value in self.data.values():\\n header_string += value[2] + \\\",\\\"\\n if value[0] != None:\\n data_string += value[1].format(value[0])\\n else:\\n data_string += \\\",\\\"\\n # remove the extra comma and replace with a newline\\n header_string = header_string[:-1]\\n header_string += \\\"\\\\n\\\"\\n data_string = data_string[:-1]\\n data_string += \\\"\\\\n\\\"\\n \\n # show what we built\\n #print(header_string)\\n #print(data_string)\\n \\n # open a temp file\\n with open(\\\"{:s}\\\\\\\\VWSInput\\\\\\\\temp_data.csv\\\".format(self.path), \\\"w\\\") as temp_file:\\n #temp_file.write(header_string)\\n temp_file.write(data_string)\\n \\n # move to the input file\\n filetools.mv(\\\"{:s}\\\\\\\\VWSInput\\\\\\\\temp_data.csv\\\".format(self.path), \\\"{:s}\\\\\\\\VWSInput\\\\\\\\data.csv\\\".format(self.path))\\n \\n return\",\n \"def write(self, s):\\n ...\",\n \"def csv_writer(data, path):\\n with open(path, \\\"wb\\\") as csv_file:\\n writer = csv.writer(csv_file, delimiter=',')\\n for line in data:\\n writer.writerow(line)\",\n \"def csvWriter(asin, price, name):\\n # NOT USED\\n date = arrow.now().format('YYYY/MM/DD')\\n headers = ['Date', 'ASIN', 'Price', 'Name']\\n with open('CSVs/' + asin + '.csv', 'w') as newWrite:\\n writer = csv.writer(newWrite)\",\n \"def write_the_contents_to_the_same_file(self):\\n if not len(self.student_list):\\n print('There is no contents to write')\\n return\\n\\n if self._filename is None:\\n self._filename = self.input_filename()\\n\\n with open(self._filename, 'w') as OUT:\\n OUT.write(self.student_list.to_csv(date_format='%Y-%m-%d',\\n sep='\\\\t', header=False, columns=self.columns_to_save))\\n print(f'Data are saved into {self._filename!r}')\",\n \"def write(self, file_variable):\\n file_variable.write(\\\",\\\".join(map(str, [self.code, self.title, self.credit, self.term])))\",\n \"def save(self, data, outpath):\\n data.to_csv(outpath)\",\n \"def csv_writer(filepath, seqs):\\n with open(filepath, 'w') as f:\\n f.write('\\\\n'.join([','.join(\\n ['\\\"{}\\\"'.format(r) \\n if (' ' in r) or (',' in r) else r\\n for r in s])\\n for s in seqs]))\",\n \"def save_csv(net, wires, net_id, chip_id, chip):\\n with open('output/output.csv', 'w') as file:\\n # Write first line\\n output = csv.writer(file)\\n output.writerow([\\\"net\\\", \\\"wires\\\"])\\n\\n # Index and fill the body\\n for step in range(len(wires)):\\n output.writerow([net[step],wires[step]])\\n\\n # End of file\\n output.writerow([f\\\"chip_{chip_id}_net_{net_id}\\\", chip.cost])\",\n \"def save_to_file_csv(cls, list_objs):\\n ld = []\\n with open(cls.__name__ + \\\".csv\\\", \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n if list_objs:\\n for obj in list_objs:\\n if cls.__name__ == 'Rectangle':\\n ld.append([\\n obj.id, obj.width, obj.height, obj.x, obj.y])\\n if cls.__name__ == 'Square':\\n ld.append([obj.id, obj.size, obj.x, obj.y])\\n writer = csv.writer(f)\\n for row in ld:\\n writer.writerow(row)\",\n \"def dataSave():\\n # NR5G = gui_reader()\\n try: #Python3\\n f = open(__file__ + \\\".csv\\\",'wt', encoding='utf-8')\\n except:\\n f = open(__file__ + \\\".csv\\\",'wb')\\n f.write('%s,'%(entryCol.entry0.get()))\\n f.write('%s,'%(entryCol.entry1.get()))\\n f.write('%s,'%(entryCol.entry2.get()))\\n f.write('%s,'%(entryCol.entry3.get()))\\n f.close()\\n print(\\\"DataSave: File Saved\\\")\",\n \"def save_data_to_file(file_name, list_of_product_objects):\\r\\n objfile = open(file_name, 'w')\\r\\n for row in list_of_product_objects:\\r\\n objfile.write(row.product_name + \\\",\\\" + str(row.product_price) + \\\"\\\\n\\\")\\r\\n objfile.close()\",\n \"def csv_writer(file_path, data):\\n with open(file_path, \\\"a+\\\") as f:\\n #writer = csv.writer(f, delimiter=',')\\n writer = csv.writer(f, lineterminator='\\\\n')\\n writer.writerows(data)\\n f.close()\",\n \"def csv_writer(data, path, arr):\\n with open(path, \\\"w\\\", newline='') as csv_file:\\n writer = csv.DictWriter(csv_file, fieldnames = arr)\\n for line in data:\\n writer.writerow(line)\",\n \"def writeToFile(ruleset, className, classValue, fp):\\n size = len(ruleset)\\n if (size != 0):\\n for i in range(size):\\n j=0\\n while(j<len(ruleset[i])-1):\\n fp.write(str(ruleset[i][j]).replace(\\\"'\\\", \\\"\\\")+' & ')\\n j = j+1\\n fp.write(str(ruleset[i][j]).replace(\\\"'\\\", \\\"\\\")+\\\" -> (\\\"+className+\\\", \\\"+classValue+\\\") \\\\n\\\")\\n fp.close()\",\n \"def writeTypedClassadAttrToFile(fd, attr_name, attr_value):\\n if isinstance(attr_value, (int, long, float)):\\n # don't quote numeric values\\n fd.write('%s = %s\\\\n' % (attr_name, attr_value))\\n else:\\n escaped_value = string.replace(string.replace(str(attr_value), '\\\"', '\\\\\\\\\\\"'), '\\\\n', '\\\\\\\\n')\\n fd.write('%s = \\\"%s\\\"\\\\n' % (attr_name, escaped_value))\",\n \"def fs_write(obj, file_path):\\n try:\\n with open(str(file_path), 'w') as f:\\n f.write(obj)\\n return obj\\n except TypeError as e:\\n raise e\",\n \"def to_file(self, filename=None):\\n name = None\\n if filename is not None:\\n name = filename\\n elif self.name:\\n name = self.name\\n\\n if name:\\n #f = open(self.name, 'w')\\n f = codecs.open(name, 'w', encoding='utf-8')\\n self.seek(0)\\n f.write(self.read())\\n f.close()\\n else:\\n print \\\"No log_name for this log\\\"\",\n \"def _write_to_file(self, string):\\n with open(self.p.base_dir + '/' + self.p.filename, 'w') as f:\\n f.write(string)\",\n \"def outputFunc(filename, parks,roading,private):\\n #assert len(parks) == 3\\n \\n f = open(filename, 'wt')\\n \\n try:\\n writer = csv.writer(f)\\n writer.writerow(days)\\n writer.writerow(parks)\\n writer.writerow(roading)\\n writer.writerow(private)\\n finally:\\n f.close()\",\n \"def write(self, file_obj, file_format):\\n if ( file_format.upper() == 'FASTA' ):\\n write_func = write_fasta\\n #elif ( file_format.upper() == 'NEXUS' ):\\n # write_func = write_nexus\\n #elif ( file_format.upper() == 'PHYLIP' ):\\n # write_func = write_phylip\\n #elif ( file_format.upper() == 'COMPACT' ):\\n # write_func = write_compact \\n #elif ( file_format.upper() == 'COMPACT2' ):\\n # write_func = write_compact2 \\n #elif ( file_format.upper() == 'COMPACT3' ):\\n # write_func = write_compact3\\n else:\\n write_func = write_fasta\\n write_func(self, file_obj)\",\n \"def create_csvWriter(csvFile):\\n csvWriter = csv.writer(csvFile)\\n csvWriter.writerow(['College Name',\\n 'City',\\n 'State',\\n 'ZipCode',\\n 'Selectivity',\\n 'file_name'])\\n return csvWriter\",\n \"def _file_writer(file, extension, output_data, headers):\\n if extension == 'csv':\\n separator = ','\\n else:\\n separator = ' '\\n writer = csv.writer(file, delimiter=separator, quotechar='|')\\n if headers is True:\\n writer.writerow(['Login', 'P/N', 'Password', 'P/N'])\\n writer.writerows(output_data)\",\n \"def write (self, path):\\n\\t\\ts=[]; add=s.append\\n\\t\\tadd ('\\\\t'.join (self.schema))\\n\\t\\tfor record in self.data:\\n\\t\\t\\tadd (record.asTabDelimitedRecord())\\n\\t\\t\\n\\t\\t# f = open (path, 'w')\\n\\t\\tf = codecs.open(path, 'w', 'utf-8')\\n\\t\\tf.write (self.linesep.join (s))\\n\\t\\tf.close()\\n\\t\\tprint (\\\"data written to \\\" + path)\",\n \"def _CsvFunc(self, obj=None, verbose=False, use_pager=None, to_file=None):\\n if obj is not None:\\n self._printed_variables.append(obj)\\n lines = describe.GenerateLines(obj, verbose=verbose, recursive=False,\\n format_name='csv')\\n _WriteToStream(lines, use_pager=use_pager, to_file=to_file)\",\n \"def object_export_save(simulation, object_name, dir):\\n query = get_query(object_name, simulation)\\n # To avoid conflict if two users export a file at the same time, we\\n # generate a random name for the export file.\\n filename = dir + '/' + object_name + 's.tsv'\\n\\n with codecs.open(filename, 'w', encoding='utf8') as f:\\n if object_name == 'centroid':\\n filename = dir + '/zones.tsv'\\n fields = ['id', 'name', 'x', 'y', 'db_id']\\n elif object_name == 'crossing':\\n filename = dir + '/Intersections.tsv'\\n fields = ['id', 'name', 'x', 'y', 'db_id']\\n elif object_name == 'link':\\n filename = dir + '/links.tsv'\\n fields = ['id', 'name', 'origin', 'destination', 'lanes', 'length',\\n 'speed', 'capacity', 'vdf']\\n elif object_name == 'function':\\n filename = dir + '/functions.tsv'\\n fields = ['id', 'expression']\\n writer = csv.writer(f, delimiter='\\\\t')\\n if object_name in ('centroid', 'crossing'):\\n writer.writerow(['id', 'name', 'x', 'y', 'db_id'])\\n values = query.values_list('user_id', 'name', 'x', 'y', 'id')\\n elif object_name == 'function':\\n writer.writerow(['id', 'name', 'expression'])\\n values = query.values_list('user_id', 'name', 'expression')\\n elif object_name == 'link':\\n writer.writerow(['id', 'name', 'lanes', 'length', 'speed',\\n 'capacity', 'function', 'origin', 'destination'])\\n values = query.values_list('user_id', 'name', 'lanes', 'length',\\n 'speed', 'capacity', 'vdf__user_id')\\n # Origin and destination id must be converted to user_id.\\n centroids = get_query('centroid', simulation)\\n crossings = get_query('crossing', simulation)\\n ids = list(centroids.values_list('id', 'user_id'))\\n ids += list(crossings.values_list('id', 'user_id'))\\n # Map id of nodes to their user_id.\\n id_mapping = dict(ids)\\n origins = query.values_list('origin', flat=True)\\n origins = np.array([id_mapping[n] for n in origins])\\n destinations = query.values_list('destination', flat=True)\\n destinations = np.array([id_mapping[n] for n in destinations])\\n # Add origin and destination user ids to the values array.\\n origins = np.transpose([origins])\\n destinations = np.transpose([destinations])\\n if values:\\n values = np.hstack([values, origins, destinations])\\n writer.writerows(values)\\n\\n return filename\",\n \"def write(self, filename, data):\\n raise NotImplementedError\",\n \"def string_to_file(path_to_file, string_to_write):\\n\\t\\twith open(path_to_file, 'w+') as f:\\n\\t\\t\\tf.write(string_to_write)\",\n \"def save_to_file_csv(cls, list_objs):\\n l = []\\n if list_objs is not None:\\n for item in list_objs:\\n l.append(item.to_dictionary())\\n with open(\\\"%s.csv\\\" % cls.__name__, mode='w') as f:\\n f.write(Base.to_json_string(l))\",\n \"def write(self, object, content_type, to_file):\\n return to_file\",\n \"def save_as_csv(time_series, data, path_and_file_name):\\n\\n parent_name = \\\"test\\\"\\n parent_uqid = uuid.uuid4()\\n\\n file_obj = open(path_and_file_name, 'w')\\n file_obj.write('version,'+str(2)+'\\\\n')\\n file_obj.write('numOfCH,'+str(1)+'\\\\n')\\n file_obj.write('type, scan\\\\n')\\n file_obj.write('ch_type,'+str(0)+'\\\\n')\\n\\n file_obj.write('carpet pos,'+str(0)+'\\\\n')\\n file_obj.write('parent_name,'+str(parent_name)+'\\\\n')\\n file_obj.write('parent_uqid,'+str(parent_uqid)+'\\\\n')\\n file_obj.write('parent_filename,'+str(path_and_file_name)+'\\\\n')\\n\\n file_obj.write('pc, 0\\\\n')\\n file_obj.write('Time (ns), CH0 Auto-Correlation\\\\n')\\n for time_step in range(0, time_series.shape[0]):\\n file_obj.write(str(float(time_series[time_step]))+','+str(data[time_step])+ '\\\\n')\\n file_obj.write('end\\\\n')\\n\\n file_obj.close()\",\n \"def apple_search_csv_writer(file: IO, data: str) -> callable:\\n file_writer = csv.writer(file, delimiter=',', quotechar='\\\"', quoting=csv.QUOTE_MINIMAL)\\n file_writer.writerows(data)\\n return None\",\n \"def csvWrite(self, data, csvFileName):\\n\\twith open(csvFileName, 'w') as csv_file:\\n\\t\\twriter = csv.writer(csv_file)\\n\\t\\t\\tfor key, value in data.items():\\n\\t\\t\\t\\twriter.writerow([key,value])\",\n \"def save_csv(filename, rows):\\n with open(filename, 'w', newline='', encoding='utf-8') as f:\\n writer = csv.writer(f)\\n writer.writerow([\\n 'title', 'runtime', 'genre(s)', 'director(s)', 'writer(s)',\\n 'actor(s)', 'rating(s)', 'number of rating(s)'\\n ])\\n\\n writer.writerows(rows)\",\n \"def to_file(self, outfile):\\n\\n with open(outfile, \\\"w\\\") as outf:\\n outf.write(self.to_string())\",\n \"def _writeRecord(self, path, name, data):\\n file_path = os.path.join(path, name)\\n with open(file_path, 'w') as f:\\n for item in data:\\n f.write(str(item)+'\\\\t')\\n f.write('\\\\n')\",\n \"def write(self, filename):\\n pass\",\n \"def write(self, filename):\\n pass\",\n \"def write_table_to_file(table):\\n with open(\\\"story.csv\\\", \\\"w\\\") as file:\\n for record in table:\\n row = ';'.join(record)\\n file.write(row + \\\"\\\\n\\\")\",\n \"def save(string, file):\\n\\n save_file = open(file, 'w')\\n save_file.write(string)\\n save_file.close()\",\n \"def save_to_file_csv(cls, list_objs):\\n r_fields = ['id', 'width', 'height', 'x', 'y']\\n s_fields = ['id', 'size', 'x', 'y']\\n filename = cls.__name__ + \\\".csv\\\"\\n new_list = []\\n with open(filename, \\\"w\\\") as fp:\\n if cls.__name__ == \\\"Rectangle\\\":\\n dict_writer = csv.DictWriter(fp, fieldnames=r_fields)\\n elif cls.__name__ == \\\"Square\\\":\\n dict_writer = csv.DictWriter(fp, fieldnames=s_fields)\\n dict_writer.writeheader()\\n for objs in list_objs:\\n dict_writer.writerow(objs.to_dictionary())\",\n \"def write(self, out):\",\n \"def write(self):\",\n \"def write(self):\",\n \"def save_to_csv(today, task, description, hours, start_time, end_time):\\n fee = '$5'\\n with open('timeTracker.csv', 'a', newline='') as file:\\n fieldnames = ['Date', 'Task Name', 'Description', 'Start Time',\\n 'End Time', 'Number of hours', 'Price per hour', 'Fee Charged']\\n writer = csv.DictWriter(file, fieldnames=fieldnames)\\n writer.writeheader()\\n writer.writerow({'Date': today, 'Task Name': task, 'Description': description, 'Start Time': start_time, 'End Time': end_time,\\n 'Number of hours': hours, 'Price per hour': fee, 'Fee Charged': price})\",\n \"def write( data ):\",\n \"def write_into_csv(self, loc_details=[], itype='atm', mode='w'): \\n \\n if itype==\\\"brc\\\":\\n csvfile_name = self.branch_file\\n headers = self.branch_headers\\n else:\\n csvfile_name = self.atm_file\\n headers = self.atm_headers\\n\\n with open(csvfile_name, mode, newline='') as csvfile:\\n locwriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_ALL)\\n if mode=='w':\\n locwriter.writerow(headers) \\n\\n for loc in loc_details:\\n locwriter.writerow(loc)\",\n \"def __create_csv(self):\\n with open(self.__csv_file_name, 'w', newline='', encoding='utf-8') as csv_file:\\n writer = csv.DictWriter(csv_file, fieldnames=self.__csv_fields, delimiter=';')\\n writer.writeheader()\",\n \"def setup_writer(fileid, postfix):\\n # we dump episode num, step, total reward, and \\n # number of episodes solved in a csv file for analysis\\n csvfilename = \\\"%s.csv\\\" % fileid\\n csvfilename = os.path.join(postfix, csvfilename)\\n csvfile = open(csvfilename, 'w', 1)\\n writer = csv.writer(csvfile,\\n delimiter=',',\\n quoting=csv.QUOTE_NONNUMERIC)\\n writer.writerow(['Episode',\\n 'Step',\\n 'Total Reward',\\n 'Number of Episodes Solved'])\\n\\n return csvfile, writer\",\n \"def write(self, fname):\\n pass\",\n \"def write_data():\",\n \"def write_file(data,file_name):\\r\\n\\twith open(file_name,'wb') as new_csv_file:\\r\\n\\t\\twrtr = writer(new_csv_file)\\r\\n\\t\\tfor row in data:\\r\\n\\t\\t\\twrtr.writerow(row)\",\n \"def write_csv(reviewer_data, file_obj):\\n writer = csv.writer(file_obj)\\n writer.writerow(\\n ('Reviewer', 'Reviews', '-2', '-1', '+1', '+2', '+A', '+/- %',\\n 'Disagreements', 'Disagreement%'))\\n for (name, r_data, d_data) in reviewer_data:\\n row = (name,) + r_data + d_data\\n writer.writerow(row)\",\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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6876169","0.6498835","0.63612753","0.6353106","0.633464","0.62842685","0.61852163","0.60895437","0.6051628","0.6050783","0.60384357","0.60274184","0.59963906","0.5985917","0.59784335","0.5975056","0.596307","0.59575045","0.59389687","0.5937647","0.59298587","0.5923549","0.5917342","0.59139335","0.5905097","0.5889366","0.5875775","0.5874494","0.5873106","0.5869246","0.5868335","0.5859966","0.58496827","0.5844759","0.5839364","0.5829087","0.5824984","0.5824279","0.5823811","0.5823558","0.58217937","0.58192116","0.5816786","0.5814687","0.5810711","0.5804529","0.58033514","0.5794972","0.57853484","0.5776491","0.57708126","0.57669604","0.5766498","0.5758647","0.5754421","0.57459426","0.5744092","0.5737706","0.5727849","0.57274437","0.57204664","0.57124937","0.5710953","0.5709139","0.57053334","0.57017285","0.569754","0.5696463","0.5693235","0.5691548","0.5691433","0.5689473","0.5685731","0.5685478","0.56775135","0.56706","0.5666054","0.5664446","0.5662544","0.56617826","0.5658255","0.565159","0.5651257","0.5651257","0.56439537","0.56363916","0.5636378","0.563377","0.5630346","0.5630346","0.56281847","0.5620427","0.56194115","0.56191903","0.56141335","0.56118137","0.56108606","0.5608029","0.56076324","0.5605706"],"string":"[\n \"0.6876169\",\n \"0.6498835\",\n \"0.63612753\",\n \"0.6353106\",\n \"0.633464\",\n \"0.62842685\",\n \"0.61852163\",\n \"0.60895437\",\n \"0.6051628\",\n \"0.6050783\",\n \"0.60384357\",\n \"0.60274184\",\n \"0.59963906\",\n \"0.5985917\",\n \"0.59784335\",\n \"0.5975056\",\n \"0.596307\",\n \"0.59575045\",\n \"0.59389687\",\n \"0.5937647\",\n \"0.59298587\",\n \"0.5923549\",\n \"0.5917342\",\n \"0.59139335\",\n \"0.5905097\",\n \"0.5889366\",\n \"0.5875775\",\n \"0.5874494\",\n \"0.5873106\",\n \"0.5869246\",\n \"0.5868335\",\n \"0.5859966\",\n \"0.58496827\",\n \"0.5844759\",\n \"0.5839364\",\n \"0.5829087\",\n \"0.5824984\",\n \"0.5824279\",\n \"0.5823811\",\n \"0.5823558\",\n \"0.58217937\",\n \"0.58192116\",\n \"0.5816786\",\n \"0.5814687\",\n \"0.5810711\",\n \"0.5804529\",\n \"0.58033514\",\n \"0.5794972\",\n \"0.57853484\",\n \"0.5776491\",\n \"0.57708126\",\n \"0.57669604\",\n \"0.5766498\",\n \"0.5758647\",\n \"0.5754421\",\n \"0.57459426\",\n \"0.5744092\",\n \"0.5737706\",\n \"0.5727849\",\n \"0.57274437\",\n \"0.57204664\",\n \"0.57124937\",\n \"0.5710953\",\n \"0.5709139\",\n \"0.57053334\",\n \"0.57017285\",\n \"0.569754\",\n \"0.5696463\",\n \"0.5693235\",\n \"0.5691548\",\n \"0.5691433\",\n \"0.5689473\",\n \"0.5685731\",\n \"0.5685478\",\n \"0.56775135\",\n \"0.56706\",\n \"0.5666054\",\n \"0.5664446\",\n \"0.5662544\",\n \"0.56617826\",\n \"0.5658255\",\n \"0.565159\",\n \"0.5651257\",\n \"0.5651257\",\n \"0.56439537\",\n \"0.56363916\",\n \"0.5636378\",\n \"0.563377\",\n \"0.5630346\",\n \"0.5630346\",\n \"0.56281847\",\n \"0.5620427\",\n \"0.56194115\",\n \"0.56191903\",\n \"0.56141335\",\n \"0.56118137\",\n \"0.56108606\",\n \"0.5608029\",\n \"0.56076324\",\n \"0.5605706\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5933413"},"document_rank":{"kind":"string","value":"20"}}},{"rowIdx":3295,"cells":{"query":{"kind":"string","value":"In this function, you will instantiate several times, given the data provided. Then, you will open \"sh_additional_info.csv\" and for each line in that file, perform an operation using one of the methods of one of your classes. Follow the commented instructions in this main() function. Refer to Problem Set 07 README.md for instructions and tips."},"document":{"kind":"string","value":"def main():\n\n # Refer to Problem Set 07 README.md for instructions and tips.\n\n # 6.1: Read in < sh_basic_info.csv >\n\n basic_info = read_csv_file('sh_basic_info.csv')\n\n # 6.2: Create instances of < SuperHeroine >\n\n heroines = {}\n for hero in basic_info:\n heroines[hero['name']] = SuperHeroine(hero['name'], hero['full_name'], hero['team'],\n hero['eye_color'], hero['hair_color'], hero['base'])\n print(heroines)\n\n # 6.3: Read in < sh_additional_info.csv >\n\n additional_info = read_csv_file('sh_additional_info.csv')\n\n # 6.4: Add powers and nemesis\n\n for row in additional_info:\n name = row[\"Heroine Name\"]\n instance_affected = heroines[name]\n how_affected = row[\"Category\"]\n value = row['Value']\n if how_affected == 'power':\n instance_affected.add_power(value)\n else:\n instance_affected.add_nemesis(value)\n\n # 6.5: Write to file\n\n write_to_file('storm.txt',heroines['Storm'])\n write_to_file('scarlet_witch.txt',heroines['Scarlet Witch'])\n write_to_file('jessica_jones.txt',heroines['Jessica Jones'])"},"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 main():\n raw_data = pd.read_csv('data/raw_hospital_data.csv')\n\n fe_data = new_features(raw_data)\n fe_data = compressing_admission_type(data)\n fe_data = age_to_cat(fe_data)\n fe_data = compressing_careunit(fe_data)\n fe_data = compressing_curr_serv(fe_data)\n fe_data = compressing_ethnicity(fe_data)\n fe_data = compressing_marital_status(fe_data)\n fe_data = compressing_religion(fe_data)\n fe_data = compressing_admit_location(fe_data)\n fe_data = compress_icd9_codes(fe_data)\n\n fe_data.to_csv('data/feature_engineering_data.csv')","def __init__(self):\n self.project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\n self.excel_file = os.path.join(self.project_dir, \"data\", \"Literature_Data.xlsx\")\n self.spreadsheet_name = \"Individualized Data\"\n self.filled_output_file = os.path.join(self.project_dir, \"data\", \"filled_data.csv\")\n self.output_file = os.path.join(self.project_dir, \"data\", \"final.csv\")\n self.use_fake_data = False # For testing\n # This instance value \"self.df\" is the pandas DataFrame that contains all of the data\n # from the literature case studies. Manipulating this field is the purpose of this class.\n \n self.num_negative = 500\n self.df = None","def main():\n try:\n\n logger = settings.get_logger(__name__)\n\n # if not (check_for_data()):\n # raise Exception(\"The following files were not all found: %s\"%(\"files\")) \n\n logger.info(\"*** Import data from raw files ***\")\n #load raw file\n\n logger.info(\"Load raw data file (Huge file, please be patient)...\")\n p1c1File = \"histo_7cerf_p1c1.txt\"\n df_histo_p2c1_jour = pd.read_csv(settings.raw_path + p1c1File, sep = \",\", encoding = 'utf-8', header = None,dtype={0:str,2:str,3:str}).fillna(0)\n\n #prepare sales dataframe\n logger.info(\"Droping uneccessary columns...\")\n sales_df= df_histo_p2c1_jour.drop([1,3,4,5,6],axis=1)\n\n #set headers\n logger.info(\"Setting headers info...\")\n end_date = \"01-14-2019\"\n columns = settings.row_headers\n nb_days = len(sales_df.columns) - len(columns)\n date_range = pd.date_range(end = end_date,periods = nb_days, freq='1w').strftime(\"%d/%m/%Y\")\n columns.extend(date_range)\n sales_df.columns = columns\n\n #drop Client 0\n sales_df = sales_df[sales_df[\"Client\"]!=0]\n\n #Get p1c1 keys\n p1c1 = sales_df[[\"Product\",\"Client\"]].dropna().drop_duplicates().astype(str).copy()\n\n #Product table\n logger.info(\"Loading products descriptions...\")\n product_df = get_product_df(\"product_7cerf.txt\")\n #save product season mapping\n save_product_season(product_df)\n\n #Get keys table from previous files\n p1c1p2 = p1c1.join(product_df[[\"Key_lvl2\"]],on =[\"Product\"]).dropna().set_index([\"Product\"]).astype(str)\n\n\n #save sales history\n save_p2_sales(sales_df,p1c1p2)\n \n #Get client talbe\n logger.info(\"Loading clients descriptions...\")\n client_df = get_clients_df(\"client_7cerf.txt\",columns =[\"Store Level\",\"Business Area\"] )\n cli_features = p1c1p2.join(client_df,on=\"Client\",how=\"left\").drop([\"Client\"],axis=1)\n\n \n\n #Calculate store counts\n logger.info(\"Saving store counts file...\")\n save_storecounts(cli_features,p1c1p2)\n\n \n\n #Client counts by p2\n logger.info(\"Saving clients count by product...\")\n save_clients_count(p1c1p2)\n # return True\n except Exception as err:\n print(err)\n logger.error(err)\n # return False","def main():\n # openfile allows for CSV files with stored data of two columns\n # data = openfile(\"filename\")\n data = get_data()\n abtest = AB_test(data)\n abtest.stats()\n abtest.print_stats()","def main():\n # Load in original data\n origin_data = pd.read_csv('/Users/apple/Desktop/CSE_163/cse163_project/'\n + 'Admission_Predict_Ver1.1.csv',\n sep=r'\\s*,\\s*', header=0, encoding='ascii',\n engine='python')\n\n # Research question 1\n lasso_regression(origin_data)\n\n # Research question 2\n # We drop the 'Serial No.' column because it is unrelated to our analysis.\n df = origin_data.drop(columns=['Serial No.'])\n find_correlation(df)\n boxplots_testscores_vs_admission(df)\n\n # Research question 3\n university_rating_analysis(origin_data)","def handle(self, *args, **options):\n try:\n # csv path argument\n fpath = options['csv_path']\n # checks if file is csv\n if fpath.lower().endswith('csv'):\n encoding = get_encoding(fpath)\n with open(fpath, encoding=encoding) as file:\n reader = csv.reader(file, delimiter=\",\")\n # iterating through each row in csv\n for row in reader:\n try:\n create_instance(row[0].strip(), row[1].strip(),\n row[2].strip())\n except IntegrityError:\n # duplicate information\n self.stderr.write(self.style.WARNING(\n \"(Warning) \"\n \"Duplicate Information: {}\".format(row)))\n except IndexError:\n # problem extracting missing information\n self.stderr.write(self.style.WARNING(\n \"(Warning) Incorrect Format: {}\".format(row)))\n except ValueError:\n # missing information\n self.stderr.write(self.style.WARNING(\n \"(Warning) Missing Value: {}\".format(row)))\n except ObjectDoesNotExist:\n # queried object does not exist\n self.stderr.write(self.style.WARNING(\n \"(Warning) \"\n \"ObjectDoesNotExist: {}\".format(row)))\n else:\n # file not csv\n self.stderr.write(self.style.ERROR(\"(Error) \"\n \"File not of type csv.\"))\n except FileNotFoundError:\n # file path does not exist\n self.stderr.write(self.style.ERROR(\"(Error) File does not exist.\"))\n except IOError:\n # error reading file\n self.stderr.write(self.style.ERROR(\"(Error) Error reading file.\"))","def main():\n scores_file = open(\"scores.csv\")\n scores_data = scores_file.readlines()\n print(scores_data)\n subjects = scores_data[0].strip().split(\",\")\n score_values = []\n for score_line in scores_data[1:]:\n score_strings = score_line.strip().split(\",\")\n score_numbers = [int(value) for value in score_strings]\n score_values.append(score_numbers)\n scores_file.close()\n scores_by_subjects = reorganise_score(score_values)\n subject_details(scores_by_subjects, subjects)","def run():\n options = [\"Add\", \"Remove\", \"Update\", \"Oldest person\", \"Persons closest to average\"]\n common_options = [\"Name: \", \"Year: \"]\n file = \"model/hr/persons.csv\"\n title_list = [\"Id\", \"Name\", \"Year\"]\n choice = None\n dont_clear = False\n while choice != '0':\n if not dont_clear:\n os.system(\"clear\")\n table = data_manager.get_table_from_file(file)\n terminal_view.print_table(table, title_list)\n choice = terminal_view.get_choice_submenu(options)\n dont_clear = False\n if choice == '1':\n common.add(file, common_options)\n elif choice == '2':\n common.remove(file)\n elif choice == '3':\n common.update(file, common_options)\n elif choice == '4':\n terminal_view.print_result(hr.get_oldest_person(table), \"Oldest persons:\\n\")\n dont_clear = True\n elif choice == '5':\n msg = \"Persons with age closest to average:\\n\"\n terminal_view.print_result(hr.get_persons_closest_to_average(table), msg)\n dont_clear = True\n else:\n terminal_view.print_error_message(\"There is no such choice.\")","def main():\n filename = \"data/exercise.csv\"\n analyze(filename)","def main():\n\n #get the csv file into a data-frame\n universities_df = pd.read_csv('universities_data.csv', encoding = 'utf-8-sig')\n universities_names_list = universities_df['name'].tolist()\n\n #get list of university objects\n url = 'http://universities.hipolabs.com/search?country=Israel'\n api_universities = Get_universities(url)\n list_of_universities = api_universities.get_universities_info()\n\n #to see if we got new entities or not for exporting to csv later..\n is_new_entities = False\n\n for university in list_of_universities:\n if university.name not in universities_names_list:\n is_new_entities = True\n universities_df= universities_df.append(pd.DataFrame({\n 'alpha_two_code': [university.alpha_two_code], \n 'country': [university.country],\n 'web_pages': [str(university.web_pages)],\n 'domains': [str(university.domains)],\n 'name': [university.name],\n 'state_province':[str(university.state_province)]}) , ignore_index = True)\n\n #export back to csv if true\n if is_new_entities: \n print('we got new entities!') \n universities_df.to_csv('universities_data.csv', encoding = 'utf-8-sig', index = False)\n else:print('no new universities for now!')","def main():\n with open('csv_files/products.csv', 'a') as data_file:\n # Move to the next line before appending new row to the file\n data_file.write(\"\\n\")\n data_writer = csv.writer(data_file)\n for i in range(5, 10000):\n data_writer.writerow([str(i+1), \" description{}\".format(str(i)),\n \" type{}\".format(str(i)),\n \" {}\".format(str(random.randint(1, 100)))])\n\n with open('csv_files/customers.csv', 'a') as data_file:\n # Move to the next line before appending new row to the file\n data_file.write(\"\\n\")\n data_writer = csv.writer(data_file)\n for i in range(5, 10000):\n data_writer.writerow([str(i+1), \" first_name{}\".format(str(i)),\n \" last_name{}\".format(str(i)),\n \" address{}\".format(str(i)),\n \" phone_number{}\".format(str(i)),\n \" email{}\".format(str(i))])","def main():\n path_for_data = '/Users/avielshtern/Desktop/semb/iml/IML.HUJI-master/data/kc_house_data (1).csv'\n design_matrix, response_vector = load_data(path_for_data)\n putting_it_all_together_1(design_matrix, response_vector)\n putting_it_all_together_2(design_matrix, response_vector)\n feature_evaluation(design_matrix, response_vector)","def main():\n\n dataframes = importing(['admissions_data', 'patient_data',\n 'diagnoses_icd_data', 'services_data',\n 'icustays'])\n merged_data = merging_data(dataframes)\n cleaned = data_cleaning(merged_data)\n\n cleaned.to_csv('raw_hospital_data.csv')","def __init__(self, args):\n self.verbose = args.verbose\n self.force = args.force\n self.extra = args.extra\n self.master_csv = args.master\n self.new_files = args.new_files\n self.df_mas_lab_data = None # Master Lab data\n self.df_new_lab_data = None # Aggregated new Lab data\n self.columns = [\n \"CLIA\",\n \"FACILITY_TYPE\",\n \"CERTIFICATE_TYPE\",\n \"LAB_NAME\",\n \"STREET\",\n \"CITY\",\n \"STATE\",\n \"ZIP\",\n \"PHONE\",\n ]","def main():\n now = time.strftime('%Y%m%d%H%M%S')\n\n # info = get_info(now)\n # info_filename = 'info_' + now + '.csv'\n # info.to_csv(os.path.join('..', '..', 'data', 'raw', info_filename), index=False)\n\n questions = get_questions(now)\n\n # don't talk about all this detail in the talk","def main():\n\n csv_file = \"shortlist.csv\"\n team_count = 0\n participant_count = 0\n\n\n #Delete all existing teams and participants from the database.\n Team.objects.all().delete()\n Participant.objects.all().delete()\n\n with open(csv_file) as f:\n reader = csv.reader(f)\n data = [row for row in reader]\n\n for item in data:\n if item[0]:\n team_count += 1\n\n t = Team.objects.create(\n name=item[0].strip(),\n idea=item[30].strip()\n )\n\n no_of_p = int(item[1])\n print item[1]\n participant_count += no_of_p\n\n p1 = Participant.objects.create(\n participant_id=get_pid(),\n name=item[2].strip() + \" \" + item[3].strip(),\n gender=item[4].strip(),\n college=item[7].strip(),\n email=item[5].strip(),\n phone=str(item[6]),\n team=t\n )\n\n p2 = Participant.objects.create(\n participant_id=get_pid(),\n name=item[11].strip() + \" \" +item[12].strip(),\n gender=item[13].strip(),\n college=item[16].strip(),\n email=item[14].strip(),\n phone=str(item[15]),\n team=t\n )\n\n if no_of_p == 3:\n p3 = Participant.objects.create(\n participant_id=get_pid(),\n name=item[20].strip() + \" \" +item[21].strip(),\n college=item[25].strip(),\n gender=item[22].strip(),\n email=item[23].strip(),\n phone=str(item[24]),\n team=t\n )\n\n print \"{} teams and {} participants imported.\".format(team_count,\n participant_count)","def __init__(self):\n self.file_name = 'data.csv'\n # Column of interest\n self._col = ['product_name', 'url', 'quantity', 'packaging']\n self._col += ['brands', 'origins', 'countries_fr', 'allergens']\n self._col += ['traces_fr', 'additives_n', 'additives_fr']\n self._col += ['nutrition_grade_fr', 'categories_fr']\n self._col += ['main_category_fr']\n\n # Check if the csv is already in the file\n try:\n with open(self.file_name, 'r'):\n pass\n except FileNotFoundError:\n CsvAnalysis.download_file()\n finally:\n # Read the csv file, and create a dataframe\n self.food_cat = pandas.read_csv(self.file_name,\n sep=\"\\t\",\n low_memory=False,\n usecols=self._col,\n encoding=\"utf8\")\n\n # Remove countries which aren't France\n mask = self.food_cat['countries_fr']\n self.food_cat = self.food_cat[mask == 'France']\n\n # Delete column countries_fr\n del self.food_cat['countries_fr']\n\n # Remove empty row countries_fr from dataframe\n columns = ['main_category_fr', 'product_name', 'nutrition_grade_fr']\n for column in columns:\n self.food_cat = self.food_cat[~self.food_cat[column].isnull()]\n\n # Remove empty row from product_name\n self.food_cat.sort_values(by='categories_fr')\n\n # Select the last value from categories_fr\n # to use it as a subcategory\n col = 'categories_fr'\n self.food_cat[col] = self.food_cat[col].str.split(',').str.get(-1)\n self.food_cat.sort_values(by='categories_fr')","def __init__(self):\r\n self.filter_p_number = 3 # First one with enough data for statistics\r\n self.prfs_d = extract_settings_elvis()\r\n\r\n ccds = True\r\n filtered = False\r\n scamp = False\r\n\r\n input_df = read_csv('cats/cat_clean_ssos.csv', index_col=0)\r\n filt_cat = self.gets_filtered_catalog() # Gets data from filtered\r\n\r\n if ccds:\r\n cats_d = self.extract_cats()\r\n self.extract_stats_ccds(cats_d, input_df, filt_cat)\r\n elif filtered:\r\n self.extract_stats_filt(filt_cat, input_df)\r\n elif scamp:\r\n pass\r\n # self.extract_stats_scamp(input_df)\r\n else:\r\n pass","def main():\n draft_class = 56\n from_csv = 'smjhl-2020-09-10.csv'\n to_csv = 'S' + str(draft_class) + '-bmi.csv'\n\n\n full_data = pd.read_csv(f\"../{from_csv}\")\n draft_class_data = full_data.loc[full_data['Draft Class Numeric'] == draft_class].copy()\n height_weight_raw = draft_class_data[[\"First Name\", \"Last Name\", \"Height\", \"Weight\"]]\n\n bmi_chart = bmi_magic(height_weight_raw)\n bmi_chart = bmi_chart.sort_values(by=[\"BMI\"], axis=0, ascending=False)\n\n # print(full_data)\n print(bmi_chart)\n bmi_chart.to_csv(to_csv)","def main():\n\n # Read the CSV and get its content\n jobOfferList, professionsList = usefulFunctions.readCsv()\n \n # Create an empty output tab with the right number of lines and columns\n finalTab = usefulFunctions.createEmpty(jobOfferList, professionsList)\n \n # Fill the tab\n finalTab = usefulFunctions.fillTabExceptTotals(jobOfferList, professionsList, finalTab)\n \n # Update the totals \n finalTab = usefulFunctions.fillTotals(finalTab)\n \n print(\"\\nTable des métiers par profession et type de contrat : \")\n for line in finalTab:\n print(line)","def part1():\n print('=== Starting Part 1 ===')\n data = pd.read_csv(DATA)\n\n print('Number of species:', hw2_pandas.species_count(data))\n print('Highest level pokemon:', hw2_pandas.max_level(data))\n print('Low-level Pokemon', hw2_pandas.filter_range(data, 1, 9))\n print('Average attack for fire types',\n hw2_pandas.mean_attack_for_type(data, 'fire'))\n print('Count of each Pokemon type:')\n print(hw2_pandas.count_types(data))\n print('Highest stage for each Pokemon type')\n print(hw2_pandas.highest_stage_per_type(data))\n print('Average attack for each Pokemon type')\n print(hw2_pandas.mean_attack_per_type(data))","def test_add_data():\n add_furniture(\"invoice_file.csv\", \"Elisa Miles\", \"LR04\", \"Leather Sofa\", 25.00)\n add_furniture(\"invoice_file.csv\", \"Edward Data\", \"KT78\", \"Kitchen Table\", 10.00)\n add_furniture(\"invoice_file.csv\", \"Alex Gonzales\", \"BR02\", \"Queen Mattress\", 17.00)","def main():\n s = content.DataFiles()\n \n date_list = generate.get_list_dates(2016, 2016, 500)\n prod_list = list(s.get_collist_by_name(os.path.join(content.data_fldr,'food','garden_produce.csv'), 'name')[0])\n \n tbl_cust = generate.TableGenerator(8, ['STRING','PEOPLE', 'PEOPLE', 'PLACE'], ['Customer ID', 'First Name', 'Surname', 'Country'])\n tbl_cust.save_table('customers.csv')\n cust_list = list(s.get_collist_by_name('customers.csv', 'Customer ID')[0])\n \n tbl_sales = generate.TableGenerator(25, [date_list, cust_list, prod_list, 'CURRENCY'], ['Date of sale', 'Customer ID', 'Product', 'Amount'])\n tbl_sales.save_table('sales.csv')","def main():\n\n # start at loading the dataset\n data = h1bdata_loading()\n merged_data = pd.concat([data[year] for year in range(2010,2017)], ignore_index= True)\n raw_data = h1b_data(data)\n \n \n\n # Then clean the data\n #h1b_data = Clean_df(raw_data)\n #print(\"data cleaned >>>\")\n\n\n while True:\n try:\n print (\"================================ H1b Visa Approve Rate Exploring ================================\")\n print (\"\")\n print (\" How do you want to explore the H1b Data? \")\n print (\" <a> : Overview \t\t \")\n print (\" <b> : Location \")\n print (\" <c> : Industry \")\n print (\" <d> : Company \") \n print (\" You can always input 'quit' to leave the system \")\n print (\"=================================================================================================\")\n\n key = option_input()\n if key == 'a':\n overview(data)\n if key == 'b':\n location(data)\n if key == 'c':\n industry_exploring(merged_data)\n if key == 'd':\n company_exploring(merged_data)\n except wrong_option_exception:\n print (\"Invalid option, please reselect.\")","def main(argv):\n # Question 1\n # Saves the features given in a list\n features = (argv[2].split(sep=\", \"))\n the_data = data.load_data(argv[1], features)\n statistic_functions = [sum, mean, median]\n # Saves the relevant records\n summer_data, not_summer = data.filter_by_feature(the_data, \"season\", [1])\n holiday_data, not_holiday = data.filter_by_feature(the_data, \"is_holiday\", [1])\n print(\"Question 1:\")\n print(\"Summer:\")\n data.print_details(summer_data, [\"hum\", \"t1\", \"cnt\"], statistic_functions)\n print(\"Holiday:\")\n data.print_details(holiday_data, [\"hum\", \"t1\", \"cnt\"], statistic_functions)\n print(\"All:\")\n data.print_details(the_data, [\"hum\", \"t1\", \"cnt\"], statistic_functions)\n\n # Question 2\n print(\"\\nQuestion 2\")\n print(\"If t1<=13.0, then:\")\n # Saves the relevant records\n winter_data, not_winter = data.filter_by_feature(the_data, \"season\", [3])\n w_h_data, not_w_h_data = data.filter_by_feature(winter_data, \"is_holiday\", [1])\n population_statistics(\"Winter holiday records:\", w_h_data, \"t1\", [\"cnt\"], THRESHOLD, 0, statistic_functions[1:])\n population_statistics(\"Winter weekday records:\", not_w_h_data, \"t1\", [\"cnt\"], THRESHOLD, 0, statistic_functions[1:])\n print(\"If t1>13.0, then:\")\n population_statistics(\"Winter holiday records:\", w_h_data, \"t1\", [\"cnt\"], THRESHOLD, 1, statistic_functions[1:])\n population_statistics(\"Winter weekday records:\", not_w_h_data, \"t1\", [\"cnt\"], THRESHOLD, 1, statistic_functions[1:])","def main():\n print(time.time())\n data = '../datasets/between_phase/clean_df.csv'\n print(\"Process Beginning\")\n print(\"Reading Clean CSV\")\n clean_df = pd.read_csv(data, dtype={\"journey_pattern_id\": str})\n print(clean_df.shape)\n base_table = Base_Table(clean_df)\n print(\"Adding datetime\")\n base_table.add_datetime()\n print(\"Adding Day\")\n base_table.add_day()\n print(\"Adding Hour\")\n base_table.add_hour()\n print(\"Adding Time Bin\")\n base_table.add_time_bin()\n print(\"Adding Weekend Boolean\")\n base_table.add_weekend()\n print(\"Adding Distance\")\n base_table.add_distance_feature()\n print(\"Updating Stop Id\")\n base_table.add_nearest_stop_distance()\n print(\"Filtering Data\")\n base_table.remove_null_stops()\n print(\"Adding Travel Time\")\n base_table.add_travel_time()\n print(\"Adding Congestion\")\n base_table.congestion_feature()\n bs = base_table.get_df()\n bs.to_csv('../datasets/output_files/base_table.csv')\n return bs","def load(cls):\n \n # Loop through procedures and build patient procedure lists:\n procs = csv.reader(file(PROCEDURES_FILE,'U'),dialect='excel-tab')\n header = procs.next() \n for proc in procs:\n cls(dict(zip(header,proc))) # Create a procedure instance ","def main():\n data = pd.read_csv('countries.csv')\n # import_data_pandas(data)\n # continent_data(data)\n # continent_data_le(data)\n continent_data_gdp_growth(data)","def main(raw_filepath, interim_filepath, processed_filepath):\n raw_filepath = Path(raw_filepath)\n interim_filepath = Path(interim_filepath)\n processed_filepath = Path(processed_filepath)\n\n logger = logging.getLogger(__name__)\n logger.info('making final data set from raw data')\n\n years = ['2010', '2011', '2012', '2013', '2014']\n\n #############################################################\n ################ Life Expectancy Outcome ####################\n #############################################################\n\n le_birth = pd.read_csv(raw_filepath / 'US_A.csv',\n usecols=['Tract ID', 'e(0)'],\n dtype={'Tract ID': \"object\"}) \\\n .rename(columns={'Tract ID': 't10_cen_uid_u_2010'}) \\\n .set_index('t10_cen_uid_u_2010')\n\n le_other = pd.read_csv(raw_filepath / 'US_B.csv',\n usecols=['Tract ID', 'Age Group', 'e(x)'],\n dtype={'Tract ID': \"object\"}) \\\n .rename(columns={'Tract ID': 't10_cen_uid_u_2010'}) \\\n .set_index(['t10_cen_uid_u_2010', 'Age Group']) \\\n .sort_index() \\\n .loc[(slice(None), ['15-24', '35-44', '55-64']), :] \\\n .unstack() \\\n .reindex(le_birth.index) # use the same tracts for all experiments\n\n le_other.columns = ['e(20)', 'e(40)', 'e(60)']\n\n # le_birth.to_csv(processed_filepath / 'y_00.csv', header=True)\n # le_other['e(20)'].to_csv(processed_filepath / 'y_20.csv', header=True)\n # le_other['e(40)'].to_csv(processed_filepath / 'y_40.csv', header=True)\n # le_other['e(60)'].to_csv(processed_filepath / 'y_60.csv', header=True)\n\n\n ##############################################################\n ################## Priority Dataset ##########################\n ##############################################################\n\n with open(raw_filepath / 'T10_Priority_Wide_Interpolated.csv', 'r') as f:\n cols = f.readline().strip().split(',')\n\n proj_cols = [x for x in cols if x[-4:] in years]# and\n # get all the priority NETS columns for later\n net_cols = ['t10_cen_uid_u_2010'] + [x[:11] + '_d_' + x[14:] for x in cols if '_net_' in x]\n\n data_X = pd.read_csv(raw_filepath / 'T10_Priority_Wide_Interpolated.csv', usecols=proj_cols,\n dtype={'t10_cen_uid_u_2010': \"object\"}) \\\n .set_index('t10_cen_uid_u_2010')\n\n # Create % younger than 25 (this method is far less than ideal)\n ag25up = data_X.filter(regex='.*(_pop_c_|ag25up).*')\n ag25up_coltuples = [(x[:-4], x[-4:]) for x in ag25up.columns]\n ag25up.columns = pd.MultiIndex.from_tuples(ag25up_coltuples)\n ag25up_long = ag25up.stack()\n ag25dwn_p = ((ag25up_long['t10_ldb_pop_c_'] - ag25up_long['t10_ldb_ag25up_c_'])\n / ag25up_long['t10_ldb_pop_c_']).unstack()\n ag25dwn_p.columns = ['t10_ldb_ag25dwn_p_' + x for x in ag25dwn_p.columns]\n\n # Create % older than 65\n ag65up = data_X.filter(regex='.*(_pop_c_|a60up).*')\n ag65up_coltuples = [(x[:-4], x[-4:]) for x in ag65up.columns]\n ag65up.columns = pd.MultiIndex.from_tuples(ag65up_coltuples)\n ag65up_long = ag65up.stack()\n ag65up_p = (ag65up_long['t10_ldb_a60up_c_'] / ag65up_long['t10_ldb_pop_c_']) \\\n .unstack()\n ag65up_p.columns = ['t10_ldb_ag60up_p_' + x for x in ag65up_p.columns]\n\n # Add our new measure\n data_X = pd.concat([data_X, ag25dwn_p, ag65up_p], axis=1)\n\n # Get rid of all count variables, including nets\n no_count_cols = [x for x in data_X.columns if '_c_' not in x]\n data_X = data_X[no_count_cols]\n\n\n drop_cols = ['t10_gis_area_l_2010',\n 'm10_cen_uid_u_2010',\n 'm10_cen_memi_x_2010',\n 'c10_cen_uid_u_2010',\n 'z10_cen_uid_u_2010']\n\n data_X = data_X.drop(columns=drop_cols) \\\n .reindex(le_birth.index)\n\n data_X.columns = pd.Index([(x[:-5], int(x[-4:])) for x in data_X.columns])\n\n X_priority = data_X.groupby(axis=1, level=0).mean()\n X_priority.to_csv(interim_filepath / 'X_priority.csv')\n\n ###########################################################\n #################### NETS Dataset #########################\n ###########################################################\n\n X_nets_allyrs = pd.read_csv(raw_filepath / 'recvd_t10_vars_v8_20190607.csv', usecols=net_cols,\n dtype={'t10_cen_uid_u_2010': \"object\"}) \\\n .set_index('t10_cen_uid_u_2010') \\\n .reindex(le_birth.index)\n\n X_nets_allyrs.columns = pd.Index([(x[:-5], int(x[-4:])) for x in X_nets_allyrs.columns])\n X_nets = X_nets_allyrs.groupby(axis=1, level=0).mean()\n X_nets.to_csv(interim_filepath / 'X_nets.csv')\n\n # Split predictive data by Variable Set\n X_all = pd.concat([X_priority, X_nets], axis=1) \\\n .dropna(how='any')\n\n final_index = le_birth.index.intersection(X_all.index)\n X_all = X_all.reindex(final_index)\n le_birth = le_birth.reindex(final_index)\n le_other = le_other.reindex(final_index)\n\n le_birth.to_csv(processed_filepath / 'y_00.csv', header=True)\n le_other['e(20)'].to_csv(processed_filepath / 'y_20.csv', header=True)\n le_other['e(40)'].to_csv(processed_filepath / 'y_40.csv', header=True)\n le_other['e(60)'].to_csv(processed_filepath / 'y_60.csv', header=True)\n\n # Var Set 1\n p1_features = ['t10_ldb_hinci_m',\n 't10_ldb_pop_d',\n 't10_ldb_nhblk_p',\n 't10_ldb_hisp_p',\n 't10_ldb_col_p']\n X_p1 = X_all[p1_features]\n X_p1.to_csv(processed_filepath / 'X_varGroup1.csv')\n\n # Var Set 2\n p2_features = [\n \"t10_ldb_hinci_m\",\n \"t10_ldb_pop_d\",\n \"t10_ldb_ag25dwn_p\",\n \"t10_ldb_ag60up_p\",\n \"t10_ldb_nhblk_p\",\n \"t10_ldb_hisp_p\",\n \"t10_ldb_col_p\",\n \"t10_ldb_lep_p\",\n \"t10_ldb_mrenti_m\",\n \"t10_ldb_multi_p\",\n \"t10_ldb_nhwht_p\",\n \"t10_ldb_asian_p\",\n \"t10_ldb_fb_p\",\n \"t10_ldb_hs_p\",\n \"t10_ldb_unemp_p\",\n \"t10_ldb_npov_p\",\n \"t10_ldb_vac_p\",\n \"t10_ldb_own_p\",\n \"t10_ldb_mhmvali_m\"\n ]\n X_p2 = X_all[p2_features]\n X_p2.to_csv(processed_filepath / 'X_varGroup2.csv')\n\n # Var Set 3\n X_p3 = X_nets.reindex(final_index)\n X_p3.to_csv(processed_filepath / 'X_varGroup3.csv')\n\n # Var Set 4\n X_p4 = X_all\n X_p4.to_csv(processed_filepath / 'X_varGroup4.csv')","def __init__(self, file_path):\n # will raise an error if the path is invalid, we don't need an\n # if statement here\n df = pandas.read_excel(file_path)\n\n \"\"\"\n read in the cities using a dictionary comprehension\n dictionary = { key: value for elem in iterable }\n In this case we are reading in the name of the city as the key\n and its corresponding CityLocation object as the value. We\n have made the assumption that each city has a unique name.\n \"\"\"\n #\n self.lulu = [Order(row[1][\"Date\"], row[1][\"Order Number\"],\n row[1][\"Brand\"], row[1][\"Garment\"],\n row[1][\"Count\"], row[1][\"Style name\"])\n for row in df.iterrows()\n if row[1][\"Brand\"] == \"Lululime\"]\n self.lulu = LululimeFactory()\n GarmentMaker(self.lulu)\n # brand = self.lulu[0].brand\n # garment = self.lulu[0].garment\n # print(brand)\n # print(garment)\n\n lulu_order = ((row[1][\"Date\"], row[1][\"Garment\"],\n row[1][\"Brand\"], row[1][\"Garment\"])\n for row in df.iterrows() if\n row[1][\"Brand\"] == \"Lululime\")\n for item in lulu_order:\n print(item)\n\n lulu_order = LululimeFactory()\n # test = GarmentMaker(lulu_order)\n # print(test)\n\n # for lulu in self.lulubrand:\n # print(lulu)\n # print(*self.lulubrand)","def main():\n logger = logging.getLogger(__name__)\n logger.info('making final data set from raw data')\n get_user_config()","def run_methods(self):\n try:\n # dictionaries of population time series\n self.batch_exponential()\n except Exception as e:\n print(str(e))","def __init__(self, cfg, radious, type_feature, type_filtering, h_filterig):\n print(\"feat test!!\")\n self.path_root = cfg['preprocessing']['path_root']\n self.path_data = cfg['data']['path']\n self.path_checkpoint = os.path.join(self.path_data, \"preprocess_checkpoint.csv\")\n self.file_checkpoint_data = open(self.path_checkpoint, \"a+\").close()\n # self.file_checkpoint_data.close()\n if (len(open(self.path_checkpoint).readlines()) == 0):\n print(\"creating the file...\")\n with open(self.path_checkpoint, \"a+\") as f:\n f.write('radious,type_feature,type_filtering,h_filterig'+ \"\\n\")\n self.init_refined = self.path_root + \"/data/new_refined/\"\n self.init_casf = self.path_root + \"/data/new_core_2016/\"\n self.dict_atoms = dict_atoms_hot\n self.dict_atoms_simple = dict_atoms_simple\n self.dict_words = atom_most_common\n self.dict_atoms_masses = dict_atoms_masses\n self.dict_atoms_charges = dict_atoms_charges\n self.radious = radious\n self.type_feature = type_feature\n self.type_filtering = type_filtering\n self.h_filterig = h_filterig\n ##################refined files###################\n self.files_refined = os.listdir(self.init_refined)\n self.files_refined = [file for file in self.files_refined if file[0].isdigit()]\n self.files_refined.sort()\n self.idx_files_refined = list(range(0, len(self.files_refined)))\n # self.idx_files_refined = [0, 1]\n self.max_length = 0\n # array_names = [str(radious), self.type_feature, self.type_filtering, self.h_filterig]\n # self.name_checkpoint_features = '_'.join(array_names)\n # os.makedirs(os.path.join(self.path_data, \"checkpoints\"), exist_ok=True)\n # self.path_checkpoint_features = os.path.join(self.path_data, \"checkpoints\", self.name_checkpoint_features + \".pkl\")\n # if (os.path.exists(self.path_checkpoint_features)):\n # print(\"loading feature ids...\")\n # checkpoint_features = torch.load(self.path_checkpoint_features)\n # self.idx_max_length = checkpoint_features['idx_max_length']\n # self.max_length = checkpoint_features['max_length']\n # self.idx_write = checkpoint_features['idx_write']\n # else:\n # self.idx_max_length = 130\n # self.max_length = 0\n # self.idx_write = 0\n # save_checkpoint_feature(self.path_checkpoint_features, self.idx_max_length, self.max_length, self.idx_write)\n\n # self.max_length = 0\n # self.write_filtered_pad_feat_geo()\n # else:\n # f, m, g = self._get_feat_geo_from_file(0)\n # self.max_length = f.shape[0]","def main():\n\n file_name_base = \"./lab-record/result/fairness/\"\n scenarios = ['lan', 'wan1', 'wan2']\n scenario = scenarios[2]\n\n algorithms = [\"bbr\", \"scalable\", \"bic\", \"highspeed\", \"htcp\", \"hybla\",\n \"illinois\", \"vegas\", \"yeah\"]\n names = [\"BBR\", \"Scalable\", \"BIC\", \"High Speed\",\n \"H-TCP\", \"Hybla\", \"Illinois\", \"Vegas\", \"YeAH\"]\n\n test_types = [\"vs_reno\", \"vs_cubic\", \"vs_itself\"]\n\n fsize = 36\n \n index_reno = []\n index_cubic = []\n index_itself = []\n\n data = []\n \n print 'Loadint statistics for ' + file_name_base + '/' + scenario\n\n for algorithm in algorithms:\n for test in test_types:\n path_base = file_name_base + \"/\" + scenario + \"/\" + test + \"/\" + \\\n algorithm + \"/\"\n if test == \"vs_itself\":\n exp_name = names[algorithms.index(algorithm)] + \"_1\"\n con_name = names[algorithms.index(algorithm)] + \"_2\"\n print path_base + exp_name\n print path_base + con_name\n exp_filename = \"/\" + algorithm + \"_1.log\"\n con_filename = \"/\" + algorithm + \"_2.log\"\n process(path_base, exp_filename, con_filename, index_itself)\n if test == \"vs_reno\":\n exp_name = names[algorithms.index(algorithm)]\n con_name = \"Reno\"\n print path_base + exp_name\n print path_base + con_name\n exp_filename = \"/\" + algorithm + \".log\"\n con_filename = \"/reno.log\"\n process(path_base, exp_filename, con_filename, index_reno)\n if test == \"vs_cubic\":\n con_name = \"CUBIC\"\n exp_name = names[algorithms.index(algorithm)]\n print path_base + exp_name\n print path_base + con_name\n exp_filename = \"/\" + algorithm + \".log\"\n con_filename = \"/cubic.log\"\n process(path_base, exp_filename, con_filename, index_cubic)\n\n size = 9\n x = numpy.arange(size)\n\n total_width, n = 1.2, 2.5\n width = 1.0 / n\n x = x - (total_width - width) / 2\n\n for i in range(0, len(x)):\n x[i] += 0.5 * i\n\n # Exp\n fig = plt.figure()\n\n # Con\n con_reno = plt.bar(x + 0 * width - 1.2,\n index_reno,\n width=width,\n label='Against Reno',\n alpha=0.5,\n color=\"darkorange\")\n\n con_cubic = plt.bar(x + 1 * width - 1.2,\n index_cubic,\n width=width,\n label='Against CUBIC',\n alpha=0.5,\n color=\"lawngreen\")\n\n con_itself = plt.bar(x + 2 * width - 1.2,\n index_itself,\n width=width,\n label='Against Another Same CCA',\n alpha=0.5,\n color=\"dodgerblue\")\n\n # Index\n plt.xticks(x + 1.5 * width - 1.2, [\"BBR\", \"Scalable\", \"BIC\", \"High Speed\",\n \"H-TCP\", \"Hybla\", \"Illinois\", \"Vegas\",\n \"YeAH\"],\n fontsize=fsize,\n rotation=\"45\")\n plt.ylabel(\"Jain`s Fairness Index\", fontsize=fsize)\n plt.yticks(fontsize=fsize)\n plt.ylim(0.5, 1.1)\n\n ax = plt.subplot(111)\n ax.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,\n ncol=3, mode=\"expand\", borderaxespad=0., fontsize=fsize)\n\n plt.subplots_adjust(left=0.07, right=0.98, top=0.9, bottom=0.2)\n\n plt.show()","def __init__(self, data):\n\n self.produce_csv = data['produce_csv']\n self.produce_graphics = data['produce_graphics']\n self.report_name = data['report_name']\n self.file_name = self.report_name + '.csv'\n self.annual_file_name = self.report_name + '_annual.csv'\n self.csv_dir = ''\n self.diagnostic_dir = ''\n\n self.daily_variables = {\n 'year': ['time.cal_year', '', []],\n 'j_day': ['time.day', '', []]\n }\n\n self.annual_variables = {\n 'year': ['time.cal_year', '', 0]\n }","def main():\r\n run_processes('tests.csv', 'labs.csv')","def ERCC_Stat(self):\n self.l_ERCC_name = []\n# self.l_RGCs_name = []\n self.l_mRNA_name = []\n self.l_ERCC_FPKM = {}\n# self.l_RGCs_FPKM = {}\n self.l_mRNA_FPKM = {}\n\n self.l_ERCC_UMI = {}\n self.l_mRNA_UMI = {}\n\n# self.l_cirRNA_FPKM={}\n \n self.l_ERCC_HTSname = []\n# self.l_RGCs_HTSname = []\n self.l_mRNA_HTSname = []\n self.l_ERCC_RPKM = {}\n# self.l_RGCs_RPKM = {}\n self.l_mRNA_RPKM = {}\n \n \n self.l_ERCC_MOLs = {}\n# self.l_RGCs_MOLs = {}\n self.l_mRNA_MOLs = {}\n self.l_cirRNA_MOLs={}\n self.l_mRNA_MOLs_HTSname = {}\n \n self.regression = {}\n \n self.__load_FPKM()\n self.__load_MOLs() # ERCC RGC mols\n self.__get_mRNA_MOLs() # get mRNA mols using ERCC_FPKM, ERCC_MOLs and mRNA_FPKM\n# self.__load_Count()\n self.__load_umi()\n \n out_file = \"%s/02.%s.ERCC_Mols.xls\" % (self.dir_StatInfo, self.s_idx)\n f_out_file = open( out_file,\"w\" )\n \n l_info = [\n \"Sample\", \"ERCC_MOLs\", \"mRNA_MOLs\",\n \"RefSeq_mRNA_MOLs\", \"Regression_R\",\n \"Regression_P\", \"RefSeq_mRNA_TPM>0\", \"ERCC_UMI\", \"RefSeq_mRNA_UMI\"\n ] \n print >>f_out_file, \"\\t\".join(l_info)\n \n for samp in self.samInfo_pd_RNA['sample']:\n idx = (self.samInfo_pd_RNA['sample'] == samp)\n brief_name = self.samInfo_pd_RNA[idx]['brief_name'].values[0]\n rename = self.samInfo_pd_RNA[idx]['rename'].values[0]\n\n ERCC_MOLs = sum( self.l_ERCC_MOLs[brief_name])\n# RGC_MOLs = sum( self.l_RGCs_MOLs[brief_name])\n mRNA_MOLs = np.sum(self.l_mRNA_MOLs[brief_name])\n RefSeq_mRNA_MOLs = \\\n np.sum(self.l_mRNA_MOLs[brief_name][self.mRNA_refSeq_index])\n \n RefSeq_mRNA_lFPKM = \\\n np.array(self.l_mRNA_FPKM[brief_name],dtype=float)\n \n RefSeq_mRNA_lFPKM = RefSeq_mRNA_lFPKM[ self.mRNA_refSeq_index ]\n RefSeq_mRNA_Exps = \\\n np.shape(RefSeq_mRNA_lFPKM[RefSeq_mRNA_lFPKM > 0])[0]\n\n regression_R = self.regression[brief_name]['r_value']\n regression_P = self.regression[brief_name]['p_value']\n \n RefSeq_mRNA_lUMI = \\\n np.array(self.l_mRNA_UMI[brief_name],dtype=int)\n\n RefSeq_mRNA_UMI_count = np.sum( RefSeq_mRNA_lUMI )\n\n ERCC_lUMI = \\\n np.array(self.l_ERCC_UMI[brief_name],dtype=int)\n\n ERCC_UMI_count= np.sum( ERCC_lUMI )\n \n l_out = [\n rename,\n ERCC_MOLs, mRNA_MOLs, RefSeq_mRNA_MOLs,\n regression_R, regression_P, RefSeq_mRNA_Exps, ERCC_UMI_count, RefSeq_mRNA_UMI_count\n ]\n l_out = [str(i) for i in l_out]\n print >>f_out_file, \"\\t\".join(l_out)\n f_out_file.close()","def main():\n\n if os.path.exists(os.path.join(PROCESSED_PATH,\n 'all_posts_data.csv')):\n print(\"-- all_posts_data.csv found locally - delete interm files if rerun needed\")\n total_df = pd.read_csv(PROCESSED_PATH / 'all_posts_data.csv')\n else:\n training_post_filenames = glob.glob(os.path.join(DATA_DIR,\n 'raw',\n 'clpsych16-data',\n 'data',\n 'training',\n 'posts', '*.xml'))\n dev_post_filenames = glob.glob(os.path.join(DATA_DIR,\n 'raw',\n 'clpsych16-data',\n 'data',\n 'testing',\n 'posts', '*.xml'))\n\n new_posts2017 = glob.glob(os.path.join(DATA_DIR,\n 'raw',\n 'clpsych17-test',\n 'posts', '*.xml'))\n\n training_labels = os.path.join(DATA_DIR,\n 'raw',\n 'clpsych16-data',\n 'data',\n 'training',\n 'labels.tsv')\n dev_labels = os.path.join(DATA_DIR,\n 'raw',\n 'clpsych16-data',\n 'data',\n 'testing',\n 'labels.tsv')\n\n training_df = create_posts_df(training_post_filenames)\n dev_df = create_posts_df(dev_post_filenames)\n new_df = create_posts_df(new_posts2017)\n\n training_df['corpus_source'] = '2016train_2017train'\n dev_df['corpus_source'] = '2016test_2017train'\n new_df['corpus_source'] = '2017test'\n\n training_df = merge_post_labels(training_df, training_labels)\n dev_df = merge_post_labels(dev_df, dev_labels)\n\n training_df = merge_author_ranks(training_df)\n dev_df = merge_author_ranks(dev_df)\n new_df = merge_author_ranks(new_df)\n\n total_df = pd.concat([training_df, dev_df, new_df])\n\n test_labels = os.path.join(DATA_DIR,\n 'raw',\n 'clpsych17-test',\n 'test_ids.tsv')\n total_df.reset_index(inplace=True)\n total_df = merge_test_ids(total_df, test_labels)\n label_file = os.path.join(DATA_DIR,\n 'raw',\n 'clpsych17-test-labels.tsv')\n merge_ground_truth(total_df, label_file)\n output_path = PROCESSED_PATH / 'all_posts_data.csv'\n \n\n # clean body of text\n total_df['cleaned_body'], total_df['contained_quote'] = zip(*total_df['body'].apply(process_body))\n total_df['images'] = total_df['body'].apply(process_images)\n\n print('--Writing data to {}--'.format(output_path))\n total_df.to_csv(output_path, index=False)\n\n sentences_df = total_df.loc[:, ['post_id', 'cleaned_body', 'label', 'predict_me']]\n # the following will split posts into sentences and write out to a separate csv\n split_to_sentences(sentences_df)","def __init__(self, path):\n\n # Metadata Definition\n metadata = pd.read_csv(path, nrows=5, header=None)\n self.subject = str(metadata.loc[0, 0])\n base_date = dt.datetime.strptime(metadata.loc[2, 0], '%d.%m.%Y').date()\n if metadata.loc[4, 0] != 'Unknown Line':\n self.valid_measurements = str(metadata.loc[4, 0])\n else:\n metadata = pd.read_csv(path, nrows=6, header=None)\n self.valid_measurements = str(metadata.loc[5, 0])\n\n column_names = ['hour', 'minutes', 'SYS(mmHg)', 'DIA(mmHg)', 'UNKNOW_1', 'UNKNOW_2', 'CODE', 'UNKNOW_3']\n self.data = pd.read_csv(path, sep=',', skiprows=51, skipfooter=1, header=None, names=column_names, engine='python')\n\n # Adjusting Date\n dates = [base_date]\n times = [dt.time(hour=self.data.loc[i, 'hour'], minute=self.data.loc[i, 'minutes']) for i in range(len(self.data))]\n current_date = base_date\n for i in range(1, len(times)):\n if times[i] < times[i-1]:\n current_date += dt.timedelta(days=1)\n dates.append(current_date)\n\n self.data.reset_index(inplace=True)\n self.data['timestamp'] = pd.to_datetime([dt.datetime.combine(dates[i], times[i]) for i in range(len(dates))])\n self.data['date'] = dates\n self.data['time'] = times\n\n order = ['timestamp', 'date', 'time', 'SYS(mmHg)', 'DIA(mmHg)', 'UNKNOW_1', 'UNKNOW_2', 'UNKNOW_3', 'CODE']\n self.data = self.data[order]\n\n try:\n self.data.set_index('timestamp', inplace=True)\n except KeyError:\n print('Timestamp can not be set as an index:')\n print(KeyError)\n\n xml_line = open(path, 'r').readlines()[-1]\n xml_root = ET.fromstring(xml_line)\n self.metadata = self._etree_to_dict(xml_root)['XML']","def stat_parser():\n from tools import file_importer, file_outporter\n from math import log\n \n print(\"this is stat parser\")\n \n relPath = \"bob/processed/24h_bobdata_ed2.csv\"\n outPathUp = \"bob/processed/24h_bobprots_up_full.csv\"\n outPathDown = \"bob/processed/24h_bobprots_down_full.csv\"\n inpF = file_importer(relPath)\n outFUp = file_outporter(outPathUp)\n outFDown = file_outporter(outPathDown)\n \n \n skipFlag = True\n \n for inpLine in inpF:\n if skipFlag:\n skipFlag = False\n outFDown.write(\"ID,Uniprot ID,Gene name,unique peptides (unique+razor),KO1,KO2,KO3,WT1,WT2,WT3,enrichment,P value\\n\")\n outFUp.write(\"ID,Uniprot ID,Gene name,unique peptides (unique+razor),KO1,KO2,KO3,WT1,WT2,WT3,enrichment,P value\\n\")\n continue\n inpLine = inpLine.split(\"\\\" \\\"\")\n curLine = []\n for inpI in inpLine:\n curLine.append(inpI.strip(\"\\\"\\n\"))\n try: \n curLine[-1] = float(curLine[-1])\n except ValueError:\n curLine[-1] = 1 \n if curLine[-1] < 0.05 and int(curLine[3]) > 1: # check if protein has at least 2 unique peptides and has a significant p value\n curLine[4:10] = [int(x) for x in curLine[4:10]]\n enrScore = log((sum(curLine[4:7]) / 3.0)/(sum(curLine[7:10]) / 3.0),2) # calculate log2 enrichment score\n # print int(sum(curLine[4:7]) / 3.0), int(sum(curLine[7:10]) / 3.0)\n if sum(curLine[4:7]) / 3.0 > sum(curLine[7:10]) / 3.0: # if the mean of the KO intensities is higher than the wt \n for outI in curLine:\n outFDown.write(str(outI).strip(\" \"))\n if outI is not curLine[-1]:\n outFDown.write(\",\")\n if outI is curLine[-2]:\n outFDown.write(str(enrScore)+ \",\")\n else:\n outFDown.write(\"\\n\")\n # outFDown.write(curLine[1] + \",\" + curLine[2] + \"\\n\")\n else:\n # outFUp.write(curLine[1] + \",\" + curLine[2] + \"\\n\")\n for outI in curLine:\n outFUp.write(str(outI).strip(\" \"))\n if outI is not curLine[-1]:\n outFUp.write(\",\")\n if outI is curLine[-2]:\n outFUp.write(str(enrScore)+ \",\")\n else:\n outFUp.write(\"\\n\")\n \n inpF.close()\n outFUp.close()\n outFDown.close()\n print(\"stat_parser completed\")","def __init__(self,k,p,expfile,sampfile):\n \n self.k = k\n self.p = p\n self.expression =pd.read_table(expfile,sep = '\\t')\n self.samples = pd.read_table(sampfile,sep = '\\t',names = ['samples','patient'])\n self.set_data() # a functionto wrangle the data a bit.","def __init__(self, sc, dataset_path):\n\n logger.info(\"Starting up the Recommendation Engine: \")\n\n self.sc = sc\n\n\t#Load cusomer data for later use\n\t\n logger.info(\"Loading Customer data...\")\n customer_file_path = os.path.join(dataset_path, 'tpo_customer.csv')\n customer_raw_RDD = self.sc.textFile(customer_file_path)\n customer_raw_data_header = customer_raw_RDD.take(1)[0]\n self.customer_RDD = customer_raw_RDD.filter(lambda line: line!=customer_raw_data_header)\\\n .map(lambda line: line.split(\",\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[4]),(tokens[5]),(tokens[6]),(tokens[7]))).cache()\n\tlogger.info(\"Loading Customer data success...\")\n\t#CUSTOMCUSTOMER_NAME,CUSTOMER_ADDRESS1,CUSTOMER_ADDRESS2,CUSTOMER_CITY,CUSTOMER_STATE,CUSTOMER_COUNTRY,CUSTOMER_ZIPCODE,CREATED_BY,CREATION_DATE,LAST_UPDATED_BY,LAST_UPDATE_DATE\n \n\n\n\t\n\t#Load turbine data for later use\t\n logger.info(\"Loading Turbine data...\")\n turbine_file_path = os.path.join(dataset_path, 'test_tpo_unit_config.csv')\n turbine_raw_RDD = self.sc.textFile(turbine_file_path)\n turbine_raw_data_header = turbine_raw_RDD.take(1)[0]\n self.turbine_RDD = turbine_raw_RDD.filter(lambda line: line!=turbine_raw_data_header)\\\n .map(lambda line: line.split(\",\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[5]),(tokens[34]),(tokens[51]),(tokens[35]))).cache()\n\tlogger.info(\"Loading Turbine data success...\")\n \n\t\n\t\n\t\n\t#Load site data for later use\t\n logger.info(\"Loading Site data...\")\n site_file_path = os.path.join(dataset_path, 'tpo_site.csv')\n site_raw_RDD = self.sc.textFile(site_file_path)\n site_raw_data_header = site_raw_RDD.take(1)[0]\n self.site_RDD = site_raw_RDD.filter(lambda line: line!=site_raw_data_header)\\\n .map(lambda line: line.split(\",\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[4]),(tokens[5]),(tokens[6]),(tokens[7]),(tokens[16]))).cache()\n\tlogger.info(\"Loading Site data success...\")\n\t\n\n\n\n\t# Load ratings data for later use\n logger.info(\"Loading Ratings data...\")\n ratings_file_path = os.path.join(dataset_path, 'ratings.csv')\n ratings_raw_RDD = self.sc.textFile(ratings_file_path)\n ratings_raw_data_header = ratings_raw_RDD.take(1)[0]\n self.ratings_RDD = ratings_raw_RDD.filter(lambda line: line!=ratings_raw_data_header)\\\n .map(lambda line: line.split(\",\")).map(lambda tokens: (int(tokens[0]),int(tokens[1]),float(tokens[2]))).cache()\n # Load movies data for later use\n logger.info(\"Loading Movies data...\")\n movies_file_path = os.path.join(dataset_path, 'movies.csv')\n movies_raw_RDD = self.sc.textFile(movies_file_path)\n movies_raw_data_header = movies_raw_RDD.take(1)[0]\n self.movies_RDD = movies_raw_RDD.filter(lambda line: line!=movies_raw_data_header)\\\n .map(lambda line: line.split(\",\")).map(lambda tokens: (int(tokens[0]),tokens[1],tokens[2])).cache()\n self.movies_titles_RDD = self.movies_RDD.map(lambda x: (int(x[0]),x[1])).cache()\n # Pre-calculate movies ratings counts\n self.__count_and_average_ratings()\n\n # Train the model\n self.rank = 8\n self.seed = 5L\n self.iterations = 10\n self.regularization_parameter = 0.1\n self.__train_model()","def main():\n parser = ArgumentParser(usage='%(prog)s [options] ecommonsMetadata.csv')\n parser.add_argument(\"-d\", \"--date\", dest=\"date\",\n help=\"Date on or after that an ETD was published for \\\n creating DOIs. Put in format YYYY-MM\")\n parser.add_argument(\"datafile\", help=\"eCommons metadata worked from.\")\n\n args = parser.parse_args()\n\n if not len(sys.argv) > 0:\n parser.print_help()\n parser.exit()\n\n workingdir = csvparse(args.datafile, args.date)\n doiparse(workingdir)\n print('ANVL files available in: ' + workingdir)","def main():\n csv_file_name = ''\n do_linear = False\n\n if len(sys.argv) == 3:\n csv_file_name = sys.argv[1]\n do_linear = bool(int(sys.argv[2]))\n\n data = open(csv_file_name)\n\n #ignore title\n first_line = data.readline()\n\n #read the remaining data within the file\n body = data.readlines()\n length = len(body)\n position_array = np.zeros((length, 2))\n class_array = np.zeros((length, 1))\n\n index = 0\n for line in body:\n values = line.strip().split(',')\n position_array[index][0] = values[0]\n position_array[index][1] = values[1]\n class_array[index] = values[2]\n index += 1\n\n if do_linear == False:\n #plot_spiral(position_array, class_array, \"spiral.png\")\n linear_position_array, linear_class_array, linear_model = linear_classifier(position_array, class_array, 4)\n plot_spiral_and_predicted_class(linear_position_array, linear_class_array, linear_model, \"linear.png\", \"Linear Classification Results\")\n\n else:\n nonlinear_position_array, nonlinear_class_array, nonlinear_model = non_linear_classifier(position_array, class_array, 4)\n plot_spiral_and_predicted_class(nonlinear_position_array, nonlinear_class_array, nonlinear_model, \"nonlinear.png\", \"Nonlinear Classification Results\")","def main():\n\n preprocessed_file = preprocess_clinical_trials()\n\n preprocessed_file.to_csv(PREPROCESSED_CLINICAL_TRIALS_FILE_PATH, index=False)","def __init__(self, className, name, title=None, unit=None):\n self.className = className\n filename = os.path.join(DATA, name + '.csv')\n with open(filename,encoding='utf8') as csv_file:\n reader = csv.reader(csv_file)\n for row_number, row in enumerate(reader):\n if row[1] == filename:\n continue\n if row[0] == '':\n self.title = row[1]\n continue\n if row[0] == 'unit':\n self.unit = row[1]\n continue\n try:\n datetime.strptime(row[0], \"%Y-%m-%d\")\n break\n except: ValueError\n super().__init__(name, title, unit)\n with open(filename,encoding='utf8') as csv_file:\n reader = csv.reader(csv_file)\n for skip in range(row_number): # row_number is first data line\n next(reader)\n for row in reader:\n try:\n self.data[datetime.strptime(row[0], \"%Y-%m-%d\")]=float(row[1])\n except: ValueError\n self.first_date=min(self.data.keys())\n self.last_date=max(self.data.keys())","def main():\n master_csv = open(\"master.csv\", \"w\")\n master_csv.write(\"lat, lon, year, month, day, T_max, T_min, PrecipMM, T_ave, PrecipCM, RelHum\\n\")\n MoLS_comp_csv = open(\"MoLS_comp.csv\", \"w\")\n lat_lon_csv = open(\"lat_lon.csv\", \"w\")\n\n for csvFilename in os.listdir('.'):\n\n if not csvFilename.endswith('.csv') or csvFilename == \"master.csv\" or csvFilename == \"MoLS_comp.csv\" or csvFilename == \"lat_lon.csv\":\n continue # skip non-csv files\n\n csvFileObj = open(csvFilename)\n readerObj = csv.reader(csvFileObj)\n print(\"Currently parsing \" + str(csvFilename))\n for row in readerObj:\n if readerObj.line_num <= 8 :\n continue\n\n year = int(row[0])\n vp = float(row[8]) / 1000.0\n month, day = get_month(int(row[1]))\n T_ave = (float(row[6]) + float(row[7])) / 2\n PrecipCM = float(row[3]) / 10\n svp = .611 * math.e ** (5321 * ((1 / 273.0) - (1 / (T_ave + 273.15))))\n rh_ave = round((vp / svp) * 100, 2)\n\n # print([[csvFilename], , row[0], row[1], row[3], row[6], row[7], row[8]])\n # print(readerObj.line_num)\n # print([csvFilename.split(\"_\")[0], csvFilename.split(\"_\")[1].split(\".csv\")[0], row[0], row[1], row[3],\n # row[6], row[7], row[8]])\n\n master_csv.write(str(csvFilename.split(\"_\")[0]) + \",\" + str(csvFilename.split(\"_\")[1].split(\".csv\")[0]) +\n \",\" + str(year) + \",\" + str(month) + \",\" + str(day) + \",\" + str(row[6]) + \",\" + str(row[7])\n + \",\" + str(row[3]) + \",\" + str(T_ave) + \",\" + str(PrecipCM) + \",\" + str(rh_ave) + \"\\n\")\n MoLS_comp_csv.write(str(year) + \",\" + str(month) + \",\" + str(day) + \",\" + str(row[6]) + \",\" + str(row[7])\n + \",\" + str(row[3]) + \",\" + str(T_ave) + \",\" + str(PrecipCM) + \",\" + str(rh_ave) + \"\\n\")\n lat_lon_csv.write(str(csvFilename.split(\"_\")[0]) + \",\" + str(csvFilename.split(\"_\")[1].split(\".csv\")[0]) + \"\\n\")\n\n master_csv.close()\n MoLS_comp_csv.close()\n lat_lon_csv.close()","def __init__(self):\n self.file_name = \"entries.csv\"\n self.csv_header = \"date,name,minutes,note\"\n try:\n with open(self.file_name) as file:\n reader = csv.DictReader(file)\n self.entries = list(reader)\n except FileNotFoundError:\n with open(self.file_name, \"a\") as file:\n file.write(f'{self.csv_header}\\n')\n\n try:\n for i in range(len(self.entries)):\n entry = self.entries[i]\n self.entries[i] = Entry(\n entry[\"date\"],\n entry[\"name\"],\n entry[\"minutes\"],\n entry[\"note\"]\n )\n print(f\"Worklog with {len(self.entries)} entries has been loaded.\\n\")\n print(\"Starting program...\")\n time.sleep(.75)\n except TypeError:\n raise TypeError(\"Could not read data file.\"\n + \" Ensure that CSV is properly formatted.\")\n except AttributeError:\n print(\"No existing worklog found.\\nNew worklog has been created.\\n\")\n self.entries = []\n print(\"Starting program...\")\n time.sleep(.75)","def __init__(self, data_dir, html_dir, paver_html_dir, resolution_1, resolution_2, picture_format, hierarchy_version, original_mapping_dir):\n\n pn = proteomaps_PATHNAMES(hierarchy_version)\n PROTEIN_HIERARCHY_DIR = pn.PROTEIN_HIERARCHY_DIR\n po = proteomaps_organisms(pn)\n\n filenames_file = data_dir + \"/filenames.csv\"\n print \"Data set directory: \" + data_dir\n \n for row in csv.reader(open(filenames_file, 'r'), delimiter='\\t'):\n organism, data_file, data_set_name, data_set_name_matlab, article_name = row\n print \"\\nData set \" + data_set_name + \":\\nWriting html files to directory \" + html_dir\n\n data_type = \"cost\"\n proteomap_process_html(paver_html_dir, html_dir, data_dir, data_set_name, organism, resolution_1, resolution_2, article_name, data_type, picture_format,po,PROTEIN_HIERARCHY_DIR, original_mapping_dir)\n\n data_type = \"abundance\"\n proteomap_process_html(paver_html_dir, html_dir, data_dir, data_set_name, organism, resolution_1, resolution_2, article_name, data_type, picture_format,po,PROTEIN_HIERARCHY_DIR, original_mapping_dir)","def main():\n\takpPoints,chpPoints = extractSupporterCities(\"Data/PreprocessedAkpTweets.csv\",\n\t\t\t\t\t\t\t\t\t\t\t \"Data/PreprocessedChpTweets.csv\")\n\tgenerateMapPoints(akpPoints,chpPoints)\n\tgenerateCitySentimentData(akpPoints,chpPoints)\n\tgenerateChoroplethMap(\"Data/tr_cities_modified.json\",\"Data/city_ratio.csv\")","def __init__(self,csvrow):\n self.raw = csvrow\n data = csvrow.split(',')\n self.number = data[0]\n self.area = int(data[1])\n self.population = int(data[5])\n self.latitude = float(data[7])\n self.longitude = float(data[8])","def __init__(self):\n \n self.csv_features = {} # Create dictionary to load the CSV features\n self.meta_features = [] # Create list to load the metadata features","def __init__(self, updated=False):\n self.deputies = []\n self.senators = []\n\n if updated:\n file = IDENTITY_FILE_UPDATED\n else:\n file = IDENTITY_FILE\n\n with open(file, 'rt') as csvfile:\n spamreader = csv.DictReader(csvfile, delimiter=';')\n for row in spamreader:\n # Senators and deputies has different contracts\n # TODO: CREATE ANOTHER FEATURE TELLING SENATORS vs DEPUTIES\n try:\n if row.get('sen:CodigoParlamentar') or 'senador' in row.get('post', '').lower():\n self.add_senator(Senator(row))\n\n if row.get('cam:ideCadastro') or 'deputado' in row.get('post', '').lower():\n self.add_deputy(Deputy(row))\n except AttributeError:\n import code; code.interact(local=dict(globals(), **locals()))","def main():\n\n outFile = r'../product/yoshinoya_rawdata.csv'\n\n with open(r'../data/yoshinoya_id.csv') as yoshinoya_id:\n\n # Reader to read store id\n id_reader = csv.reader(yoshinoya_id)\n\n # Skip the headers\n header = next(yoshinoya_id, None)\n\n # Keys from the get_data function\n headers = ['storeid', 'brand', 'name', 'lat', 'lon', 'postalCode',\n 'address', 'MON_open', 'MON_close', 'TUE_open', 'TUE_close',\n 'WED_open', 'WED_close', 'THU_open', 'THU_close', 'FRI_open',\n 'FRI_close', 'SAT_open', 'SAT_close', 'SUN_open', 'SUN_close']\n\n with open(outFile, 'w', newline='') as csvfile:\n\n writer = csv.DictWriter(csvfile, delimiter=',', lineterminator='\\n',\n fieldnames=headers)\n\n # Write the headers\n writer.writeheader()\n\n for row in id_reader:\n\n storeid = row[0]\n\n print(f\"Processing {storeid}...\")\n\n store_row = get_data_yoshinoya(storeid)\n\n if store_row is None:\n\n print(f\"failed to request the page with storeid {storeid}\")\n continue\n\n writer.writerow(store_row)\n\n csvfile.close()","def collect_data(self):\n categories = []\n list_of_feature_lists = []\n feature_sets = set()\n with open(self.csv_path, \"r\") as f:\n reader = csv.DictReader(f)\n # collecting some stats for FDR calculation:\n self.PSM_count = 0\n self.decoy_count = 0\n\n if self[\"dump_svm_matrix\"]:\n self.init_svm_matrix_dump()\n additional_matrix_info = []\n\n for i, row in enumerate(\n sorted(\n reader,\n reverse=self[\"bigger_scores_better\"],\n key=lambda d: float(d[self.col_for_sorting]),\n )\n ):\n\n features = self.row_to_features(row)\n\n if tuple(features) in feature_sets:\n continue\n feature_sets.add(tuple(features))\n\n category, psm_FDR = self.get_psm_category(row)\n\n list_of_feature_lists.append(features)\n categories.append(category)\n\n if self[\"dump_svm_matrix\"]:\n label = -1 if row_is_decoy(row) else 1\n sequence = \"{0}.{1}#{2}.{3}\".format(\n row[\"Sequence Pre AA\"].strip(),\n row[\"Sequence\"].strip(),\n row[\"Modifications\"].strip(),\n row[\"Sequence Post AA\"].strip(),\n )\n additional_matrix_info.append(\n {\n \"psm_id\": row[\"Spectrum Title\"].strip(),\n \"label\": label,\n \"scannr\": row[\"Spectrum Title\"].strip().split(\".\")[-2],\n \"peptide\": sequence,\n \"proteins\": self.parse_protein_ids(row[\"Protein ID\"]),\n }\n )\n\n if i % 1000 == 0:\n score_val = float(row[self.col_for_sorting])\n msg = (\n \"Generating feature matrix from input csv \"\n \"(line ~{0}) with score {1} and FDR \"\n \"{2}\".format(i, score_val, psm_FDR)\n )\n print(msg, end=\"\\r\")\n\n # All data points are collected in one big matrix, to make standardization possible\n print(\"\\nConverting feature matrix to NumPy array...\")\n X_raw = np.array(list_of_feature_lists, dtype=float)\n\n print(\"Replacing empty/NaN values with the mean of each column...\")\n self.nan_replacer = Imputer()\n self.nan_replacer.fit(X_raw)\n X_raw = self.nan_replacer.transform(X_raw)\n # Standardize input matrix to ease machine learning! Scaled data has zero mean and unit variance\n print(\"Standardizing input matrix...\")\n self.scaler = SCALER.fit(X_raw)\n self.X = self.scaler.transform(X_raw)\n self.categories = np.array(categories)\n print()\n\n if self[\"dump_svm_matrix\"]:\n print(\"Dumping SVM matrix to\", self[\"dump_svm_matrix\"])\n\n for i, matrix_row in enumerate(self.X):\n matrix_row_info = additional_matrix_info[i]\n self.dump_svm_matrix_row(\n row=list(matrix_row),\n psm_id=matrix_row_info[\"psm_id\"],\n label=matrix_row_info[\"label\"],\n scannr=matrix_row_info[\"scannr\"],\n peptide=matrix_row_info[\"peptide\"],\n proteins=matrix_row_info[\"proteins\"],\n )\n\n print(\"Dumped SVM matrix to\", self[\"dump_svm_matrix\"])\n return","def load(cls):\n \n # Loop through problems and build patient problem lists:\n probs = csv.reader(file(PROBLEMS_FILE,'U'),dialect='excel-tab')\n header = probs.next() \n for prob in probs:\n cls(dict(zip(header,prob))) # Create a problem instance ","def main():\n args = parse_arguments()\n\n de_data = pd.read_csv(args.raw_file, sep=\"\\t\")\n de_data.rename(columns={\"Unnamed: 0\": \"gene_id\"}, inplace=True)\n de_data.fillna(value=1, inplace=True)\n columns = {}\n col_order = []\n\n # Make sure all listed numeric columns are valid numeric variables based\n # on a union of numeric column names from cuffdiff, edgeR, deseq2 and test\n # files.\n numeric_columns = [\n \"baseMean\",\n \"log2FoldChange\",\n \"lfcSE\",\n \"stat\",\n \"pvalue\",\n \"padj\",\n \"value_1\",\n \"value_2\",\n \"log2(fold_change)\",\n \"test_stat\",\n \"p_value\",\n \"q_value\",\n \"logfc\",\n \"fdr\",\n \"stat\",\n \"logFC\",\n \"logCPM\",\n \"LR\",\n \"Pvalue\",\n \"FDR\",\n ]\n de_columns = de_data.columns\n\n for column in numeric_columns:\n if column not in de_columns:\n continue\n\n if not is_numeric_dtype(de_data[column]):\n msg = (\n f\"Column {column} is not numeric. Please make sure \"\n f\"that the input file has valid numeric values (i.e. \"\n f\"periods for decimal places).\"\n )\n send_message(error(msg))\n raise ValueError(msg)\n\n if args.gene_id:\n if args.gene_id == \"index\":\n columns[\"gene_id\"] = list(de_data.index.astype(str))\n col_order.append(\"gene_id\")\n else:\n columns[\"gene_id\"] = list(de_data[args.gene_id].astype(str))\n col_order.append(\"gene_id\")\n\n if args.logfc:\n col = np.array(de_data[args.logfc])\n col[np.isinf(col)] = 0\n columns[\"logfc\"] = list(col)\n col_order.append(\"logfc\")\n\n if args.fdr:\n columns[\"fdr\"] = list(de_data[args.fdr])\n col_order.append(\"fdr\")\n\n if args.pvalue:\n columns[\"pvalue\"] = list(de_data[args.pvalue])\n col_order.append(\"pvalue\")\n\n if args.fwer:\n columns[\"fwer\"] = list(de_data[args.fwer])\n col_order.append(\"fwer\")\n\n if args.logodds:\n columns[\"logodds\"] = list(de_data[args.logodds])\n col_order.append(\"logodds\")\n\n if args.stat:\n columns[\"stat\"] = list(de_data[args.stat])\n col_order.append(\"stat\")\n\n with open(args.output_json, \"w\") as f:\n json.dump(columns, f, separators=(\",\", \":\"), allow_nan=False)\n\n outdf = pd.DataFrame(columns)\n outdf = outdf[col_order]\n outdf.to_csv(args.output_file, sep=\"\\t\", index=False, compression=\"gzip\")","def main():\n # Specify path\n training_filepath = 'data/training.csv'\n testing_filepath = 'data/public_test_features.csv'\n\n # Check whether the specified path exists or not\n isExist = os.path.exists(training_filepath)\n if(isExist):\n print('Reading from ' + training_filepath)\n else:\n print('Training file not found in the app path.')\n exit()\n preprocess_file(training_filepath, 'data/clean_training1.csv', True)\n # Check whether the specified path exists or not\n isExist = os.path.exists(testing_filepath)\n if(isExist):\n print('Reading from ' + testing_filepath)\n else:\n print('Testing file not found in the app path.')\n exit()\n preprocess_file(testing_filepath,'data/clean_testing1.csv', False)","def main():\n# file_name = input(\"Please Provide File Name (e.g: sample_data.txt): \")\n file_name = \"sample_data.txt\"\n file_path = get_path(file_name)\n if file_path != -1:\n df = generate_DataFrame(file_path=file_path)\n# table_name = input(\"Please Enter table Name(emp_details)\")\n table_name = \"emp_details\"\n table_create(table_name)\n for x, i in df.iterrows():\n insert_update(i,table_name)\n print('processing id:', x)","def __init__(\n self,\n data_columns: Sequence[str] = None,\n bijector: Tuple[InitFunction, Bijector_Info] = None,\n latent: distributions.LatentDist = None,\n conditional_columns: Sequence[str] = None,\n data_error_model: Callable = None,\n condition_error_model: Callable = None,\n autoscale_conditions: bool = True,\n N: int = 1,\n info: Any = None,\n file: str = None,\n ) -> None:\n\n # validate parameters\n if data_columns is None and file is None:\n raise ValueError(\"You must provide data_columns OR file.\")\n if file is not None and any(\n (\n data_columns is not None,\n bijector is not None,\n conditional_columns is not None,\n latent is not None,\n data_error_model is not None,\n condition_error_model is not None,\n info is not None,\n )\n ):\n raise ValueError(\n \"If providing a file, please do not provide any other parameters.\"\n )\n\n # if file is provided, load everything from the file\n if file is not None:\n # load the file\n with open(file, \"rb\") as handle:\n save_dict = pickle.load(handle)\n\n # make sure the saved file is for this class\n c = save_dict.pop(\"class\")\n if c != self.__class__.__name__:\n raise TypeError(\n f\"This save file isn't a {self.__class__.__name__}. It is a {c}.\"\n )\n\n # load the ensemble from the dictionary\n self._ensemble = {\n name: Flow(_dictionary=flow_dict)\n for name, flow_dict in save_dict[\"ensemble\"].items()\n }\n # load the metadata\n self.data_columns = save_dict[\"data_columns\"]\n self.conditional_columns = save_dict[\"conditional_columns\"]\n self.data_error_model = save_dict[\"data_error_model\"]\n self.condition_error_model = save_dict[\"condition_error_model\"]\n self.info = save_dict[\"info\"]\n\n self._latent_info = save_dict[\"latent_info\"]\n self.latent = getattr(distributions, self._latent_info[0])(\n *self._latent_info[1]\n )\n\n # otherwise create a new ensemble from the provided parameters\n else:\n # save the ensemble of flows\n self._ensemble = {\n f\"Flow {i}\": Flow(\n data_columns=data_columns,\n bijector=bijector,\n conditional_columns=conditional_columns,\n latent=latent,\n data_error_model=data_error_model,\n condition_error_model=condition_error_model,\n autoscale_conditions=autoscale_conditions,\n seed=i,\n info=f\"Flow {i}\",\n )\n for i in range(N)\n }\n # save the metadata\n self.data_columns = data_columns\n self.conditional_columns = conditional_columns\n self.latent = self._ensemble[\"Flow 0\"].latent\n self.data_error_model = data_error_model\n self.condition_error_model = condition_error_model\n self.info = info","def main():\n # LoL = readcsv( \"wds.csv\" )\n # print(LoL[:10])\n\n # test writing\n # write_to_csv( LoL[:10], \"tenrows.csv\" )\n\n # text csv_to_html_table_starter\n # output_html = csv_to_html_table_starter( LoL[:10] )\n # print(\"\\noutput_html is\\n\\n\" + output_html)\n # create_html_page(output_html, \"test.html\")\n Wcount_first()\n Wcount_last()\n Wcount_middle()","def main():\n langs = []\n\n with open(\"sql/07_populate.sql\", 'w', encoding='utf8') as sql:\n sql.write(\"--this file is generated from csv files in data folder\\n\\n\")\n\n langs = write_lang_city(sql)\n write_groups_diets(sql, langs)\n\n with open(\"sql/10_populate_test_data.sql\", 'w', encoding='utf8') as sql:\n sql.write(\"--this file is generated from csv files in moc_data folder\\n\\n\")\n write_test_data(sql)\n # This command sets postgis coordinates based on latitude and longitude\n sql.write(\"UPDATE restaurant SET geo_location = ST_POINT(latitude, longitude);\\n\")\n sql.close()","def main ( independentBaseName, dependentBaseName, independentTSID, dependentTSID, statisticsFile, nEquations ):\n # Get the logger for diagnostics and print out command line parameters (use str() in case None)\n logger = logging.getLogger()\n logger.info ( \"independentBaseName='\" + str(independentBaseName) + \"'\" )\n logger.info ( \"dependentBaseName='\" + str(dependentBaseName) + \"'\" )\n logger.info ( \"independentTSID='\" + str(independentTSID) + \"'\" )\n logger.info ( \"dependentTSID='\" + str(dependentTSID) + \"'\" )\n logger.info ( \"statisticsFile='\" + str(statisticsFile) + \"'\" )\n logger.info ( \"nEquations=\" + str(nEquations) )\n # Define lists\n _TSID=[]\n _TSID_Indep=[]\n _n1=[]\n _MeanX1=[]\n _SX1=[]\n _n2=[]\n _MeanX2=[]\n _SX2=[]\n _MeanY1=[]\n _SY1=[]\n _NY=[]\n _MeanY=[]\n _SY=[]\n _SkewY=[]\n _a=[]\n _b=[]\n _R=[]\n _R2=[]\n _meanY1Est=[]\n _SY1Est=[]\n _RMSE=[]\n _SEE=[]\n _SEP=[]\n _SESlope=[]\n _TestScore=[]\n _TestQuantile=[]\n _TestRelated=[]\n _Y2=[]\n _MeanY2=[]\n _SY2=[]\n _Skew=[]\n\n # Set values\n missingValue = -999\n p = 0.95 # p = one sided exceedence probability\n\n # Read data and determine statistics\n for i in range (0,nEquations):\n # Construct name based on number of equations\n if nEquations == 1:\n independentName = independentBaseName + '.csv'\n dependentName = dependentBaseName + '.csv'\n else:\n monthsString = string.rjust(str(i+1),2)\n monthsString = string.replace(monthsString,' ', '0')\n monthsString = '_' + monthsString\n independentName = independentBaseName + monthsString + '.csv'\n dependentName = dependentBaseName + monthsString + '.csv'\n\n # Read the data from the CSV files\n [TSID_Indep, X] = Read_TS.Read_CSV(independentName)\n [TSID, Y] = Read_TS.Read_CSV(dependentName)\n\n # Override the TSID with that from the command line\n #if ( dependentTSID != None ):\n # TSID = dependentTSID\n #if ( independentTSID != None ):\n # TSID_Indep = independentTSID\n\n # remove missing values\n [independent, x_n2, dependent, n1, n2] = Statistics.overlapping(X, Y, missingValue)\n\n # calculate basic statistics\n [MeanX1, SX1]=Statistics.statistics(independent)\n [MeanY1, SY1]=Statistics.statistics(dependent)\n if x_n2 != []:\n [MeanX2, SX2]=Statistics.statistics(x_n2)\n else: # No data that can be filled\n [MeanX2, SX2]=[missingValue, missingValue]\n\n # calculate additional statistics for dependent variable\n [MeanY, NY, SY]=Statistics.dependent_statistics(Y, missingValue)\n SkewY = Statistics.Skew(Y)\n\n # calculate regression coefficients\n [a,b,R,R2]=Statistics.regression_coef(independent, dependent)\n\n # Estimate the values for the dependent variable\n [Yest, meanY1Est, SY1Est]=Statistics.calculate_Yest(independent, a, b)\n\n # Calculated the estimates for the dependent variable\n if x_n2 != []:\n Y2 = Statistics.LinearRegression(a,b,x_n2)\n [MeanY2, SY2]=Statistics.statistics(Y2)\n else: # No data that can be filled\n Y2 = []\n [MeanY2, SY2]=[missingValue, missingValue]\n\n # Calculate additional statistics\n if x_n2 != []:\n Skew = Statistics.Skew(Y2)\n RMSE = Statistics.RMSE(dependent, Yest, n1)\n SEE = Statistics.SEE(dependent, Yest, n1)\n SEP = Statistics.SEP(independent, SEE, n1)\n SESlope = Statistics.SESlope(independent, dependent, Yest, n1)\n TestScore = Statistics.TestScore(b, SESlope)\n TestQuantile = StudentTQuantiles.Student_T_quantile (p,n1-2)\n if TestScore >= TestQuantile:\n TestRelated = 'Yes'\n else:\n TestRelated = 'No'\n else: # No data that can be filled\n Skew = missingValue\n RMSE = missingValue\n SEE = missingValue\n SEP = [missingValue]\n SESlope = missingValue\n TestScore = missingValue\n TestQuantile = missingValue\n TestRelated = 'No'\n\n # Append all the monthly data to an array containing the data for all months\n # This will create a list with a single entry for a run with one equation\n _TSID.append(TSID)\n _TSID_Indep.append(TSID_Indep)\n _n1.append(n1)\n _MeanX1.append(MeanX1)\n _SX1.append(SX1)\n _n2.append(n2)\n _MeanX2.append(MeanX2)\n _SX2.append(SX2)\n _MeanY1.append(MeanY1)\n _SY1.append(SY1)\n _NY.append(NY)\n _MeanY.append(MeanY)\n _SY.append(SY)\n _SkewY.append(SkewY)\n _a.append(a)\n _b.append(b)\n _R.append(R)\n _R2.append(R2)\n _meanY1Est.append(meanY1Est)\n _SY1Est.append(SY1Est)\n _RMSE.append(RMSE)\n _SEE.append(SEE)\n _SEP.append(SEP)\n _SESlope.append(SESlope)\n _TestScore.append(TestScore)\n _TestQuantile.append(TestQuantile)\n _TestRelated.append(TestRelated)\n _Y2.append(Y2)\n _MeanY2.append(MeanY2)\n _SY2.append(SY2)\n _Skew.append(Skew)\n\n # Pass the lists with all information to be written to a CSV file\n Write_Stats.Write_CSV(statisticsFile,\n _TSID,\n _TSID_Indep,\n _n1,\n _MeanX1,\n _SX1,\n _n2,\n _MeanX2,\n _SX2,\n _MeanY1,\n _SY1,\n _NY,\n _MeanY,\n _SY,\n _SkewY,\n _a,\n _b,\n _R,\n _R2,\n _meanY1Est,\n _SY1Est,\n _RMSE,\n _SEE,\n _SEP,\n _SESlope,\n _TestScore,\n _TestQuantile,\n _TestRelated,\n _Y2,\n _MeanY2,\n _SY2,\n _Skew)\n logger.info ('Statistics file written')\n print ('Statistics file written')","def driver():\n\n directory = r\"C:/Users/Aftab Alam/Documents/GitHub\"\n directory = directory + r\"/SRM-placement-analyser/data/\"\n fileList = [directory+\"InfosysResult.xlsx\",directory+\"TCSResult.xlsx\",directory+\"CognizantResult.xlsx\",directory+\"WiproResult.xlsx\"]\n \n listOfPlaced = extractCommonData.extractCommonData(fileList)\n createNewExcelSheet(directory,listOfPlaced)","def __init__(self):\n self.animals_list = []\n self.book = None\n try:\n with open(os.getcwd() + '/animals.csv', 'r') as f:\n read_file = csv.reader(f)\n for row in read_file:\n self.animals_list += row\n except LookupError:\n print(\"Check if 'animals.csv' file is in the main directory.\")","def __init__(self, filename):\n self.data = pd.read_csv(filename)\n\n # Dialogue information.\n self.dialogue_ids = sorted(list(set(self.data['dialogue_id'])))\n self.number_of_dialogues = len(self.dialogue_ids)\n\n # Dialogue Act information.\n self.DAs = sorted(list(set(self.data['dialogue_act'])))\n self.number_of_DAs = len(self.DAs)\n\n # Speaker information.\n self.speakers = sorted(list(set(self.data['speaker'])))\n\n # Level information.\n self.levels = sorted(list(set(self.data['level'])))\n\n # Extracts the unique (speaker, DA) dialogue turn tuples from the data set.\n speaker_da_tuples = self.data[['speaker', 'dialogue_act']].drop_duplicates().values\n speaker_da_tuples = [tuple(pair) for pair in speaker_da_tuples]\n\n # Constructs a dictionary consisting of the unique turn tuples and their corresponding vector representation.\n self.number_of_classes = len(speaker_da_tuples)\n self.class_dict = dict()\n class_vectors = np.identity(self.number_of_classes)\n for i in range(self.number_of_classes):\n self.class_dict[speaker_da_tuples[i]] = class_vectors[i]","def __init__(self, instancefile):\n coord = []; demand = [], # initialize lists\n with open(instancefile,\"r\") as iFile: # read data from file\n self.InstanceName = iFile.readline().strip() # name of instamce\n iFile.readline(); iFile.readline(); iFile.readline() # skip lines\n vals = iFile.readline().strip().split()\n self.MaxNumVeh = int(vals[0]) # read data\n self.MaxVehCap = float(vals[1]) # read data\n iFile.readline(); iFile.readline(); iFile.readline(); iFile.readline() # skip lines\n line = iFile.readline().strip()\n while line != \"\": # read customer data\n vals = line.split()\n coord.append([float(vals[1]), float(vals[2])])\n demand.append(float(vals[3]))\n line = iFile.readline().strip()\n self.NumCust = len(coord)-1 # set number of customers\n self.Coord = np.array(coord) # create object variables\n self.CustDem = np.array(demand)\n self.DistMatrix = squareform(pdist(self.Coord,\"euclidean\")) # compute distance matrix","def main():\n\n # Ensure the output directory exists\n if not os.path.exists(OUTPUT_DIR):\n os.makedirs(OUTPUT_DIR)\n\n process_csv()","def __init__(\n self,\n file_name=None,\n file_contents=None,\n uploaded_file: UploadedFile = None,\n user: User = None,\n gating_strategy: GatingStrategy = None,\n ):\n if uploaded_file:\n self.upload_file = uploaded_file\n file_name = uploaded_file.name\n file_contents = uploaded_file.content\n # print(file_contents)\n self.content = file_contents\n self.file_name = file_name\n self.gating_strategy = gating_strategy\n self.df = pd.read_csv(self.content, parse_dates=[\"Date\"])\n\n # List of columns always expected\n # ToDo: Find out if any of these columns are 'required' - if so\n # cannot continue without them.\n\n # Use variables to store static_column names in case they change\n # in future\n self.sc_panel = \"Panel\"\n self.sc_clinical_sample = \"Clinical_sample\"\n self.sc_filename = \"filename\"\n self.sc_operator1 = \"Operator name\"\n self.sc_comments = \"Comments\"\n self.sc_batch = \"batch\"\n self.sc_date = \"Date\"\n self.required_columns = [\n self.sc_filename,\n self.sc_panel,\n self.sc_clinical_sample,\n ]\n\n self.static_columns = [\n self.sc_batch,\n self.sc_operator1,\n self.sc_comments,\n self.sc_date,\n ]\n\n # Store the unique panels in the data\n # ToDo: I think there should be only one unique panel - check.\n self.panels = self.df[\"Panel\"].unique().tolist()\n self.panel_name = self.panels[0].upper()\n\n # Compute names of parameters present. These are all the other\n # columns in the file that are not in the static_columns list\n # and are not unregistered_derived_parameters\n parameter_columns = set(self.df.columns) - set(self.static_columns)\n parameter_columns -= set(self.required_columns)\n self.parameter_columns = list(parameter_columns)\n\n # Store unregistered parameters. Derived ones will be dynamically\n # added to the Parameter table before upload\n self.unregistered_derived_parameters = []\n self.unregistered_parameters = []\n for parameter_column in self.parameter_columns:\n try:\n parameter_object = Parameter.objects.get(\n gating_hierarchy=parameter_column\n )\n except Parameter.DoesNotExist:\n if parameter_column.endswith(\"Count_back\") or parameter_column.endswith(\n \"freq\"\n ):\n self.unregistered_derived_parameters.append(parameter_column)\n else:\n self.unregistered_parameters.append(parameter_column)\n self.parameter_columns = [\n column\n for column in self.parameter_columns\n if column not in self.unregistered_parameters\n and column not in self.unregistered_derived_parameters\n ]\n\n # Names for pseudo parameters (parameters computed from data)\n self.pseudo_parameters_numeric = []\n if self.sc_batch in self.df.columns:\n self.pseudo_parameters_numeric.append(\n (self.sc_batch, f\"{self.panel_name}_batch\")\n )\n if self.sc_operator1 in self.df.columns:\n self.pseudo_parameters_numeric.append(\n (self.sc_operator1, f\"{self.panel_name}_operator_1\")\n )\n\n self.pseudo_parameters_date = []\n if self.sc_date in self.df.columns:\n self.pseudo_parameters_date.append(\n (self.sc_date, f\"{self.panel_name}_date_processed\")\n )\n\n self.pseudo_parameters_text = []\n if self.sc_comments in self.df.columns:\n self.pseudo_parameters_text.append(\n (self.sc_comments, f\"{self.panel_name}_comments\")\n )\n\n # Number of rows to process\n self.nrows = len(self.df)\n\n # Default uploaded file\n if not uploaded_file:\n self.upload_file = UploadedFile(\n name=self.file_name,\n user=user,\n description=\"Panel results\",\n row_number=self.nrows,\n content=self.content,\n notes=\"\",\n content_type=\"PANEL_RESULTS\",\n )\n self.upload_file.save()","def main(input_filepath, output_filepath):\n productsDict = dataToDict(input_filepath)\n productsList = dictToCSV(productsDict)\n toCSV(productsList, output_filepath)\n\n logger = logging.getLogger(__name__)\n logger.info('making final data set from raw data')","def run_code_for_question_one_part_two():\n df_flights_info = read_csv_file_data(\"../Data/T_Fare_Flight_Q1.csv\")\n df_flights_info = evaluate_percentage_of_class_for_each_flight(df_flights_info)\n df_flights_info.to_csv(\"../Output/Question_1_Part_2_percentages.csv\")\n print(df_flights_info.head())","def main():\n if len(sys.argv) != 4:\n sys.exit('Please run with : python data-eng.py donors_file.txt zipcode_output_filename date_output_filename')\n compute_stats(sys.argv[1], sys.argv[2], sys.argv[3])","def __init__(self,\n feature_selection=True,\n clinical_path='data/tidy/train_cli.csv',\n proteomic_path='data/tidy/train_pro.csv',\n rna_path='data/tidy/train_rna.csv',\n mismatch_path='data/tidy/sum_tab_1.csv',\n test_proteomic_path='data/raw/test_pro.tsv',\n test_clinical_path='data/raw/test_cli.tsv',\n train_rna_path='data/raw/train_rna.tsv',\n test_rna_path='data/raw/test_rna.tsv',\n mislabel_path='data/tidy/sum_tab_2.csv'):\n self.clinical = pd.read_csv(clinical_path, index_col=0)\n self.proteomic = self.preprocess(\n pd.read_csv(proteomic_path, index_col=0)\n )\n self.rna = self.preprocess(\n pd.read_csv(rna_path, index_col=0)\n )\n self.mismatch = pd.read_csv(mismatch_path, index_col=0)\n self.test_proteomic = self.preprocess(\n pd.read_csv(test_proteomic_path, index_col=0, sep='\\t').T\n )\n self.test_rna = self.preprocess(\n pd.read_csv(test_rna_path, index_col=0, sep='\\t').T\n )\n self.test_clinical = pd.read_csv(test_clinical_path, index_col=0, sep='\\t')\n self.train_rna = pd.read_csv(train_rna_path, index_col=0, sep='\\t').T\n self.train_pro_rna = self.train_rna.merge(self.proteomic, how='outer', left_index=True, right_index=True)\n self.test_pro_rna = self.test_rna.merge(self.test_proteomic, how='outer', left_index=True, right_index=True)\n self.train_all = self.train_pro_rna.merge(self.clinical, how='outer', left_index=True, right_index=True)\n self.train_all = self.train_all.replace(['Female', 'Male','MSI-Low/MSS', 'MSI-High'], [0, 1, 0, 1])\n self.test_all = self.test_pro_rna.merge(self.test_clinical, how='outer', left_index=True, right_index=True)\n self.test_all = self.test_all.replace(['Female', 'Male', 'MSI-Low/MSS', 'MSI-High'], [0, 1, 0, 1])\n self.mislabel = pd.read_csv(mislabel_path, index_col=0)\n\n if feature_selection:\n self.select_features()\n\n # create training labels for if a sample has been mislabeled\n self.mislabel_labels = []\n for i in range(0, len(self.mislabel.index)):\n if self.mislabel.iloc[i, 0] == self.mislabel.iloc[i, 1] and self.mislabel.iloc[i, 1] == self.mislabel.iloc[i, 2]:\n self.mislabel_labels.append(0)\n else:\n self.mislabel_labels.append(1)","def __init__(self, filename=None, filetype=None, instrument=None):\n if filename:\n if instrument == 'Element':\n skipfooter = 4\n header = 1\n drop = 9\n elif instrument == 'Agilent':\n skipfooter = 4\n header = 3\n drop = 3\n else:\n skipfooter = 0\n header = 0\n drop = 0\n\n if filetype == 'xlsx':\n pwd = os.getcwd()\n os.chdir(os.path.dirname(filename))\n self.imported = pd.ExcelFile(filename)\n self.data = self.imported.parse(\n 0, index_col=0, skipfooter=skipfooter, header=header)\n self.data = self.data.drop(self.data.index[:drop], axis=0)\n os.chdir(pwd)\n # TODO xlsx doesnt work with agilent type\n elif filetype == 'csv':\n pwd = os.getcwd()\n os.chdir(os.path.dirname(filename))\n self.data = pd.read_csv(filename, sep=',', index_col=0, skipfooter=skipfooter,\n header=header, engine='python')\n os.chdir(pwd)\n elif filetype == 'asc':\n pwd = os.getcwd()\n os.chdir(os.path.dirname(filename))\n self.data = pd.read_csv(filename, sep='\\t', index_col=0, skipfooter=skipfooter,\n header=header, engine='python')\n self.data = self.data.drop(self.data.index[:drop], axis=0)\n self.data.dropna(axis=1, how='all', inplace=True)\n self.data = self.data.apply(pd.to_numeric, errors='coerce')\n os.chdir(pwd)\n else:\n warnings.warn('File type not supported.')\n\n self.data.index = self.data.index.astype('float32')\n self.time = self.data.index\n self.elements = list(map(elem_resolution, self.data.columns))\n self.data.columns = self.elements\n\n self.srms = pd.ExcelFile('./SRM.xlsx').parse(index_col=0)\n self.sum_koeficients = pd.ExcelFile(\n './default_sum_koef.xlsx').parse(0, index_col=0, header=None).to_dict()[1]\n\n self.srm = None\n self.iolite = None\n self.names = None\n self.internal_std = None\n self.ablation_time = None\n\n self.laser_off = []\n self.laser_on = []\n self.skip = {'bcg_start': 0,\n 'bcg_end': 0,\n 'sample_start': 0,\n 'sample_end': 0} # time in seconds to skip from each bcg and sample\n\n self.filter_line = None\n self.starts = None\n self.ends = None\n self.bcg = None\n self.average_peaks = None\n self.ratio = None\n self.quantified = None\n self.lod = None\n self.correction_elements = None\n self.corrected_IS = None\n self.corrected_SO = None\n\n self.dx = None\n self.dy = None\n self.maps = {}\n self.qmaps = {}\n\n self.regression_values = {}\n self.regression_equations = {}","def main(xls, seqtype):\n data_extraction = {}\n # 1 - Load data\n logger.info(f'Load {xls}')\n manifest, metadata = load_xls(xls)\n # 2 - Check file and data\n logger.info(f'Start to validate XLS')\n check_samples(manifest, metadata)\n check_seqtype(manifest, seqtype)\n check_metadata(metadata, seqtype)\n logger.success(f'Successfully validate XLS')\n # 3 - Export XLS to TSV for Qiime2\n logger.info(f'Start to export XLS to TSV')\n data_extraction = extract_manifest(manifest, seqtype, data_extraction)\n data_extraction, metadata_vars = extract_metadata(metadata, seqtype, data_extraction)\n export_to_tsv_for_qiime(data_extraction, metadata_vars, seqtype)\n logger.success(f'Done')","def process(self):\n parser = csv.reader(self.reader,delimiter=self.delimiter_DIC[self.delim])\n firstRec = True\n for fields in parser:\n if firstRec:\n fieldNames = fields\n firstRec = False\n else:\n self.dicts.append({})\n for i,f in enumerate(fields):\n try:\n self.dicts[-1][fieldNames[i]] = f\n except:\n import pdb\n pdb.set_trace()\n if self.eng is \"spectrumMill\":\n for i,row in enumerate(self.dicts):\n fileSM = row[self.engine[self.eng][0]]\n acNoSM = row[self.engine[self.eng][1]]\n masSM=row[self.engine[self.eng][2]]\n chrgeSM=row[self.engine[self.eng][3]]\n preAmSM=row[self.engine[self.eng][4]].replace('(','').replace(')','')\n pepSM=row[self.engine[self.eng][5]]\n nAmSM=row[self.engine[self.eng][6]].replace('(','').replace(')','')\n modSM=row[self.engine[self.eng][7]].split('\\s')+row[self.engine[self.eng][8]].split('\\s')\n modLis = [mod.strip() for mod in modSM if mod!=' ']\n modSM = ';'.join(modLis)\n scoreSM=row[self.engine[self.eng][9]]\n descrimentSM=row[self.engine[self.eng][10]]\n if modSM !='':\n modPepInHupaFormat=self.modTermDic.spectrumMill(preAmSM,pepSM,nAmSM,modSM,self.eng)\n parsedData=acNoSM+'\\t'+masSM+'\\t'+chrgeSM+'\\t'+modPepInHupaFormat+'\\t'+scoreSM+'\\n'\n data = self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n else:\n parsedData=acNoSM+'\\t'+masSM+'\\t'+chrgeSM+'\\t'+preAmSM+'.'+pepSM+'.'+nAmSM+'\\t'+'-'+'\\t'+scoreSM+'\\n'\n data = self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n\n if self.eng is \"mascot\":\n \"\"\"\n In Mascot, under every gi (protein) corresponding peptide information will be there\n \"\"\"\n giFound=True\n for i,row in enumerate(self.dicts):\n if row[self.engine[self.eng][0]]!='':\n giAsKey = row[self.engine[self.eng][0]]\n giFound=False\n if giFound==False:\n massM=row[self.engine[self.eng][1]]\n chargeM=row[self.engine[self.eng][2]]\n preAmM=row[self.engine[self.eng][3]]\n pepM=row[self.engine[self.eng][4]]\n nAmM = row[self.engine[self.eng][5]]\n modM=row[self.engine[self.eng][6]]\n modSiteM=row[self.engine[self.eng][7]]\n scoreM=row[self.engine[self.eng][8]]\n evalM=row[self.engine[self.eng][9]]\n if modM !='':\n \"\"\"\n modificationFormat from modification.py creates a MASTER_UNIMOD dictionary \n Where all modifications of unimod would be available. \n At same time formatMod function in modificationFormat class would convert modification format \"\"\"\n modPepInHupaFormat=self.modTermDic.mascot(preAmM,pepM,nAmM,modSiteM,modM,self.eng)\n parsedData=giAsKey+'\\t'+massM+'\\t'+chargeM+'\\t'+modPepInHupaFormat+'\\t'+scoreM+'\\n'\n data=self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n else:\n \n parsedData=giAsKey+'\\t'+massM+'\\t'+chargeM+'\\t'+preAmM+'.'+pepM+'.'+nAmM+'\\t'+'-'+'\\t'+scoreM+'\\n'\n data=self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n\n if self.eng is \"inspect\":\n \"\"\"\n InSpect does not have mass information in TSV file\n So we need to fetch it from spectrum file (this is not yet done)\n \"\"\"\n for i,row in enumerate(self.dicts):\n data = row[self.engine[self.eng][0]]+'\\t'+row[self.engine[self.eng][1]]+'\\t'+row[self.engine[self.eng][2]]+'\\t'+row[self.engine[self.eng][3]]+'\\t'+row[self.engine[self.eng][4]]+'\\t'+row[self.engine[self.eng][5]]+'\\n'\n #return data\n #data = self.mapCaller(data)\n #self.writer.write(data)\n\n if self.eng is \"omssa\":\n #OMSSA csv doesnot contain start and last residue of the peptide, instead contains position. So start and last residue need to fetch from protein sequence\n for i,row in enumerate(self.dicts):\n giO = row[self.engine[self.eng][6]]\n massO= row[self.engine[self.eng][5]]\n chargeO=row[self.engine[self.eng][8]]\n preAmO = row[self.engine[self.eng][1]]#position in protein\n pepO = row[self.engine[self.eng][2]]\n nextAmO = row[self.engine[self.eng][3]] #position in protein\n scoreO= row[self.engine[self.eng][4]]\n modO=row[self.engine[self.eng][7]]\n if modO !='':\n #parsedData=giO+'#'+massO+'#'+chargeO+'#'+preAmO+'.'+pepO+'.'+nextAmO+'#'+modO+'#'+scoreO\n modPepInHupaFormat=self.modTermDic.omssa(preAmO,pepO,nextAmO,modO,self.eng)\n parsedData=giO+'\\t'+massO+'\\t'+chargeO+'\\t'+modPepInHupaFormat+'\\t'+scoreO+'\\n'\n self.mapCaller(parsedData,self.eng)\n else:\n parsedData=giO+'\\t'+massO+'\\t'+chargeO+'\\t'+preAmO+'.'+pepO+'.'+nextAmO+'\\t'+'-'+'\\t'+scoreO+'\\n'\n self.mapCaller(parsedData,self.eng)","def __init__(self, path):\n self.csv_path = path\n # check if csv format is valid or not\n self.check_valid_csvformat(self.csv_path)\n \"\"\" empty dict to store all company names\n prepare initial company data in dictionary format \"\"\"\n self.company_data = dict()","def main():\n\t#first check args and file paths\n\tcheckArgs(args)\n\t\n\tdata = args.dataset_file\n\tf_name = data.split(\".\")\n\tprint \"\\n[AP]\\t\"+\"######## \"+f_name[0] + '.' + f_name[1]+\" ########\"\n\tprint \"\\n[AP]\\tChecked inputs, now acquiring data\"\n\n\thost = \"localhost\"\n\tuser = \"readonly\"\n\tpasswd = \"readonlypswd\"\n\tdb = args.db_schema\n\tdb_table = args.db_table\n\n\tnameFile = data[0:-20]\n\tdataset = queryDataset(host,user,passwd,db,db_table,\"tmpFile.txt\",nameFile)\n\tif dataset is not None:\n\t\tdataset = dataset.rstrip('\\n')\n\t\tdataset = dataset.replace(\"/\",\"-\")\n\n\t\tlocations_list, length_list = generateDataset(data)\n\n\t\tif len(locations_list) < 2:\n\t\t\tprint \"\\n[SKIP]\\t{dataset} has only one unique line! Can't estimate anything.\\n\\tSKIP THIS FILE!\\n\".format(dataset=str(dataset))\n\t\t\treturn 0\n\n\t\t# Alias for estAbund calling\n\t\testAbund = sonicLength.estAbund\n\n\t\t# Call estAbund and store returned object in results\n\t\tresults = estAbund(robjects.StrVector(locations_list), robjects.FloatVector(length_list))\n\n\t\t# Put estimation for theta in estimations_theta and associated locations in locations_theta; then organize data in dic_of_theta\n\t\ttheta = results.rx2(\"theta\")\n\t\testimations_theta = tuple(theta)\n\t\tlocations_theta = tuple(theta.names)\n\t\t# dic_of_theta\n\t\tdic_of_theta = {}\n\t\tfor i in range(len(locations_theta)):\n\t\t\tdic_of_theta.update({locations_theta[i]:estimations_theta[i]})\n\n\t\t# Put different fragment lengths in length_phi and associated frequencies in freq_phi\n\t\tphi = results.rx2(\"phi\")\n\t\tfreq_phi = tuple(phi)\n\t\tlength_phi = tuple(phi.names)\n\n\t\tlength_phi_numbers = fragmentsLengthPlot(length_phi,freq_phi,length_list,nameFile,dataset)\n\n\t\tprintThetaInfo(estimations_theta,locations_theta,nameFile)\n\n\t\t# Retrieving redundant reads data\n\t\tdic_of_redundant_reads_count, sequence_count_list = redundant_reads_count(from_file_to_list(data,'.tsv'))\n\n\t\t# Box Plot\n\t\tsequence_count = []\n\t\tfor v in sequence_count_list:\n\t\t\tsequence_count.append(int(v))\n\t\tbox_plot(sequence_count, estimations_theta, nameFile,dataset)\n\n\t\t# Plot: unique lengths retrieved for a genomic location VS expected number of parent fragment for the same location\n\t\tphi_VS_theta(length_phi, freq_phi, nameFile, dataset)\n\n\n\t\t#######################################################################################################\n\t\t# Produce .tsv output about measured redundant reads count, abundance-corrected redundant reads count # \n\t\t# and some descriptive of unique fragments lengths #\n\t\t#######################################################################################################\n\n\t\t# Retrieving data\n\t\tdic_of_relative_abundance, dic_of_corrected_reads_count, dic_of_percentage_difference = corrected_reads_count(dic_of_redundant_reads_count, dic_of_theta)\n\t\tdic_of_unique_lengths, dic_of_unique_lengths_number, dic_of_median_of_unique_lengths, dic_of_MAD = fragment_lengths_statistics(data)\n\t\tdic_of_lengths = lengths_explicit_list(from_file_to_list(data,'.txt'))\n\n\t\t# Writing File\n\t\tcorrected_file = open(dataset + \".\" + nameFile+\".outcomes\"+\".tsv\", 'w')\n\t\tcorrected_file.write(\"Chromosome\\tIntegration_locus\\tStrand\\tSequence_Count\\tEstimated_Relative_Abundance\\tCorrected_Sequence_Count\\tPercentage_Variation\\tNumber_of_fragments_of_unique_lengths\\tLength_Min\\tLength_Max\\tLenght_Median\\tRounded_Lenght_Median\\tMAD\\tUnique_Lengths_List\\tUnique_Lengths_Amount\\tCEM_region_?\") ## ! NB ! ## \\tCEM_region_?\" has to remain the last!!!\n\t\tgenome_locations = dic_of_redundant_reads_count.keys()\n\t\tgenome_locations.sort()\n\t\tfor key in genome_locations:\n\t\t\tsplitted_location = key.split(' ')\n\t\t\tcorrected_file.write(\"\\n\" + splitted_location[0] + \"\\t\" + splitted_location[1] + \"\\t\" + splitted_location[2] + \"\\t\" + str(dic_of_redundant_reads_count[key]) + \"\\t\" + str(round(dic_of_relative_abundance[key],5)) + \"\\t\" + str(round(dic_of_corrected_reads_count[key],0)) + \"\\t\" + str(dic_of_percentage_difference[key]) + \"\\t\" + str(dic_of_unique_lengths_number[key]) + \"\\t\" + str(min(dic_of_unique_lengths[key])) + \"\\t\" + str(max(dic_of_unique_lengths[key])) + \"\\t\" + str(dic_of_median_of_unique_lengths[key]) + \"\\t\" + str(math.ceil(dic_of_median_of_unique_lengths[key]))+ \"\\t\" + str(dic_of_MAD[key]) + \"\\t\" + str(dic_of_unique_lengths[key]) + \"\\t\" + str(dic_of_lengths[key]))\n\t\t\tresponse, cem_symbol, cem_coordinates = is_CEM(key)\n\t\t\tif (response == True):\n\t\t\t\tcorrected_file.write(\"\\t\" + cem_symbol)\n\n\t\t# Write database file - Like corrected_file with more field appended in the end\n\t\tdb_file = open(dataset + \".\" + nameFile+\".db_file\"+\".tsv\", 'w')\n\t\tgenome_locations = dic_of_redundant_reads_count.keys()\n\t\tgenome_locations.sort()\n\t\tdataset_split = dataset.split('.')\n\t\tdataset_label = '_'.join(dataset_split)\n\t\tfor key in genome_locations:\n\t\t\tsplitted_location = key.split(' ')\n\t\t\tdb_file.write(splitted_location[0] + \"\\t\" + splitted_location[1] + \"\\t\" + splitted_location[2] + \"\\t\" + str(dic_of_redundant_reads_count[key]) + \"\\t\" + str(round(dic_of_relative_abundance[key],5)) + \"\\t\" + str(round(dic_of_corrected_reads_count[key],0)) + \"\\t\" + str(dic_of_percentage_difference[key]) + \"\\t\" + str(dic_of_unique_lengths_number[key]) + \"\\t\" + str(min(dic_of_unique_lengths[key])) + \"\\t\" + str(max(dic_of_unique_lengths[key])) + \"\\t\" + str(dic_of_median_of_unique_lengths[key]) + \"\\t\" + str(math.ceil(dic_of_median_of_unique_lengths[key]))+ \"\\t\" + str(dic_of_MAD[key]) + \"\\t\" + str(dic_of_unique_lengths[key])[1:-1] + \"\\t\" + str(dic_of_lengths[key])[1:-1] + \"\\t\")\n\t\t\tdb_file.write(\"\\t\".join(dataset_split) + \"\\t\" + dataset_label + \"\\t\")\n\t\t\tresponse, cem_symbol, cem_coordinates = is_CEM(key)\n\t\t\tif (response == True):\n\t\t\t\tdb_file.write(cem_symbol + \"\\t\" + cem_coordinates)\n\t\t\telse:\n\t\t\t\tdb_file.write(\"\\t\")\n\t\t\tdb_file.write(\"\\n\")\n\n\t\tdb_file.close()\n\n\t\t#######################################################################################################\n\n\t\t# Last print for user\n\t\tprint \"\\n[AP]\\tTask Finished, closing.\\n\"\n\telse:\n\t\tprint \"\\n[AP]\\tThe dataset is not in the reference DB. Skipped.\\n\"\n\n\treturn 0","def __init__(self, raw_data_file,):\n self.raw_data_file = raw_data_file\n self.clean_data = self.cleanData()\n self.microtrip_data = []","def Basic_Stat(self):\n out_file = \"%s/01.%s.BasicInfo_QC_map_SpikeIn.xls\" % (self.dir_StatInfo, self.s_idx)\n f_out_file = open( out_file,\"w\" )\n \n l_info = [\n \"Rename\", \"Raw_Reads\", \"Clean_Reads\",\n \"Pre_Map_Reads\", \"Aligned_Reads\", \"HTSseq_Known_Reads\",\n \"HTSeq_Refseq_Reads\",\n \"ERCC_Reads\",\n \"ERCC_Mols\"\n ]\n if not self.given_GTF:\n l_info = [\n \"Rename\", \"Raw_Reads\", \"Raw_bases\", \"Clean_Reads\", \"Clean_bases\", \"Q20(%)\",\"Q30(%)\",\"GC content(%)\",\n \"Pre_Map_Reads\", \"Aligned_Reads\", \"MappingRate\",\n \"ERCC_Reads\",\n \"ERCC_Mols\"\n ]\n \n \n out_info = \"\\t\".join(l_info)\n\n print >>f_out_file, out_info\n\n l_brief = self.samInfo_pd_RNA['brief_name']\n\n ### Load HTSeq reads\n HTS_info = m_cnt.CountInfo(\n self.s_idx,\n self.dir_mergeCout,\n# l_brief,\n# \"umi_clean_gene\",\n# self.dir_mergeCout\n )\n HTS_info.load_mat(gen_col=1, generate = 0)\n HTS_info.sam_tot_reads()\n \n ### Split refseq reads into RefSeq gene, lncGenes and novo genes.\n# self.__get_HTS_clean_split()\n \n# ### Load HTSeq refseq reads\n# Refseq_info = m_cnt.CountInfo(\n# self.s_idx,\n# self.dir_mergeCout,\n# l_brief,\n# \"dexseq_clean_refseq\",\n# self.dir_mergeCout\n# )\n# Refseq_info.load_mat(gen_col=1, generate = 0)\n# Refseq_info.sam_tot_reads()\n \n# ### Load HTSeq lncRNA reads\n# lncRNA_info = m_cnt.CountInfo(\n# self.s_idx,\n# self.dir_mergeCout,\n# l_brief,\n# \"dexseq_clean_lncRNA\",\n# self.dir_mergeCout\n# )\n# lncRNA_info.load_mat(gen_col=1, generate = 0)\n# lncRNA_info.sam_tot_reads()\n\n ### Load HTSeq novo-gene reads\n# if not self.given_GTF:\n# NeoPass_info = m_cnt.CountInfo(\n# self.s_idx,\n# self.dir_mergeCout,\n# l_brief,\n# \"dexseq_NeoPass\",\n# self.dir_mergeCout\n# )\n# NeoPass_info.load_mat(gen_col=1, generate = 0)\n# NeoPass_info.sam_tot_reads()\n \n \n \"\"\"\n Load other information\n \"\"\"\n for samp in self.samInfo_pd_RNA['sample']:\n idx = (self.samInfo_pd_RNA['sample'] == samp)\n brief_name = self.samInfo_pd_RNA[idx]['brief_name'].values[0]\n rename = self.samInfo_pd_RNA[idx]['rename'].values[0]\n data_type = self.samInfo_pd_RNA[ idx ]['end_type'].values[0]\n QC_log = \"%s/%s/%s.QC.log\" % (self.dir_clean_data, samp, samp)\n \n Tophat_log = \"%s/%s/align_summary.txt\" %\\\n (self.dir_tophat, brief_name)\n \n HTSeq_SpikeIn = \"%s/%s/%s.dexseq_ERCC_RGCPloyA.txt\" %\\\n (self.dir_HTS_known, brief_name, brief_name)\n \n QcStat_info = Stat.QcStat(QC_log)\n MapStat_info = Stat.TophatStat(Tophat_log)\n SpikeIn_info = Stat.SpikeIn(HTSeq_SpikeIn, self.ercc_info_file)\n \n \n QcStat_info.read_infile()\n MapStat_info.read_infile()\n SpikeIn_info.load_HTS_file()\n \n pre_map_read = MapStat_info['statInfo']['totalRead']\n aligned_read = MapStat_info['statInfo']['mappedRead']\n mappingRate = MapStat_info['statInfo']['mappingRate']\n \n if data_type == \"PE\": \n HTSseq_read = self.__get_HTS_reads(HTS_info ,samp) * 2\n Refseq_read = self.__get_HTS_reads(Refseq_info ,samp) * 2\n lncRNA_read = self.__get_HTS_reads(lncRNA_info ,samp) * 2\n NeoPass_read = 0\n if not self.given_GTF:\n NeoPass_read = self.__get_HTS_reads(NeoPass_info,samp) * 2\n read_RFP = SpikeIn_info.RGC_count['RGC-mRFP'] * 2\n read_GFP = SpikeIn_info.RGC_count['RGC-GFP' ] * 2\n read_CRE = SpikeIn_info.RGC_count['RGC-CRE' ] * 2\n read_ERCC = SpikeIn_info.ERCC_total * 2\n else:\n HTSseq_read = self.__get_HTS_reads(HTS_info ,samp)\n# Refseq_read = self.__get_HTS_reads(Refseq_info ,samp)\n# lncRNA_read = self.__get_HTS_reads(lncRNA_info ,samp)\n# if not self.given_GTF:\n# NeoPass_read = self.__get_HTS_reads(NeoPass_info,samp)\n\n# read_RFP = SpikeIn_info.RGC_count['RGC-mRFP']\n# read_GFP = SpikeIn_info.RGC_count['RGC-GFP' ]\n# read_CRE = SpikeIn_info.RGC_count['RGC-CRE' ]\n read_ERCC = SpikeIn_info.ERCC_total\n# \n# mol_RFP = self.samInfo_pd_RNA[idx]['RFP_polyA'].values[0]\n# mol_GFP = self.samInfo_pd_RNA[idx]['GFP_polyA'].values[0]\n# mol_CRE = self.samInfo_pd_RNA[idx]['CRE_polyA'].values[0]\n mol_ERCC = self.samInfo_pd_RNA[idx]['ERCC_time'].values[0] *\\\n 6.023*10**10\n\n l_out = [\n rename,\n QcStat_info.raw_reads, QcStat_info.cln_reads,\n pre_map_read, aligned_read, HTSseq_read,\n read_ERCC,\n mol_ERCC\n ]\n if not self.given_GTF:\n l_out = [\n rename,\n QcStat_info.raw_reads,QcStat_info.raw_bases, QcStat_info.cln_reads,QcStat_info.cln_bases ,QcStat_info.Q20_l_rate ,QcStat_info.Q30_l_rate ,QcStat_info.GC_l_rate,\n pre_map_read, aligned_read, mappingRate,\n read_ERCC,\n mol_ERCC\n ]\n l_out = [str(i) for i in l_out]\n print >>f_out_file, \"\\t\".join(l_out)\n \n f_out_file.close()","def _process_data(self):\r\n # Rename columns to match final feature class\r\n self._rename_columns()\r\n # Add point ID column\r\n self._add_pointid()\r\n # Sort rows by transect id and timestamp\r\n self._sort_rows()\r\n # Fill Null records with a value\r\n self._fill_nulls()\r\n # Set site_code to lower case\r\n self._lower_site_code()\r\n # Create survey_id\r\n self._calc_survey_id()\r\n # Calculate nativesg column if at least one of the veg columns is a Native seagrass type\r\n if set(self.veg_columns).intersection(set(NATIVESG_CODES)) > 0:\r\n self.nativesg_columns = list(set(self.veg_columns).intersection(set(NATIVESG_CODES)))\r\n self._calc_nativesg()\r\n #\r","def dataLoad():\n try:\n try: #Python3\n f = open(__file__ + \".csv\",\"rt\")\n except: #Python2\n f = open(__file__ + \".csv\",\"rb\")\n data = f.read().split(',')\n entryCol.entry0.delete(0,END)\n entryCol.entry0.insert(0,data[0])\n entryCol.entry1.delete(0,END)\n entryCol.entry1.insert(0,data[1])\n entryCol.entry2.delete(0,END)\n entryCol.entry2.insert(0,data[2])\n entryCol.entry3.delete(0,END)\n entryCol.entry3.insert(0,data[3])\n botWind.writeN(\"DataLoad: File\")\n except:\n botWind.writeN(\"DataLoad: Default\")","def process_data(rows, options):\n cohort = int(options.cohort)\n id_expiry = PHASE_END_DATES[cohort][4]\n for row in rows:\n new_student = Person()\n for k, v in row.items():\n setattr(new_student, k, v)\n new_student.student_cohort = cohort\n new_student.id_expiry = id_expiry\n if options.section:\n new_student.student_sec_phase1 = options.section\n if options.add:\n new_student.save()\n print \"Saved:\", new_student","def main():\n #find sys args and handle appropriately\n argv = sys.argv\n if(len(argv) != 2):\n print(\"Invalid number of input strings.\")\n print(\"Usage: python mdc.py [inputfile]\")\n else:\n #run the IO script, expect out a list of lists, etc..\n data = CSVIO.readDataCSV(argv[1])\n #create a list of classNames from the data, trim/convert as necessary\n classNames = data[0][1:]\n try:\n while(True):\n classNames.remove('')\n except ValueError:\n pass\n try:\n classNames = [item.split('=')[1] for item in classNames]\n except IndexError as ie:\n print(\"I've failed you Dr. Weiss...\")\n #declare/init our class with proper values\n pc = training.PatternClassifier(data[0][0], len(classNames), classNames, len(data[1][2:]), \\\n data[1][2:], len(data[2:]), data[2:])\n #run the training data with leaving out i for our test on each sample\n for i in range(0, pc.nSamples):\n pc.train(i)\n #output to console/file\n print(pc)\n CSVIO.writeToFile(argv[1], pc)","def lcia_methods__metadata(self):\r\n with UnicodeReader(os.path.join(dirpath, \"categoryUUIDs.csv\"), \r\n encoding='latin-1', \r\n delimiter=dt) as csv_file:\r\n next(csv_file) \r\n csv_data = [{'name': (line[0], line[2], line[4]),\r\n 'description': line[7]\r\n } for line in csv_file]\r\n \r\n filename = \"LCIA_implementation_2019.xlsx\" # this was donwloaded and updated on Oct 2019 from ecoinvent website. \r\n wb = xlrd.open_workbook(os.path.join(dirpath, filename))\r\n #characterizaton factors\r\n sheet= wb.sheet_by_name(\"CFs\")\r\n cf_data = [{\r\n 'method': (sheet.cell(row, 0).value,\r\n sheet.cell(row, 1).value,\r\n sheet.cell(row, 2).value),\r\n 'name': sheet.cell(row, 3).value,\r\n 'categories': (sheet.cell(row, 4).value, sheet.cell(row, 5).value),\r\n 'amount': sheet.cell(row, 7).value\r\n }\r\n for row in range(1, sheet.nrows)\r\n if sheet.cell(row, 0).value not in \r\n {'selected LCI results, additional', 'selected LCI results'} and isinstance(sheet.cell(row, 7).value, Number)]\r\n #units\r\n sheet= wb.sheet_by_name(\"units\")\r\n units = {(sheet.cell(row, 0).value, sheet.cell(row, 1).value, \r\n sheet.cell(row, 2).value): sheet.cell(row, 4).value for row in range(1, sheet.nrows)}\r\n return csv_data, cf_data, units, filename","def run(self):\n\n # How to retrieve your input data.\n input_1_data = self.in_data['input_1']\n\n # How to retrieve your params value.\n param_1 = self.param['param_1']\n\n # How to process data.\n # Just write any number of methods you want and use them here.\n sample_out_data = self.sample_method(input_1_data, param_1)\n\n # Go to the definition of this method to see how to log.\n self.demo_log()\n\n # This is how to set output data.\n self.out_data['output_1'] = sample_out_data","def perform_process(transformer: transformer_class.Transformer, check_md: dict) -> dict:\n # Process each CSV file into BETYdb\n start_timestamp = datetime.datetime.now()\n files_count = 0\n files_csv = 0\n lines_read = 0\n error_count = 0\n files_loaded = []\n for one_file in check_md['list_files']():\n files_count += 1\n if os.path.splitext(one_file)[1].lower() == '.csv':\n files_csv += 1\n\n # Make sure we can access the file\n if not os.path.exists(one_file):\n msg = \"Unable to access csv file '%s'\" % one_file\n logging.debug(msg)\n return {'code': -1000,\n 'error': msg}\n\n try:\n # Read in the lines from the file\n with open(one_file, 'r') as in_file:\n reader = csv.DictReader(in_file)\n files_loaded.append(one_file)\n for row in reader:\n centroid_lonlat = [row['lon'], row['lat']]\n time_fmt = row['dp_time']\n timestamp = row['timestamp']\n dp_metadata = {\n \"source\": row['source'],\n \"value\": row['value']\n }\n trait = row['trait']\n\n __internal__.create_datapoint_with_dependencies(transformer.args.clowder_url, transformer.args.clowder_key,\n trait, (centroid_lonlat[1], centroid_lonlat[0]), time_fmt,\n time_fmt, dp_metadata, timestamp)\n lines_read += 1\n\n except Exception:\n logging.exception(\"Error reading CSV file '%s'. Continuing processing\", os.path.basename(one_file))\n error_count += 1\n\n if files_csv <= 0:\n logging.info(\"No CSV files were found in the list of files to process\")\n if error_count > 0:\n logging.error(\"Errors were found during processing\")\n return {'code': -1001, 'error': \"Too many errors occurred during processing. Please correct and try again\"}\n\n return {\n 'code': 0,\n configuration.TRANSFORMER_NAME: {\n 'version': configuration.TRANSFORMER_VERSION,\n 'utc_timestamp': datetime.datetime.utcnow().isoformat(),\n 'processing_time': str(datetime.datetime.now() - start_timestamp),\n 'num_files_received': str(files_count),\n 'num_csv_files': str(files_csv),\n 'lines_loaded': str(lines_read),\n 'files_processed': str(files_loaded)\n }\n }","def __init__(self, path):\n with open(path, 'r') as bt:\n self.headers = bt.readline().split(',')\n self.data = []\n for line in bt:\n self.data.append(list(eval(line)))\n self.scores = []\n self.models = {'dtr': DecisionTreeRegressor(),\n 'br': BaggingRegressor(n_jobs=-1),\n 'rfr': RandomForestRegressor(n_jobs=-1),\n }","def getArguments(Comm):\n input_dir=''\n dataset=''\n l=0.0\n if len(Comm)==4:\n input_dir=str(Comm[1])\n dataset=str(Comm[2])\n l=float(Comm[3])\n else:\n print \"To run this program you have to provide a training file, a test file, an output file and a smoothing parameter\"\n print \"the chemicals must be integer indexed. This script read chemical feature files based on chemical index in integer\"\n print \"example: python PRW_10cv.py /path/to/N1/L1to5/ N1L1to5 0.9\"\n exit(1)\n feature=get_feature()\n RCRS=[]\n TPR35=[]\n for i in range(1,11):\n #10cv for 1 to 10\n trainfile=input_dir+\"train\"+str(i)+\".csv\"\n Train=get_train(trainfile,feature)\n\n testfile=input_dir+\"test\"+str(i)+\".csv\"\n \n testrow=[]\n testcol=[]\n print \"Reading test instances : \",testfile\n for line in open(testfile,\"r\").xreadlines():\n z=line.strip().split(\",\")\n chem=str(z[0])\n prot=str(z[1])\n testrow.append(chem)\n testcol.append(prot)\n rcrs=get_PRW_rcrs(feature,Train,zip(testrow,testcol),l)\n tpr35=TPRbyRowRank(rcrs,35)\n TPR35.append(tpr35)\n RCRS=RCRS+rcrs\n avgtpr35=np.average(TPR35)\n semtpr35=(np.std(TPR35)/math.sqrt(len(TPR35)))\n print \"Dataset=%s, Avg.TPR35=%s, S.E.M.TPR35=%s\"%(dataset,str(avgtpr35),str(semtpr35))\n print TPR35\n print \"Rank\\tTPR\"\n for i in range(1,351):\n tpr=TPRbyRowRank(RCRS,i)\n print \"%s\\t%s\"%(str(i),str(tpr))\n return","def main(): \n for info_hash_record in info_hashs:\n get_and_save_bt_info(info_hash_record)","def __init__(self):\n with open(\"sat.json\", \"r\") as infile:\n self._sat = json.load(infile)[\"data\"]\n #Define the headers for the csv\n self._headers = [\"DBN\", \"School Name\", \"Number of Test Takers\", \"Critical Reading Mean\", \"Mathematics Mean\", \"Writing Mean\"]","def main():\n df_path = './DuReader_reformatted/DuReader_for_dbCombinedPara500-150-sample10000.csv'\n df = pd.read_csv(df_path, sep='\\t', index_col=0).dropna() # drop 2 nan question and 8 nan title\n epoch = 5 # about 6 hours\n total_time_list, back_end_time_list = get_time_avg(df['question'].tolist(), epoch)\n df['time_avg'] = total_time_list\n df['backend_time'] = back_end_time_list\n new_df_path = os.path.splitext(df_path)[0] + '-whole-epoch-' + str(epoch) + '.csv'\n df.to_csv(new_df_path, sep='\\t')\n print('file successfully saved to ', new_df_path)","def automated(a):\n\n try:\n\n lg.warning(\"user gave the input path/file as:\"+' '+str(a))\n df=pd.read_excel(a)\n lg.warning(\"data successfully loaded from the file/path\"+' '+str(a))\n\n lg.info(\"starting all the pre-processing done for the train dataset\")\n\n df.dropna(inplace=True)\n lg.warning(\"successfully dropped all null values in the given dataset\")\n\n def change_into_datetime(col):\n df[col]=pd.to_datetime(df[col])\n\n for i in ['Date_of_Journey','Dep_Time', 'Arrival_Time']:\n change_into_datetime(i)\n lg.info(\"successfully changed the required columns into datetime format\")\n\n df['journey_day']=df['Date_of_Journey'].dt.day\n lg.info(\"successfully extracted day from Date_of_journey and creating a separate column for day\")\n df['journey_month']=df['Date_of_Journey'].dt.month\n lg.info(\"successfully extracted month from Date_of_Journey and creating a separate column for month\")\n\n def extract_hour(data,col):\n data[col+'_hour']=data[col].dt.hour\n def extract_min(data,col):\n data[col+'_min']=data[col].dt.minute\n def drop_col(data,col):\n data.drop(col,axis=1,inplace=True)\n\n\n extract_hour(df,'Dep_Time')\n lg.info(\"successfully extracted hours from Dep_Time and dumped the data into new column Dep_Time_hour\")\n extract_min(df,'Dep_Time')\n lg.info(\"successfully extracted minutes from Dep_Time and dumped the data into new column Dep_Time_min\")\n drop_col(df,'Dep_Time')\n lg.warning(\"dropping the original Dep_Time column as we extracted the values form that column\")\n extract_hour(df,'Arrival_Time')\n lg.info(\"successfully extracted hours from Arrival_Time and dumped the data into new column Arrival_Time_hour\")\n extract_min(df,'Arrival_Time')\n lg.info(\"successfully extracted min from Arrival_Time and dumped the data into new column Arrival_Time_min\")\n drop_col(df,'Arrival_Time')\n lg.warning(\"dropping the original Arrival_Time column as we extracted the values form that column\")\n\n duration = list(df[\"Duration\"])\n\n for i in range(len(duration)):\n if len(duration[i].split()) != 2:\n if \"h\" in duration[i]:\n duration[i] = duration[i].strip() + \" 0m\"\n else:\n duration[i] = \"0h \" + duration[i]\n\n duration_hours = []\n duration_mins = []\n for i in range(len(duration)):\n duration_hours.append(int(duration[i].split(sep = \"h\")[0]))\n duration_mins.append(int(duration[i].split(sep = \"m\")[0].split()[-1]))\n\n df[\"Duration_hours\"] = duration_hours\n lg.info(\"successfully extracted hours from Duration column and dumped the data into new column Duration_hours\")\n df[\"Duration_mins\"] = duration_mins\n lg.info(\"successfully extracted minutes from Duration column and dumped the data into new column Duration_mins\")\n\n df.drop([\"Date_of_Journey\",\"Duration\",\"Additional_Info\"], inplace=True,axis=1)\n lg.warning(\"dropping the Date_of_Journey, Duration, Additional_Info columns as we extracted the required \"\n \"information\")\n\n Airline=pd.get_dummies(df['Airline'],drop_first=True)\n lg.info(\"creating dummy variables for Airline and dropping the first dummy column\")\n\n source=pd.get_dummies(df['Source'],drop_first=True)\n lg.info(\"creating dummy variables for Source and dropping the first dummy column\")\n\n destination=pd.get_dummies(df['Destination'],drop_first=True)\n lg.info(\"creating dummy variables for Destination and dropping the first dummy column\")\n\n dict={'non-stop':0, '2 stops':2, '1 stop':1, '3 stops':3, '4 stops':4}\n df['Total_Stops']=df['Total_Stops'].map(dict)\n lg.info(\"successfully mapped the Total_Stops column to 0,1,2,3,4 respectfully\")\n\n df=pd.concat([df, Airline, source, destination], axis = 1)\n lg.warning(\"concatenating all the newly created columns into the main dataframe\")\n\n df.drop([\"Airline\", 'Source', 'Destination','Route'],inplace=True,axis=1)\n lg.warning(\"dropping the categorical columns as we dummy encoded them\")\n\n df['Trujet']=0\n lg.info(\"adding an extra column as this feature is not there in our test dataset\")\n\n\n model = open('flight_rf.pkl','rb')\n forest = pickle.load(model)\n lg.info(\"loading our test model for prediction\")\n\n y_prediction = forest.predict(df)\n lg.info(\"processing the prediction\")\n\n a=pd.DataFrame(y_prediction)\n lg.info(\"dumping all our predicted values into a dataframe and showing the results\")\n\n print(a)\n return a\n\n except Exception as e:\n lg.warning(\"error occurred during execution, which is:\"+' '+str(e))\n return \"error occurs is:\"+' '+str(e)","def test():\n\n # todo: using 'analysisname' for group by, I think I can also use 'File Number'\n statListDict = None # list of dict mapping human readbale to column names\n masterDf = None\n interfaceDefaults = None\n\n # machine learning db\n if 0:\n # this is from mac laptop\n #path = '/Users/cudmore/data/laura-ephys/Superior vs Inferior database_master.csv'\n path = '/Users/cudmore/data/laura-ephys/SANdatabaseForMachineLearning.xlsx'\n analysisName = 'File Number'\n #statListDict = None #sanpy.bAnalysisUtil.getStatList()\n categoricalList = ['LOCATION', 'SEX', 'File Number']#, 'File Name']\n hueTypes = ['LOCATION', 'SEX', 'File Number'] #, 'File Name'] #, 'None']\n sortOrder = ['LOCATION', 'SEX', 'File Number']\n\n # sanpy database\n if 0:\n #import sanpy\n #sys.path.append(os.path.join(os.path.dirname(sys.path[0]),'sanpy'))\n #import bAnalysisUtil\n #statListDict = bAnalysisUtil.statList\n import statlist\n statListDict = statlist.statList\n\n # this is from mac laptop\n #path = '/Users/cudmore/data/laura-ephys/Superior vs Inferior database_master.csv'\n path = '../examples/Superior vs Inferior database_master.csv'\n path = '/Users/cudmore/data/laura-ephys/Superior_Inferior_database_master_jan25.csv'\n path = '/Users/cudmore/data/laura-ephys/Superior vs Inferior database_master.csv'\n path = '/Users/cudmore/data/laura-ephys/Superior vs Inferior database_master_20210402.csv'\n\n #path = 'data/Superior vs Inferior database_master_20210402.csv'\n path = 'data/Superior vs Inferior database_master_20210402.csv'\n #path = '/Users/cudmore/data/laura-ephys/Superior_Inferior_database_master_jan25.csv'\n path = 'data/Superior vs Inferior database_13_Feb_master.csv'\n analysisName = 'analysisname'\n #statListDict = None #sanpy.bAnalysisUtil.getStatList()\n categoricalList = ['include', 'condition', 'region', 'Sex', 'RegSex', 'File Number', 'analysisname']#, 'File Name']\n hueTypes = ['region', 'sex', 'RegSex', 'condition', 'File Number', 'analysisname'] #, 'File Name'] #, 'None']\n sortOrder = ['region', 'sex', 'condition']\n\n interfaceDefaults = {'Y Statistic': 'Spike Frequency (Hz)',\n 'X Statistic': 'region',\n 'Hue': 'region',\n 'Group By': 'File Number'}\n # bimpy database\n if 0:\n path = '../examples/edges_db.csv'\n analysisName = 'fileNumber'\n categoricalList = ['san', 'region', 'path', 'file', 'fileNumber', 'nCon']\n hueTypes = categoricalList\n sortOrder = ['san', 'region']\n\n # dualAnalysis database\n if 0:\n # grab our list of dict mapping human readable to .csv column names\n sys.path.append(os.path.join(os.path.dirname(sys.path[0]),'sanpy'))\n import bAnalysisUtil\n statListDict = bAnalysisUtil.statList\n\n path = '/Users/cudmore/Sites/SanPy/examples/dual-analysis/dualAnalysis_final_db.csv'\n analysisName = 'fileNumber' # # rows in .xlsx database, one recording per row\n # trial is 1a/1b/1c... trial withing cellNumber\n categoricalList = ['include', 'region', 'fileNumber', 'cellNumber', 'trial', 'quality']\n hueTypes = categoricalList\n sortOrder = ['region']\n\n # sparkmaster lcr database\n if 0:\n path = '/Users/cudmore/Sites/SanPy/examples/dual-analysis/lcr-database.csv'\n analysisName = 'fileNumber' # # rows in .xlsx database, one recording per row\n # trial is 1a/1b/1c... trial withing cellNumber\n categoricalList = ['quality', 'region', 'fileNumber', 'dateFolder', 'tifFile']\n hueTypes = categoricalList\n sortOrder = ['region']\n\n # lcr/vm analysis using lcrPicker.py\n if 0:\n #basePath = '/Users/cudmore/Sites/SanPy/examples/dual-analysis/'\n #path = basePath + 'dual-data/20210115/20210115__0002_lcrPicker.csv'\n #path = basePath + 'dual-data/20210115/20210115__0001_lcrPicker.csv'\n\n # output of lcrPicker.py ... mergeDatabase()\n path = '/Users/cudmore/Sites/SanPy/examples/dual-analysis/lcrPicker-db.csv'\n categoricalList = None\n hueTypes = None\n analysisName= 'tifFile'\n sortOrder = None\n\n # merged sanpy+lcr pre spike slope\n # generated by dualAnalysis.py xxx()\n # usnig to compare lcr slope to edddr for fig 9\n if 0:\n path = '/Users/cudmore/Sites/SanPy/examples/dual-analysis/combined-sanpy-lcr-db.csv'\n statListDict = None\n categoricalList = None\n hueTypes = None\n analysisName= 'filename'\n sortOrder = None\n\n if 1:\n path = 'data'\n ad = sanpy.analysisDir(path, autoLoad=True)\n for row in range(len(ad)):\n ad.getAnalysis(row)\n masterDf = ad.pool_build()\n categoricalList = ['file', 'File Number']\n hueTypes = ['file', 'File Number']\n analysisName = 'file'\n from sanpy.bAnalysisUtil import statList as statListDict\n sortOrder = ['file', 'File Number']\n interfaceDefaults = {'Y Statistic': 'Spike Frequency (Hz)',\n 'X Statistic': 'Spike Number',\n 'Hue': 'file',\n 'Group By': 'file'}\n\n #\n app = QtWidgets.QApplication(sys.argv)\n\n ex = bScatterPlotMainWindow(path, categoricalList, hueTypes,\n analysisName, sortOrder, statListDict=statListDict,\n masterDf = masterDf,\n interfaceDefaults = interfaceDefaults)\n ex.show()\n\n sys.exit(app.exec_())","def main():\n\n house_path = '../../Data/wijk1_huizen.csv'\n battery_path = '../../Data/wijk1_batterijen.txt'\n\n houses, batteries = read_data(house_path, battery_path)\n\n smart_wijk = SmartGrid(51,51)\n smart_wijk.add_house_dictionaries(houses)\n smart_wijk.add_battery_dictionaries(batteries)\n\n for element in houses:\n smart_wijk.create_house(element['position'], element['output'])\n for element in batteries:\n smart_wijk.create_battery(element['position'], element['capacity'])\n\n solution_reader(smart_wijk, '../../Results/best_brabo_solution.csv')","def _main(hgt_results_fp,\n method):\n\n with open(hgt_results_fp, 'U') as input_f:\n\t if method == 'ranger-dtl':\n\t parse_rangerdtl(input_f=input_f)\n\t elif method == 'trex':\n\t parse_trex(input_f=input_f)\n\t elif method == 'riata-hgt':\n\t parse_riatahgt(input_f=input_f)\n\t elif method == 'jane4':\n\t parse_jane4(input_f=input_f)\n\t elif method == 'consel':\n\t parse_consel(input_f=input_f)","def get_data(self, csv_file):\n pass","def new_csv_imp(infile):\r\n with open(infile, \"r\") as fd:\r\n txt = fd.readlines()\r\n if len(txt) > 1:\r\n if 'Serial' in txt[0]:\r\n print('{:} is Solinst'.format(infile))\r\n if 'UNIT: ' in txt[7]:\r\n level_units = str(txt[7])[5:].strip().lower()\r\n if 'UNIT: ' in txt[12]:\r\n temp_units = str(txt[12])[5:].strip().lower()\r\n f = pd.read_csv(infile, skiprows=13, parse_dates=[[0, 1]], usecols=[0, 1, 3, 4])\r\n print(f.columns)\r\n f['DateTime'] = pd.to_datetime(f['Date_Time'], errors='coerce')\r\n f.set_index('DateTime', inplace=True)\r\n f.drop('Date_Time', axis=1, inplace=True)\r\n f.rename(columns={'LEVEL': 'Level', 'TEMP': 'Temp'}, inplace=True)\r\n level = 'Level'\r\n temp = 'Temp'\r\n\r\n if level_units == \"feet\" or level_units == \"ft\":\r\n f[level] = pd.to_numeric(f[level])\r\n elif level_units == \"kpa\":\r\n f[level] = pd.to_numeric(f[level]) * 0.33456\r\n printmes(\"Units in kpa, converting {:} to ft...\".format(os.path.basename(infile)))\r\n elif level_units == \"mbar\":\r\n f[level] = pd.to_numeric(f[level]) * 0.0334552565551\r\n elif level_units == \"psi\":\r\n f[level] = pd.to_numeric(f[level]) * 2.306726\r\n printmes(\"Units in psi, converting {:} to ft...\".format(os.path.basename(infile)))\r\n elif level_units == \"m\" or level_units == \"meters\":\r\n f[level] = pd.to_numeric(f[level]) * 3.28084\r\n printmes(\"Units in psi, converting {:} to ft...\".format(os.path.basename(infile)))\r\n else:\r\n f[level] = pd.to_numeric(f[level])\r\n printmes(\"Unknown units, no conversion\")\r\n\r\n if temp_units == 'Deg C' or temp_units == u'\\N{DEGREE SIGN}' + u'C':\r\n f[temp] = f[temp]\r\n elif temp_units == 'Deg F' or temp_units == u'\\N{DEGREE SIGN}' + u'F':\r\n printmes('Temp in F, converting {:} to C...'.format(os.path.basename(infile)))\r\n f[temp] = (f[temp] - 32.0) * 5.0 / 9.0\r\n return f\r\n\r\n elif 'Date' in txt[1]:\r\n print('{:} is Global'.format(infile))\r\n f = pd.read_csv(infile, skiprows=1, parse_dates=[[0, 1]])\r\n # f = f.reset_index()\r\n f['DateTime'] = pd.to_datetime(f['Date_ Time'], errors='coerce')\r\n f = f[f.DateTime.notnull()]\r\n if ' Feet' in list(f.columns.values):\r\n f['Level'] = f[' Feet']\r\n f.drop([' Feet'], inplace=True, axis=1)\r\n elif 'Feet' in list(f.columns.values):\r\n f['Level'] = f['Feet']\r\n f.drop(['Feet'], inplace=True, axis=1)\r\n else:\r\n f['Level'] = f.iloc[:, 1]\r\n # Remove first and/or last measurements if the transducer was out of the water\r\n # f = dataendclean(f, 'Level')\r\n flist = f.columns.tolist()\r\n if ' Temp C' in flist:\r\n f['Temperature'] = f[' Temp C']\r\n f['Temp'] = f['Temperature']\r\n f.drop([' Temp C', 'Temperature'], inplace=True, axis=1)\r\n elif ' Temp F' in flist:\r\n f['Temperature'] = (f[' Temp F'] - 32) * 5 / 9\r\n f['Temp'] = f['Temperature']\r\n f.drop([' Temp F', 'Temperature'], inplace=True, axis=1)\r\n else:\r\n f['Temp'] = np.nan\r\n f.set_index(['DateTime'], inplace=True)\r\n f['date'] = f.index.to_julian_date().values\r\n f['datediff'] = f['date'].diff()\r\n f = f[f['datediff'] > 0]\r\n f = f[f['datediff'] < 1]\r\n # bse = int(pd.to_datetime(f.index).minute[0])\r\n # f = hourly_resample(f, bse)\r\n f.rename(columns={' Volts': 'Volts'}, inplace=True)\r\n f.drop([u'date', u'datediff', u'Date_ Time'], inplace=True, axis=1)\r\n return f\r\n else:\r\n print('{:} is unrecognized'.format(infile))","def entry_parser():\n # from tools import file_importer, file_outporter\n from copy import copy\n from collections import defaultdict\n import os.path\n \n print(\"this is entry parser\")\n \n # inPathL = [\"bob/processed/proteinGroups - OST-1-09042017.txt\",\"bob/processed/proteinGroups_OST2.txt\",\"bob/processed/proteinGroups_OST3.txt\"]\n inpathL = []\n inpF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \"data\", \"cav1ko\", \"txt_cav1ko-1-17082017\", \"proteinGroups.txt\"),\"r\")\n # outPath = \"bob/processed/OST-24-05-2017_combined.csv\"\n fileCount = 1\n # outF = file_outporter(outPath)\n outF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \"data\", \"cav1ko\", \"processed\", \"cav1ko-1.csv\"),\"w\")\n # newFlag = True\n \n finDict = defaultdict(list)\n cN = 0\n # for relPath in inPathL:\n outDict = {}\n # inpF = file_importer(relPath)\n headerFlag = True\n \n for inpLine in inpF:\n cN += 1\n if headerFlag:\n headerFlag = False\n headerLine = inpLine\n continue\n inpLine = inpLine.strip(\"\\n\\r\")\n inpItem = inpLine.split(\"\\t\")\n geneL = inpItem[0].split(\";\")\n lenS = len(geneL[0])\n curGene = geneL[0]\n for geneI in geneL: # find gene name with the shortest length\n if len(geneI) < lenS:\n lenS = len(geneI)\n curGene = geneI\n if \"__\" in curGene: continue # get rid of contaminant lines\n try: # get rid of wonky lines introduced by excel\n int(curGene)\n continue\n except ValueError: \n pass\n\n if curGene[-2] == \"-\":\n curGene = curGene[:-2]\n if curGene[-3] == \"-\":\n curGene = curGene[:-3]\n \n # remove ambiguities based on gene name from the entire entry:\n \n corrPos = geneL.index(curGene)\n corrLine = []\n targetCount = 46 # after the 45th item row in the list, peptide IDs and modification start to appear which are allowed to have multiple entries and do not need to be disambiguated\n currCount = 1\n pepFlag = True\n for inpE in inpItem:\n currCount += 1\n if currCount == targetCount:\n pepFlag = False\n # print inpE\n if \";\" in inpE and pepFlag:\n try:\n corrLine.append(inpE.split(\";\")[corrPos])\n except IndexError:\n corrLine.append(inpE.split(\";\")[0])\n else:\n corrLine.append(inpE.rstrip(\"\\n\"))\n\n \n if inpItem[6] == \"\":\n # print \"no protein name found. adding the uniprot ID.\"\n inpItem[6] = curGene\n \n \"\"\"\n try:\n for inpN in inpItem[4:10]:\n inpItem[inpItem.index(inpN)] = int(inpN)\n countFlag = True\n except ValueError:\n print inpItem[4:10]\n countFlag = False\n if countFlag:\n if sum(inpItem[4:10]) == 0: continue # there are some unexpressed proteins in there\n \n \"\"\"\n # print len(corrLine)\n if curGene in outDict: # handle duplicate protein entries and merge them together\n # print \"%s is duplicate\" % curGene\n if curGene == \"Protein IDs\": \n \"\"\"\n quickCount2 = 0\n for quickDictI in outDict[curGene]:\n print str(quickCount2) + \" \" + quickDictI\n quickCount2 += 1\n quickList = inpItem\n quickCount3 = 0\n for quickImp in quickList:\n print str(quickCount3) + \" \" + quickImp\n quickCount3 += 1 \n # print inpItem\n # print outDict[curGene]\n \"\"\"\n continue\n combList = []\n \n \"\"\"\n addL = []\n for i in outDict[curGene][3:]:\n addL.append(i)\n addL2 = []\n for j in corrLine[3:]:\n addL2.append(i)\n outL[3:] = map(add, addL, addL2) # admittedly this looks terrible\n \"\"\"\n \n indexN = 0\n for cItem in corrLine:\n # print indexN\n # print \"---\"\n # print len(corrLine)\n if indexN < 18 or 30 <= indexN <= 43:\n try:\n currC = int(cItem)\n currC = currC + int(outDict[curGene][indexN]) # numbers like peptide counts or LFQ values are added up during merge\n except ValueError:\n currC = cItem\n \n elif 18 <= indexN <= 25 or 28 <= indexN <= 29: # sequence coverage and scores\n currC = max([float(cItem),float(outDict[curGene][indexN])])\n \n elif 26 <= indexN <= 27 or indexN == 44:\n \"\"\"\n quickCount = 0\n for corrItem in corrLine:\n print str(quickCount) + \" \" + corrItem\n quickCount += 1\n \n import time\n \n print relPath\n print corrLine\n print outDict[curGene]\n print \"++++++++++++++++++++++++\"\n print indexN\n time.sleep(0.5)\"\"\"\n currC = cItem\n\n \n else:\n corrL = cItem.split(\";\")\n # print indexN\n # print corrLine\n # print outDict[curGene][indexN]\n dictL = outDict[curGene][indexN].split(\";\")\n mergeL = copy(dictL)\n for corrI in corrL:\n if corrI not in dictL:\n mergeL.append(corrI)\n \n currC = \";\".join(mergeL)\n\n combList.append(currC)\n\n \n indexN +=1\n \n \n combList[-1] = \"merged\" \n outDict[curGene] = combList \n # print \"merged:\"\n # print combList\n else:\n corrLine.append(\"unique\")\n outDict[curGene] = corrLine\n\n \n print(fileCount)\n \n\n # if not newFlag: print fileCount, testKey, finDict[testKey] \n # if newFlag:\n # newFlag = False\n \n for outKey,outValue in list(outDict.items()): \n if outKey in finDict: # add modified dicts together into single, unified dict\n # print fileCount, finDict[outKey]\n # print outValue\n outIndex = 0\n for outItem in outValue:\n finDict[outKey][outIndex].append(outItem)\n outIndex += 1\n # print finDict[outKey]\n\n else: # or just add new entries\n if fileCount == 1:\n for outItem in outValue:\n finDict[outKey].append([outItem])\n \n else: # fill up entries that were not present in the previous cycle\n loopCount = 0\n while loopCount < fileCount - 1:\n for i in range(len(outValue)):\n if len(finDict[outKey]) == i:\n finDict[outKey].append([])\n else:\n finDict[outKey][i].append(\"\")\n loopCount += 1\n outIndex = 0\n for outItem in outValue:\n # print finDict[outKey]\n finDict[outKey][outIndex].append(outItem) \n outIndex += 1\n\n for testKey in finDict: # fill up entries in result dict which were not present in previous file\n if len(finDict[testKey][0]) < fileCount:\n for i in range(len(finDict[testKey])):\n finDict[testKey][i].append(\"\")\n\n if len(inpathL) > 1: fileCount += 1 # this is needed if multiple files are parsed\n for finK, finV in list(finDict.items()):\n for finI in finV[-1]:\n if finI != \"unique\" and finI != \"\":\n print(finK, finV)\n\n \n \n outN = 0 \n # prepare header for file:\n headList = headerLine.strip(\"\\n\\r\").split(\"\\t\")\n if fileCount > 1:\n for headerItem in headList[:-1]:\n headerI = headerItem.replace(\",\",\".\")\n headerCount = 1\n while headerCount < fileCount:\n outF.write(headerI + \"-\" + str(headerCount) + \"|\")\n headerCount += 1 \n outF.write(headerI + \"-\" + str(headerCount) + \"\\t\")\n \n headerCount = 1\n while headerCount < fileCount:\n outF.write(headList[-1] + \"-\" + str(headerCount) + \"|\")\n headerCount += 1\n \n outF.write(headList[-1] + \"-\" + str(headerCount) + \"\\n\")\n\n elif fileCount == 1:\n for headerItem in headList[:-1]:\n headerI = headerItem.replace(\",\",\".\") \n outF.write(headerI + \"\\t\")\n outF.write(headList[-1].replace(\",\",\".\") + \"\\n\")\n \n else:\n print(\"number of input files should be at least one. Got less somehow\")\n raise ValueError\n \n \n for outDK, outDV in list(finDict.items()): # write out assembled results to a file\n outN += 1\n if len(outDK) > 30: print(\"this line should not be displayed\")\n # print outDV[1]\n # if outN == 100: break\n nameCount = 0\n for outI in outDV:\n # if nameCount == 0: print outI\n for outPiece in outI[:-1]:\n outU = outPiece.replace(\",\",\".\")\n if outU == \"\": outF.write(\"_|\")\n else: outF.write(str(outU) + \"|\")\n if outI[-1] == \"\": # handle missing entries\n if nameCount == 6: outF.write(outDV[0][0] + \"\\t\") # replace missing gene names with their uniprot ID\n else: outF.write(\"_\\t\")\n else: outF.write(str(outI[-1]).replace(\",\",\".\") + \"\\t\")\n nameCount += 1\n outF.write(\"\\n\")\n \n\n print(\"unique proteins: \", outN)\n print(\"lines parsed: \", cN)\n # print headerLine\n inpF.close()\n outF.close()","def __init__(self, books_filename, authors_filename, books_authors_link_filename): \n with open(books_filename, newline='') as booksFile:\n books_reader = csv.reader(booksFile)\n try:\n bookArray = []\n newBookArray = []\n idCounter = 0\n for row in books_reader:\n newBookArray = [idCounter, row[0], int(row[1])]\n bookArray.append(newBookArray)\n idCounter = idCounter + 1\n self.simpleBookArray = bookArray\n except csv.Error as e:\n sys.exit('file {}, line {}: {}'.format(books_filename, books_reader.line_num, e))\n \n \"\"\"\n This function takes in the author_reader and puts the csv file into an array of arrays, in which\n each \"author\" is defined as an inner array, and each inner array is organized like so:\n [id, last name, first name, birth year, death year]\n \"\"\" \n with open(authors_filename, newline='') as authorsFile:\n authors_reader = csv.reader(authorsFile)\n try:\n authorArray = []\n newAuthorArray = []\n for row in authors_reader:\n if row[4] == \"NULL\":\n endDate = None\n else:\n endDate = row[4]\n if endDate == None:\n newAuthorArray = [int(row[0]), row[1], row[2], int(row[3]), endDate]\n else:\n newAuthorArray = [int(row[0]), row[1], row[2], int(row[3]), int(row[4])]\n authorArray.append(newAuthorArray)\n self.simpleAuthorArray = authorArray\n except csv.Error as e:\n sys.exit('file {}, line {}: {}'.format(authors_filename, authors_reader.line_num, e))\n \n \"\"\"\n This function takes in the link_reader and puts the csv file into an array of arrays, in which each\n \"book\" is defined as an inner array, and each inner array is organized as the following:\n [book id, author id]\n \"\"\"\n with open(books_authors_link_filename, newline='') as linkFile:\n link_reader = csv.reader(linkFile)\n try:\n linkArray = []\n newLinkArray = []\n for row in link_reader:\n newLinkArray = [int(row[0]), int(row[1])]\n linkArray.append(newLinkArray)\n self.simpleLinkArray = linkArray\n except csv.Error as e:\n sys.exit('file {}, line {}: {}'.format(books_authors_link_filename, link_reader.line_num, e))"],"string":"[\n \"def main():\\n raw_data = pd.read_csv('data/raw_hospital_data.csv')\\n\\n fe_data = new_features(raw_data)\\n fe_data = compressing_admission_type(data)\\n fe_data = age_to_cat(fe_data)\\n fe_data = compressing_careunit(fe_data)\\n fe_data = compressing_curr_serv(fe_data)\\n fe_data = compressing_ethnicity(fe_data)\\n fe_data = compressing_marital_status(fe_data)\\n fe_data = compressing_religion(fe_data)\\n fe_data = compressing_admit_location(fe_data)\\n fe_data = compress_icd9_codes(fe_data)\\n\\n fe_data.to_csv('data/feature_engineering_data.csv')\",\n \"def __init__(self):\\n self.project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\\n self.excel_file = os.path.join(self.project_dir, \\\"data\\\", \\\"Literature_Data.xlsx\\\")\\n self.spreadsheet_name = \\\"Individualized Data\\\"\\n self.filled_output_file = os.path.join(self.project_dir, \\\"data\\\", \\\"filled_data.csv\\\")\\n self.output_file = os.path.join(self.project_dir, \\\"data\\\", \\\"final.csv\\\")\\n self.use_fake_data = False # For testing\\n # This instance value \\\"self.df\\\" is the pandas DataFrame that contains all of the data\\n # from the literature case studies. Manipulating this field is the purpose of this class.\\n \\n self.num_negative = 500\\n self.df = None\",\n \"def main():\\n try:\\n\\n logger = settings.get_logger(__name__)\\n\\n # if not (check_for_data()):\\n # raise Exception(\\\"The following files were not all found: %s\\\"%(\\\"files\\\")) \\n\\n logger.info(\\\"*** Import data from raw files ***\\\")\\n #load raw file\\n\\n logger.info(\\\"Load raw data file (Huge file, please be patient)...\\\")\\n p1c1File = \\\"histo_7cerf_p1c1.txt\\\"\\n df_histo_p2c1_jour = pd.read_csv(settings.raw_path + p1c1File, sep = \\\",\\\", encoding = 'utf-8', header = None,dtype={0:str,2:str,3:str}).fillna(0)\\n\\n #prepare sales dataframe\\n logger.info(\\\"Droping uneccessary columns...\\\")\\n sales_df= df_histo_p2c1_jour.drop([1,3,4,5,6],axis=1)\\n\\n #set headers\\n logger.info(\\\"Setting headers info...\\\")\\n end_date = \\\"01-14-2019\\\"\\n columns = settings.row_headers\\n nb_days = len(sales_df.columns) - len(columns)\\n date_range = pd.date_range(end = end_date,periods = nb_days, freq='1w').strftime(\\\"%d/%m/%Y\\\")\\n columns.extend(date_range)\\n sales_df.columns = columns\\n\\n #drop Client 0\\n sales_df = sales_df[sales_df[\\\"Client\\\"]!=0]\\n\\n #Get p1c1 keys\\n p1c1 = sales_df[[\\\"Product\\\",\\\"Client\\\"]].dropna().drop_duplicates().astype(str).copy()\\n\\n #Product table\\n logger.info(\\\"Loading products descriptions...\\\")\\n product_df = get_product_df(\\\"product_7cerf.txt\\\")\\n #save product season mapping\\n save_product_season(product_df)\\n\\n #Get keys table from previous files\\n p1c1p2 = p1c1.join(product_df[[\\\"Key_lvl2\\\"]],on =[\\\"Product\\\"]).dropna().set_index([\\\"Product\\\"]).astype(str)\\n\\n\\n #save sales history\\n save_p2_sales(sales_df,p1c1p2)\\n \\n #Get client talbe\\n logger.info(\\\"Loading clients descriptions...\\\")\\n client_df = get_clients_df(\\\"client_7cerf.txt\\\",columns =[\\\"Store Level\\\",\\\"Business Area\\\"] )\\n cli_features = p1c1p2.join(client_df,on=\\\"Client\\\",how=\\\"left\\\").drop([\\\"Client\\\"],axis=1)\\n\\n \\n\\n #Calculate store counts\\n logger.info(\\\"Saving store counts file...\\\")\\n save_storecounts(cli_features,p1c1p2)\\n\\n \\n\\n #Client counts by p2\\n logger.info(\\\"Saving clients count by product...\\\")\\n save_clients_count(p1c1p2)\\n # return True\\n except Exception as err:\\n print(err)\\n logger.error(err)\\n # return False\",\n \"def main():\\n # openfile allows for CSV files with stored data of two columns\\n # data = openfile(\\\"filename\\\")\\n data = get_data()\\n abtest = AB_test(data)\\n abtest.stats()\\n abtest.print_stats()\",\n \"def main():\\n # Load in original data\\n origin_data = pd.read_csv('/Users/apple/Desktop/CSE_163/cse163_project/'\\n + 'Admission_Predict_Ver1.1.csv',\\n sep=r'\\\\s*,\\\\s*', header=0, encoding='ascii',\\n engine='python')\\n\\n # Research question 1\\n lasso_regression(origin_data)\\n\\n # Research question 2\\n # We drop the 'Serial No.' column because it is unrelated to our analysis.\\n df = origin_data.drop(columns=['Serial No.'])\\n find_correlation(df)\\n boxplots_testscores_vs_admission(df)\\n\\n # Research question 3\\n university_rating_analysis(origin_data)\",\n \"def handle(self, *args, **options):\\n try:\\n # csv path argument\\n fpath = options['csv_path']\\n # checks if file is csv\\n if fpath.lower().endswith('csv'):\\n encoding = get_encoding(fpath)\\n with open(fpath, encoding=encoding) as file:\\n reader = csv.reader(file, delimiter=\\\",\\\")\\n # iterating through each row in csv\\n for row in reader:\\n try:\\n create_instance(row[0].strip(), row[1].strip(),\\n row[2].strip())\\n except IntegrityError:\\n # duplicate information\\n self.stderr.write(self.style.WARNING(\\n \\\"(Warning) \\\"\\n \\\"Duplicate Information: {}\\\".format(row)))\\n except IndexError:\\n # problem extracting missing information\\n self.stderr.write(self.style.WARNING(\\n \\\"(Warning) Incorrect Format: {}\\\".format(row)))\\n except ValueError:\\n # missing information\\n self.stderr.write(self.style.WARNING(\\n \\\"(Warning) Missing Value: {}\\\".format(row)))\\n except ObjectDoesNotExist:\\n # queried object does not exist\\n self.stderr.write(self.style.WARNING(\\n \\\"(Warning) \\\"\\n \\\"ObjectDoesNotExist: {}\\\".format(row)))\\n else:\\n # file not csv\\n self.stderr.write(self.style.ERROR(\\\"(Error) \\\"\\n \\\"File not of type csv.\\\"))\\n except FileNotFoundError:\\n # file path does not exist\\n self.stderr.write(self.style.ERROR(\\\"(Error) File does not exist.\\\"))\\n except IOError:\\n # error reading file\\n self.stderr.write(self.style.ERROR(\\\"(Error) Error reading file.\\\"))\",\n \"def main():\\n scores_file = open(\\\"scores.csv\\\")\\n scores_data = scores_file.readlines()\\n print(scores_data)\\n subjects = scores_data[0].strip().split(\\\",\\\")\\n score_values = []\\n for score_line in scores_data[1:]:\\n score_strings = score_line.strip().split(\\\",\\\")\\n score_numbers = [int(value) for value in score_strings]\\n score_values.append(score_numbers)\\n scores_file.close()\\n scores_by_subjects = reorganise_score(score_values)\\n subject_details(scores_by_subjects, subjects)\",\n \"def run():\\n options = [\\\"Add\\\", \\\"Remove\\\", \\\"Update\\\", \\\"Oldest person\\\", \\\"Persons closest to average\\\"]\\n common_options = [\\\"Name: \\\", \\\"Year: \\\"]\\n file = \\\"model/hr/persons.csv\\\"\\n title_list = [\\\"Id\\\", \\\"Name\\\", \\\"Year\\\"]\\n choice = None\\n dont_clear = False\\n while choice != '0':\\n if not dont_clear:\\n os.system(\\\"clear\\\")\\n table = data_manager.get_table_from_file(file)\\n terminal_view.print_table(table, title_list)\\n choice = terminal_view.get_choice_submenu(options)\\n dont_clear = False\\n if choice == '1':\\n common.add(file, common_options)\\n elif choice == '2':\\n common.remove(file)\\n elif choice == '3':\\n common.update(file, common_options)\\n elif choice == '4':\\n terminal_view.print_result(hr.get_oldest_person(table), \\\"Oldest persons:\\\\n\\\")\\n dont_clear = True\\n elif choice == '5':\\n msg = \\\"Persons with age closest to average:\\\\n\\\"\\n terminal_view.print_result(hr.get_persons_closest_to_average(table), msg)\\n dont_clear = True\\n else:\\n terminal_view.print_error_message(\\\"There is no such choice.\\\")\",\n \"def main():\\n filename = \\\"data/exercise.csv\\\"\\n analyze(filename)\",\n \"def main():\\n\\n #get the csv file into a data-frame\\n universities_df = pd.read_csv('universities_data.csv', encoding = 'utf-8-sig')\\n universities_names_list = universities_df['name'].tolist()\\n\\n #get list of university objects\\n url = 'http://universities.hipolabs.com/search?country=Israel'\\n api_universities = Get_universities(url)\\n list_of_universities = api_universities.get_universities_info()\\n\\n #to see if we got new entities or not for exporting to csv later..\\n is_new_entities = False\\n\\n for university in list_of_universities:\\n if university.name not in universities_names_list:\\n is_new_entities = True\\n universities_df= universities_df.append(pd.DataFrame({\\n 'alpha_two_code': [university.alpha_two_code], \\n 'country': [university.country],\\n 'web_pages': [str(university.web_pages)],\\n 'domains': [str(university.domains)],\\n 'name': [university.name],\\n 'state_province':[str(university.state_province)]}) , ignore_index = True)\\n\\n #export back to csv if true\\n if is_new_entities: \\n print('we got new entities!') \\n universities_df.to_csv('universities_data.csv', encoding = 'utf-8-sig', index = False)\\n else:print('no new universities for now!')\",\n \"def main():\\n with open('csv_files/products.csv', 'a') as data_file:\\n # Move to the next line before appending new row to the file\\n data_file.write(\\\"\\\\n\\\")\\n data_writer = csv.writer(data_file)\\n for i in range(5, 10000):\\n data_writer.writerow([str(i+1), \\\" description{}\\\".format(str(i)),\\n \\\" type{}\\\".format(str(i)),\\n \\\" {}\\\".format(str(random.randint(1, 100)))])\\n\\n with open('csv_files/customers.csv', 'a') as data_file:\\n # Move to the next line before appending new row to the file\\n data_file.write(\\\"\\\\n\\\")\\n data_writer = csv.writer(data_file)\\n for i in range(5, 10000):\\n data_writer.writerow([str(i+1), \\\" first_name{}\\\".format(str(i)),\\n \\\" last_name{}\\\".format(str(i)),\\n \\\" address{}\\\".format(str(i)),\\n \\\" phone_number{}\\\".format(str(i)),\\n \\\" email{}\\\".format(str(i))])\",\n \"def main():\\n path_for_data = '/Users/avielshtern/Desktop/semb/iml/IML.HUJI-master/data/kc_house_data (1).csv'\\n design_matrix, response_vector = load_data(path_for_data)\\n putting_it_all_together_1(design_matrix, response_vector)\\n putting_it_all_together_2(design_matrix, response_vector)\\n feature_evaluation(design_matrix, response_vector)\",\n \"def main():\\n\\n dataframes = importing(['admissions_data', 'patient_data',\\n 'diagnoses_icd_data', 'services_data',\\n 'icustays'])\\n merged_data = merging_data(dataframes)\\n cleaned = data_cleaning(merged_data)\\n\\n cleaned.to_csv('raw_hospital_data.csv')\",\n \"def __init__(self, args):\\n self.verbose = args.verbose\\n self.force = args.force\\n self.extra = args.extra\\n self.master_csv = args.master\\n self.new_files = args.new_files\\n self.df_mas_lab_data = None # Master Lab data\\n self.df_new_lab_data = None # Aggregated new Lab data\\n self.columns = [\\n \\\"CLIA\\\",\\n \\\"FACILITY_TYPE\\\",\\n \\\"CERTIFICATE_TYPE\\\",\\n \\\"LAB_NAME\\\",\\n \\\"STREET\\\",\\n \\\"CITY\\\",\\n \\\"STATE\\\",\\n \\\"ZIP\\\",\\n \\\"PHONE\\\",\\n ]\",\n \"def main():\\n now = time.strftime('%Y%m%d%H%M%S')\\n\\n # info = get_info(now)\\n # info_filename = 'info_' + now + '.csv'\\n # info.to_csv(os.path.join('..', '..', 'data', 'raw', info_filename), index=False)\\n\\n questions = get_questions(now)\\n\\n # don't talk about all this detail in the talk\",\n \"def main():\\n\\n csv_file = \\\"shortlist.csv\\\"\\n team_count = 0\\n participant_count = 0\\n\\n\\n #Delete all existing teams and participants from the database.\\n Team.objects.all().delete()\\n Participant.objects.all().delete()\\n\\n with open(csv_file) as f:\\n reader = csv.reader(f)\\n data = [row for row in reader]\\n\\n for item in data:\\n if item[0]:\\n team_count += 1\\n\\n t = Team.objects.create(\\n name=item[0].strip(),\\n idea=item[30].strip()\\n )\\n\\n no_of_p = int(item[1])\\n print item[1]\\n participant_count += no_of_p\\n\\n p1 = Participant.objects.create(\\n participant_id=get_pid(),\\n name=item[2].strip() + \\\" \\\" + item[3].strip(),\\n gender=item[4].strip(),\\n college=item[7].strip(),\\n email=item[5].strip(),\\n phone=str(item[6]),\\n team=t\\n )\\n\\n p2 = Participant.objects.create(\\n participant_id=get_pid(),\\n name=item[11].strip() + \\\" \\\" +item[12].strip(),\\n gender=item[13].strip(),\\n college=item[16].strip(),\\n email=item[14].strip(),\\n phone=str(item[15]),\\n team=t\\n )\\n\\n if no_of_p == 3:\\n p3 = Participant.objects.create(\\n participant_id=get_pid(),\\n name=item[20].strip() + \\\" \\\" +item[21].strip(),\\n college=item[25].strip(),\\n gender=item[22].strip(),\\n email=item[23].strip(),\\n phone=str(item[24]),\\n team=t\\n )\\n\\n print \\\"{} teams and {} participants imported.\\\".format(team_count,\\n participant_count)\",\n \"def __init__(self):\\n self.file_name = 'data.csv'\\n # Column of interest\\n self._col = ['product_name', 'url', 'quantity', 'packaging']\\n self._col += ['brands', 'origins', 'countries_fr', 'allergens']\\n self._col += ['traces_fr', 'additives_n', 'additives_fr']\\n self._col += ['nutrition_grade_fr', 'categories_fr']\\n self._col += ['main_category_fr']\\n\\n # Check if the csv is already in the file\\n try:\\n with open(self.file_name, 'r'):\\n pass\\n except FileNotFoundError:\\n CsvAnalysis.download_file()\\n finally:\\n # Read the csv file, and create a dataframe\\n self.food_cat = pandas.read_csv(self.file_name,\\n sep=\\\"\\\\t\\\",\\n low_memory=False,\\n usecols=self._col,\\n encoding=\\\"utf8\\\")\\n\\n # Remove countries which aren't France\\n mask = self.food_cat['countries_fr']\\n self.food_cat = self.food_cat[mask == 'France']\\n\\n # Delete column countries_fr\\n del self.food_cat['countries_fr']\\n\\n # Remove empty row countries_fr from dataframe\\n columns = ['main_category_fr', 'product_name', 'nutrition_grade_fr']\\n for column in columns:\\n self.food_cat = self.food_cat[~self.food_cat[column].isnull()]\\n\\n # Remove empty row from product_name\\n self.food_cat.sort_values(by='categories_fr')\\n\\n # Select the last value from categories_fr\\n # to use it as a subcategory\\n col = 'categories_fr'\\n self.food_cat[col] = self.food_cat[col].str.split(',').str.get(-1)\\n self.food_cat.sort_values(by='categories_fr')\",\n \"def __init__(self):\\r\\n self.filter_p_number = 3 # First one with enough data for statistics\\r\\n self.prfs_d = extract_settings_elvis()\\r\\n\\r\\n ccds = True\\r\\n filtered = False\\r\\n scamp = False\\r\\n\\r\\n input_df = read_csv('cats/cat_clean_ssos.csv', index_col=0)\\r\\n filt_cat = self.gets_filtered_catalog() # Gets data from filtered\\r\\n\\r\\n if ccds:\\r\\n cats_d = self.extract_cats()\\r\\n self.extract_stats_ccds(cats_d, input_df, filt_cat)\\r\\n elif filtered:\\r\\n self.extract_stats_filt(filt_cat, input_df)\\r\\n elif scamp:\\r\\n pass\\r\\n # self.extract_stats_scamp(input_df)\\r\\n else:\\r\\n pass\",\n \"def main():\\n draft_class = 56\\n from_csv = 'smjhl-2020-09-10.csv'\\n to_csv = 'S' + str(draft_class) + '-bmi.csv'\\n\\n\\n full_data = pd.read_csv(f\\\"../{from_csv}\\\")\\n draft_class_data = full_data.loc[full_data['Draft Class Numeric'] == draft_class].copy()\\n height_weight_raw = draft_class_data[[\\\"First Name\\\", \\\"Last Name\\\", \\\"Height\\\", \\\"Weight\\\"]]\\n\\n bmi_chart = bmi_magic(height_weight_raw)\\n bmi_chart = bmi_chart.sort_values(by=[\\\"BMI\\\"], axis=0, ascending=False)\\n\\n # print(full_data)\\n print(bmi_chart)\\n bmi_chart.to_csv(to_csv)\",\n \"def main():\\n\\n # Read the CSV and get its content\\n jobOfferList, professionsList = usefulFunctions.readCsv()\\n \\n # Create an empty output tab with the right number of lines and columns\\n finalTab = usefulFunctions.createEmpty(jobOfferList, professionsList)\\n \\n # Fill the tab\\n finalTab = usefulFunctions.fillTabExceptTotals(jobOfferList, professionsList, finalTab)\\n \\n # Update the totals \\n finalTab = usefulFunctions.fillTotals(finalTab)\\n \\n print(\\\"\\\\nTable des métiers par profession et type de contrat : \\\")\\n for line in finalTab:\\n print(line)\",\n \"def part1():\\n print('=== Starting Part 1 ===')\\n data = pd.read_csv(DATA)\\n\\n print('Number of species:', hw2_pandas.species_count(data))\\n print('Highest level pokemon:', hw2_pandas.max_level(data))\\n print('Low-level Pokemon', hw2_pandas.filter_range(data, 1, 9))\\n print('Average attack for fire types',\\n hw2_pandas.mean_attack_for_type(data, 'fire'))\\n print('Count of each Pokemon type:')\\n print(hw2_pandas.count_types(data))\\n print('Highest stage for each Pokemon type')\\n print(hw2_pandas.highest_stage_per_type(data))\\n print('Average attack for each Pokemon type')\\n print(hw2_pandas.mean_attack_per_type(data))\",\n \"def test_add_data():\\n add_furniture(\\\"invoice_file.csv\\\", \\\"Elisa Miles\\\", \\\"LR04\\\", \\\"Leather Sofa\\\", 25.00)\\n add_furniture(\\\"invoice_file.csv\\\", \\\"Edward Data\\\", \\\"KT78\\\", \\\"Kitchen Table\\\", 10.00)\\n add_furniture(\\\"invoice_file.csv\\\", \\\"Alex Gonzales\\\", \\\"BR02\\\", \\\"Queen Mattress\\\", 17.00)\",\n \"def main():\\n s = content.DataFiles()\\n \\n date_list = generate.get_list_dates(2016, 2016, 500)\\n prod_list = list(s.get_collist_by_name(os.path.join(content.data_fldr,'food','garden_produce.csv'), 'name')[0])\\n \\n tbl_cust = generate.TableGenerator(8, ['STRING','PEOPLE', 'PEOPLE', 'PLACE'], ['Customer ID', 'First Name', 'Surname', 'Country'])\\n tbl_cust.save_table('customers.csv')\\n cust_list = list(s.get_collist_by_name('customers.csv', 'Customer ID')[0])\\n \\n tbl_sales = generate.TableGenerator(25, [date_list, cust_list, prod_list, 'CURRENCY'], ['Date of sale', 'Customer ID', 'Product', 'Amount'])\\n tbl_sales.save_table('sales.csv')\",\n \"def main():\\n\\n # start at loading the dataset\\n data = h1bdata_loading()\\n merged_data = pd.concat([data[year] for year in range(2010,2017)], ignore_index= True)\\n raw_data = h1b_data(data)\\n \\n \\n\\n # Then clean the data\\n #h1b_data = Clean_df(raw_data)\\n #print(\\\"data cleaned >>>\\\")\\n\\n\\n while True:\\n try:\\n print (\\\"================================ H1b Visa Approve Rate Exploring ================================\\\")\\n print (\\\"\\\")\\n print (\\\" How do you want to explore the H1b Data? \\\")\\n print (\\\" <a> : Overview \\t\\t \\\")\\n print (\\\" <b> : Location \\\")\\n print (\\\" <c> : Industry \\\")\\n print (\\\" <d> : Company \\\") \\n print (\\\" You can always input 'quit' to leave the system \\\")\\n print (\\\"=================================================================================================\\\")\\n\\n key = option_input()\\n if key == 'a':\\n overview(data)\\n if key == 'b':\\n location(data)\\n if key == 'c':\\n industry_exploring(merged_data)\\n if key == 'd':\\n company_exploring(merged_data)\\n except wrong_option_exception:\\n print (\\\"Invalid option, please reselect.\\\")\",\n \"def main(argv):\\n # Question 1\\n # Saves the features given in a list\\n features = (argv[2].split(sep=\\\", \\\"))\\n the_data = data.load_data(argv[1], features)\\n statistic_functions = [sum, mean, median]\\n # Saves the relevant records\\n summer_data, not_summer = data.filter_by_feature(the_data, \\\"season\\\", [1])\\n holiday_data, not_holiday = data.filter_by_feature(the_data, \\\"is_holiday\\\", [1])\\n print(\\\"Question 1:\\\")\\n print(\\\"Summer:\\\")\\n data.print_details(summer_data, [\\\"hum\\\", \\\"t1\\\", \\\"cnt\\\"], statistic_functions)\\n print(\\\"Holiday:\\\")\\n data.print_details(holiday_data, [\\\"hum\\\", \\\"t1\\\", \\\"cnt\\\"], statistic_functions)\\n print(\\\"All:\\\")\\n data.print_details(the_data, [\\\"hum\\\", \\\"t1\\\", \\\"cnt\\\"], statistic_functions)\\n\\n # Question 2\\n print(\\\"\\\\nQuestion 2\\\")\\n print(\\\"If t1<=13.0, then:\\\")\\n # Saves the relevant records\\n winter_data, not_winter = data.filter_by_feature(the_data, \\\"season\\\", [3])\\n w_h_data, not_w_h_data = data.filter_by_feature(winter_data, \\\"is_holiday\\\", [1])\\n population_statistics(\\\"Winter holiday records:\\\", w_h_data, \\\"t1\\\", [\\\"cnt\\\"], THRESHOLD, 0, statistic_functions[1:])\\n population_statistics(\\\"Winter weekday records:\\\", not_w_h_data, \\\"t1\\\", [\\\"cnt\\\"], THRESHOLD, 0, statistic_functions[1:])\\n print(\\\"If t1>13.0, then:\\\")\\n population_statistics(\\\"Winter holiday records:\\\", w_h_data, \\\"t1\\\", [\\\"cnt\\\"], THRESHOLD, 1, statistic_functions[1:])\\n population_statistics(\\\"Winter weekday records:\\\", not_w_h_data, \\\"t1\\\", [\\\"cnt\\\"], THRESHOLD, 1, statistic_functions[1:])\",\n \"def main():\\n print(time.time())\\n data = '../datasets/between_phase/clean_df.csv'\\n print(\\\"Process Beginning\\\")\\n print(\\\"Reading Clean CSV\\\")\\n clean_df = pd.read_csv(data, dtype={\\\"journey_pattern_id\\\": str})\\n print(clean_df.shape)\\n base_table = Base_Table(clean_df)\\n print(\\\"Adding datetime\\\")\\n base_table.add_datetime()\\n print(\\\"Adding Day\\\")\\n base_table.add_day()\\n print(\\\"Adding Hour\\\")\\n base_table.add_hour()\\n print(\\\"Adding Time Bin\\\")\\n base_table.add_time_bin()\\n print(\\\"Adding Weekend Boolean\\\")\\n base_table.add_weekend()\\n print(\\\"Adding Distance\\\")\\n base_table.add_distance_feature()\\n print(\\\"Updating Stop Id\\\")\\n base_table.add_nearest_stop_distance()\\n print(\\\"Filtering Data\\\")\\n base_table.remove_null_stops()\\n print(\\\"Adding Travel Time\\\")\\n base_table.add_travel_time()\\n print(\\\"Adding Congestion\\\")\\n base_table.congestion_feature()\\n bs = base_table.get_df()\\n bs.to_csv('../datasets/output_files/base_table.csv')\\n return bs\",\n \"def load(cls):\\n \\n # Loop through procedures and build patient procedure lists:\\n procs = csv.reader(file(PROCEDURES_FILE,'U'),dialect='excel-tab')\\n header = procs.next() \\n for proc in procs:\\n cls(dict(zip(header,proc))) # Create a procedure instance \",\n \"def main():\\n data = pd.read_csv('countries.csv')\\n # import_data_pandas(data)\\n # continent_data(data)\\n # continent_data_le(data)\\n continent_data_gdp_growth(data)\",\n \"def main(raw_filepath, interim_filepath, processed_filepath):\\n raw_filepath = Path(raw_filepath)\\n interim_filepath = Path(interim_filepath)\\n processed_filepath = Path(processed_filepath)\\n\\n logger = logging.getLogger(__name__)\\n logger.info('making final data set from raw data')\\n\\n years = ['2010', '2011', '2012', '2013', '2014']\\n\\n #############################################################\\n ################ Life Expectancy Outcome ####################\\n #############################################################\\n\\n le_birth = pd.read_csv(raw_filepath / 'US_A.csv',\\n usecols=['Tract ID', 'e(0)'],\\n dtype={'Tract ID': \\\"object\\\"}) \\\\\\n .rename(columns={'Tract ID': 't10_cen_uid_u_2010'}) \\\\\\n .set_index('t10_cen_uid_u_2010')\\n\\n le_other = pd.read_csv(raw_filepath / 'US_B.csv',\\n usecols=['Tract ID', 'Age Group', 'e(x)'],\\n dtype={'Tract ID': \\\"object\\\"}) \\\\\\n .rename(columns={'Tract ID': 't10_cen_uid_u_2010'}) \\\\\\n .set_index(['t10_cen_uid_u_2010', 'Age Group']) \\\\\\n .sort_index() \\\\\\n .loc[(slice(None), ['15-24', '35-44', '55-64']), :] \\\\\\n .unstack() \\\\\\n .reindex(le_birth.index) # use the same tracts for all experiments\\n\\n le_other.columns = ['e(20)', 'e(40)', 'e(60)']\\n\\n # le_birth.to_csv(processed_filepath / 'y_00.csv', header=True)\\n # le_other['e(20)'].to_csv(processed_filepath / 'y_20.csv', header=True)\\n # le_other['e(40)'].to_csv(processed_filepath / 'y_40.csv', header=True)\\n # le_other['e(60)'].to_csv(processed_filepath / 'y_60.csv', header=True)\\n\\n\\n ##############################################################\\n ################## Priority Dataset ##########################\\n ##############################################################\\n\\n with open(raw_filepath / 'T10_Priority_Wide_Interpolated.csv', 'r') as f:\\n cols = f.readline().strip().split(',')\\n\\n proj_cols = [x for x in cols if x[-4:] in years]# and\\n # get all the priority NETS columns for later\\n net_cols = ['t10_cen_uid_u_2010'] + [x[:11] + '_d_' + x[14:] for x in cols if '_net_' in x]\\n\\n data_X = pd.read_csv(raw_filepath / 'T10_Priority_Wide_Interpolated.csv', usecols=proj_cols,\\n dtype={'t10_cen_uid_u_2010': \\\"object\\\"}) \\\\\\n .set_index('t10_cen_uid_u_2010')\\n\\n # Create % younger than 25 (this method is far less than ideal)\\n ag25up = data_X.filter(regex='.*(_pop_c_|ag25up).*')\\n ag25up_coltuples = [(x[:-4], x[-4:]) for x in ag25up.columns]\\n ag25up.columns = pd.MultiIndex.from_tuples(ag25up_coltuples)\\n ag25up_long = ag25up.stack()\\n ag25dwn_p = ((ag25up_long['t10_ldb_pop_c_'] - ag25up_long['t10_ldb_ag25up_c_'])\\n / ag25up_long['t10_ldb_pop_c_']).unstack()\\n ag25dwn_p.columns = ['t10_ldb_ag25dwn_p_' + x for x in ag25dwn_p.columns]\\n\\n # Create % older than 65\\n ag65up = data_X.filter(regex='.*(_pop_c_|a60up).*')\\n ag65up_coltuples = [(x[:-4], x[-4:]) for x in ag65up.columns]\\n ag65up.columns = pd.MultiIndex.from_tuples(ag65up_coltuples)\\n ag65up_long = ag65up.stack()\\n ag65up_p = (ag65up_long['t10_ldb_a60up_c_'] / ag65up_long['t10_ldb_pop_c_']) \\\\\\n .unstack()\\n ag65up_p.columns = ['t10_ldb_ag60up_p_' + x for x in ag65up_p.columns]\\n\\n # Add our new measure\\n data_X = pd.concat([data_X, ag25dwn_p, ag65up_p], axis=1)\\n\\n # Get rid of all count variables, including nets\\n no_count_cols = [x for x in data_X.columns if '_c_' not in x]\\n data_X = data_X[no_count_cols]\\n\\n\\n drop_cols = ['t10_gis_area_l_2010',\\n 'm10_cen_uid_u_2010',\\n 'm10_cen_memi_x_2010',\\n 'c10_cen_uid_u_2010',\\n 'z10_cen_uid_u_2010']\\n\\n data_X = data_X.drop(columns=drop_cols) \\\\\\n .reindex(le_birth.index)\\n\\n data_X.columns = pd.Index([(x[:-5], int(x[-4:])) for x in data_X.columns])\\n\\n X_priority = data_X.groupby(axis=1, level=0).mean()\\n X_priority.to_csv(interim_filepath / 'X_priority.csv')\\n\\n ###########################################################\\n #################### NETS Dataset #########################\\n ###########################################################\\n\\n X_nets_allyrs = pd.read_csv(raw_filepath / 'recvd_t10_vars_v8_20190607.csv', usecols=net_cols,\\n dtype={'t10_cen_uid_u_2010': \\\"object\\\"}) \\\\\\n .set_index('t10_cen_uid_u_2010') \\\\\\n .reindex(le_birth.index)\\n\\n X_nets_allyrs.columns = pd.Index([(x[:-5], int(x[-4:])) for x in X_nets_allyrs.columns])\\n X_nets = X_nets_allyrs.groupby(axis=1, level=0).mean()\\n X_nets.to_csv(interim_filepath / 'X_nets.csv')\\n\\n # Split predictive data by Variable Set\\n X_all = pd.concat([X_priority, X_nets], axis=1) \\\\\\n .dropna(how='any')\\n\\n final_index = le_birth.index.intersection(X_all.index)\\n X_all = X_all.reindex(final_index)\\n le_birth = le_birth.reindex(final_index)\\n le_other = le_other.reindex(final_index)\\n\\n le_birth.to_csv(processed_filepath / 'y_00.csv', header=True)\\n le_other['e(20)'].to_csv(processed_filepath / 'y_20.csv', header=True)\\n le_other['e(40)'].to_csv(processed_filepath / 'y_40.csv', header=True)\\n le_other['e(60)'].to_csv(processed_filepath / 'y_60.csv', header=True)\\n\\n # Var Set 1\\n p1_features = ['t10_ldb_hinci_m',\\n 't10_ldb_pop_d',\\n 't10_ldb_nhblk_p',\\n 't10_ldb_hisp_p',\\n 't10_ldb_col_p']\\n X_p1 = X_all[p1_features]\\n X_p1.to_csv(processed_filepath / 'X_varGroup1.csv')\\n\\n # Var Set 2\\n p2_features = [\\n \\\"t10_ldb_hinci_m\\\",\\n \\\"t10_ldb_pop_d\\\",\\n \\\"t10_ldb_ag25dwn_p\\\",\\n \\\"t10_ldb_ag60up_p\\\",\\n \\\"t10_ldb_nhblk_p\\\",\\n \\\"t10_ldb_hisp_p\\\",\\n \\\"t10_ldb_col_p\\\",\\n \\\"t10_ldb_lep_p\\\",\\n \\\"t10_ldb_mrenti_m\\\",\\n \\\"t10_ldb_multi_p\\\",\\n \\\"t10_ldb_nhwht_p\\\",\\n \\\"t10_ldb_asian_p\\\",\\n \\\"t10_ldb_fb_p\\\",\\n \\\"t10_ldb_hs_p\\\",\\n \\\"t10_ldb_unemp_p\\\",\\n \\\"t10_ldb_npov_p\\\",\\n \\\"t10_ldb_vac_p\\\",\\n \\\"t10_ldb_own_p\\\",\\n \\\"t10_ldb_mhmvali_m\\\"\\n ]\\n X_p2 = X_all[p2_features]\\n X_p2.to_csv(processed_filepath / 'X_varGroup2.csv')\\n\\n # Var Set 3\\n X_p3 = X_nets.reindex(final_index)\\n X_p3.to_csv(processed_filepath / 'X_varGroup3.csv')\\n\\n # Var Set 4\\n X_p4 = X_all\\n X_p4.to_csv(processed_filepath / 'X_varGroup4.csv')\",\n \"def __init__(self, file_path):\\n # will raise an error if the path is invalid, we don't need an\\n # if statement here\\n df = pandas.read_excel(file_path)\\n\\n \\\"\\\"\\\"\\n read in the cities using a dictionary comprehension\\n dictionary = { key: value for elem in iterable }\\n In this case we are reading in the name of the city as the key\\n and its corresponding CityLocation object as the value. We\\n have made the assumption that each city has a unique name.\\n \\\"\\\"\\\"\\n #\\n self.lulu = [Order(row[1][\\\"Date\\\"], row[1][\\\"Order Number\\\"],\\n row[1][\\\"Brand\\\"], row[1][\\\"Garment\\\"],\\n row[1][\\\"Count\\\"], row[1][\\\"Style name\\\"])\\n for row in df.iterrows()\\n if row[1][\\\"Brand\\\"] == \\\"Lululime\\\"]\\n self.lulu = LululimeFactory()\\n GarmentMaker(self.lulu)\\n # brand = self.lulu[0].brand\\n # garment = self.lulu[0].garment\\n # print(brand)\\n # print(garment)\\n\\n lulu_order = ((row[1][\\\"Date\\\"], row[1][\\\"Garment\\\"],\\n row[1][\\\"Brand\\\"], row[1][\\\"Garment\\\"])\\n for row in df.iterrows() if\\n row[1][\\\"Brand\\\"] == \\\"Lululime\\\")\\n for item in lulu_order:\\n print(item)\\n\\n lulu_order = LululimeFactory()\\n # test = GarmentMaker(lulu_order)\\n # print(test)\\n\\n # for lulu in self.lulubrand:\\n # print(lulu)\\n # print(*self.lulubrand)\",\n \"def main():\\n logger = logging.getLogger(__name__)\\n logger.info('making final data set from raw data')\\n get_user_config()\",\n \"def run_methods(self):\\n try:\\n # dictionaries of population time series\\n self.batch_exponential()\\n except Exception as e:\\n print(str(e))\",\n \"def __init__(self, cfg, radious, type_feature, type_filtering, h_filterig):\\n print(\\\"feat test!!\\\")\\n self.path_root = cfg['preprocessing']['path_root']\\n self.path_data = cfg['data']['path']\\n self.path_checkpoint = os.path.join(self.path_data, \\\"preprocess_checkpoint.csv\\\")\\n self.file_checkpoint_data = open(self.path_checkpoint, \\\"a+\\\").close()\\n # self.file_checkpoint_data.close()\\n if (len(open(self.path_checkpoint).readlines()) == 0):\\n print(\\\"creating the file...\\\")\\n with open(self.path_checkpoint, \\\"a+\\\") as f:\\n f.write('radious,type_feature,type_filtering,h_filterig'+ \\\"\\\\n\\\")\\n self.init_refined = self.path_root + \\\"/data/new_refined/\\\"\\n self.init_casf = self.path_root + \\\"/data/new_core_2016/\\\"\\n self.dict_atoms = dict_atoms_hot\\n self.dict_atoms_simple = dict_atoms_simple\\n self.dict_words = atom_most_common\\n self.dict_atoms_masses = dict_atoms_masses\\n self.dict_atoms_charges = dict_atoms_charges\\n self.radious = radious\\n self.type_feature = type_feature\\n self.type_filtering = type_filtering\\n self.h_filterig = h_filterig\\n ##################refined files###################\\n self.files_refined = os.listdir(self.init_refined)\\n self.files_refined = [file for file in self.files_refined if file[0].isdigit()]\\n self.files_refined.sort()\\n self.idx_files_refined = list(range(0, len(self.files_refined)))\\n # self.idx_files_refined = [0, 1]\\n self.max_length = 0\\n # array_names = [str(radious), self.type_feature, self.type_filtering, self.h_filterig]\\n # self.name_checkpoint_features = '_'.join(array_names)\\n # os.makedirs(os.path.join(self.path_data, \\\"checkpoints\\\"), exist_ok=True)\\n # self.path_checkpoint_features = os.path.join(self.path_data, \\\"checkpoints\\\", self.name_checkpoint_features + \\\".pkl\\\")\\n # if (os.path.exists(self.path_checkpoint_features)):\\n # print(\\\"loading feature ids...\\\")\\n # checkpoint_features = torch.load(self.path_checkpoint_features)\\n # self.idx_max_length = checkpoint_features['idx_max_length']\\n # self.max_length = checkpoint_features['max_length']\\n # self.idx_write = checkpoint_features['idx_write']\\n # else:\\n # self.idx_max_length = 130\\n # self.max_length = 0\\n # self.idx_write = 0\\n # save_checkpoint_feature(self.path_checkpoint_features, self.idx_max_length, self.max_length, self.idx_write)\\n\\n # self.max_length = 0\\n # self.write_filtered_pad_feat_geo()\\n # else:\\n # f, m, g = self._get_feat_geo_from_file(0)\\n # self.max_length = f.shape[0]\",\n \"def main():\\n\\n file_name_base = \\\"./lab-record/result/fairness/\\\"\\n scenarios = ['lan', 'wan1', 'wan2']\\n scenario = scenarios[2]\\n\\n algorithms = [\\\"bbr\\\", \\\"scalable\\\", \\\"bic\\\", \\\"highspeed\\\", \\\"htcp\\\", \\\"hybla\\\",\\n \\\"illinois\\\", \\\"vegas\\\", \\\"yeah\\\"]\\n names = [\\\"BBR\\\", \\\"Scalable\\\", \\\"BIC\\\", \\\"High Speed\\\",\\n \\\"H-TCP\\\", \\\"Hybla\\\", \\\"Illinois\\\", \\\"Vegas\\\", \\\"YeAH\\\"]\\n\\n test_types = [\\\"vs_reno\\\", \\\"vs_cubic\\\", \\\"vs_itself\\\"]\\n\\n fsize = 36\\n \\n index_reno = []\\n index_cubic = []\\n index_itself = []\\n\\n data = []\\n \\n print 'Loadint statistics for ' + file_name_base + '/' + scenario\\n\\n for algorithm in algorithms:\\n for test in test_types:\\n path_base = file_name_base + \\\"/\\\" + scenario + \\\"/\\\" + test + \\\"/\\\" + \\\\\\n algorithm + \\\"/\\\"\\n if test == \\\"vs_itself\\\":\\n exp_name = names[algorithms.index(algorithm)] + \\\"_1\\\"\\n con_name = names[algorithms.index(algorithm)] + \\\"_2\\\"\\n print path_base + exp_name\\n print path_base + con_name\\n exp_filename = \\\"/\\\" + algorithm + \\\"_1.log\\\"\\n con_filename = \\\"/\\\" + algorithm + \\\"_2.log\\\"\\n process(path_base, exp_filename, con_filename, index_itself)\\n if test == \\\"vs_reno\\\":\\n exp_name = names[algorithms.index(algorithm)]\\n con_name = \\\"Reno\\\"\\n print path_base + exp_name\\n print path_base + con_name\\n exp_filename = \\\"/\\\" + algorithm + \\\".log\\\"\\n con_filename = \\\"/reno.log\\\"\\n process(path_base, exp_filename, con_filename, index_reno)\\n if test == \\\"vs_cubic\\\":\\n con_name = \\\"CUBIC\\\"\\n exp_name = names[algorithms.index(algorithm)]\\n print path_base + exp_name\\n print path_base + con_name\\n exp_filename = \\\"/\\\" + algorithm + \\\".log\\\"\\n con_filename = \\\"/cubic.log\\\"\\n process(path_base, exp_filename, con_filename, index_cubic)\\n\\n size = 9\\n x = numpy.arange(size)\\n\\n total_width, n = 1.2, 2.5\\n width = 1.0 / n\\n x = x - (total_width - width) / 2\\n\\n for i in range(0, len(x)):\\n x[i] += 0.5 * i\\n\\n # Exp\\n fig = plt.figure()\\n\\n # Con\\n con_reno = plt.bar(x + 0 * width - 1.2,\\n index_reno,\\n width=width,\\n label='Against Reno',\\n alpha=0.5,\\n color=\\\"darkorange\\\")\\n\\n con_cubic = plt.bar(x + 1 * width - 1.2,\\n index_cubic,\\n width=width,\\n label='Against CUBIC',\\n alpha=0.5,\\n color=\\\"lawngreen\\\")\\n\\n con_itself = plt.bar(x + 2 * width - 1.2,\\n index_itself,\\n width=width,\\n label='Against Another Same CCA',\\n alpha=0.5,\\n color=\\\"dodgerblue\\\")\\n\\n # Index\\n plt.xticks(x + 1.5 * width - 1.2, [\\\"BBR\\\", \\\"Scalable\\\", \\\"BIC\\\", \\\"High Speed\\\",\\n \\\"H-TCP\\\", \\\"Hybla\\\", \\\"Illinois\\\", \\\"Vegas\\\",\\n \\\"YeAH\\\"],\\n fontsize=fsize,\\n rotation=\\\"45\\\")\\n plt.ylabel(\\\"Jain`s Fairness Index\\\", fontsize=fsize)\\n plt.yticks(fontsize=fsize)\\n plt.ylim(0.5, 1.1)\\n\\n ax = plt.subplot(111)\\n ax.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,\\n ncol=3, mode=\\\"expand\\\", borderaxespad=0., fontsize=fsize)\\n\\n plt.subplots_adjust(left=0.07, right=0.98, top=0.9, bottom=0.2)\\n\\n plt.show()\",\n \"def __init__(self, data):\\n\\n self.produce_csv = data['produce_csv']\\n self.produce_graphics = data['produce_graphics']\\n self.report_name = data['report_name']\\n self.file_name = self.report_name + '.csv'\\n self.annual_file_name = self.report_name + '_annual.csv'\\n self.csv_dir = ''\\n self.diagnostic_dir = ''\\n\\n self.daily_variables = {\\n 'year': ['time.cal_year', '', []],\\n 'j_day': ['time.day', '', []]\\n }\\n\\n self.annual_variables = {\\n 'year': ['time.cal_year', '', 0]\\n }\",\n \"def main():\\r\\n run_processes('tests.csv', 'labs.csv')\",\n \"def ERCC_Stat(self):\\n self.l_ERCC_name = []\\n# self.l_RGCs_name = []\\n self.l_mRNA_name = []\\n self.l_ERCC_FPKM = {}\\n# self.l_RGCs_FPKM = {}\\n self.l_mRNA_FPKM = {}\\n\\n self.l_ERCC_UMI = {}\\n self.l_mRNA_UMI = {}\\n\\n# self.l_cirRNA_FPKM={}\\n \\n self.l_ERCC_HTSname = []\\n# self.l_RGCs_HTSname = []\\n self.l_mRNA_HTSname = []\\n self.l_ERCC_RPKM = {}\\n# self.l_RGCs_RPKM = {}\\n self.l_mRNA_RPKM = {}\\n \\n \\n self.l_ERCC_MOLs = {}\\n# self.l_RGCs_MOLs = {}\\n self.l_mRNA_MOLs = {}\\n self.l_cirRNA_MOLs={}\\n self.l_mRNA_MOLs_HTSname = {}\\n \\n self.regression = {}\\n \\n self.__load_FPKM()\\n self.__load_MOLs() # ERCC RGC mols\\n self.__get_mRNA_MOLs() # get mRNA mols using ERCC_FPKM, ERCC_MOLs and mRNA_FPKM\\n# self.__load_Count()\\n self.__load_umi()\\n \\n out_file = \\\"%s/02.%s.ERCC_Mols.xls\\\" % (self.dir_StatInfo, self.s_idx)\\n f_out_file = open( out_file,\\\"w\\\" )\\n \\n l_info = [\\n \\\"Sample\\\", \\\"ERCC_MOLs\\\", \\\"mRNA_MOLs\\\",\\n \\\"RefSeq_mRNA_MOLs\\\", \\\"Regression_R\\\",\\n \\\"Regression_P\\\", \\\"RefSeq_mRNA_TPM>0\\\", \\\"ERCC_UMI\\\", \\\"RefSeq_mRNA_UMI\\\"\\n ] \\n print >>f_out_file, \\\"\\\\t\\\".join(l_info)\\n \\n for samp in self.samInfo_pd_RNA['sample']:\\n idx = (self.samInfo_pd_RNA['sample'] == samp)\\n brief_name = self.samInfo_pd_RNA[idx]['brief_name'].values[0]\\n rename = self.samInfo_pd_RNA[idx]['rename'].values[0]\\n\\n ERCC_MOLs = sum( self.l_ERCC_MOLs[brief_name])\\n# RGC_MOLs = sum( self.l_RGCs_MOLs[brief_name])\\n mRNA_MOLs = np.sum(self.l_mRNA_MOLs[brief_name])\\n RefSeq_mRNA_MOLs = \\\\\\n np.sum(self.l_mRNA_MOLs[brief_name][self.mRNA_refSeq_index])\\n \\n RefSeq_mRNA_lFPKM = \\\\\\n np.array(self.l_mRNA_FPKM[brief_name],dtype=float)\\n \\n RefSeq_mRNA_lFPKM = RefSeq_mRNA_lFPKM[ self.mRNA_refSeq_index ]\\n RefSeq_mRNA_Exps = \\\\\\n np.shape(RefSeq_mRNA_lFPKM[RefSeq_mRNA_lFPKM > 0])[0]\\n\\n regression_R = self.regression[brief_name]['r_value']\\n regression_P = self.regression[brief_name]['p_value']\\n \\n RefSeq_mRNA_lUMI = \\\\\\n np.array(self.l_mRNA_UMI[brief_name],dtype=int)\\n\\n RefSeq_mRNA_UMI_count = np.sum( RefSeq_mRNA_lUMI )\\n\\n ERCC_lUMI = \\\\\\n np.array(self.l_ERCC_UMI[brief_name],dtype=int)\\n\\n ERCC_UMI_count= np.sum( ERCC_lUMI )\\n \\n l_out = [\\n rename,\\n ERCC_MOLs, mRNA_MOLs, RefSeq_mRNA_MOLs,\\n regression_R, regression_P, RefSeq_mRNA_Exps, ERCC_UMI_count, RefSeq_mRNA_UMI_count\\n ]\\n l_out = [str(i) for i in l_out]\\n print >>f_out_file, \\\"\\\\t\\\".join(l_out)\\n f_out_file.close()\",\n \"def main():\\n\\n if os.path.exists(os.path.join(PROCESSED_PATH,\\n 'all_posts_data.csv')):\\n print(\\\"-- all_posts_data.csv found locally - delete interm files if rerun needed\\\")\\n total_df = pd.read_csv(PROCESSED_PATH / 'all_posts_data.csv')\\n else:\\n training_post_filenames = glob.glob(os.path.join(DATA_DIR,\\n 'raw',\\n 'clpsych16-data',\\n 'data',\\n 'training',\\n 'posts', '*.xml'))\\n dev_post_filenames = glob.glob(os.path.join(DATA_DIR,\\n 'raw',\\n 'clpsych16-data',\\n 'data',\\n 'testing',\\n 'posts', '*.xml'))\\n\\n new_posts2017 = glob.glob(os.path.join(DATA_DIR,\\n 'raw',\\n 'clpsych17-test',\\n 'posts', '*.xml'))\\n\\n training_labels = os.path.join(DATA_DIR,\\n 'raw',\\n 'clpsych16-data',\\n 'data',\\n 'training',\\n 'labels.tsv')\\n dev_labels = os.path.join(DATA_DIR,\\n 'raw',\\n 'clpsych16-data',\\n 'data',\\n 'testing',\\n 'labels.tsv')\\n\\n training_df = create_posts_df(training_post_filenames)\\n dev_df = create_posts_df(dev_post_filenames)\\n new_df = create_posts_df(new_posts2017)\\n\\n training_df['corpus_source'] = '2016train_2017train'\\n dev_df['corpus_source'] = '2016test_2017train'\\n new_df['corpus_source'] = '2017test'\\n\\n training_df = merge_post_labels(training_df, training_labels)\\n dev_df = merge_post_labels(dev_df, dev_labels)\\n\\n training_df = merge_author_ranks(training_df)\\n dev_df = merge_author_ranks(dev_df)\\n new_df = merge_author_ranks(new_df)\\n\\n total_df = pd.concat([training_df, dev_df, new_df])\\n\\n test_labels = os.path.join(DATA_DIR,\\n 'raw',\\n 'clpsych17-test',\\n 'test_ids.tsv')\\n total_df.reset_index(inplace=True)\\n total_df = merge_test_ids(total_df, test_labels)\\n label_file = os.path.join(DATA_DIR,\\n 'raw',\\n 'clpsych17-test-labels.tsv')\\n merge_ground_truth(total_df, label_file)\\n output_path = PROCESSED_PATH / 'all_posts_data.csv'\\n \\n\\n # clean body of text\\n total_df['cleaned_body'], total_df['contained_quote'] = zip(*total_df['body'].apply(process_body))\\n total_df['images'] = total_df['body'].apply(process_images)\\n\\n print('--Writing data to {}--'.format(output_path))\\n total_df.to_csv(output_path, index=False)\\n\\n sentences_df = total_df.loc[:, ['post_id', 'cleaned_body', 'label', 'predict_me']]\\n # the following will split posts into sentences and write out to a separate csv\\n split_to_sentences(sentences_df)\",\n \"def __init__(self, path):\\n\\n # Metadata Definition\\n metadata = pd.read_csv(path, nrows=5, header=None)\\n self.subject = str(metadata.loc[0, 0])\\n base_date = dt.datetime.strptime(metadata.loc[2, 0], '%d.%m.%Y').date()\\n if metadata.loc[4, 0] != 'Unknown Line':\\n self.valid_measurements = str(metadata.loc[4, 0])\\n else:\\n metadata = pd.read_csv(path, nrows=6, header=None)\\n self.valid_measurements = str(metadata.loc[5, 0])\\n\\n column_names = ['hour', 'minutes', 'SYS(mmHg)', 'DIA(mmHg)', 'UNKNOW_1', 'UNKNOW_2', 'CODE', 'UNKNOW_3']\\n self.data = pd.read_csv(path, sep=',', skiprows=51, skipfooter=1, header=None, names=column_names, engine='python')\\n\\n # Adjusting Date\\n dates = [base_date]\\n times = [dt.time(hour=self.data.loc[i, 'hour'], minute=self.data.loc[i, 'minutes']) for i in range(len(self.data))]\\n current_date = base_date\\n for i in range(1, len(times)):\\n if times[i] < times[i-1]:\\n current_date += dt.timedelta(days=1)\\n dates.append(current_date)\\n\\n self.data.reset_index(inplace=True)\\n self.data['timestamp'] = pd.to_datetime([dt.datetime.combine(dates[i], times[i]) for i in range(len(dates))])\\n self.data['date'] = dates\\n self.data['time'] = times\\n\\n order = ['timestamp', 'date', 'time', 'SYS(mmHg)', 'DIA(mmHg)', 'UNKNOW_1', 'UNKNOW_2', 'UNKNOW_3', 'CODE']\\n self.data = self.data[order]\\n\\n try:\\n self.data.set_index('timestamp', inplace=True)\\n except KeyError:\\n print('Timestamp can not be set as an index:')\\n print(KeyError)\\n\\n xml_line = open(path, 'r').readlines()[-1]\\n xml_root = ET.fromstring(xml_line)\\n self.metadata = self._etree_to_dict(xml_root)['XML']\",\n \"def stat_parser():\\n from tools import file_importer, file_outporter\\n from math import log\\n \\n print(\\\"this is stat parser\\\")\\n \\n relPath = \\\"bob/processed/24h_bobdata_ed2.csv\\\"\\n outPathUp = \\\"bob/processed/24h_bobprots_up_full.csv\\\"\\n outPathDown = \\\"bob/processed/24h_bobprots_down_full.csv\\\"\\n inpF = file_importer(relPath)\\n outFUp = file_outporter(outPathUp)\\n outFDown = file_outporter(outPathDown)\\n \\n \\n skipFlag = True\\n \\n for inpLine in inpF:\\n if skipFlag:\\n skipFlag = False\\n outFDown.write(\\\"ID,Uniprot ID,Gene name,unique peptides (unique+razor),KO1,KO2,KO3,WT1,WT2,WT3,enrichment,P value\\\\n\\\")\\n outFUp.write(\\\"ID,Uniprot ID,Gene name,unique peptides (unique+razor),KO1,KO2,KO3,WT1,WT2,WT3,enrichment,P value\\\\n\\\")\\n continue\\n inpLine = inpLine.split(\\\"\\\\\\\" \\\\\\\"\\\")\\n curLine = []\\n for inpI in inpLine:\\n curLine.append(inpI.strip(\\\"\\\\\\\"\\\\n\\\"))\\n try: \\n curLine[-1] = float(curLine[-1])\\n except ValueError:\\n curLine[-1] = 1 \\n if curLine[-1] < 0.05 and int(curLine[3]) > 1: # check if protein has at least 2 unique peptides and has a significant p value\\n curLine[4:10] = [int(x) for x in curLine[4:10]]\\n enrScore = log((sum(curLine[4:7]) / 3.0)/(sum(curLine[7:10]) / 3.0),2) # calculate log2 enrichment score\\n # print int(sum(curLine[4:7]) / 3.0), int(sum(curLine[7:10]) / 3.0)\\n if sum(curLine[4:7]) / 3.0 > sum(curLine[7:10]) / 3.0: # if the mean of the KO intensities is higher than the wt \\n for outI in curLine:\\n outFDown.write(str(outI).strip(\\\" \\\"))\\n if outI is not curLine[-1]:\\n outFDown.write(\\\",\\\")\\n if outI is curLine[-2]:\\n outFDown.write(str(enrScore)+ \\\",\\\")\\n else:\\n outFDown.write(\\\"\\\\n\\\")\\n # outFDown.write(curLine[1] + \\\",\\\" + curLine[2] + \\\"\\\\n\\\")\\n else:\\n # outFUp.write(curLine[1] + \\\",\\\" + curLine[2] + \\\"\\\\n\\\")\\n for outI in curLine:\\n outFUp.write(str(outI).strip(\\\" \\\"))\\n if outI is not curLine[-1]:\\n outFUp.write(\\\",\\\")\\n if outI is curLine[-2]:\\n outFUp.write(str(enrScore)+ \\\",\\\")\\n else:\\n outFUp.write(\\\"\\\\n\\\")\\n \\n inpF.close()\\n outFUp.close()\\n outFDown.close()\\n print(\\\"stat_parser completed\\\")\",\n \"def __init__(self,k,p,expfile,sampfile):\\n \\n self.k = k\\n self.p = p\\n self.expression =pd.read_table(expfile,sep = '\\\\t')\\n self.samples = pd.read_table(sampfile,sep = '\\\\t',names = ['samples','patient'])\\n self.set_data() # a functionto wrangle the data a bit.\",\n \"def __init__(self, sc, dataset_path):\\n\\n logger.info(\\\"Starting up the Recommendation Engine: \\\")\\n\\n self.sc = sc\\n\\n\\t#Load cusomer data for later use\\n\\t\\n logger.info(\\\"Loading Customer data...\\\")\\n customer_file_path = os.path.join(dataset_path, 'tpo_customer.csv')\\n customer_raw_RDD = self.sc.textFile(customer_file_path)\\n customer_raw_data_header = customer_raw_RDD.take(1)[0]\\n self.customer_RDD = customer_raw_RDD.filter(lambda line: line!=customer_raw_data_header)\\\\\\n .map(lambda line: line.split(\\\",\\\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[4]),(tokens[5]),(tokens[6]),(tokens[7]))).cache()\\n\\tlogger.info(\\\"Loading Customer data success...\\\")\\n\\t#CUSTOMCUSTOMER_NAME,CUSTOMER_ADDRESS1,CUSTOMER_ADDRESS2,CUSTOMER_CITY,CUSTOMER_STATE,CUSTOMER_COUNTRY,CUSTOMER_ZIPCODE,CREATED_BY,CREATION_DATE,LAST_UPDATED_BY,LAST_UPDATE_DATE\\n \\n\\n\\n\\t\\n\\t#Load turbine data for later use\\t\\n logger.info(\\\"Loading Turbine data...\\\")\\n turbine_file_path = os.path.join(dataset_path, 'test_tpo_unit_config.csv')\\n turbine_raw_RDD = self.sc.textFile(turbine_file_path)\\n turbine_raw_data_header = turbine_raw_RDD.take(1)[0]\\n self.turbine_RDD = turbine_raw_RDD.filter(lambda line: line!=turbine_raw_data_header)\\\\\\n .map(lambda line: line.split(\\\",\\\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[5]),(tokens[34]),(tokens[51]),(tokens[35]))).cache()\\n\\tlogger.info(\\\"Loading Turbine data success...\\\")\\n \\n\\t\\n\\t\\n\\t\\n\\t#Load site data for later use\\t\\n logger.info(\\\"Loading Site data...\\\")\\n site_file_path = os.path.join(dataset_path, 'tpo_site.csv')\\n site_raw_RDD = self.sc.textFile(site_file_path)\\n site_raw_data_header = site_raw_RDD.take(1)[0]\\n self.site_RDD = site_raw_RDD.filter(lambda line: line!=site_raw_data_header)\\\\\\n .map(lambda line: line.split(\\\",\\\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[4]),(tokens[5]),(tokens[6]),(tokens[7]),(tokens[16]))).cache()\\n\\tlogger.info(\\\"Loading Site data success...\\\")\\n\\t\\n\\n\\n\\n\\t# Load ratings data for later use\\n logger.info(\\\"Loading Ratings data...\\\")\\n ratings_file_path = os.path.join(dataset_path, 'ratings.csv')\\n ratings_raw_RDD = self.sc.textFile(ratings_file_path)\\n ratings_raw_data_header = ratings_raw_RDD.take(1)[0]\\n self.ratings_RDD = ratings_raw_RDD.filter(lambda line: line!=ratings_raw_data_header)\\\\\\n .map(lambda line: line.split(\\\",\\\")).map(lambda tokens: (int(tokens[0]),int(tokens[1]),float(tokens[2]))).cache()\\n # Load movies data for later use\\n logger.info(\\\"Loading Movies data...\\\")\\n movies_file_path = os.path.join(dataset_path, 'movies.csv')\\n movies_raw_RDD = self.sc.textFile(movies_file_path)\\n movies_raw_data_header = movies_raw_RDD.take(1)[0]\\n self.movies_RDD = movies_raw_RDD.filter(lambda line: line!=movies_raw_data_header)\\\\\\n .map(lambda line: line.split(\\\",\\\")).map(lambda tokens: (int(tokens[0]),tokens[1],tokens[2])).cache()\\n self.movies_titles_RDD = self.movies_RDD.map(lambda x: (int(x[0]),x[1])).cache()\\n # Pre-calculate movies ratings counts\\n self.__count_and_average_ratings()\\n\\n # Train the model\\n self.rank = 8\\n self.seed = 5L\\n self.iterations = 10\\n self.regularization_parameter = 0.1\\n self.__train_model()\",\n \"def main():\\n parser = ArgumentParser(usage='%(prog)s [options] ecommonsMetadata.csv')\\n parser.add_argument(\\\"-d\\\", \\\"--date\\\", dest=\\\"date\\\",\\n help=\\\"Date on or after that an ETD was published for \\\\\\n creating DOIs. Put in format YYYY-MM\\\")\\n parser.add_argument(\\\"datafile\\\", help=\\\"eCommons metadata worked from.\\\")\\n\\n args = parser.parse_args()\\n\\n if not len(sys.argv) > 0:\\n parser.print_help()\\n parser.exit()\\n\\n workingdir = csvparse(args.datafile, args.date)\\n doiparse(workingdir)\\n print('ANVL files available in: ' + workingdir)\",\n \"def main():\\n csv_file_name = ''\\n do_linear = False\\n\\n if len(sys.argv) == 3:\\n csv_file_name = sys.argv[1]\\n do_linear = bool(int(sys.argv[2]))\\n\\n data = open(csv_file_name)\\n\\n #ignore title\\n first_line = data.readline()\\n\\n #read the remaining data within the file\\n body = data.readlines()\\n length = len(body)\\n position_array = np.zeros((length, 2))\\n class_array = np.zeros((length, 1))\\n\\n index = 0\\n for line in body:\\n values = line.strip().split(',')\\n position_array[index][0] = values[0]\\n position_array[index][1] = values[1]\\n class_array[index] = values[2]\\n index += 1\\n\\n if do_linear == False:\\n #plot_spiral(position_array, class_array, \\\"spiral.png\\\")\\n linear_position_array, linear_class_array, linear_model = linear_classifier(position_array, class_array, 4)\\n plot_spiral_and_predicted_class(linear_position_array, linear_class_array, linear_model, \\\"linear.png\\\", \\\"Linear Classification Results\\\")\\n\\n else:\\n nonlinear_position_array, nonlinear_class_array, nonlinear_model = non_linear_classifier(position_array, class_array, 4)\\n plot_spiral_and_predicted_class(nonlinear_position_array, nonlinear_class_array, nonlinear_model, \\\"nonlinear.png\\\", \\\"Nonlinear Classification Results\\\")\",\n \"def main():\\n\\n preprocessed_file = preprocess_clinical_trials()\\n\\n preprocessed_file.to_csv(PREPROCESSED_CLINICAL_TRIALS_FILE_PATH, index=False)\",\n \"def __init__(self, className, name, title=None, unit=None):\\n self.className = className\\n filename = os.path.join(DATA, name + '.csv')\\n with open(filename,encoding='utf8') as csv_file:\\n reader = csv.reader(csv_file)\\n for row_number, row in enumerate(reader):\\n if row[1] == filename:\\n continue\\n if row[0] == '':\\n self.title = row[1]\\n continue\\n if row[0] == 'unit':\\n self.unit = row[1]\\n continue\\n try:\\n datetime.strptime(row[0], \\\"%Y-%m-%d\\\")\\n break\\n except: ValueError\\n super().__init__(name, title, unit)\\n with open(filename,encoding='utf8') as csv_file:\\n reader = csv.reader(csv_file)\\n for skip in range(row_number): # row_number is first data line\\n next(reader)\\n for row in reader:\\n try:\\n self.data[datetime.strptime(row[0], \\\"%Y-%m-%d\\\")]=float(row[1])\\n except: ValueError\\n self.first_date=min(self.data.keys())\\n self.last_date=max(self.data.keys())\",\n \"def main():\\n master_csv = open(\\\"master.csv\\\", \\\"w\\\")\\n master_csv.write(\\\"lat, lon, year, month, day, T_max, T_min, PrecipMM, T_ave, PrecipCM, RelHum\\\\n\\\")\\n MoLS_comp_csv = open(\\\"MoLS_comp.csv\\\", \\\"w\\\")\\n lat_lon_csv = open(\\\"lat_lon.csv\\\", \\\"w\\\")\\n\\n for csvFilename in os.listdir('.'):\\n\\n if not csvFilename.endswith('.csv') or csvFilename == \\\"master.csv\\\" or csvFilename == \\\"MoLS_comp.csv\\\" or csvFilename == \\\"lat_lon.csv\\\":\\n continue # skip non-csv files\\n\\n csvFileObj = open(csvFilename)\\n readerObj = csv.reader(csvFileObj)\\n print(\\\"Currently parsing \\\" + str(csvFilename))\\n for row in readerObj:\\n if readerObj.line_num <= 8 :\\n continue\\n\\n year = int(row[0])\\n vp = float(row[8]) / 1000.0\\n month, day = get_month(int(row[1]))\\n T_ave = (float(row[6]) + float(row[7])) / 2\\n PrecipCM = float(row[3]) / 10\\n svp = .611 * math.e ** (5321 * ((1 / 273.0) - (1 / (T_ave + 273.15))))\\n rh_ave = round((vp / svp) * 100, 2)\\n\\n # print([[csvFilename], , row[0], row[1], row[3], row[6], row[7], row[8]])\\n # print(readerObj.line_num)\\n # print([csvFilename.split(\\\"_\\\")[0], csvFilename.split(\\\"_\\\")[1].split(\\\".csv\\\")[0], row[0], row[1], row[3],\\n # row[6], row[7], row[8]])\\n\\n master_csv.write(str(csvFilename.split(\\\"_\\\")[0]) + \\\",\\\" + str(csvFilename.split(\\\"_\\\")[1].split(\\\".csv\\\")[0]) +\\n \\\",\\\" + str(year) + \\\",\\\" + str(month) + \\\",\\\" + str(day) + \\\",\\\" + str(row[6]) + \\\",\\\" + str(row[7])\\n + \\\",\\\" + str(row[3]) + \\\",\\\" + str(T_ave) + \\\",\\\" + str(PrecipCM) + \\\",\\\" + str(rh_ave) + \\\"\\\\n\\\")\\n MoLS_comp_csv.write(str(year) + \\\",\\\" + str(month) + \\\",\\\" + str(day) + \\\",\\\" + str(row[6]) + \\\",\\\" + str(row[7])\\n + \\\",\\\" + str(row[3]) + \\\",\\\" + str(T_ave) + \\\",\\\" + str(PrecipCM) + \\\",\\\" + str(rh_ave) + \\\"\\\\n\\\")\\n lat_lon_csv.write(str(csvFilename.split(\\\"_\\\")[0]) + \\\",\\\" + str(csvFilename.split(\\\"_\\\")[1].split(\\\".csv\\\")[0]) + \\\"\\\\n\\\")\\n\\n master_csv.close()\\n MoLS_comp_csv.close()\\n lat_lon_csv.close()\",\n \"def __init__(self):\\n self.file_name = \\\"entries.csv\\\"\\n self.csv_header = \\\"date,name,minutes,note\\\"\\n try:\\n with open(self.file_name) as file:\\n reader = csv.DictReader(file)\\n self.entries = list(reader)\\n except FileNotFoundError:\\n with open(self.file_name, \\\"a\\\") as file:\\n file.write(f'{self.csv_header}\\\\n')\\n\\n try:\\n for i in range(len(self.entries)):\\n entry = self.entries[i]\\n self.entries[i] = Entry(\\n entry[\\\"date\\\"],\\n entry[\\\"name\\\"],\\n entry[\\\"minutes\\\"],\\n entry[\\\"note\\\"]\\n )\\n print(f\\\"Worklog with {len(self.entries)} entries has been loaded.\\\\n\\\")\\n print(\\\"Starting program...\\\")\\n time.sleep(.75)\\n except TypeError:\\n raise TypeError(\\\"Could not read data file.\\\"\\n + \\\" Ensure that CSV is properly formatted.\\\")\\n except AttributeError:\\n print(\\\"No existing worklog found.\\\\nNew worklog has been created.\\\\n\\\")\\n self.entries = []\\n print(\\\"Starting program...\\\")\\n time.sleep(.75)\",\n \"def __init__(self, data_dir, html_dir, paver_html_dir, resolution_1, resolution_2, picture_format, hierarchy_version, original_mapping_dir):\\n\\n pn = proteomaps_PATHNAMES(hierarchy_version)\\n PROTEIN_HIERARCHY_DIR = pn.PROTEIN_HIERARCHY_DIR\\n po = proteomaps_organisms(pn)\\n\\n filenames_file = data_dir + \\\"/filenames.csv\\\"\\n print \\\"Data set directory: \\\" + data_dir\\n \\n for row in csv.reader(open(filenames_file, 'r'), delimiter='\\\\t'):\\n organism, data_file, data_set_name, data_set_name_matlab, article_name = row\\n print \\\"\\\\nData set \\\" + data_set_name + \\\":\\\\nWriting html files to directory \\\" + html_dir\\n\\n data_type = \\\"cost\\\"\\n proteomap_process_html(paver_html_dir, html_dir, data_dir, data_set_name, organism, resolution_1, resolution_2, article_name, data_type, picture_format,po,PROTEIN_HIERARCHY_DIR, original_mapping_dir)\\n\\n data_type = \\\"abundance\\\"\\n proteomap_process_html(paver_html_dir, html_dir, data_dir, data_set_name, organism, resolution_1, resolution_2, article_name, data_type, picture_format,po,PROTEIN_HIERARCHY_DIR, original_mapping_dir)\",\n \"def main():\\n\\takpPoints,chpPoints = extractSupporterCities(\\\"Data/PreprocessedAkpTweets.csv\\\",\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"Data/PreprocessedChpTweets.csv\\\")\\n\\tgenerateMapPoints(akpPoints,chpPoints)\\n\\tgenerateCitySentimentData(akpPoints,chpPoints)\\n\\tgenerateChoroplethMap(\\\"Data/tr_cities_modified.json\\\",\\\"Data/city_ratio.csv\\\")\",\n \"def __init__(self,csvrow):\\n self.raw = csvrow\\n data = csvrow.split(',')\\n self.number = data[0]\\n self.area = int(data[1])\\n self.population = int(data[5])\\n self.latitude = float(data[7])\\n self.longitude = float(data[8])\",\n \"def __init__(self):\\n \\n self.csv_features = {} # Create dictionary to load the CSV features\\n self.meta_features = [] # Create list to load the metadata features\",\n \"def __init__(self, updated=False):\\n self.deputies = []\\n self.senators = []\\n\\n if updated:\\n file = IDENTITY_FILE_UPDATED\\n else:\\n file = IDENTITY_FILE\\n\\n with open(file, 'rt') as csvfile:\\n spamreader = csv.DictReader(csvfile, delimiter=';')\\n for row in spamreader:\\n # Senators and deputies has different contracts\\n # TODO: CREATE ANOTHER FEATURE TELLING SENATORS vs DEPUTIES\\n try:\\n if row.get('sen:CodigoParlamentar') or 'senador' in row.get('post', '').lower():\\n self.add_senator(Senator(row))\\n\\n if row.get('cam:ideCadastro') or 'deputado' in row.get('post', '').lower():\\n self.add_deputy(Deputy(row))\\n except AttributeError:\\n import code; code.interact(local=dict(globals(), **locals()))\",\n \"def main():\\n\\n outFile = r'../product/yoshinoya_rawdata.csv'\\n\\n with open(r'../data/yoshinoya_id.csv') as yoshinoya_id:\\n\\n # Reader to read store id\\n id_reader = csv.reader(yoshinoya_id)\\n\\n # Skip the headers\\n header = next(yoshinoya_id, None)\\n\\n # Keys from the get_data function\\n headers = ['storeid', 'brand', 'name', 'lat', 'lon', 'postalCode',\\n 'address', 'MON_open', 'MON_close', 'TUE_open', 'TUE_close',\\n 'WED_open', 'WED_close', 'THU_open', 'THU_close', 'FRI_open',\\n 'FRI_close', 'SAT_open', 'SAT_close', 'SUN_open', 'SUN_close']\\n\\n with open(outFile, 'w', newline='') as csvfile:\\n\\n writer = csv.DictWriter(csvfile, delimiter=',', lineterminator='\\\\n',\\n fieldnames=headers)\\n\\n # Write the headers\\n writer.writeheader()\\n\\n for row in id_reader:\\n\\n storeid = row[0]\\n\\n print(f\\\"Processing {storeid}...\\\")\\n\\n store_row = get_data_yoshinoya(storeid)\\n\\n if store_row is None:\\n\\n print(f\\\"failed to request the page with storeid {storeid}\\\")\\n continue\\n\\n writer.writerow(store_row)\\n\\n csvfile.close()\",\n \"def collect_data(self):\\n categories = []\\n list_of_feature_lists = []\\n feature_sets = set()\\n with open(self.csv_path, \\\"r\\\") as f:\\n reader = csv.DictReader(f)\\n # collecting some stats for FDR calculation:\\n self.PSM_count = 0\\n self.decoy_count = 0\\n\\n if self[\\\"dump_svm_matrix\\\"]:\\n self.init_svm_matrix_dump()\\n additional_matrix_info = []\\n\\n for i, row in enumerate(\\n sorted(\\n reader,\\n reverse=self[\\\"bigger_scores_better\\\"],\\n key=lambda d: float(d[self.col_for_sorting]),\\n )\\n ):\\n\\n features = self.row_to_features(row)\\n\\n if tuple(features) in feature_sets:\\n continue\\n feature_sets.add(tuple(features))\\n\\n category, psm_FDR = self.get_psm_category(row)\\n\\n list_of_feature_lists.append(features)\\n categories.append(category)\\n\\n if self[\\\"dump_svm_matrix\\\"]:\\n label = -1 if row_is_decoy(row) else 1\\n sequence = \\\"{0}.{1}#{2}.{3}\\\".format(\\n row[\\\"Sequence Pre AA\\\"].strip(),\\n row[\\\"Sequence\\\"].strip(),\\n row[\\\"Modifications\\\"].strip(),\\n row[\\\"Sequence Post AA\\\"].strip(),\\n )\\n additional_matrix_info.append(\\n {\\n \\\"psm_id\\\": row[\\\"Spectrum Title\\\"].strip(),\\n \\\"label\\\": label,\\n \\\"scannr\\\": row[\\\"Spectrum Title\\\"].strip().split(\\\".\\\")[-2],\\n \\\"peptide\\\": sequence,\\n \\\"proteins\\\": self.parse_protein_ids(row[\\\"Protein ID\\\"]),\\n }\\n )\\n\\n if i % 1000 == 0:\\n score_val = float(row[self.col_for_sorting])\\n msg = (\\n \\\"Generating feature matrix from input csv \\\"\\n \\\"(line ~{0}) with score {1} and FDR \\\"\\n \\\"{2}\\\".format(i, score_val, psm_FDR)\\n )\\n print(msg, end=\\\"\\\\r\\\")\\n\\n # All data points are collected in one big matrix, to make standardization possible\\n print(\\\"\\\\nConverting feature matrix to NumPy array...\\\")\\n X_raw = np.array(list_of_feature_lists, dtype=float)\\n\\n print(\\\"Replacing empty/NaN values with the mean of each column...\\\")\\n self.nan_replacer = Imputer()\\n self.nan_replacer.fit(X_raw)\\n X_raw = self.nan_replacer.transform(X_raw)\\n # Standardize input matrix to ease machine learning! Scaled data has zero mean and unit variance\\n print(\\\"Standardizing input matrix...\\\")\\n self.scaler = SCALER.fit(X_raw)\\n self.X = self.scaler.transform(X_raw)\\n self.categories = np.array(categories)\\n print()\\n\\n if self[\\\"dump_svm_matrix\\\"]:\\n print(\\\"Dumping SVM matrix to\\\", self[\\\"dump_svm_matrix\\\"])\\n\\n for i, matrix_row in enumerate(self.X):\\n matrix_row_info = additional_matrix_info[i]\\n self.dump_svm_matrix_row(\\n row=list(matrix_row),\\n psm_id=matrix_row_info[\\\"psm_id\\\"],\\n label=matrix_row_info[\\\"label\\\"],\\n scannr=matrix_row_info[\\\"scannr\\\"],\\n peptide=matrix_row_info[\\\"peptide\\\"],\\n proteins=matrix_row_info[\\\"proteins\\\"],\\n )\\n\\n print(\\\"Dumped SVM matrix to\\\", self[\\\"dump_svm_matrix\\\"])\\n return\",\n \"def load(cls):\\n \\n # Loop through problems and build patient problem lists:\\n probs = csv.reader(file(PROBLEMS_FILE,'U'),dialect='excel-tab')\\n header = probs.next() \\n for prob in probs:\\n cls(dict(zip(header,prob))) # Create a problem instance \",\n \"def main():\\n args = parse_arguments()\\n\\n de_data = pd.read_csv(args.raw_file, sep=\\\"\\\\t\\\")\\n de_data.rename(columns={\\\"Unnamed: 0\\\": \\\"gene_id\\\"}, inplace=True)\\n de_data.fillna(value=1, inplace=True)\\n columns = {}\\n col_order = []\\n\\n # Make sure all listed numeric columns are valid numeric variables based\\n # on a union of numeric column names from cuffdiff, edgeR, deseq2 and test\\n # files.\\n numeric_columns = [\\n \\\"baseMean\\\",\\n \\\"log2FoldChange\\\",\\n \\\"lfcSE\\\",\\n \\\"stat\\\",\\n \\\"pvalue\\\",\\n \\\"padj\\\",\\n \\\"value_1\\\",\\n \\\"value_2\\\",\\n \\\"log2(fold_change)\\\",\\n \\\"test_stat\\\",\\n \\\"p_value\\\",\\n \\\"q_value\\\",\\n \\\"logfc\\\",\\n \\\"fdr\\\",\\n \\\"stat\\\",\\n \\\"logFC\\\",\\n \\\"logCPM\\\",\\n \\\"LR\\\",\\n \\\"Pvalue\\\",\\n \\\"FDR\\\",\\n ]\\n de_columns = de_data.columns\\n\\n for column in numeric_columns:\\n if column not in de_columns:\\n continue\\n\\n if not is_numeric_dtype(de_data[column]):\\n msg = (\\n f\\\"Column {column} is not numeric. Please make sure \\\"\\n f\\\"that the input file has valid numeric values (i.e. \\\"\\n f\\\"periods for decimal places).\\\"\\n )\\n send_message(error(msg))\\n raise ValueError(msg)\\n\\n if args.gene_id:\\n if args.gene_id == \\\"index\\\":\\n columns[\\\"gene_id\\\"] = list(de_data.index.astype(str))\\n col_order.append(\\\"gene_id\\\")\\n else:\\n columns[\\\"gene_id\\\"] = list(de_data[args.gene_id].astype(str))\\n col_order.append(\\\"gene_id\\\")\\n\\n if args.logfc:\\n col = np.array(de_data[args.logfc])\\n col[np.isinf(col)] = 0\\n columns[\\\"logfc\\\"] = list(col)\\n col_order.append(\\\"logfc\\\")\\n\\n if args.fdr:\\n columns[\\\"fdr\\\"] = list(de_data[args.fdr])\\n col_order.append(\\\"fdr\\\")\\n\\n if args.pvalue:\\n columns[\\\"pvalue\\\"] = list(de_data[args.pvalue])\\n col_order.append(\\\"pvalue\\\")\\n\\n if args.fwer:\\n columns[\\\"fwer\\\"] = list(de_data[args.fwer])\\n col_order.append(\\\"fwer\\\")\\n\\n if args.logodds:\\n columns[\\\"logodds\\\"] = list(de_data[args.logodds])\\n col_order.append(\\\"logodds\\\")\\n\\n if args.stat:\\n columns[\\\"stat\\\"] = list(de_data[args.stat])\\n col_order.append(\\\"stat\\\")\\n\\n with open(args.output_json, \\\"w\\\") as f:\\n json.dump(columns, f, separators=(\\\",\\\", \\\":\\\"), allow_nan=False)\\n\\n outdf = pd.DataFrame(columns)\\n outdf = outdf[col_order]\\n outdf.to_csv(args.output_file, sep=\\\"\\\\t\\\", index=False, compression=\\\"gzip\\\")\",\n \"def main():\\n # Specify path\\n training_filepath = 'data/training.csv'\\n testing_filepath = 'data/public_test_features.csv'\\n\\n # Check whether the specified path exists or not\\n isExist = os.path.exists(training_filepath)\\n if(isExist):\\n print('Reading from ' + training_filepath)\\n else:\\n print('Training file not found in the app path.')\\n exit()\\n preprocess_file(training_filepath, 'data/clean_training1.csv', True)\\n # Check whether the specified path exists or not\\n isExist = os.path.exists(testing_filepath)\\n if(isExist):\\n print('Reading from ' + testing_filepath)\\n else:\\n print('Testing file not found in the app path.')\\n exit()\\n preprocess_file(testing_filepath,'data/clean_testing1.csv', False)\",\n \"def main():\\n# file_name = input(\\\"Please Provide File Name (e.g: sample_data.txt): \\\")\\n file_name = \\\"sample_data.txt\\\"\\n file_path = get_path(file_name)\\n if file_path != -1:\\n df = generate_DataFrame(file_path=file_path)\\n# table_name = input(\\\"Please Enter table Name(emp_details)\\\")\\n table_name = \\\"emp_details\\\"\\n table_create(table_name)\\n for x, i in df.iterrows():\\n insert_update(i,table_name)\\n print('processing id:', x)\",\n \"def __init__(\\n self,\\n data_columns: Sequence[str] = None,\\n bijector: Tuple[InitFunction, Bijector_Info] = None,\\n latent: distributions.LatentDist = None,\\n conditional_columns: Sequence[str] = None,\\n data_error_model: Callable = None,\\n condition_error_model: Callable = None,\\n autoscale_conditions: bool = True,\\n N: int = 1,\\n info: Any = None,\\n file: str = None,\\n ) -> None:\\n\\n # validate parameters\\n if data_columns is None and file is None:\\n raise ValueError(\\\"You must provide data_columns OR file.\\\")\\n if file is not None and any(\\n (\\n data_columns is not None,\\n bijector is not None,\\n conditional_columns is not None,\\n latent is not None,\\n data_error_model is not None,\\n condition_error_model is not None,\\n info is not None,\\n )\\n ):\\n raise ValueError(\\n \\\"If providing a file, please do not provide any other parameters.\\\"\\n )\\n\\n # if file is provided, load everything from the file\\n if file is not None:\\n # load the file\\n with open(file, \\\"rb\\\") as handle:\\n save_dict = pickle.load(handle)\\n\\n # make sure the saved file is for this class\\n c = save_dict.pop(\\\"class\\\")\\n if c != self.__class__.__name__:\\n raise TypeError(\\n f\\\"This save file isn't a {self.__class__.__name__}. It is a {c}.\\\"\\n )\\n\\n # load the ensemble from the dictionary\\n self._ensemble = {\\n name: Flow(_dictionary=flow_dict)\\n for name, flow_dict in save_dict[\\\"ensemble\\\"].items()\\n }\\n # load the metadata\\n self.data_columns = save_dict[\\\"data_columns\\\"]\\n self.conditional_columns = save_dict[\\\"conditional_columns\\\"]\\n self.data_error_model = save_dict[\\\"data_error_model\\\"]\\n self.condition_error_model = save_dict[\\\"condition_error_model\\\"]\\n self.info = save_dict[\\\"info\\\"]\\n\\n self._latent_info = save_dict[\\\"latent_info\\\"]\\n self.latent = getattr(distributions, self._latent_info[0])(\\n *self._latent_info[1]\\n )\\n\\n # otherwise create a new ensemble from the provided parameters\\n else:\\n # save the ensemble of flows\\n self._ensemble = {\\n f\\\"Flow {i}\\\": Flow(\\n data_columns=data_columns,\\n bijector=bijector,\\n conditional_columns=conditional_columns,\\n latent=latent,\\n data_error_model=data_error_model,\\n condition_error_model=condition_error_model,\\n autoscale_conditions=autoscale_conditions,\\n seed=i,\\n info=f\\\"Flow {i}\\\",\\n )\\n for i in range(N)\\n }\\n # save the metadata\\n self.data_columns = data_columns\\n self.conditional_columns = conditional_columns\\n self.latent = self._ensemble[\\\"Flow 0\\\"].latent\\n self.data_error_model = data_error_model\\n self.condition_error_model = condition_error_model\\n self.info = info\",\n \"def main():\\n # LoL = readcsv( \\\"wds.csv\\\" )\\n # print(LoL[:10])\\n\\n # test writing\\n # write_to_csv( LoL[:10], \\\"tenrows.csv\\\" )\\n\\n # text csv_to_html_table_starter\\n # output_html = csv_to_html_table_starter( LoL[:10] )\\n # print(\\\"\\\\noutput_html is\\\\n\\\\n\\\" + output_html)\\n # create_html_page(output_html, \\\"test.html\\\")\\n Wcount_first()\\n Wcount_last()\\n Wcount_middle()\",\n \"def main():\\n langs = []\\n\\n with open(\\\"sql/07_populate.sql\\\", 'w', encoding='utf8') as sql:\\n sql.write(\\\"--this file is generated from csv files in data folder\\\\n\\\\n\\\")\\n\\n langs = write_lang_city(sql)\\n write_groups_diets(sql, langs)\\n\\n with open(\\\"sql/10_populate_test_data.sql\\\", 'w', encoding='utf8') as sql:\\n sql.write(\\\"--this file is generated from csv files in moc_data folder\\\\n\\\\n\\\")\\n write_test_data(sql)\\n # This command sets postgis coordinates based on latitude and longitude\\n sql.write(\\\"UPDATE restaurant SET geo_location = ST_POINT(latitude, longitude);\\\\n\\\")\\n sql.close()\",\n \"def main ( independentBaseName, dependentBaseName, independentTSID, dependentTSID, statisticsFile, nEquations ):\\n # Get the logger for diagnostics and print out command line parameters (use str() in case None)\\n logger = logging.getLogger()\\n logger.info ( \\\"independentBaseName='\\\" + str(independentBaseName) + \\\"'\\\" )\\n logger.info ( \\\"dependentBaseName='\\\" + str(dependentBaseName) + \\\"'\\\" )\\n logger.info ( \\\"independentTSID='\\\" + str(independentTSID) + \\\"'\\\" )\\n logger.info ( \\\"dependentTSID='\\\" + str(dependentTSID) + \\\"'\\\" )\\n logger.info ( \\\"statisticsFile='\\\" + str(statisticsFile) + \\\"'\\\" )\\n logger.info ( \\\"nEquations=\\\" + str(nEquations) )\\n # Define lists\\n _TSID=[]\\n _TSID_Indep=[]\\n _n1=[]\\n _MeanX1=[]\\n _SX1=[]\\n _n2=[]\\n _MeanX2=[]\\n _SX2=[]\\n _MeanY1=[]\\n _SY1=[]\\n _NY=[]\\n _MeanY=[]\\n _SY=[]\\n _SkewY=[]\\n _a=[]\\n _b=[]\\n _R=[]\\n _R2=[]\\n _meanY1Est=[]\\n _SY1Est=[]\\n _RMSE=[]\\n _SEE=[]\\n _SEP=[]\\n _SESlope=[]\\n _TestScore=[]\\n _TestQuantile=[]\\n _TestRelated=[]\\n _Y2=[]\\n _MeanY2=[]\\n _SY2=[]\\n _Skew=[]\\n\\n # Set values\\n missingValue = -999\\n p = 0.95 # p = one sided exceedence probability\\n\\n # Read data and determine statistics\\n for i in range (0,nEquations):\\n # Construct name based on number of equations\\n if nEquations == 1:\\n independentName = independentBaseName + '.csv'\\n dependentName = dependentBaseName + '.csv'\\n else:\\n monthsString = string.rjust(str(i+1),2)\\n monthsString = string.replace(monthsString,' ', '0')\\n monthsString = '_' + monthsString\\n independentName = independentBaseName + monthsString + '.csv'\\n dependentName = dependentBaseName + monthsString + '.csv'\\n\\n # Read the data from the CSV files\\n [TSID_Indep, X] = Read_TS.Read_CSV(independentName)\\n [TSID, Y] = Read_TS.Read_CSV(dependentName)\\n\\n # Override the TSID with that from the command line\\n #if ( dependentTSID != None ):\\n # TSID = dependentTSID\\n #if ( independentTSID != None ):\\n # TSID_Indep = independentTSID\\n\\n # remove missing values\\n [independent, x_n2, dependent, n1, n2] = Statistics.overlapping(X, Y, missingValue)\\n\\n # calculate basic statistics\\n [MeanX1, SX1]=Statistics.statistics(independent)\\n [MeanY1, SY1]=Statistics.statistics(dependent)\\n if x_n2 != []:\\n [MeanX2, SX2]=Statistics.statistics(x_n2)\\n else: # No data that can be filled\\n [MeanX2, SX2]=[missingValue, missingValue]\\n\\n # calculate additional statistics for dependent variable\\n [MeanY, NY, SY]=Statistics.dependent_statistics(Y, missingValue)\\n SkewY = Statistics.Skew(Y)\\n\\n # calculate regression coefficients\\n [a,b,R,R2]=Statistics.regression_coef(independent, dependent)\\n\\n # Estimate the values for the dependent variable\\n [Yest, meanY1Est, SY1Est]=Statistics.calculate_Yest(independent, a, b)\\n\\n # Calculated the estimates for the dependent variable\\n if x_n2 != []:\\n Y2 = Statistics.LinearRegression(a,b,x_n2)\\n [MeanY2, SY2]=Statistics.statistics(Y2)\\n else: # No data that can be filled\\n Y2 = []\\n [MeanY2, SY2]=[missingValue, missingValue]\\n\\n # Calculate additional statistics\\n if x_n2 != []:\\n Skew = Statistics.Skew(Y2)\\n RMSE = Statistics.RMSE(dependent, Yest, n1)\\n SEE = Statistics.SEE(dependent, Yest, n1)\\n SEP = Statistics.SEP(independent, SEE, n1)\\n SESlope = Statistics.SESlope(independent, dependent, Yest, n1)\\n TestScore = Statistics.TestScore(b, SESlope)\\n TestQuantile = StudentTQuantiles.Student_T_quantile (p,n1-2)\\n if TestScore >= TestQuantile:\\n TestRelated = 'Yes'\\n else:\\n TestRelated = 'No'\\n else: # No data that can be filled\\n Skew = missingValue\\n RMSE = missingValue\\n SEE = missingValue\\n SEP = [missingValue]\\n SESlope = missingValue\\n TestScore = missingValue\\n TestQuantile = missingValue\\n TestRelated = 'No'\\n\\n # Append all the monthly data to an array containing the data for all months\\n # This will create a list with a single entry for a run with one equation\\n _TSID.append(TSID)\\n _TSID_Indep.append(TSID_Indep)\\n _n1.append(n1)\\n _MeanX1.append(MeanX1)\\n _SX1.append(SX1)\\n _n2.append(n2)\\n _MeanX2.append(MeanX2)\\n _SX2.append(SX2)\\n _MeanY1.append(MeanY1)\\n _SY1.append(SY1)\\n _NY.append(NY)\\n _MeanY.append(MeanY)\\n _SY.append(SY)\\n _SkewY.append(SkewY)\\n _a.append(a)\\n _b.append(b)\\n _R.append(R)\\n _R2.append(R2)\\n _meanY1Est.append(meanY1Est)\\n _SY1Est.append(SY1Est)\\n _RMSE.append(RMSE)\\n _SEE.append(SEE)\\n _SEP.append(SEP)\\n _SESlope.append(SESlope)\\n _TestScore.append(TestScore)\\n _TestQuantile.append(TestQuantile)\\n _TestRelated.append(TestRelated)\\n _Y2.append(Y2)\\n _MeanY2.append(MeanY2)\\n _SY2.append(SY2)\\n _Skew.append(Skew)\\n\\n # Pass the lists with all information to be written to a CSV file\\n Write_Stats.Write_CSV(statisticsFile,\\n _TSID,\\n _TSID_Indep,\\n _n1,\\n _MeanX1,\\n _SX1,\\n _n2,\\n _MeanX2,\\n _SX2,\\n _MeanY1,\\n _SY1,\\n _NY,\\n _MeanY,\\n _SY,\\n _SkewY,\\n _a,\\n _b,\\n _R,\\n _R2,\\n _meanY1Est,\\n _SY1Est,\\n _RMSE,\\n _SEE,\\n _SEP,\\n _SESlope,\\n _TestScore,\\n _TestQuantile,\\n _TestRelated,\\n _Y2,\\n _MeanY2,\\n _SY2,\\n _Skew)\\n logger.info ('Statistics file written')\\n print ('Statistics file written')\",\n \"def driver():\\n\\n directory = r\\\"C:/Users/Aftab Alam/Documents/GitHub\\\"\\n directory = directory + r\\\"/SRM-placement-analyser/data/\\\"\\n fileList = [directory+\\\"InfosysResult.xlsx\\\",directory+\\\"TCSResult.xlsx\\\",directory+\\\"CognizantResult.xlsx\\\",directory+\\\"WiproResult.xlsx\\\"]\\n \\n listOfPlaced = extractCommonData.extractCommonData(fileList)\\n createNewExcelSheet(directory,listOfPlaced)\",\n \"def __init__(self):\\n self.animals_list = []\\n self.book = None\\n try:\\n with open(os.getcwd() + '/animals.csv', 'r') as f:\\n read_file = csv.reader(f)\\n for row in read_file:\\n self.animals_list += row\\n except LookupError:\\n print(\\\"Check if 'animals.csv' file is in the main directory.\\\")\",\n \"def __init__(self, filename):\\n self.data = pd.read_csv(filename)\\n\\n # Dialogue information.\\n self.dialogue_ids = sorted(list(set(self.data['dialogue_id'])))\\n self.number_of_dialogues = len(self.dialogue_ids)\\n\\n # Dialogue Act information.\\n self.DAs = sorted(list(set(self.data['dialogue_act'])))\\n self.number_of_DAs = len(self.DAs)\\n\\n # Speaker information.\\n self.speakers = sorted(list(set(self.data['speaker'])))\\n\\n # Level information.\\n self.levels = sorted(list(set(self.data['level'])))\\n\\n # Extracts the unique (speaker, DA) dialogue turn tuples from the data set.\\n speaker_da_tuples = self.data[['speaker', 'dialogue_act']].drop_duplicates().values\\n speaker_da_tuples = [tuple(pair) for pair in speaker_da_tuples]\\n\\n # Constructs a dictionary consisting of the unique turn tuples and their corresponding vector representation.\\n self.number_of_classes = len(speaker_da_tuples)\\n self.class_dict = dict()\\n class_vectors = np.identity(self.number_of_classes)\\n for i in range(self.number_of_classes):\\n self.class_dict[speaker_da_tuples[i]] = class_vectors[i]\",\n \"def __init__(self, instancefile):\\n coord = []; demand = [], # initialize lists\\n with open(instancefile,\\\"r\\\") as iFile: # read data from file\\n self.InstanceName = iFile.readline().strip() # name of instamce\\n iFile.readline(); iFile.readline(); iFile.readline() # skip lines\\n vals = iFile.readline().strip().split()\\n self.MaxNumVeh = int(vals[0]) # read data\\n self.MaxVehCap = float(vals[1]) # read data\\n iFile.readline(); iFile.readline(); iFile.readline(); iFile.readline() # skip lines\\n line = iFile.readline().strip()\\n while line != \\\"\\\": # read customer data\\n vals = line.split()\\n coord.append([float(vals[1]), float(vals[2])])\\n demand.append(float(vals[3]))\\n line = iFile.readline().strip()\\n self.NumCust = len(coord)-1 # set number of customers\\n self.Coord = np.array(coord) # create object variables\\n self.CustDem = np.array(demand)\\n self.DistMatrix = squareform(pdist(self.Coord,\\\"euclidean\\\")) # compute distance matrix\",\n \"def main():\\n\\n # Ensure the output directory exists\\n if not os.path.exists(OUTPUT_DIR):\\n os.makedirs(OUTPUT_DIR)\\n\\n process_csv()\",\n \"def __init__(\\n self,\\n file_name=None,\\n file_contents=None,\\n uploaded_file: UploadedFile = None,\\n user: User = None,\\n gating_strategy: GatingStrategy = None,\\n ):\\n if uploaded_file:\\n self.upload_file = uploaded_file\\n file_name = uploaded_file.name\\n file_contents = uploaded_file.content\\n # print(file_contents)\\n self.content = file_contents\\n self.file_name = file_name\\n self.gating_strategy = gating_strategy\\n self.df = pd.read_csv(self.content, parse_dates=[\\\"Date\\\"])\\n\\n # List of columns always expected\\n # ToDo: Find out if any of these columns are 'required' - if so\\n # cannot continue without them.\\n\\n # Use variables to store static_column names in case they change\\n # in future\\n self.sc_panel = \\\"Panel\\\"\\n self.sc_clinical_sample = \\\"Clinical_sample\\\"\\n self.sc_filename = \\\"filename\\\"\\n self.sc_operator1 = \\\"Operator name\\\"\\n self.sc_comments = \\\"Comments\\\"\\n self.sc_batch = \\\"batch\\\"\\n self.sc_date = \\\"Date\\\"\\n self.required_columns = [\\n self.sc_filename,\\n self.sc_panel,\\n self.sc_clinical_sample,\\n ]\\n\\n self.static_columns = [\\n self.sc_batch,\\n self.sc_operator1,\\n self.sc_comments,\\n self.sc_date,\\n ]\\n\\n # Store the unique panels in the data\\n # ToDo: I think there should be only one unique panel - check.\\n self.panels = self.df[\\\"Panel\\\"].unique().tolist()\\n self.panel_name = self.panels[0].upper()\\n\\n # Compute names of parameters present. These are all the other\\n # columns in the file that are not in the static_columns list\\n # and are not unregistered_derived_parameters\\n parameter_columns = set(self.df.columns) - set(self.static_columns)\\n parameter_columns -= set(self.required_columns)\\n self.parameter_columns = list(parameter_columns)\\n\\n # Store unregistered parameters. Derived ones will be dynamically\\n # added to the Parameter table before upload\\n self.unregistered_derived_parameters = []\\n self.unregistered_parameters = []\\n for parameter_column in self.parameter_columns:\\n try:\\n parameter_object = Parameter.objects.get(\\n gating_hierarchy=parameter_column\\n )\\n except Parameter.DoesNotExist:\\n if parameter_column.endswith(\\\"Count_back\\\") or parameter_column.endswith(\\n \\\"freq\\\"\\n ):\\n self.unregistered_derived_parameters.append(parameter_column)\\n else:\\n self.unregistered_parameters.append(parameter_column)\\n self.parameter_columns = [\\n column\\n for column in self.parameter_columns\\n if column not in self.unregistered_parameters\\n and column not in self.unregistered_derived_parameters\\n ]\\n\\n # Names for pseudo parameters (parameters computed from data)\\n self.pseudo_parameters_numeric = []\\n if self.sc_batch in self.df.columns:\\n self.pseudo_parameters_numeric.append(\\n (self.sc_batch, f\\\"{self.panel_name}_batch\\\")\\n )\\n if self.sc_operator1 in self.df.columns:\\n self.pseudo_parameters_numeric.append(\\n (self.sc_operator1, f\\\"{self.panel_name}_operator_1\\\")\\n )\\n\\n self.pseudo_parameters_date = []\\n if self.sc_date in self.df.columns:\\n self.pseudo_parameters_date.append(\\n (self.sc_date, f\\\"{self.panel_name}_date_processed\\\")\\n )\\n\\n self.pseudo_parameters_text = []\\n if self.sc_comments in self.df.columns:\\n self.pseudo_parameters_text.append(\\n (self.sc_comments, f\\\"{self.panel_name}_comments\\\")\\n )\\n\\n # Number of rows to process\\n self.nrows = len(self.df)\\n\\n # Default uploaded file\\n if not uploaded_file:\\n self.upload_file = UploadedFile(\\n name=self.file_name,\\n user=user,\\n description=\\\"Panel results\\\",\\n row_number=self.nrows,\\n content=self.content,\\n notes=\\\"\\\",\\n content_type=\\\"PANEL_RESULTS\\\",\\n )\\n self.upload_file.save()\",\n \"def main(input_filepath, output_filepath):\\n productsDict = dataToDict(input_filepath)\\n productsList = dictToCSV(productsDict)\\n toCSV(productsList, output_filepath)\\n\\n logger = logging.getLogger(__name__)\\n logger.info('making final data set from raw data')\",\n \"def run_code_for_question_one_part_two():\\n df_flights_info = read_csv_file_data(\\\"../Data/T_Fare_Flight_Q1.csv\\\")\\n df_flights_info = evaluate_percentage_of_class_for_each_flight(df_flights_info)\\n df_flights_info.to_csv(\\\"../Output/Question_1_Part_2_percentages.csv\\\")\\n print(df_flights_info.head())\",\n \"def main():\\n if len(sys.argv) != 4:\\n sys.exit('Please run with : python data-eng.py donors_file.txt zipcode_output_filename date_output_filename')\\n compute_stats(sys.argv[1], sys.argv[2], sys.argv[3])\",\n \"def __init__(self,\\n feature_selection=True,\\n clinical_path='data/tidy/train_cli.csv',\\n proteomic_path='data/tidy/train_pro.csv',\\n rna_path='data/tidy/train_rna.csv',\\n mismatch_path='data/tidy/sum_tab_1.csv',\\n test_proteomic_path='data/raw/test_pro.tsv',\\n test_clinical_path='data/raw/test_cli.tsv',\\n train_rna_path='data/raw/train_rna.tsv',\\n test_rna_path='data/raw/test_rna.tsv',\\n mislabel_path='data/tidy/sum_tab_2.csv'):\\n self.clinical = pd.read_csv(clinical_path, index_col=0)\\n self.proteomic = self.preprocess(\\n pd.read_csv(proteomic_path, index_col=0)\\n )\\n self.rna = self.preprocess(\\n pd.read_csv(rna_path, index_col=0)\\n )\\n self.mismatch = pd.read_csv(mismatch_path, index_col=0)\\n self.test_proteomic = self.preprocess(\\n pd.read_csv(test_proteomic_path, index_col=0, sep='\\\\t').T\\n )\\n self.test_rna = self.preprocess(\\n pd.read_csv(test_rna_path, index_col=0, sep='\\\\t').T\\n )\\n self.test_clinical = pd.read_csv(test_clinical_path, index_col=0, sep='\\\\t')\\n self.train_rna = pd.read_csv(train_rna_path, index_col=0, sep='\\\\t').T\\n self.train_pro_rna = self.train_rna.merge(self.proteomic, how='outer', left_index=True, right_index=True)\\n self.test_pro_rna = self.test_rna.merge(self.test_proteomic, how='outer', left_index=True, right_index=True)\\n self.train_all = self.train_pro_rna.merge(self.clinical, how='outer', left_index=True, right_index=True)\\n self.train_all = self.train_all.replace(['Female', 'Male','MSI-Low/MSS', 'MSI-High'], [0, 1, 0, 1])\\n self.test_all = self.test_pro_rna.merge(self.test_clinical, how='outer', left_index=True, right_index=True)\\n self.test_all = self.test_all.replace(['Female', 'Male', 'MSI-Low/MSS', 'MSI-High'], [0, 1, 0, 1])\\n self.mislabel = pd.read_csv(mislabel_path, index_col=0)\\n\\n if feature_selection:\\n self.select_features()\\n\\n # create training labels for if a sample has been mislabeled\\n self.mislabel_labels = []\\n for i in range(0, len(self.mislabel.index)):\\n if self.mislabel.iloc[i, 0] == self.mislabel.iloc[i, 1] and self.mislabel.iloc[i, 1] == self.mislabel.iloc[i, 2]:\\n self.mislabel_labels.append(0)\\n else:\\n self.mislabel_labels.append(1)\",\n \"def __init__(self, filename=None, filetype=None, instrument=None):\\n if filename:\\n if instrument == 'Element':\\n skipfooter = 4\\n header = 1\\n drop = 9\\n elif instrument == 'Agilent':\\n skipfooter = 4\\n header = 3\\n drop = 3\\n else:\\n skipfooter = 0\\n header = 0\\n drop = 0\\n\\n if filetype == 'xlsx':\\n pwd = os.getcwd()\\n os.chdir(os.path.dirname(filename))\\n self.imported = pd.ExcelFile(filename)\\n self.data = self.imported.parse(\\n 0, index_col=0, skipfooter=skipfooter, header=header)\\n self.data = self.data.drop(self.data.index[:drop], axis=0)\\n os.chdir(pwd)\\n # TODO xlsx doesnt work with agilent type\\n elif filetype == 'csv':\\n pwd = os.getcwd()\\n os.chdir(os.path.dirname(filename))\\n self.data = pd.read_csv(filename, sep=',', index_col=0, skipfooter=skipfooter,\\n header=header, engine='python')\\n os.chdir(pwd)\\n elif filetype == 'asc':\\n pwd = os.getcwd()\\n os.chdir(os.path.dirname(filename))\\n self.data = pd.read_csv(filename, sep='\\\\t', index_col=0, skipfooter=skipfooter,\\n header=header, engine='python')\\n self.data = self.data.drop(self.data.index[:drop], axis=0)\\n self.data.dropna(axis=1, how='all', inplace=True)\\n self.data = self.data.apply(pd.to_numeric, errors='coerce')\\n os.chdir(pwd)\\n else:\\n warnings.warn('File type not supported.')\\n\\n self.data.index = self.data.index.astype('float32')\\n self.time = self.data.index\\n self.elements = list(map(elem_resolution, self.data.columns))\\n self.data.columns = self.elements\\n\\n self.srms = pd.ExcelFile('./SRM.xlsx').parse(index_col=0)\\n self.sum_koeficients = pd.ExcelFile(\\n './default_sum_koef.xlsx').parse(0, index_col=0, header=None).to_dict()[1]\\n\\n self.srm = None\\n self.iolite = None\\n self.names = None\\n self.internal_std = None\\n self.ablation_time = None\\n\\n self.laser_off = []\\n self.laser_on = []\\n self.skip = {'bcg_start': 0,\\n 'bcg_end': 0,\\n 'sample_start': 0,\\n 'sample_end': 0} # time in seconds to skip from each bcg and sample\\n\\n self.filter_line = None\\n self.starts = None\\n self.ends = None\\n self.bcg = None\\n self.average_peaks = None\\n self.ratio = None\\n self.quantified = None\\n self.lod = None\\n self.correction_elements = None\\n self.corrected_IS = None\\n self.corrected_SO = None\\n\\n self.dx = None\\n self.dy = None\\n self.maps = {}\\n self.qmaps = {}\\n\\n self.regression_values = {}\\n self.regression_equations = {}\",\n \"def main(xls, seqtype):\\n data_extraction = {}\\n # 1 - Load data\\n logger.info(f'Load {xls}')\\n manifest, metadata = load_xls(xls)\\n # 2 - Check file and data\\n logger.info(f'Start to validate XLS')\\n check_samples(manifest, metadata)\\n check_seqtype(manifest, seqtype)\\n check_metadata(metadata, seqtype)\\n logger.success(f'Successfully validate XLS')\\n # 3 - Export XLS to TSV for Qiime2\\n logger.info(f'Start to export XLS to TSV')\\n data_extraction = extract_manifest(manifest, seqtype, data_extraction)\\n data_extraction, metadata_vars = extract_metadata(metadata, seqtype, data_extraction)\\n export_to_tsv_for_qiime(data_extraction, metadata_vars, seqtype)\\n logger.success(f'Done')\",\n \"def process(self):\\n parser = csv.reader(self.reader,delimiter=self.delimiter_DIC[self.delim])\\n firstRec = True\\n for fields in parser:\\n if firstRec:\\n fieldNames = fields\\n firstRec = False\\n else:\\n self.dicts.append({})\\n for i,f in enumerate(fields):\\n try:\\n self.dicts[-1][fieldNames[i]] = f\\n except:\\n import pdb\\n pdb.set_trace()\\n if self.eng is \\\"spectrumMill\\\":\\n for i,row in enumerate(self.dicts):\\n fileSM = row[self.engine[self.eng][0]]\\n acNoSM = row[self.engine[self.eng][1]]\\n masSM=row[self.engine[self.eng][2]]\\n chrgeSM=row[self.engine[self.eng][3]]\\n preAmSM=row[self.engine[self.eng][4]].replace('(','').replace(')','')\\n pepSM=row[self.engine[self.eng][5]]\\n nAmSM=row[self.engine[self.eng][6]].replace('(','').replace(')','')\\n modSM=row[self.engine[self.eng][7]].split('\\\\s')+row[self.engine[self.eng][8]].split('\\\\s')\\n modLis = [mod.strip() for mod in modSM if mod!=' ']\\n modSM = ';'.join(modLis)\\n scoreSM=row[self.engine[self.eng][9]]\\n descrimentSM=row[self.engine[self.eng][10]]\\n if modSM !='':\\n modPepInHupaFormat=self.modTermDic.spectrumMill(preAmSM,pepSM,nAmSM,modSM,self.eng)\\n parsedData=acNoSM+'\\\\t'+masSM+'\\\\t'+chrgeSM+'\\\\t'+modPepInHupaFormat+'\\\\t'+scoreSM+'\\\\n'\\n data = self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n else:\\n parsedData=acNoSM+'\\\\t'+masSM+'\\\\t'+chrgeSM+'\\\\t'+preAmSM+'.'+pepSM+'.'+nAmSM+'\\\\t'+'-'+'\\\\t'+scoreSM+'\\\\n'\\n data = self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n\\n if self.eng is \\\"mascot\\\":\\n \\\"\\\"\\\"\\n In Mascot, under every gi (protein) corresponding peptide information will be there\\n \\\"\\\"\\\"\\n giFound=True\\n for i,row in enumerate(self.dicts):\\n if row[self.engine[self.eng][0]]!='':\\n giAsKey = row[self.engine[self.eng][0]]\\n giFound=False\\n if giFound==False:\\n massM=row[self.engine[self.eng][1]]\\n chargeM=row[self.engine[self.eng][2]]\\n preAmM=row[self.engine[self.eng][3]]\\n pepM=row[self.engine[self.eng][4]]\\n nAmM = row[self.engine[self.eng][5]]\\n modM=row[self.engine[self.eng][6]]\\n modSiteM=row[self.engine[self.eng][7]]\\n scoreM=row[self.engine[self.eng][8]]\\n evalM=row[self.engine[self.eng][9]]\\n if modM !='':\\n \\\"\\\"\\\"\\n modificationFormat from modification.py creates a MASTER_UNIMOD dictionary \\n Where all modifications of unimod would be available. \\n At same time formatMod function in modificationFormat class would convert modification format \\\"\\\"\\\"\\n modPepInHupaFormat=self.modTermDic.mascot(preAmM,pepM,nAmM,modSiteM,modM,self.eng)\\n parsedData=giAsKey+'\\\\t'+massM+'\\\\t'+chargeM+'\\\\t'+modPepInHupaFormat+'\\\\t'+scoreM+'\\\\n'\\n data=self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n else:\\n \\n parsedData=giAsKey+'\\\\t'+massM+'\\\\t'+chargeM+'\\\\t'+preAmM+'.'+pepM+'.'+nAmM+'\\\\t'+'-'+'\\\\t'+scoreM+'\\\\n'\\n data=self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n\\n if self.eng is \\\"inspect\\\":\\n \\\"\\\"\\\"\\n InSpect does not have mass information in TSV file\\n So we need to fetch it from spectrum file (this is not yet done)\\n \\\"\\\"\\\"\\n for i,row in enumerate(self.dicts):\\n data = row[self.engine[self.eng][0]]+'\\\\t'+row[self.engine[self.eng][1]]+'\\\\t'+row[self.engine[self.eng][2]]+'\\\\t'+row[self.engine[self.eng][3]]+'\\\\t'+row[self.engine[self.eng][4]]+'\\\\t'+row[self.engine[self.eng][5]]+'\\\\n'\\n #return data\\n #data = self.mapCaller(data)\\n #self.writer.write(data)\\n\\n if self.eng is \\\"omssa\\\":\\n #OMSSA csv doesnot contain start and last residue of the peptide, instead contains position. So start and last residue need to fetch from protein sequence\\n for i,row in enumerate(self.dicts):\\n giO = row[self.engine[self.eng][6]]\\n massO= row[self.engine[self.eng][5]]\\n chargeO=row[self.engine[self.eng][8]]\\n preAmO = row[self.engine[self.eng][1]]#position in protein\\n pepO = row[self.engine[self.eng][2]]\\n nextAmO = row[self.engine[self.eng][3]] #position in protein\\n scoreO= row[self.engine[self.eng][4]]\\n modO=row[self.engine[self.eng][7]]\\n if modO !='':\\n #parsedData=giO+'#'+massO+'#'+chargeO+'#'+preAmO+'.'+pepO+'.'+nextAmO+'#'+modO+'#'+scoreO\\n modPepInHupaFormat=self.modTermDic.omssa(preAmO,pepO,nextAmO,modO,self.eng)\\n parsedData=giO+'\\\\t'+massO+'\\\\t'+chargeO+'\\\\t'+modPepInHupaFormat+'\\\\t'+scoreO+'\\\\n'\\n self.mapCaller(parsedData,self.eng)\\n else:\\n parsedData=giO+'\\\\t'+massO+'\\\\t'+chargeO+'\\\\t'+preAmO+'.'+pepO+'.'+nextAmO+'\\\\t'+'-'+'\\\\t'+scoreO+'\\\\n'\\n self.mapCaller(parsedData,self.eng)\",\n \"def __init__(self, path):\\n self.csv_path = path\\n # check if csv format is valid or not\\n self.check_valid_csvformat(self.csv_path)\\n \\\"\\\"\\\" empty dict to store all company names\\n prepare initial company data in dictionary format \\\"\\\"\\\"\\n self.company_data = dict()\",\n \"def main():\\n\\t#first check args and file paths\\n\\tcheckArgs(args)\\n\\t\\n\\tdata = args.dataset_file\\n\\tf_name = data.split(\\\".\\\")\\n\\tprint \\\"\\\\n[AP]\\\\t\\\"+\\\"######## \\\"+f_name[0] + '.' + f_name[1]+\\\" ########\\\"\\n\\tprint \\\"\\\\n[AP]\\\\tChecked inputs, now acquiring data\\\"\\n\\n\\thost = \\\"localhost\\\"\\n\\tuser = \\\"readonly\\\"\\n\\tpasswd = \\\"readonlypswd\\\"\\n\\tdb = args.db_schema\\n\\tdb_table = args.db_table\\n\\n\\tnameFile = data[0:-20]\\n\\tdataset = queryDataset(host,user,passwd,db,db_table,\\\"tmpFile.txt\\\",nameFile)\\n\\tif dataset is not None:\\n\\t\\tdataset = dataset.rstrip('\\\\n')\\n\\t\\tdataset = dataset.replace(\\\"/\\\",\\\"-\\\")\\n\\n\\t\\tlocations_list, length_list = generateDataset(data)\\n\\n\\t\\tif len(locations_list) < 2:\\n\\t\\t\\tprint \\\"\\\\n[SKIP]\\\\t{dataset} has only one unique line! Can't estimate anything.\\\\n\\\\tSKIP THIS FILE!\\\\n\\\".format(dataset=str(dataset))\\n\\t\\t\\treturn 0\\n\\n\\t\\t# Alias for estAbund calling\\n\\t\\testAbund = sonicLength.estAbund\\n\\n\\t\\t# Call estAbund and store returned object in results\\n\\t\\tresults = estAbund(robjects.StrVector(locations_list), robjects.FloatVector(length_list))\\n\\n\\t\\t# Put estimation for theta in estimations_theta and associated locations in locations_theta; then organize data in dic_of_theta\\n\\t\\ttheta = results.rx2(\\\"theta\\\")\\n\\t\\testimations_theta = tuple(theta)\\n\\t\\tlocations_theta = tuple(theta.names)\\n\\t\\t# dic_of_theta\\n\\t\\tdic_of_theta = {}\\n\\t\\tfor i in range(len(locations_theta)):\\n\\t\\t\\tdic_of_theta.update({locations_theta[i]:estimations_theta[i]})\\n\\n\\t\\t# Put different fragment lengths in length_phi and associated frequencies in freq_phi\\n\\t\\tphi = results.rx2(\\\"phi\\\")\\n\\t\\tfreq_phi = tuple(phi)\\n\\t\\tlength_phi = tuple(phi.names)\\n\\n\\t\\tlength_phi_numbers = fragmentsLengthPlot(length_phi,freq_phi,length_list,nameFile,dataset)\\n\\n\\t\\tprintThetaInfo(estimations_theta,locations_theta,nameFile)\\n\\n\\t\\t# Retrieving redundant reads data\\n\\t\\tdic_of_redundant_reads_count, sequence_count_list = redundant_reads_count(from_file_to_list(data,'.tsv'))\\n\\n\\t\\t# Box Plot\\n\\t\\tsequence_count = []\\n\\t\\tfor v in sequence_count_list:\\n\\t\\t\\tsequence_count.append(int(v))\\n\\t\\tbox_plot(sequence_count, estimations_theta, nameFile,dataset)\\n\\n\\t\\t# Plot: unique lengths retrieved for a genomic location VS expected number of parent fragment for the same location\\n\\t\\tphi_VS_theta(length_phi, freq_phi, nameFile, dataset)\\n\\n\\n\\t\\t#######################################################################################################\\n\\t\\t# Produce .tsv output about measured redundant reads count, abundance-corrected redundant reads count # \\n\\t\\t# and some descriptive of unique fragments lengths #\\n\\t\\t#######################################################################################################\\n\\n\\t\\t# Retrieving data\\n\\t\\tdic_of_relative_abundance, dic_of_corrected_reads_count, dic_of_percentage_difference = corrected_reads_count(dic_of_redundant_reads_count, dic_of_theta)\\n\\t\\tdic_of_unique_lengths, dic_of_unique_lengths_number, dic_of_median_of_unique_lengths, dic_of_MAD = fragment_lengths_statistics(data)\\n\\t\\tdic_of_lengths = lengths_explicit_list(from_file_to_list(data,'.txt'))\\n\\n\\t\\t# Writing File\\n\\t\\tcorrected_file = open(dataset + \\\".\\\" + nameFile+\\\".outcomes\\\"+\\\".tsv\\\", 'w')\\n\\t\\tcorrected_file.write(\\\"Chromosome\\\\tIntegration_locus\\\\tStrand\\\\tSequence_Count\\\\tEstimated_Relative_Abundance\\\\tCorrected_Sequence_Count\\\\tPercentage_Variation\\\\tNumber_of_fragments_of_unique_lengths\\\\tLength_Min\\\\tLength_Max\\\\tLenght_Median\\\\tRounded_Lenght_Median\\\\tMAD\\\\tUnique_Lengths_List\\\\tUnique_Lengths_Amount\\\\tCEM_region_?\\\") ## ! NB ! ## \\\\tCEM_region_?\\\" has to remain the last!!!\\n\\t\\tgenome_locations = dic_of_redundant_reads_count.keys()\\n\\t\\tgenome_locations.sort()\\n\\t\\tfor key in genome_locations:\\n\\t\\t\\tsplitted_location = key.split(' ')\\n\\t\\t\\tcorrected_file.write(\\\"\\\\n\\\" + splitted_location[0] + \\\"\\\\t\\\" + splitted_location[1] + \\\"\\\\t\\\" + splitted_location[2] + \\\"\\\\t\\\" + str(dic_of_redundant_reads_count[key]) + \\\"\\\\t\\\" + str(round(dic_of_relative_abundance[key],5)) + \\\"\\\\t\\\" + str(round(dic_of_corrected_reads_count[key],0)) + \\\"\\\\t\\\" + str(dic_of_percentage_difference[key]) + \\\"\\\\t\\\" + str(dic_of_unique_lengths_number[key]) + \\\"\\\\t\\\" + str(min(dic_of_unique_lengths[key])) + \\\"\\\\t\\\" + str(max(dic_of_unique_lengths[key])) + \\\"\\\\t\\\" + str(dic_of_median_of_unique_lengths[key]) + \\\"\\\\t\\\" + str(math.ceil(dic_of_median_of_unique_lengths[key]))+ \\\"\\\\t\\\" + str(dic_of_MAD[key]) + \\\"\\\\t\\\" + str(dic_of_unique_lengths[key]) + \\\"\\\\t\\\" + str(dic_of_lengths[key]))\\n\\t\\t\\tresponse, cem_symbol, cem_coordinates = is_CEM(key)\\n\\t\\t\\tif (response == True):\\n\\t\\t\\t\\tcorrected_file.write(\\\"\\\\t\\\" + cem_symbol)\\n\\n\\t\\t# Write database file - Like corrected_file with more field appended in the end\\n\\t\\tdb_file = open(dataset + \\\".\\\" + nameFile+\\\".db_file\\\"+\\\".tsv\\\", 'w')\\n\\t\\tgenome_locations = dic_of_redundant_reads_count.keys()\\n\\t\\tgenome_locations.sort()\\n\\t\\tdataset_split = dataset.split('.')\\n\\t\\tdataset_label = '_'.join(dataset_split)\\n\\t\\tfor key in genome_locations:\\n\\t\\t\\tsplitted_location = key.split(' ')\\n\\t\\t\\tdb_file.write(splitted_location[0] + \\\"\\\\t\\\" + splitted_location[1] + \\\"\\\\t\\\" + splitted_location[2] + \\\"\\\\t\\\" + str(dic_of_redundant_reads_count[key]) + \\\"\\\\t\\\" + str(round(dic_of_relative_abundance[key],5)) + \\\"\\\\t\\\" + str(round(dic_of_corrected_reads_count[key],0)) + \\\"\\\\t\\\" + str(dic_of_percentage_difference[key]) + \\\"\\\\t\\\" + str(dic_of_unique_lengths_number[key]) + \\\"\\\\t\\\" + str(min(dic_of_unique_lengths[key])) + \\\"\\\\t\\\" + str(max(dic_of_unique_lengths[key])) + \\\"\\\\t\\\" + str(dic_of_median_of_unique_lengths[key]) + \\\"\\\\t\\\" + str(math.ceil(dic_of_median_of_unique_lengths[key]))+ \\\"\\\\t\\\" + str(dic_of_MAD[key]) + \\\"\\\\t\\\" + str(dic_of_unique_lengths[key])[1:-1] + \\\"\\\\t\\\" + str(dic_of_lengths[key])[1:-1] + \\\"\\\\t\\\")\\n\\t\\t\\tdb_file.write(\\\"\\\\t\\\".join(dataset_split) + \\\"\\\\t\\\" + dataset_label + \\\"\\\\t\\\")\\n\\t\\t\\tresponse, cem_symbol, cem_coordinates = is_CEM(key)\\n\\t\\t\\tif (response == True):\\n\\t\\t\\t\\tdb_file.write(cem_symbol + \\\"\\\\t\\\" + cem_coordinates)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdb_file.write(\\\"\\\\t\\\")\\n\\t\\t\\tdb_file.write(\\\"\\\\n\\\")\\n\\n\\t\\tdb_file.close()\\n\\n\\t\\t#######################################################################################################\\n\\n\\t\\t# Last print for user\\n\\t\\tprint \\\"\\\\n[AP]\\\\tTask Finished, closing.\\\\n\\\"\\n\\telse:\\n\\t\\tprint \\\"\\\\n[AP]\\\\tThe dataset is not in the reference DB. Skipped.\\\\n\\\"\\n\\n\\treturn 0\",\n \"def __init__(self, raw_data_file,):\\n self.raw_data_file = raw_data_file\\n self.clean_data = self.cleanData()\\n self.microtrip_data = []\",\n \"def Basic_Stat(self):\\n out_file = \\\"%s/01.%s.BasicInfo_QC_map_SpikeIn.xls\\\" % (self.dir_StatInfo, self.s_idx)\\n f_out_file = open( out_file,\\\"w\\\" )\\n \\n l_info = [\\n \\\"Rename\\\", \\\"Raw_Reads\\\", \\\"Clean_Reads\\\",\\n \\\"Pre_Map_Reads\\\", \\\"Aligned_Reads\\\", \\\"HTSseq_Known_Reads\\\",\\n \\\"HTSeq_Refseq_Reads\\\",\\n \\\"ERCC_Reads\\\",\\n \\\"ERCC_Mols\\\"\\n ]\\n if not self.given_GTF:\\n l_info = [\\n \\\"Rename\\\", \\\"Raw_Reads\\\", \\\"Raw_bases\\\", \\\"Clean_Reads\\\", \\\"Clean_bases\\\", \\\"Q20(%)\\\",\\\"Q30(%)\\\",\\\"GC content(%)\\\",\\n \\\"Pre_Map_Reads\\\", \\\"Aligned_Reads\\\", \\\"MappingRate\\\",\\n \\\"ERCC_Reads\\\",\\n \\\"ERCC_Mols\\\"\\n ]\\n \\n \\n out_info = \\\"\\\\t\\\".join(l_info)\\n\\n print >>f_out_file, out_info\\n\\n l_brief = self.samInfo_pd_RNA['brief_name']\\n\\n ### Load HTSeq reads\\n HTS_info = m_cnt.CountInfo(\\n self.s_idx,\\n self.dir_mergeCout,\\n# l_brief,\\n# \\\"umi_clean_gene\\\",\\n# self.dir_mergeCout\\n )\\n HTS_info.load_mat(gen_col=1, generate = 0)\\n HTS_info.sam_tot_reads()\\n \\n ### Split refseq reads into RefSeq gene, lncGenes and novo genes.\\n# self.__get_HTS_clean_split()\\n \\n# ### Load HTSeq refseq reads\\n# Refseq_info = m_cnt.CountInfo(\\n# self.s_idx,\\n# self.dir_mergeCout,\\n# l_brief,\\n# \\\"dexseq_clean_refseq\\\",\\n# self.dir_mergeCout\\n# )\\n# Refseq_info.load_mat(gen_col=1, generate = 0)\\n# Refseq_info.sam_tot_reads()\\n \\n# ### Load HTSeq lncRNA reads\\n# lncRNA_info = m_cnt.CountInfo(\\n# self.s_idx,\\n# self.dir_mergeCout,\\n# l_brief,\\n# \\\"dexseq_clean_lncRNA\\\",\\n# self.dir_mergeCout\\n# )\\n# lncRNA_info.load_mat(gen_col=1, generate = 0)\\n# lncRNA_info.sam_tot_reads()\\n\\n ### Load HTSeq novo-gene reads\\n# if not self.given_GTF:\\n# NeoPass_info = m_cnt.CountInfo(\\n# self.s_idx,\\n# self.dir_mergeCout,\\n# l_brief,\\n# \\\"dexseq_NeoPass\\\",\\n# self.dir_mergeCout\\n# )\\n# NeoPass_info.load_mat(gen_col=1, generate = 0)\\n# NeoPass_info.sam_tot_reads()\\n \\n \\n \\\"\\\"\\\"\\n Load other information\\n \\\"\\\"\\\"\\n for samp in self.samInfo_pd_RNA['sample']:\\n idx = (self.samInfo_pd_RNA['sample'] == samp)\\n brief_name = self.samInfo_pd_RNA[idx]['brief_name'].values[0]\\n rename = self.samInfo_pd_RNA[idx]['rename'].values[0]\\n data_type = self.samInfo_pd_RNA[ idx ]['end_type'].values[0]\\n QC_log = \\\"%s/%s/%s.QC.log\\\" % (self.dir_clean_data, samp, samp)\\n \\n Tophat_log = \\\"%s/%s/align_summary.txt\\\" %\\\\\\n (self.dir_tophat, brief_name)\\n \\n HTSeq_SpikeIn = \\\"%s/%s/%s.dexseq_ERCC_RGCPloyA.txt\\\" %\\\\\\n (self.dir_HTS_known, brief_name, brief_name)\\n \\n QcStat_info = Stat.QcStat(QC_log)\\n MapStat_info = Stat.TophatStat(Tophat_log)\\n SpikeIn_info = Stat.SpikeIn(HTSeq_SpikeIn, self.ercc_info_file)\\n \\n \\n QcStat_info.read_infile()\\n MapStat_info.read_infile()\\n SpikeIn_info.load_HTS_file()\\n \\n pre_map_read = MapStat_info['statInfo']['totalRead']\\n aligned_read = MapStat_info['statInfo']['mappedRead']\\n mappingRate = MapStat_info['statInfo']['mappingRate']\\n \\n if data_type == \\\"PE\\\": \\n HTSseq_read = self.__get_HTS_reads(HTS_info ,samp) * 2\\n Refseq_read = self.__get_HTS_reads(Refseq_info ,samp) * 2\\n lncRNA_read = self.__get_HTS_reads(lncRNA_info ,samp) * 2\\n NeoPass_read = 0\\n if not self.given_GTF:\\n NeoPass_read = self.__get_HTS_reads(NeoPass_info,samp) * 2\\n read_RFP = SpikeIn_info.RGC_count['RGC-mRFP'] * 2\\n read_GFP = SpikeIn_info.RGC_count['RGC-GFP' ] * 2\\n read_CRE = SpikeIn_info.RGC_count['RGC-CRE' ] * 2\\n read_ERCC = SpikeIn_info.ERCC_total * 2\\n else:\\n HTSseq_read = self.__get_HTS_reads(HTS_info ,samp)\\n# Refseq_read = self.__get_HTS_reads(Refseq_info ,samp)\\n# lncRNA_read = self.__get_HTS_reads(lncRNA_info ,samp)\\n# if not self.given_GTF:\\n# NeoPass_read = self.__get_HTS_reads(NeoPass_info,samp)\\n\\n# read_RFP = SpikeIn_info.RGC_count['RGC-mRFP']\\n# read_GFP = SpikeIn_info.RGC_count['RGC-GFP' ]\\n# read_CRE = SpikeIn_info.RGC_count['RGC-CRE' ]\\n read_ERCC = SpikeIn_info.ERCC_total\\n# \\n# mol_RFP = self.samInfo_pd_RNA[idx]['RFP_polyA'].values[0]\\n# mol_GFP = self.samInfo_pd_RNA[idx]['GFP_polyA'].values[0]\\n# mol_CRE = self.samInfo_pd_RNA[idx]['CRE_polyA'].values[0]\\n mol_ERCC = self.samInfo_pd_RNA[idx]['ERCC_time'].values[0] *\\\\\\n 6.023*10**10\\n\\n l_out = [\\n rename,\\n QcStat_info.raw_reads, QcStat_info.cln_reads,\\n pre_map_read, aligned_read, HTSseq_read,\\n read_ERCC,\\n mol_ERCC\\n ]\\n if not self.given_GTF:\\n l_out = [\\n rename,\\n QcStat_info.raw_reads,QcStat_info.raw_bases, QcStat_info.cln_reads,QcStat_info.cln_bases ,QcStat_info.Q20_l_rate ,QcStat_info.Q30_l_rate ,QcStat_info.GC_l_rate,\\n pre_map_read, aligned_read, mappingRate,\\n read_ERCC,\\n mol_ERCC\\n ]\\n l_out = [str(i) for i in l_out]\\n print >>f_out_file, \\\"\\\\t\\\".join(l_out)\\n \\n f_out_file.close()\",\n \"def _process_data(self):\\r\\n # Rename columns to match final feature class\\r\\n self._rename_columns()\\r\\n # Add point ID column\\r\\n self._add_pointid()\\r\\n # Sort rows by transect id and timestamp\\r\\n self._sort_rows()\\r\\n # Fill Null records with a value\\r\\n self._fill_nulls()\\r\\n # Set site_code to lower case\\r\\n self._lower_site_code()\\r\\n # Create survey_id\\r\\n self._calc_survey_id()\\r\\n # Calculate nativesg column if at least one of the veg columns is a Native seagrass type\\r\\n if set(self.veg_columns).intersection(set(NATIVESG_CODES)) > 0:\\r\\n self.nativesg_columns = list(set(self.veg_columns).intersection(set(NATIVESG_CODES)))\\r\\n self._calc_nativesg()\\r\\n #\\r\",\n \"def dataLoad():\\n try:\\n try: #Python3\\n f = open(__file__ + \\\".csv\\\",\\\"rt\\\")\\n except: #Python2\\n f = open(__file__ + \\\".csv\\\",\\\"rb\\\")\\n data = f.read().split(',')\\n entryCol.entry0.delete(0,END)\\n entryCol.entry0.insert(0,data[0])\\n entryCol.entry1.delete(0,END)\\n entryCol.entry1.insert(0,data[1])\\n entryCol.entry2.delete(0,END)\\n entryCol.entry2.insert(0,data[2])\\n entryCol.entry3.delete(0,END)\\n entryCol.entry3.insert(0,data[3])\\n botWind.writeN(\\\"DataLoad: File\\\")\\n except:\\n botWind.writeN(\\\"DataLoad: Default\\\")\",\n \"def process_data(rows, options):\\n cohort = int(options.cohort)\\n id_expiry = PHASE_END_DATES[cohort][4]\\n for row in rows:\\n new_student = Person()\\n for k, v in row.items():\\n setattr(new_student, k, v)\\n new_student.student_cohort = cohort\\n new_student.id_expiry = id_expiry\\n if options.section:\\n new_student.student_sec_phase1 = options.section\\n if options.add:\\n new_student.save()\\n print \\\"Saved:\\\", new_student\",\n \"def main():\\n #find sys args and handle appropriately\\n argv = sys.argv\\n if(len(argv) != 2):\\n print(\\\"Invalid number of input strings.\\\")\\n print(\\\"Usage: python mdc.py [inputfile]\\\")\\n else:\\n #run the IO script, expect out a list of lists, etc..\\n data = CSVIO.readDataCSV(argv[1])\\n #create a list of classNames from the data, trim/convert as necessary\\n classNames = data[0][1:]\\n try:\\n while(True):\\n classNames.remove('')\\n except ValueError:\\n pass\\n try:\\n classNames = [item.split('=')[1] for item in classNames]\\n except IndexError as ie:\\n print(\\\"I've failed you Dr. Weiss...\\\")\\n #declare/init our class with proper values\\n pc = training.PatternClassifier(data[0][0], len(classNames), classNames, len(data[1][2:]), \\\\\\n data[1][2:], len(data[2:]), data[2:])\\n #run the training data with leaving out i for our test on each sample\\n for i in range(0, pc.nSamples):\\n pc.train(i)\\n #output to console/file\\n print(pc)\\n CSVIO.writeToFile(argv[1], pc)\",\n \"def lcia_methods__metadata(self):\\r\\n with UnicodeReader(os.path.join(dirpath, \\\"categoryUUIDs.csv\\\"), \\r\\n encoding='latin-1', \\r\\n delimiter=dt) as csv_file:\\r\\n next(csv_file) \\r\\n csv_data = [{'name': (line[0], line[2], line[4]),\\r\\n 'description': line[7]\\r\\n } for line in csv_file]\\r\\n \\r\\n filename = \\\"LCIA_implementation_2019.xlsx\\\" # this was donwloaded and updated on Oct 2019 from ecoinvent website. \\r\\n wb = xlrd.open_workbook(os.path.join(dirpath, filename))\\r\\n #characterizaton factors\\r\\n sheet= wb.sheet_by_name(\\\"CFs\\\")\\r\\n cf_data = [{\\r\\n 'method': (sheet.cell(row, 0).value,\\r\\n sheet.cell(row, 1).value,\\r\\n sheet.cell(row, 2).value),\\r\\n 'name': sheet.cell(row, 3).value,\\r\\n 'categories': (sheet.cell(row, 4).value, sheet.cell(row, 5).value),\\r\\n 'amount': sheet.cell(row, 7).value\\r\\n }\\r\\n for row in range(1, sheet.nrows)\\r\\n if sheet.cell(row, 0).value not in \\r\\n {'selected LCI results, additional', 'selected LCI results'} and isinstance(sheet.cell(row, 7).value, Number)]\\r\\n #units\\r\\n sheet= wb.sheet_by_name(\\\"units\\\")\\r\\n units = {(sheet.cell(row, 0).value, sheet.cell(row, 1).value, \\r\\n sheet.cell(row, 2).value): sheet.cell(row, 4).value for row in range(1, sheet.nrows)}\\r\\n return csv_data, cf_data, units, filename\",\n \"def run(self):\\n\\n # How to retrieve your input data.\\n input_1_data = self.in_data['input_1']\\n\\n # How to retrieve your params value.\\n param_1 = self.param['param_1']\\n\\n # How to process data.\\n # Just write any number of methods you want and use them here.\\n sample_out_data = self.sample_method(input_1_data, param_1)\\n\\n # Go to the definition of this method to see how to log.\\n self.demo_log()\\n\\n # This is how to set output data.\\n self.out_data['output_1'] = sample_out_data\",\n \"def perform_process(transformer: transformer_class.Transformer, check_md: dict) -> dict:\\n # Process each CSV file into BETYdb\\n start_timestamp = datetime.datetime.now()\\n files_count = 0\\n files_csv = 0\\n lines_read = 0\\n error_count = 0\\n files_loaded = []\\n for one_file in check_md['list_files']():\\n files_count += 1\\n if os.path.splitext(one_file)[1].lower() == '.csv':\\n files_csv += 1\\n\\n # Make sure we can access the file\\n if not os.path.exists(one_file):\\n msg = \\\"Unable to access csv file '%s'\\\" % one_file\\n logging.debug(msg)\\n return {'code': -1000,\\n 'error': msg}\\n\\n try:\\n # Read in the lines from the file\\n with open(one_file, 'r') as in_file:\\n reader = csv.DictReader(in_file)\\n files_loaded.append(one_file)\\n for row in reader:\\n centroid_lonlat = [row['lon'], row['lat']]\\n time_fmt = row['dp_time']\\n timestamp = row['timestamp']\\n dp_metadata = {\\n \\\"source\\\": row['source'],\\n \\\"value\\\": row['value']\\n }\\n trait = row['trait']\\n\\n __internal__.create_datapoint_with_dependencies(transformer.args.clowder_url, transformer.args.clowder_key,\\n trait, (centroid_lonlat[1], centroid_lonlat[0]), time_fmt,\\n time_fmt, dp_metadata, timestamp)\\n lines_read += 1\\n\\n except Exception:\\n logging.exception(\\\"Error reading CSV file '%s'. Continuing processing\\\", os.path.basename(one_file))\\n error_count += 1\\n\\n if files_csv <= 0:\\n logging.info(\\\"No CSV files were found in the list of files to process\\\")\\n if error_count > 0:\\n logging.error(\\\"Errors were found during processing\\\")\\n return {'code': -1001, 'error': \\\"Too many errors occurred during processing. Please correct and try again\\\"}\\n\\n return {\\n 'code': 0,\\n configuration.TRANSFORMER_NAME: {\\n 'version': configuration.TRANSFORMER_VERSION,\\n 'utc_timestamp': datetime.datetime.utcnow().isoformat(),\\n 'processing_time': str(datetime.datetime.now() - start_timestamp),\\n 'num_files_received': str(files_count),\\n 'num_csv_files': str(files_csv),\\n 'lines_loaded': str(lines_read),\\n 'files_processed': str(files_loaded)\\n }\\n }\",\n \"def __init__(self, path):\\n with open(path, 'r') as bt:\\n self.headers = bt.readline().split(',')\\n self.data = []\\n for line in bt:\\n self.data.append(list(eval(line)))\\n self.scores = []\\n self.models = {'dtr': DecisionTreeRegressor(),\\n 'br': BaggingRegressor(n_jobs=-1),\\n 'rfr': RandomForestRegressor(n_jobs=-1),\\n }\",\n \"def getArguments(Comm):\\n input_dir=''\\n dataset=''\\n l=0.0\\n if len(Comm)==4:\\n input_dir=str(Comm[1])\\n dataset=str(Comm[2])\\n l=float(Comm[3])\\n else:\\n print \\\"To run this program you have to provide a training file, a test file, an output file and a smoothing parameter\\\"\\n print \\\"the chemicals must be integer indexed. This script read chemical feature files based on chemical index in integer\\\"\\n print \\\"example: python PRW_10cv.py /path/to/N1/L1to5/ N1L1to5 0.9\\\"\\n exit(1)\\n feature=get_feature()\\n RCRS=[]\\n TPR35=[]\\n for i in range(1,11):\\n #10cv for 1 to 10\\n trainfile=input_dir+\\\"train\\\"+str(i)+\\\".csv\\\"\\n Train=get_train(trainfile,feature)\\n\\n testfile=input_dir+\\\"test\\\"+str(i)+\\\".csv\\\"\\n \\n testrow=[]\\n testcol=[]\\n print \\\"Reading test instances : \\\",testfile\\n for line in open(testfile,\\\"r\\\").xreadlines():\\n z=line.strip().split(\\\",\\\")\\n chem=str(z[0])\\n prot=str(z[1])\\n testrow.append(chem)\\n testcol.append(prot)\\n rcrs=get_PRW_rcrs(feature,Train,zip(testrow,testcol),l)\\n tpr35=TPRbyRowRank(rcrs,35)\\n TPR35.append(tpr35)\\n RCRS=RCRS+rcrs\\n avgtpr35=np.average(TPR35)\\n semtpr35=(np.std(TPR35)/math.sqrt(len(TPR35)))\\n print \\\"Dataset=%s, Avg.TPR35=%s, S.E.M.TPR35=%s\\\"%(dataset,str(avgtpr35),str(semtpr35))\\n print TPR35\\n print \\\"Rank\\\\tTPR\\\"\\n for i in range(1,351):\\n tpr=TPRbyRowRank(RCRS,i)\\n print \\\"%s\\\\t%s\\\"%(str(i),str(tpr))\\n return\",\n \"def main(): \\n for info_hash_record in info_hashs:\\n get_and_save_bt_info(info_hash_record)\",\n \"def __init__(self):\\n with open(\\\"sat.json\\\", \\\"r\\\") as infile:\\n self._sat = json.load(infile)[\\\"data\\\"]\\n #Define the headers for the csv\\n self._headers = [\\\"DBN\\\", \\\"School Name\\\", \\\"Number of Test Takers\\\", \\\"Critical Reading Mean\\\", \\\"Mathematics Mean\\\", \\\"Writing Mean\\\"]\",\n \"def main():\\n df_path = './DuReader_reformatted/DuReader_for_dbCombinedPara500-150-sample10000.csv'\\n df = pd.read_csv(df_path, sep='\\\\t', index_col=0).dropna() # drop 2 nan question and 8 nan title\\n epoch = 5 # about 6 hours\\n total_time_list, back_end_time_list = get_time_avg(df['question'].tolist(), epoch)\\n df['time_avg'] = total_time_list\\n df['backend_time'] = back_end_time_list\\n new_df_path = os.path.splitext(df_path)[0] + '-whole-epoch-' + str(epoch) + '.csv'\\n df.to_csv(new_df_path, sep='\\\\t')\\n print('file successfully saved to ', new_df_path)\",\n \"def automated(a):\\n\\n try:\\n\\n lg.warning(\\\"user gave the input path/file as:\\\"+' '+str(a))\\n df=pd.read_excel(a)\\n lg.warning(\\\"data successfully loaded from the file/path\\\"+' '+str(a))\\n\\n lg.info(\\\"starting all the pre-processing done for the train dataset\\\")\\n\\n df.dropna(inplace=True)\\n lg.warning(\\\"successfully dropped all null values in the given dataset\\\")\\n\\n def change_into_datetime(col):\\n df[col]=pd.to_datetime(df[col])\\n\\n for i in ['Date_of_Journey','Dep_Time', 'Arrival_Time']:\\n change_into_datetime(i)\\n lg.info(\\\"successfully changed the required columns into datetime format\\\")\\n\\n df['journey_day']=df['Date_of_Journey'].dt.day\\n lg.info(\\\"successfully extracted day from Date_of_journey and creating a separate column for day\\\")\\n df['journey_month']=df['Date_of_Journey'].dt.month\\n lg.info(\\\"successfully extracted month from Date_of_Journey and creating a separate column for month\\\")\\n\\n def extract_hour(data,col):\\n data[col+'_hour']=data[col].dt.hour\\n def extract_min(data,col):\\n data[col+'_min']=data[col].dt.minute\\n def drop_col(data,col):\\n data.drop(col,axis=1,inplace=True)\\n\\n\\n extract_hour(df,'Dep_Time')\\n lg.info(\\\"successfully extracted hours from Dep_Time and dumped the data into new column Dep_Time_hour\\\")\\n extract_min(df,'Dep_Time')\\n lg.info(\\\"successfully extracted minutes from Dep_Time and dumped the data into new column Dep_Time_min\\\")\\n drop_col(df,'Dep_Time')\\n lg.warning(\\\"dropping the original Dep_Time column as we extracted the values form that column\\\")\\n extract_hour(df,'Arrival_Time')\\n lg.info(\\\"successfully extracted hours from Arrival_Time and dumped the data into new column Arrival_Time_hour\\\")\\n extract_min(df,'Arrival_Time')\\n lg.info(\\\"successfully extracted min from Arrival_Time and dumped the data into new column Arrival_Time_min\\\")\\n drop_col(df,'Arrival_Time')\\n lg.warning(\\\"dropping the original Arrival_Time column as we extracted the values form that column\\\")\\n\\n duration = list(df[\\\"Duration\\\"])\\n\\n for i in range(len(duration)):\\n if len(duration[i].split()) != 2:\\n if \\\"h\\\" in duration[i]:\\n duration[i] = duration[i].strip() + \\\" 0m\\\"\\n else:\\n duration[i] = \\\"0h \\\" + duration[i]\\n\\n duration_hours = []\\n duration_mins = []\\n for i in range(len(duration)):\\n duration_hours.append(int(duration[i].split(sep = \\\"h\\\")[0]))\\n duration_mins.append(int(duration[i].split(sep = \\\"m\\\")[0].split()[-1]))\\n\\n df[\\\"Duration_hours\\\"] = duration_hours\\n lg.info(\\\"successfully extracted hours from Duration column and dumped the data into new column Duration_hours\\\")\\n df[\\\"Duration_mins\\\"] = duration_mins\\n lg.info(\\\"successfully extracted minutes from Duration column and dumped the data into new column Duration_mins\\\")\\n\\n df.drop([\\\"Date_of_Journey\\\",\\\"Duration\\\",\\\"Additional_Info\\\"], inplace=True,axis=1)\\n lg.warning(\\\"dropping the Date_of_Journey, Duration, Additional_Info columns as we extracted the required \\\"\\n \\\"information\\\")\\n\\n Airline=pd.get_dummies(df['Airline'],drop_first=True)\\n lg.info(\\\"creating dummy variables for Airline and dropping the first dummy column\\\")\\n\\n source=pd.get_dummies(df['Source'],drop_first=True)\\n lg.info(\\\"creating dummy variables for Source and dropping the first dummy column\\\")\\n\\n destination=pd.get_dummies(df['Destination'],drop_first=True)\\n lg.info(\\\"creating dummy variables for Destination and dropping the first dummy column\\\")\\n\\n dict={'non-stop':0, '2 stops':2, '1 stop':1, '3 stops':3, '4 stops':4}\\n df['Total_Stops']=df['Total_Stops'].map(dict)\\n lg.info(\\\"successfully mapped the Total_Stops column to 0,1,2,3,4 respectfully\\\")\\n\\n df=pd.concat([df, Airline, source, destination], axis = 1)\\n lg.warning(\\\"concatenating all the newly created columns into the main dataframe\\\")\\n\\n df.drop([\\\"Airline\\\", 'Source', 'Destination','Route'],inplace=True,axis=1)\\n lg.warning(\\\"dropping the categorical columns as we dummy encoded them\\\")\\n\\n df['Trujet']=0\\n lg.info(\\\"adding an extra column as this feature is not there in our test dataset\\\")\\n\\n\\n model = open('flight_rf.pkl','rb')\\n forest = pickle.load(model)\\n lg.info(\\\"loading our test model for prediction\\\")\\n\\n y_prediction = forest.predict(df)\\n lg.info(\\\"processing the prediction\\\")\\n\\n a=pd.DataFrame(y_prediction)\\n lg.info(\\\"dumping all our predicted values into a dataframe and showing the results\\\")\\n\\n print(a)\\n return a\\n\\n except Exception as e:\\n lg.warning(\\\"error occurred during execution, which is:\\\"+' '+str(e))\\n return \\\"error occurs is:\\\"+' '+str(e)\",\n \"def test():\\n\\n # todo: using 'analysisname' for group by, I think I can also use 'File Number'\\n statListDict = None # list of dict mapping human readbale to column names\\n masterDf = None\\n interfaceDefaults = None\\n\\n # machine learning db\\n if 0:\\n # this is from mac laptop\\n #path = '/Users/cudmore/data/laura-ephys/Superior vs Inferior database_master.csv'\\n path = '/Users/cudmore/data/laura-ephys/SANdatabaseForMachineLearning.xlsx'\\n analysisName = 'File Number'\\n #statListDict = None #sanpy.bAnalysisUtil.getStatList()\\n categoricalList = ['LOCATION', 'SEX', 'File Number']#, 'File Name']\\n hueTypes = ['LOCATION', 'SEX', 'File Number'] #, 'File Name'] #, 'None']\\n sortOrder = ['LOCATION', 'SEX', 'File Number']\\n\\n # sanpy database\\n if 0:\\n #import sanpy\\n #sys.path.append(os.path.join(os.path.dirname(sys.path[0]),'sanpy'))\\n #import bAnalysisUtil\\n #statListDict = bAnalysisUtil.statList\\n import statlist\\n statListDict = statlist.statList\\n\\n # this is from mac laptop\\n #path = '/Users/cudmore/data/laura-ephys/Superior vs Inferior database_master.csv'\\n path = '../examples/Superior vs Inferior database_master.csv'\\n path = '/Users/cudmore/data/laura-ephys/Superior_Inferior_database_master_jan25.csv'\\n path = '/Users/cudmore/data/laura-ephys/Superior vs Inferior database_master.csv'\\n path = '/Users/cudmore/data/laura-ephys/Superior vs Inferior database_master_20210402.csv'\\n\\n #path = 'data/Superior vs Inferior database_master_20210402.csv'\\n path = 'data/Superior vs Inferior database_master_20210402.csv'\\n #path = '/Users/cudmore/data/laura-ephys/Superior_Inferior_database_master_jan25.csv'\\n path = 'data/Superior vs Inferior database_13_Feb_master.csv'\\n analysisName = 'analysisname'\\n #statListDict = None #sanpy.bAnalysisUtil.getStatList()\\n categoricalList = ['include', 'condition', 'region', 'Sex', 'RegSex', 'File Number', 'analysisname']#, 'File Name']\\n hueTypes = ['region', 'sex', 'RegSex', 'condition', 'File Number', 'analysisname'] #, 'File Name'] #, 'None']\\n sortOrder = ['region', 'sex', 'condition']\\n\\n interfaceDefaults = {'Y Statistic': 'Spike Frequency (Hz)',\\n 'X Statistic': 'region',\\n 'Hue': 'region',\\n 'Group By': 'File Number'}\\n # bimpy database\\n if 0:\\n path = '../examples/edges_db.csv'\\n analysisName = 'fileNumber'\\n categoricalList = ['san', 'region', 'path', 'file', 'fileNumber', 'nCon']\\n hueTypes = categoricalList\\n sortOrder = ['san', 'region']\\n\\n # dualAnalysis database\\n if 0:\\n # grab our list of dict mapping human readable to .csv column names\\n sys.path.append(os.path.join(os.path.dirname(sys.path[0]),'sanpy'))\\n import bAnalysisUtil\\n statListDict = bAnalysisUtil.statList\\n\\n path = '/Users/cudmore/Sites/SanPy/examples/dual-analysis/dualAnalysis_final_db.csv'\\n analysisName = 'fileNumber' # # rows in .xlsx database, one recording per row\\n # trial is 1a/1b/1c... trial withing cellNumber\\n categoricalList = ['include', 'region', 'fileNumber', 'cellNumber', 'trial', 'quality']\\n hueTypes = categoricalList\\n sortOrder = ['region']\\n\\n # sparkmaster lcr database\\n if 0:\\n path = '/Users/cudmore/Sites/SanPy/examples/dual-analysis/lcr-database.csv'\\n analysisName = 'fileNumber' # # rows in .xlsx database, one recording per row\\n # trial is 1a/1b/1c... trial withing cellNumber\\n categoricalList = ['quality', 'region', 'fileNumber', 'dateFolder', 'tifFile']\\n hueTypes = categoricalList\\n sortOrder = ['region']\\n\\n # lcr/vm analysis using lcrPicker.py\\n if 0:\\n #basePath = '/Users/cudmore/Sites/SanPy/examples/dual-analysis/'\\n #path = basePath + 'dual-data/20210115/20210115__0002_lcrPicker.csv'\\n #path = basePath + 'dual-data/20210115/20210115__0001_lcrPicker.csv'\\n\\n # output of lcrPicker.py ... mergeDatabase()\\n path = '/Users/cudmore/Sites/SanPy/examples/dual-analysis/lcrPicker-db.csv'\\n categoricalList = None\\n hueTypes = None\\n analysisName= 'tifFile'\\n sortOrder = None\\n\\n # merged sanpy+lcr pre spike slope\\n # generated by dualAnalysis.py xxx()\\n # usnig to compare lcr slope to edddr for fig 9\\n if 0:\\n path = '/Users/cudmore/Sites/SanPy/examples/dual-analysis/combined-sanpy-lcr-db.csv'\\n statListDict = None\\n categoricalList = None\\n hueTypes = None\\n analysisName= 'filename'\\n sortOrder = None\\n\\n if 1:\\n path = 'data'\\n ad = sanpy.analysisDir(path, autoLoad=True)\\n for row in range(len(ad)):\\n ad.getAnalysis(row)\\n masterDf = ad.pool_build()\\n categoricalList = ['file', 'File Number']\\n hueTypes = ['file', 'File Number']\\n analysisName = 'file'\\n from sanpy.bAnalysisUtil import statList as statListDict\\n sortOrder = ['file', 'File Number']\\n interfaceDefaults = {'Y Statistic': 'Spike Frequency (Hz)',\\n 'X Statistic': 'Spike Number',\\n 'Hue': 'file',\\n 'Group By': 'file'}\\n\\n #\\n app = QtWidgets.QApplication(sys.argv)\\n\\n ex = bScatterPlotMainWindow(path, categoricalList, hueTypes,\\n analysisName, sortOrder, statListDict=statListDict,\\n masterDf = masterDf,\\n interfaceDefaults = interfaceDefaults)\\n ex.show()\\n\\n sys.exit(app.exec_())\",\n \"def main():\\n\\n house_path = '../../Data/wijk1_huizen.csv'\\n battery_path = '../../Data/wijk1_batterijen.txt'\\n\\n houses, batteries = read_data(house_path, battery_path)\\n\\n smart_wijk = SmartGrid(51,51)\\n smart_wijk.add_house_dictionaries(houses)\\n smart_wijk.add_battery_dictionaries(batteries)\\n\\n for element in houses:\\n smart_wijk.create_house(element['position'], element['output'])\\n for element in batteries:\\n smart_wijk.create_battery(element['position'], element['capacity'])\\n\\n solution_reader(smart_wijk, '../../Results/best_brabo_solution.csv')\",\n \"def _main(hgt_results_fp,\\n method):\\n\\n with open(hgt_results_fp, 'U') as input_f:\\n\\t if method == 'ranger-dtl':\\n\\t parse_rangerdtl(input_f=input_f)\\n\\t elif method == 'trex':\\n\\t parse_trex(input_f=input_f)\\n\\t elif method == 'riata-hgt':\\n\\t parse_riatahgt(input_f=input_f)\\n\\t elif method == 'jane4':\\n\\t parse_jane4(input_f=input_f)\\n\\t elif method == 'consel':\\n\\t parse_consel(input_f=input_f)\",\n \"def get_data(self, csv_file):\\n pass\",\n \"def new_csv_imp(infile):\\r\\n with open(infile, \\\"r\\\") as fd:\\r\\n txt = fd.readlines()\\r\\n if len(txt) > 1:\\r\\n if 'Serial' in txt[0]:\\r\\n print('{:} is Solinst'.format(infile))\\r\\n if 'UNIT: ' in txt[7]:\\r\\n level_units = str(txt[7])[5:].strip().lower()\\r\\n if 'UNIT: ' in txt[12]:\\r\\n temp_units = str(txt[12])[5:].strip().lower()\\r\\n f = pd.read_csv(infile, skiprows=13, parse_dates=[[0, 1]], usecols=[0, 1, 3, 4])\\r\\n print(f.columns)\\r\\n f['DateTime'] = pd.to_datetime(f['Date_Time'], errors='coerce')\\r\\n f.set_index('DateTime', inplace=True)\\r\\n f.drop('Date_Time', axis=1, inplace=True)\\r\\n f.rename(columns={'LEVEL': 'Level', 'TEMP': 'Temp'}, inplace=True)\\r\\n level = 'Level'\\r\\n temp = 'Temp'\\r\\n\\r\\n if level_units == \\\"feet\\\" or level_units == \\\"ft\\\":\\r\\n f[level] = pd.to_numeric(f[level])\\r\\n elif level_units == \\\"kpa\\\":\\r\\n f[level] = pd.to_numeric(f[level]) * 0.33456\\r\\n printmes(\\\"Units in kpa, converting {:} to ft...\\\".format(os.path.basename(infile)))\\r\\n elif level_units == \\\"mbar\\\":\\r\\n f[level] = pd.to_numeric(f[level]) * 0.0334552565551\\r\\n elif level_units == \\\"psi\\\":\\r\\n f[level] = pd.to_numeric(f[level]) * 2.306726\\r\\n printmes(\\\"Units in psi, converting {:} to ft...\\\".format(os.path.basename(infile)))\\r\\n elif level_units == \\\"m\\\" or level_units == \\\"meters\\\":\\r\\n f[level] = pd.to_numeric(f[level]) * 3.28084\\r\\n printmes(\\\"Units in psi, converting {:} to ft...\\\".format(os.path.basename(infile)))\\r\\n else:\\r\\n f[level] = pd.to_numeric(f[level])\\r\\n printmes(\\\"Unknown units, no conversion\\\")\\r\\n\\r\\n if temp_units == 'Deg C' or temp_units == u'\\\\N{DEGREE SIGN}' + u'C':\\r\\n f[temp] = f[temp]\\r\\n elif temp_units == 'Deg F' or temp_units == u'\\\\N{DEGREE SIGN}' + u'F':\\r\\n printmes('Temp in F, converting {:} to C...'.format(os.path.basename(infile)))\\r\\n f[temp] = (f[temp] - 32.0) * 5.0 / 9.0\\r\\n return f\\r\\n\\r\\n elif 'Date' in txt[1]:\\r\\n print('{:} is Global'.format(infile))\\r\\n f = pd.read_csv(infile, skiprows=1, parse_dates=[[0, 1]])\\r\\n # f = f.reset_index()\\r\\n f['DateTime'] = pd.to_datetime(f['Date_ Time'], errors='coerce')\\r\\n f = f[f.DateTime.notnull()]\\r\\n if ' Feet' in list(f.columns.values):\\r\\n f['Level'] = f[' Feet']\\r\\n f.drop([' Feet'], inplace=True, axis=1)\\r\\n elif 'Feet' in list(f.columns.values):\\r\\n f['Level'] = f['Feet']\\r\\n f.drop(['Feet'], inplace=True, axis=1)\\r\\n else:\\r\\n f['Level'] = f.iloc[:, 1]\\r\\n # Remove first and/or last measurements if the transducer was out of the water\\r\\n # f = dataendclean(f, 'Level')\\r\\n flist = f.columns.tolist()\\r\\n if ' Temp C' in flist:\\r\\n f['Temperature'] = f[' Temp C']\\r\\n f['Temp'] = f['Temperature']\\r\\n f.drop([' Temp C', 'Temperature'], inplace=True, axis=1)\\r\\n elif ' Temp F' in flist:\\r\\n f['Temperature'] = (f[' Temp F'] - 32) * 5 / 9\\r\\n f['Temp'] = f['Temperature']\\r\\n f.drop([' Temp F', 'Temperature'], inplace=True, axis=1)\\r\\n else:\\r\\n f['Temp'] = np.nan\\r\\n f.set_index(['DateTime'], inplace=True)\\r\\n f['date'] = f.index.to_julian_date().values\\r\\n f['datediff'] = f['date'].diff()\\r\\n f = f[f['datediff'] > 0]\\r\\n f = f[f['datediff'] < 1]\\r\\n # bse = int(pd.to_datetime(f.index).minute[0])\\r\\n # f = hourly_resample(f, bse)\\r\\n f.rename(columns={' Volts': 'Volts'}, inplace=True)\\r\\n f.drop([u'date', u'datediff', u'Date_ Time'], inplace=True, axis=1)\\r\\n return f\\r\\n else:\\r\\n print('{:} is unrecognized'.format(infile))\",\n \"def entry_parser():\\n # from tools import file_importer, file_outporter\\n from copy import copy\\n from collections import defaultdict\\n import os.path\\n \\n print(\\\"this is entry parser\\\")\\n \\n # inPathL = [\\\"bob/processed/proteinGroups - OST-1-09042017.txt\\\",\\\"bob/processed/proteinGroups_OST2.txt\\\",\\\"bob/processed/proteinGroups_OST3.txt\\\"]\\n inpathL = []\\n inpF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \\\"data\\\", \\\"cav1ko\\\", \\\"txt_cav1ko-1-17082017\\\", \\\"proteinGroups.txt\\\"),\\\"r\\\")\\n # outPath = \\\"bob/processed/OST-24-05-2017_combined.csv\\\"\\n fileCount = 1\\n # outF = file_outporter(outPath)\\n outF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \\\"data\\\", \\\"cav1ko\\\", \\\"processed\\\", \\\"cav1ko-1.csv\\\"),\\\"w\\\")\\n # newFlag = True\\n \\n finDict = defaultdict(list)\\n cN = 0\\n # for relPath in inPathL:\\n outDict = {}\\n # inpF = file_importer(relPath)\\n headerFlag = True\\n \\n for inpLine in inpF:\\n cN += 1\\n if headerFlag:\\n headerFlag = False\\n headerLine = inpLine\\n continue\\n inpLine = inpLine.strip(\\\"\\\\n\\\\r\\\")\\n inpItem = inpLine.split(\\\"\\\\t\\\")\\n geneL = inpItem[0].split(\\\";\\\")\\n lenS = len(geneL[0])\\n curGene = geneL[0]\\n for geneI in geneL: # find gene name with the shortest length\\n if len(geneI) < lenS:\\n lenS = len(geneI)\\n curGene = geneI\\n if \\\"__\\\" in curGene: continue # get rid of contaminant lines\\n try: # get rid of wonky lines introduced by excel\\n int(curGene)\\n continue\\n except ValueError: \\n pass\\n\\n if curGene[-2] == \\\"-\\\":\\n curGene = curGene[:-2]\\n if curGene[-3] == \\\"-\\\":\\n curGene = curGene[:-3]\\n \\n # remove ambiguities based on gene name from the entire entry:\\n \\n corrPos = geneL.index(curGene)\\n corrLine = []\\n targetCount = 46 # after the 45th item row in the list, peptide IDs and modification start to appear which are allowed to have multiple entries and do not need to be disambiguated\\n currCount = 1\\n pepFlag = True\\n for inpE in inpItem:\\n currCount += 1\\n if currCount == targetCount:\\n pepFlag = False\\n # print inpE\\n if \\\";\\\" in inpE and pepFlag:\\n try:\\n corrLine.append(inpE.split(\\\";\\\")[corrPos])\\n except IndexError:\\n corrLine.append(inpE.split(\\\";\\\")[0])\\n else:\\n corrLine.append(inpE.rstrip(\\\"\\\\n\\\"))\\n\\n \\n if inpItem[6] == \\\"\\\":\\n # print \\\"no protein name found. adding the uniprot ID.\\\"\\n inpItem[6] = curGene\\n \\n \\\"\\\"\\\"\\n try:\\n for inpN in inpItem[4:10]:\\n inpItem[inpItem.index(inpN)] = int(inpN)\\n countFlag = True\\n except ValueError:\\n print inpItem[4:10]\\n countFlag = False\\n if countFlag:\\n if sum(inpItem[4:10]) == 0: continue # there are some unexpressed proteins in there\\n \\n \\\"\\\"\\\"\\n # print len(corrLine)\\n if curGene in outDict: # handle duplicate protein entries and merge them together\\n # print \\\"%s is duplicate\\\" % curGene\\n if curGene == \\\"Protein IDs\\\": \\n \\\"\\\"\\\"\\n quickCount2 = 0\\n for quickDictI in outDict[curGene]:\\n print str(quickCount2) + \\\" \\\" + quickDictI\\n quickCount2 += 1\\n quickList = inpItem\\n quickCount3 = 0\\n for quickImp in quickList:\\n print str(quickCount3) + \\\" \\\" + quickImp\\n quickCount3 += 1 \\n # print inpItem\\n # print outDict[curGene]\\n \\\"\\\"\\\"\\n continue\\n combList = []\\n \\n \\\"\\\"\\\"\\n addL = []\\n for i in outDict[curGene][3:]:\\n addL.append(i)\\n addL2 = []\\n for j in corrLine[3:]:\\n addL2.append(i)\\n outL[3:] = map(add, addL, addL2) # admittedly this looks terrible\\n \\\"\\\"\\\"\\n \\n indexN = 0\\n for cItem in corrLine:\\n # print indexN\\n # print \\\"---\\\"\\n # print len(corrLine)\\n if indexN < 18 or 30 <= indexN <= 43:\\n try:\\n currC = int(cItem)\\n currC = currC + int(outDict[curGene][indexN]) # numbers like peptide counts or LFQ values are added up during merge\\n except ValueError:\\n currC = cItem\\n \\n elif 18 <= indexN <= 25 or 28 <= indexN <= 29: # sequence coverage and scores\\n currC = max([float(cItem),float(outDict[curGene][indexN])])\\n \\n elif 26 <= indexN <= 27 or indexN == 44:\\n \\\"\\\"\\\"\\n quickCount = 0\\n for corrItem in corrLine:\\n print str(quickCount) + \\\" \\\" + corrItem\\n quickCount += 1\\n \\n import time\\n \\n print relPath\\n print corrLine\\n print outDict[curGene]\\n print \\\"++++++++++++++++++++++++\\\"\\n print indexN\\n time.sleep(0.5)\\\"\\\"\\\"\\n currC = cItem\\n\\n \\n else:\\n corrL = cItem.split(\\\";\\\")\\n # print indexN\\n # print corrLine\\n # print outDict[curGene][indexN]\\n dictL = outDict[curGene][indexN].split(\\\";\\\")\\n mergeL = copy(dictL)\\n for corrI in corrL:\\n if corrI not in dictL:\\n mergeL.append(corrI)\\n \\n currC = \\\";\\\".join(mergeL)\\n\\n combList.append(currC)\\n\\n \\n indexN +=1\\n \\n \\n combList[-1] = \\\"merged\\\" \\n outDict[curGene] = combList \\n # print \\\"merged:\\\"\\n # print combList\\n else:\\n corrLine.append(\\\"unique\\\")\\n outDict[curGene] = corrLine\\n\\n \\n print(fileCount)\\n \\n\\n # if not newFlag: print fileCount, testKey, finDict[testKey] \\n # if newFlag:\\n # newFlag = False\\n \\n for outKey,outValue in list(outDict.items()): \\n if outKey in finDict: # add modified dicts together into single, unified dict\\n # print fileCount, finDict[outKey]\\n # print outValue\\n outIndex = 0\\n for outItem in outValue:\\n finDict[outKey][outIndex].append(outItem)\\n outIndex += 1\\n # print finDict[outKey]\\n\\n else: # or just add new entries\\n if fileCount == 1:\\n for outItem in outValue:\\n finDict[outKey].append([outItem])\\n \\n else: # fill up entries that were not present in the previous cycle\\n loopCount = 0\\n while loopCount < fileCount - 1:\\n for i in range(len(outValue)):\\n if len(finDict[outKey]) == i:\\n finDict[outKey].append([])\\n else:\\n finDict[outKey][i].append(\\\"\\\")\\n loopCount += 1\\n outIndex = 0\\n for outItem in outValue:\\n # print finDict[outKey]\\n finDict[outKey][outIndex].append(outItem) \\n outIndex += 1\\n\\n for testKey in finDict: # fill up entries in result dict which were not present in previous file\\n if len(finDict[testKey][0]) < fileCount:\\n for i in range(len(finDict[testKey])):\\n finDict[testKey][i].append(\\\"\\\")\\n\\n if len(inpathL) > 1: fileCount += 1 # this is needed if multiple files are parsed\\n for finK, finV in list(finDict.items()):\\n for finI in finV[-1]:\\n if finI != \\\"unique\\\" and finI != \\\"\\\":\\n print(finK, finV)\\n\\n \\n \\n outN = 0 \\n # prepare header for file:\\n headList = headerLine.strip(\\\"\\\\n\\\\r\\\").split(\\\"\\\\t\\\")\\n if fileCount > 1:\\n for headerItem in headList[:-1]:\\n headerI = headerItem.replace(\\\",\\\",\\\".\\\")\\n headerCount = 1\\n while headerCount < fileCount:\\n outF.write(headerI + \\\"-\\\" + str(headerCount) + \\\"|\\\")\\n headerCount += 1 \\n outF.write(headerI + \\\"-\\\" + str(headerCount) + \\\"\\\\t\\\")\\n \\n headerCount = 1\\n while headerCount < fileCount:\\n outF.write(headList[-1] + \\\"-\\\" + str(headerCount) + \\\"|\\\")\\n headerCount += 1\\n \\n outF.write(headList[-1] + \\\"-\\\" + str(headerCount) + \\\"\\\\n\\\")\\n\\n elif fileCount == 1:\\n for headerItem in headList[:-1]:\\n headerI = headerItem.replace(\\\",\\\",\\\".\\\") \\n outF.write(headerI + \\\"\\\\t\\\")\\n outF.write(headList[-1].replace(\\\",\\\",\\\".\\\") + \\\"\\\\n\\\")\\n \\n else:\\n print(\\\"number of input files should be at least one. Got less somehow\\\")\\n raise ValueError\\n \\n \\n for outDK, outDV in list(finDict.items()): # write out assembled results to a file\\n outN += 1\\n if len(outDK) > 30: print(\\\"this line should not be displayed\\\")\\n # print outDV[1]\\n # if outN == 100: break\\n nameCount = 0\\n for outI in outDV:\\n # if nameCount == 0: print outI\\n for outPiece in outI[:-1]:\\n outU = outPiece.replace(\\\",\\\",\\\".\\\")\\n if outU == \\\"\\\": outF.write(\\\"_|\\\")\\n else: outF.write(str(outU) + \\\"|\\\")\\n if outI[-1] == \\\"\\\": # handle missing entries\\n if nameCount == 6: outF.write(outDV[0][0] + \\\"\\\\t\\\") # replace missing gene names with their uniprot ID\\n else: outF.write(\\\"_\\\\t\\\")\\n else: outF.write(str(outI[-1]).replace(\\\",\\\",\\\".\\\") + \\\"\\\\t\\\")\\n nameCount += 1\\n outF.write(\\\"\\\\n\\\")\\n \\n\\n print(\\\"unique proteins: \\\", outN)\\n print(\\\"lines parsed: \\\", cN)\\n # print headerLine\\n inpF.close()\\n outF.close()\",\n \"def __init__(self, books_filename, authors_filename, books_authors_link_filename): \\n with open(books_filename, newline='') as booksFile:\\n books_reader = csv.reader(booksFile)\\n try:\\n bookArray = []\\n newBookArray = []\\n idCounter = 0\\n for row in books_reader:\\n newBookArray = [idCounter, row[0], int(row[1])]\\n bookArray.append(newBookArray)\\n idCounter = idCounter + 1\\n self.simpleBookArray = bookArray\\n except csv.Error as e:\\n sys.exit('file {}, line {}: {}'.format(books_filename, books_reader.line_num, e))\\n \\n \\\"\\\"\\\"\\n This function takes in the author_reader and puts the csv file into an array of arrays, in which\\n each \\\"author\\\" is defined as an inner array, and each inner array is organized like so:\\n [id, last name, first name, birth year, death year]\\n \\\"\\\"\\\" \\n with open(authors_filename, newline='') as authorsFile:\\n authors_reader = csv.reader(authorsFile)\\n try:\\n authorArray = []\\n newAuthorArray = []\\n for row in authors_reader:\\n if row[4] == \\\"NULL\\\":\\n endDate = None\\n else:\\n endDate = row[4]\\n if endDate == None:\\n newAuthorArray = [int(row[0]), row[1], row[2], int(row[3]), endDate]\\n else:\\n newAuthorArray = [int(row[0]), row[1], row[2], int(row[3]), int(row[4])]\\n authorArray.append(newAuthorArray)\\n self.simpleAuthorArray = authorArray\\n except csv.Error as e:\\n sys.exit('file {}, line {}: {}'.format(authors_filename, authors_reader.line_num, e))\\n \\n \\\"\\\"\\\"\\n This function takes in the link_reader and puts the csv file into an array of arrays, in which each\\n \\\"book\\\" is defined as an inner array, and each inner array is organized as the following:\\n [book id, author id]\\n \\\"\\\"\\\"\\n with open(books_authors_link_filename, newline='') as linkFile:\\n link_reader = csv.reader(linkFile)\\n try:\\n linkArray = []\\n newLinkArray = []\\n for row in link_reader:\\n newLinkArray = [int(row[0]), int(row[1])]\\n linkArray.append(newLinkArray)\\n self.simpleLinkArray = linkArray\\n except csv.Error as e:\\n sys.exit('file {}, line {}: {}'.format(books_authors_link_filename, link_reader.line_num, e))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6210108","0.60456717","0.60032433","0.5947413","0.5876277","0.58508295","0.58461136","0.5834677","0.57999545","0.57364744","0.5730089","0.57000756","0.5691697","0.5639754","0.5626317","0.56223726","0.55977935","0.55886185","0.5551414","0.55287653","0.5524884","0.55187","0.5513985","0.55032635","0.5498475","0.54731965","0.5472796","0.5467737","0.54560685","0.54558706","0.54397094","0.54364574","0.5428276","0.5419001","0.54149234","0.5402264","0.5395654","0.53759587","0.5375182","0.5374135","0.5362319","0.5356736","0.53558624","0.53501594","0.53432506","0.53431654","0.5340875","0.5340185","0.53375405","0.5336292","0.53341115","0.5332425","0.5331135","0.5330486","0.5329414","0.53203285","0.5317878","0.5316806","0.5308948","0.52977467","0.52965575","0.52812296","0.52785116","0.5275987","0.5267314","0.52643824","0.526198","0.5261966","0.5257718","0.52569747","0.5249602","0.5249341","0.52491367","0.52392966","0.52329713","0.5223758","0.52166265","0.5210268","0.5209754","0.5204013","0.52020174","0.5194606","0.51919633","0.5187404","0.5180995","0.5169925","0.51693857","0.51492596","0.51448596","0.5143506","0.5143429","0.5134071","0.5131802","0.5127097","0.51270884","0.5125235","0.51226175","0.5122234","0.51161546","0.51088417"],"string":"[\n \"0.6210108\",\n \"0.60456717\",\n \"0.60032433\",\n \"0.5947413\",\n \"0.5876277\",\n \"0.58508295\",\n \"0.58461136\",\n \"0.5834677\",\n \"0.57999545\",\n \"0.57364744\",\n \"0.5730089\",\n \"0.57000756\",\n \"0.5691697\",\n \"0.5639754\",\n \"0.5626317\",\n \"0.56223726\",\n \"0.55977935\",\n \"0.55886185\",\n \"0.5551414\",\n \"0.55287653\",\n \"0.5524884\",\n \"0.55187\",\n \"0.5513985\",\n \"0.55032635\",\n \"0.5498475\",\n \"0.54731965\",\n \"0.5472796\",\n \"0.5467737\",\n \"0.54560685\",\n \"0.54558706\",\n \"0.54397094\",\n \"0.54364574\",\n \"0.5428276\",\n \"0.5419001\",\n \"0.54149234\",\n \"0.5402264\",\n \"0.5395654\",\n \"0.53759587\",\n \"0.5375182\",\n \"0.5374135\",\n \"0.5362319\",\n \"0.5356736\",\n \"0.53558624\",\n \"0.53501594\",\n \"0.53432506\",\n \"0.53431654\",\n \"0.5340875\",\n \"0.5340185\",\n \"0.53375405\",\n \"0.5336292\",\n \"0.53341115\",\n \"0.5332425\",\n \"0.5331135\",\n \"0.5330486\",\n \"0.5329414\",\n \"0.53203285\",\n \"0.5317878\",\n \"0.5316806\",\n \"0.5308948\",\n \"0.52977467\",\n \"0.52965575\",\n \"0.52812296\",\n \"0.52785116\",\n \"0.5275987\",\n \"0.5267314\",\n \"0.52643824\",\n \"0.526198\",\n \"0.5261966\",\n \"0.5257718\",\n \"0.52569747\",\n \"0.5249602\",\n \"0.5249341\",\n \"0.52491367\",\n \"0.52392966\",\n \"0.52329713\",\n \"0.5223758\",\n \"0.52166265\",\n \"0.5210268\",\n \"0.5209754\",\n \"0.5204013\",\n \"0.52020174\",\n \"0.5194606\",\n \"0.51919633\",\n \"0.5187404\",\n \"0.5180995\",\n \"0.5169925\",\n \"0.51693857\",\n \"0.51492596\",\n \"0.51448596\",\n \"0.5143506\",\n \"0.5143429\",\n \"0.5134071\",\n \"0.5131802\",\n \"0.5127097\",\n \"0.51270884\",\n \"0.5125235\",\n \"0.51226175\",\n \"0.5122234\",\n \"0.51161546\",\n \"0.51088417\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6953013"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3296,"cells":{"query":{"kind":"string","value":"Run a raw GraphQL query"},"document":{"kind":"string","value":"def query(output, query):\n gqlapi = gql.get_api()\n print_output(output, gqlapi.query(query))"},"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 query_graphql(raw_query, endpoint):\n query = \" \".join(shlex.split(raw_query, posix=False))\n r = requests.get(endpoint, params={\"query\": query})\n if r.status_code == 200:\n return r.json()\n elif r.status_code == 400:\n response = r.json()\n assert \"errors\" in response\n raise GraphQLError(\"\".join([e[\"message\"] for e in response[\"errors\"]]))\n else:\n raise requests.exceptions.RequestException(\n f\"HTTP Status: {r.status_code}, Response Body: {r.text}\"\n )","def run_graphql(query: str, token: str):\n response = requests.post(\n 'https://api.github.com/graphql',\n json={'query': query},\n headers={'Authorization': 'Bearer ' + token})\n response.raise_for_status()\n return response.json()","def run_graphql_query(\n self,\n query,\n headers,\n status_code=200):\n request = requests.post(PH_API_URL, data=json.dumps(query), headers=headers)\n if request.status_code == status_code:\n return request.json()\n else:\n raise Exception(\n \"Unexpected status code returned: {}\".format(\n request.status_code)\n )","def raw_query(self, query: str):\n\n async def func():\n result = await LemkPgUtils.get_query_result(self.dsn, query)\n return result\n\n return self._run_async(func())","async def raw_query(self, query: str):\n result = await LemkPgUtils.get_query_result(self.dsn, query)\n return result","def raw_query(\n # TODO: Passing the whole clickhouse query here is needed as long\n # as the execute method depends on it. Otherwise we can make this\n # file rely either entirely on clickhouse query or entirely on\n # the formatter.\n clickhouse_query: Union[Query, CompositeQuery[Table]],\n request_settings: RequestSettings,\n formatted_query: FormattedQuery,\n reader: Reader,\n timer: Timer,\n query_metadata: SnubaQueryMetadata,\n stats: MutableMapping[str, Any],\n trace_id: Optional[str] = None,\n robust: bool = False,\n) -> QueryResult:\n all_confs = state.get_all_configs()\n query_settings: MutableMapping[str, Any] = {\n k.split(\"/\", 1)[1]: v\n for k, v in all_confs.items()\n if k.startswith(\"query_settings/\")\n }\n\n timer.mark(\"get_configs\")\n\n sql = formatted_query.get_sql()\n\n update_with_status = partial(\n update_query_metadata_and_stats,\n clickhouse_query,\n sql,\n timer,\n stats,\n query_metadata,\n query_settings,\n trace_id,\n )\n\n execute_query_strategy = (\n execute_query_with_readthrough_caching\n if state.get_config(\"use_readthrough_query_cache\", 1)\n else execute_query_with_caching\n )\n\n try:\n result = execute_query_strategy(\n clickhouse_query,\n request_settings,\n formatted_query,\n reader,\n timer,\n stats,\n query_settings,\n robust=robust,\n )\n except Exception as cause:\n if isinstance(cause, RateLimitExceeded):\n stats = update_with_status(QueryStatus.RATE_LIMITED)\n else:\n with configure_scope() as scope:\n if isinstance(cause, ClickhouseError):\n scope.fingerprint = [\"{{default}}\", str(cause.code)]\n if scope.span:\n if cause.code == errors.ErrorCodes.TOO_SLOW:\n sentry_sdk.set_tag(\"timeout\", \"predicted\")\n elif cause.code == errors.ErrorCodes.TIMEOUT_EXCEEDED:\n sentry_sdk.set_tag(\"timeout\", \"query_timeout\")\n elif cause.code in (\n errors.ErrorCodes.SOCKET_TIMEOUT,\n errors.ErrorCodes.NETWORK_ERROR,\n ):\n sentry_sdk.set_tag(\"timeout\", \"network\")\n elif isinstance(cause, (TimeoutError, ExecutionTimeoutError)):\n if scope.span:\n sentry_sdk.set_tag(\"timeout\", \"cache_timeout\")\n\n logger.exception(\"Error running query: %s\\n%s\", sql, cause)\n stats = update_with_status(QueryStatus.ERROR)\n raise QueryException(\n {\n \"stats\": stats,\n \"sql\": sql,\n \"experiments\": clickhouse_query.get_experiments(),\n }\n ) from cause\n else:\n stats = update_with_status(QueryStatus.SUCCESS)\n return QueryResult(\n result,\n {\n \"stats\": stats,\n \"sql\": sql,\n \"experiments\": clickhouse_query.get_experiments(),\n },\n )","def query(self, query: str, variables: Optional[Any] = None) -> Dict:\n resp = self.post(\"graphql\", json={\"query\": query, \"variables\": variables})\n if \"errors\" in resp:\n raise Exception(resp[\"errors\"][0][\"message\"])\n return resp[\"data\"]","def query(self, query, authorization_required=True):\n url = 'https://{}/api/v1/graphql'.format(self.host)\n headers = {\n 'Content-Type': 'application/json',\n }\n json = {\n 'query': query,\n }\n # Login if not yet done\n if authorization_required:\n if not self.authorized:\n self.login()\n if self.token:\n headers['Authorization'] = 'Bearer {}'.format(self.token)\n\n request = self.session.post(\n url, headers=headers, json=json,\n verify=self.verify)\n return request","def _run_query(self):","def run_query(self, query: str) -> BoltStatementResult:\n with self.neo4j_driver.driver.session() as session:\n return session.run(query)","async def run_query(query):\n async with httpx.AsyncClient(timeout=None) as client:\n response = await client.post(\n BLAZEGRAPH_URL,\n headers=BLAZEGRAPH_HEADERS,\n data=query,\n )\n assert response.status_code < 300\n return response.json()['results']['bindings']","def raw(self, query: Any, data: Any = None):\n raise NotImplementedError","def soql_query(self, query):\n self.builtin.log(\"Running SOQL Query: {}\".format(query))\n return self.cumulusci.sf.query_all(query)","def run_query(self):\n return _run_query(self.query)","def query():\n query = request.json.get('query')\n variables = request.json.get('variables') # Todo: add handling variables\n logger.debug('Query: %s', request.json)\n result = schema.execute(query)\n result_hash = format_result(result)\n return result_hash","def execute_gql_query(\n self, gql_name: str, **kwargs\n ) -> Union[dict, list, int]:\n self._query_type = \"query\"\n data = self._exec(gql_name, kwargs)\n return data","def query(self, query):","def run_sql(self, sql):\n def mk_run_sql_q(sql):\n return {\n 'type' : 'run_sql',\n 'args': {\n 'sql' : sql\n }\n }\n return self.v1q(mk_run_sql_q(sql))","def make_query(self):","def get_query():\n query = \"\"\"{\n repository(name: \"flux\", owner: \"fluxcd\") {\n forkCount\n issues {\n totalCount\n }\n pullRequests {\n totalCount\n }\n releases {\n totalCount\n }\n stargazers {\n totalCount\n }\n watchers {\n totalCount\n }\n }\n}\n \"\"\"\n return query","def raw(self, query: Any, data: Any = None):\n if data is None:\n data = {}\n assert isinstance(query, str)\n assert isinstance(data, (dict, None))\n\n return self.get_connection().execute(query, data)","def execute_graphql_request(\n schema, # type: GraphQLSchema\n params, # type: RequestParams\n allow_only_query=False, # type: bool\n backend=None, # type: GraphQLBackend\n **kwargs # type: Any\n):\n if not params.query:\n raise HttpQueryError(400, \"Must provide query string.\")\n\n try:\n if not backend:\n backend = get_default_backend()\n document = backend.document_from_string(schema, params.query)\n except Exception as e:\n return ExecutionResult(errors=[e], invalid=True)\n\n if allow_only_query:\n operation_type = document.get_operation_type(params.operation_name)\n if operation_type and operation_type != \"query\":\n raise HttpQueryError(\n 405,\n \"Can only perform a {} operation from a POST request.\".format(\n operation_type\n ),\n headers={\"Allow\": \"POST\"},\n )\n\n try:\n return document.execute(\n operation_name=params.operation_name, variables=params.variables, **kwargs\n )\n except Exception as e:\n return ExecutionResult(errors=[e], invalid=True)","def _raw(self, query: Any, data: Any = None):\n raise NotImplementedError","def sql(self, q):\r\n params = base.get_params(None, locals())\r\n url = '{0}/{1}'.format(self.get_url(), 'sql')\r\n\r\n return http.Request('POST', url, params), parsers.parse_json","async def _run_query(query, conn = None):\n # run() it if caller didn't do that already\n if not inspect.isawaitable(query):\n if not isinstance(query, r.RqlQuery):\n raise TypeError(\"query is neither awaitable nor a RqlQuery\")\n cn = conn or await db_conn\n query = query.run(cn)\n\n return await query","def test_raw_query(self):\n id = get_rand_string()\n prefix = get_rand_string()\n\n # Same data and user_id\n user_id = data = prefix + \"-\" + get_rand_string()\n\n self.conn.add(id=id, user_id=user_id, data=data)\n self.conn.commit()\n\n # Issue a prefix query, return data only (which should be equal\n # to user_id).\n response = self.conn.raw_query(q=\"user_id:%s*\" % prefix, fl=\"data\")\n\n # raw_query returns a string\n xml = parseString(response)\n\n doc_elem = xml.getElementsByTagName(\"doc\")\n\n self.assertEquals(len(doc_elem), 1,\n \"raw_query didn't return the document, id:%s, the response is:%s\" %\n (id, repr(response)))\n\n query_data = doc_elem[0].firstChild.firstChild.nodeValue\n\n self.assertEquals(query_data, data,\n (\"raw_query returned wrong value for data field, \"\n \"expected %s, got:%s\" % (data, query_data)))","def showGqlQuery(query):\n proto = query._proto_query\n kind = query._model_class.kind()\n filters = proto.filters()\n boundfilters = proto._GQL__bound_filters\n orderings = proto.orderings()\n hint = proto.hint()\n limit = proto.limit()\n offset = proto._GQL__offset\n\n select = \"SELECT * FROM %s\" % kind\n where = []\n order = []\n\n for k in sorted(filters):\n for clause in filters[k]:\n name, op = clause\n if name==-1: name = 'ANCESTOR'\n where.append(\"%s %s :%s\" % (name, op.upper(), k))\n\n for k in sorted(boundfilters):\n if isinstance(k, tuple):\n op = ' '.join(k)\n else:\n op = k\n where.append(\"%s %r\" % (op, boundfilters[k]))\n\n for p, o in orderings:\n order.append(\"%s %s\" % (p, 'DESC' if o==datastore.Query.DESCENDING else 'ASC'))\n\n gql = select\n if where:\n gql += ' WHERE '+' AND '.join(where)\n if order:\n gql += ' ORDER BY ' + ', '.join(order)\n if limit != -1:\n if offset != -1:\n gql += ' LIMIT %s,%s' % (offset,limit)\n else:\n gql += ' LIMIT %s' % limit\n elif offset != -1:\n gql += ' OFFSET %s' % offset\n return gql","def execute_graphql_request(\n self, request, data, query, variables, operation_name, show_graphiql=False\n ):\n if not query:\n if show_graphiql:\n return None\n raise HttpError(HttpResponseBadRequest(\"Must provide query string.\"))\n\n try:\n backend = self.get_backend(request)\n document = backend.document_from_string(self.schema, query)\n except Exception as e:\n return ExecutionResult(errors=[e], invalid=True)\n\n if request.method.lower() == \"get\":\n operation_type = document.get_operation_type(operation_name)\n if operation_type and operation_type != \"query\":\n if show_graphiql:\n return None\n\n raise HttpError(\n HttpResponseNotAllowed(\n [\"POST\"],\n \"Can only perform a {} operation from a POST request.\".format(\n operation_type\n ),\n )\n )\n\n # Check request weight\n try:\n if self.list_limit or self.weight_limit or self.depth_limit:\n if document:\n fragments = get_fragments(document.document_ast.definitions)\n definitions_total_weight = 0\n for definition in document.document_ast.definitions:\n if not isinstance(definition, OperationDefinition):\n continue\n\n if operation_name and definition.name != operation_name:\n continue\n\n def_weight = self.calculate_action_weight(\n definition.selection_set,\n fragments)\n definitions_total_weight += def_weight\n if self.weight_limit and definitions_total_weight > self.weight_limit:\n raise QueryWeightExceeded(\"Your query exceeds the maximum query weight allowed\")\n except Exception as e:\n return ExecutionResult(errors=[e], invalid=True)\n\n try:\n extra_options = {}\n if self.executor:\n # We only include it optionally since\n # executor is not a valid argument in all backends\n extra_options[\"executor\"] = self.executor\n\n return document.execute(\n root_value=self.get_root_value(request),\n variable_values=variables,\n operation_name=operation_name,\n context_value=self.get_context(request),\n middleware=self.get_middleware(request),\n **extra_options\n )\n except Exception as e:\n return ExecutionResult(errors=[e], invalid=True)","def _run_query(self, query):\n cursor = self.conn.cursor()\n cursor.execute(query)\n return cursor.fetchall()","def raw_as_qs(self, raw_query, params=()):\n cursor = connection.cursor()\n try:\n cursor.execute(raw_query, params)\n return self.filter(id__in=(x[0] for x in cursor))\n finally:\n cursor.close()","def execute_query(self, *, scope: Scope, params: QueryParams) -> QueryResults:","def sql_query(self, query_text, edges = False):\n q = QueryWrapper(self.graph, QueryString(query_text, 'sql'),\n edges = edges, debug = self._debug)\n return q","def query(self, query, request_type=None):\n\n #encode to UTF-8\n try: query = query.encode(\"utf-8\")\n except: query = query.decode('raw_unicode_escape').encode(\"utf-8\")\n\n lowercase_query = query.lower()\n if lowercase_query.startswith(\"select\") or \\\n lowercase_query.startswith(\"describe\") or \\\n lowercase_query.startswith(\"show\") or \\\n request_type==\"GET\":\n\n return self._get(urllib.urlencode({'sql': query}))\n\n else:\n return self._post(urllib.urlencode({'sql': query}))","def run_query(query, data_only=True):\n cmd = ['wp', 'db', 'query', '--skip-plugins', '--skip-themes', query]\n if data_only:\n cmd.append('--skip-column-names')\n return subprocess.check_output(cmd).decode('utf-8').strip()","def execute_query(self):\n try:\n # get query and templates\n query = self.request.data.get(\"query\", None)\n templates = self.request.data.get(\"templates\", \"[]\")\n registries = self.get_registries()\n order_by_field = self.request.data.get(\"order_by_field\", \"\")\n\n if order_by_field:\n order_by_field = order_by_field.split(\",\")\n\n if query is None:\n content = {\"message\": \"Query should be passed in parameter.\"}\n return Response(content, status=status.HTTP_400_BAD_REQUEST)\n\n # prepare query\n raw_query = self.build_query(query, templates, registries)\n # execute query\n data_list = self.execute_json_query(raw_query, order_by_field)\n # build and return response\n return self.build_response(data_list)\n\n except Exception as api_exception:\n content = {\"message\": str(api_exception)}\n return Response(\n content, status=status.HTTP_500_INTERNAL_SERVER_ERROR\n )","def query(self, *, sparql: str) -> Result:\n pass","def _raw(self, query: Any, data: Any = None):\n assert isinstance(query, str)\n\n conn = self._get_session()\n try:\n results = conn.execute(query)\n\n entity_items = []\n for item in results:\n entity = self.model_cls.to_entity(item)\n entity.state_.mark_retrieved()\n entity_items.append(entity)\n\n result = ResultSet(\n offset=0,\n limit=len(entity_items),\n total=len(entity_items),\n items=entity_items,\n )\n except DatabaseError as exc:\n logger.error(f\"Error while running raw query: {exc}\")\n raise\n finally:\n if not current_uow:\n conn.commit()\n conn.close()\n\n return result","async def _perform_query(self, query, login_token):\n data = {\"username\": self.user, \"query\": query.lower(), \"token\": login_token}\n return await self._perform_request(\"query\", data, lambda r: r.text())","def run_query(db, query):\n log.debug(\"run query on %s: %s\", db, query)\n conn = _connect(show_dbs(db)[db][\"uri\"])\n return conn.cursor().execute(query).fetchall()","def execute_sparql(client: NeptuneClient, query: str) -> pd.DataFrame:\n data = client.read_sparql(query)\n df = None\n if \"results\" in data and \"bindings\" in data[\"results\"]:\n df = pd.DataFrame(data[\"results\"][\"bindings\"])\n df.applymap(lambda x: x[\"value\"])\n else:\n df = pd.DataFrame(data)\n\n return df","def make_query(graph, ns, request_schema, response_schema):\n @graph.route(\"/v1/foo/get\", Operation.Query, ns)\n @qs(request_schema)\n @response(response_schema)\n def foo_query():\n \"\"\"\n My doc string\n \"\"\"\n request_data = load_query_string_data(request_schema)\n response_data = dict(\n result=True,\n value=request_data[\"required_value\"],\n )\n return dump_response_data(response_schema, response_data, Operation.Query.value.default_code)","def query(self):\n pass","def query(env):\n if app.config['ENABLE_QUERY']:\n envs = environments()\n check_env(env, envs)\n\n form = QueryForm(meta={\n 'csrf_secret': app.config['SECRET_KEY'],\n 'csrf_context': session})\n if form.validate_on_submit():\n if form.endpoints.data == 'pql':\n query = form.query.data\n elif form.query.data[0] == '[':\n query = form.query.data\n else:\n query = '[{0}]'.format(form.query.data)\n result = get_or_abort(\n puppetdb._query,\n form.endpoints.data,\n query=query)\n return render_template('query.html',\n form=form,\n result=result,\n envs=envs,\n current_env=env)\n return render_template('query.html',\n form=form,\n envs=envs,\n current_env=env)\n else:\n log.warn('Access to query interface disabled by administrator..')\n abort(403)","def generate_query(self):\n return","def run_query(\n self, project_id, partition_id, read_options=None, query=None, gql_query=None\n ):\n request_pb = _datastore_pb2.RunQueryRequest(\n project_id=project_id,\n partition_id=partition_id,\n read_options=read_options,\n query=query,\n gql_query=gql_query,\n )\n return _rpc(\n self.client._http,\n project_id,\n \"runQuery\",\n self.client._base_url,\n self.client._client_info,\n request_pb,\n _datastore_pb2.RunQueryResponse,\n )","def _run_query(self, inputs, state):\n in_shape = (self._query_batch,) + self._layer.input_shape\n queries = self._projection('Query', inputs, in_shape)\n return self._layer.apply(queries, list(state))","def query(self):","def query(self, **kwargs):","def execute_query(self, *args, **kwargs):","async def execute(entity, query: Union[ClauseElement, str], values: Union[List, Dict] = None) -> Any:\n return await uvicore.db.execute(query=query, values=values, connection=entity.__connection__)","def pp_query(query):\n print(format_query(query))","def run_http_query(\n schema, # type: GraphQLSchema\n request_method, # type: str\n data, # type: Union[Dict, List[Dict]]\n query_data=None, # type: Optional[Dict]\n batch_enabled=False, # type: bool\n catch=False, # type: bool\n **execute_options # type: Any\n):\n if not isinstance(schema, GraphQLSchema):\n raise TypeError(\"Expected a GraphQL schema, but received {!r}.\".format(schema))\n if request_method not in (\"get\", \"post\"):\n raise HttpQueryError(\n 405,\n \"GraphQL only supports GET and POST requests.\",\n headers={\"Allow\": \"GET, POST\"},\n )\n if catch:\n catch_exc = (\n HttpQueryError\n ) # type: Union[Type[HttpQueryError], Type[_NoException]]\n else:\n catch_exc = _NoException\n is_batch = isinstance(data, list)\n\n is_get_request = request_method == \"get\"\n allow_only_query = is_get_request\n\n if not is_batch:\n if not isinstance(data, (dict, MutableMapping)):\n raise HttpQueryError(\n 400, \"GraphQL params should be a dict. Received {!r}.\".format(data)\n )\n data = [data]\n elif not batch_enabled:\n raise HttpQueryError(400, \"Batch GraphQL requests are not enabled.\")\n\n if not data:\n raise HttpQueryError(400, \"Received an empty list in the batch request.\")\n\n extra_data = {} # type: Dict[str, Any]\n # If is a batch request, we don't consume the data from the query\n if not is_batch:\n extra_data = query_data or {}\n\n all_params = [get_graphql_params(entry, extra_data) for entry in data]\n\n executor = execute_options.get(\"executor\")\n response_executor = executor if executor else SyncExecutor()\n\n response_promises = [\n response_executor.execute(\n get_response, schema, params, catch_exc, allow_only_query, **execute_options\n )\n for params in all_params\n ]\n response_executor.wait_until_finished()\n\n results = [\n result.get() if is_thenable(result) else result for result in response_promises\n ]\n\n return ServerResults(results, all_params)","def _make_query(self):\r\n raise NotImplementedError()","def _send_gql_request(gateway_port):\n mutation = (\n f'mutation {{'\n + '''docs(data: {text: \"abcd\"}) { \n id \n } \n }\n '''\n )\n c = Client(host='localhost', port=gateway_port, protocol='http')\n return c.mutate(mutation=mutation)","def execute_query(query, params={}, transaction=True, context=\"\"):\r\n if transaction:\r\n query = \"g.stopTransaction(FAILURE)\\n\" + query\r\n\r\n # If we have no hosts available raise an exception\r\n if len(_hosts) <= 0:\r\n raise ThunderdomeConnectionError('Attempt to execute query before calling thunderdome.connection.setup')\r\n \r\n host = _hosts[0]\r\n #url = 'http://{}/graphs/{}/tp/gremlin'.format(host.name, _graph_name)\r\n data = json.dumps({'script':query, 'params': params})\r\n headers = {'Content-Type':'application/json', 'Accept':'application/json', 'Accept-Charset':'utf-8'}\r\n import time\r\n try:\r\n start_time = time.time()\r\n conn = httplib.HTTPConnection(host.name, host.port)\r\n conn.request(\"POST\", '/graphs/{}/tp/gremlin'.format(_graph_name), data, headers)\r\n response = conn.getresponse()\r\n content = response.read()\r\n\r\n total_time = int((time.time() - start_time) * 1000)\r\n\r\n if context and _statsd:\r\n _statsd.timing(\"{}.timer\".format(context), total_time)\r\n _statsd.incr(\"{}.counter\".format(context))\r\n\r\n\r\n except socket.error as sock_err:\r\n if _statsd:\r\n total_time = int((time.time() - start_time) * 1000)\r\n _statsd.incr(\"thunderdome.socket_error\".format(context), total_time)\r\n raise ThunderdomeQueryError('Socket error during query - {}'.format(sock_err))\r\n except:\r\n raise\r\n \r\n logger.info(json.dumps(data))\r\n logger.info(content)\r\n\r\n try:\r\n response_data = json.loads(content)\r\n except ValueError as ve:\r\n raise ThunderdomeQueryError('Loading Rexster results failed: \"{}\"'.format(ve))\r\n \r\n if response.status != 200:\r\n if 'message' in response_data and len(response_data['message']) > 0:\r\n graph_missing_re = r\"Graph \\[(.*)\\] could not be found\"\r\n if re.search(graph_missing_re, response_data['message']):\r\n raise ThunderdomeGraphMissingError(response_data['message'])\r\n else:\r\n raise ThunderdomeQueryError(\r\n response_data['message'],\r\n response_data\r\n )\r\n else:\r\n if _statsd:\r\n _statsd.incr(\"{}.error\".format(context))\r\n raise ThunderdomeQueryError(\r\n response_data['error'],\r\n response_data\r\n )\r\n\r\n return response_data['results']","def get_raw_query(self, row_id):\n cursor = self.connection.cursor()\n cursor.execute(\"\"\"\n SELECT raw_query FROM queries WHERE rowid=(?);\n \"\"\", (row_id,))\n return cursor.fetchone()[0]","def visit_query(self, query):\n return query","def query(self, query, initNs=None, initBindings=None, queryGraph=None, **kwargs):\n\n# r_queryType = pattern.search(query).group(\"prefixes\").upper()\n# print(r_queryType)\n uri = self.rest_services[\"repository\"]\n infer = kwargs.get('infer',None)\n #timeout = kwargs.get('timeout',\"0\")\n payload = {\"$\"+k: v.n3() for k,v in initBindings.items()}\n\n payload[\"infer\"] = self.infer if infer is None else infer\n payload[\"infer\"] = str(payload[\"infer\"]).lower()\n #payload[\"$\"+timeout]=0\n payload[\"query\"] = query\n r = requests.post(uri, data=payload,\n stream=True,\n headers= {\"Accept\" : \"application/sparql-results+json,application/trix\",\n 'connection': 'keep-alive',\n 'Accept-Encoding': 'gzip,deflate',\n \"Content-Type\" :\"application/x-www-form-urlencoded\"})\n\n r.raw.decode_content = True\n if r.headers['Content-Type'] == 'application/sparql-results+json;charset=UTF-8':\n return self.__make_result(r)\n elif r.headers['Content-Type'] == 'application/trix;charset=UTF-8':\n return self.__make_trix_generator__(r)\n else:\n raise ValueError(\"Response content type not parsable {r}\".format(r=r.text))","def execute_json_query(self, raw_query, order_by_field):\n return oai_record_api.execute_json_query(\n raw_query, self.request.user, order_by_field\n )","def executeQuery(payload, newQuery):\r\n\tq = newQuery.format(**payload)\r\n\tdb.query(q)\r\n\tdata = db.fetchall()\r\n\treturn data","def execute(query):\n print query\n cursor.execute(query)","def query(self) -> None:\n raise NotImplementedError()","def run_query(query):\n conn = connection.get_db_connection()\n cursor = conn.cursor()\n cursor.execute(query)\n return cursor","def query(self, q, *args):\n\n if self.dbtype == 'pg':\n print q\n return self.db.execute(q, *args).fetchall()\n else:\n cur = self.db.cursor()\n try:\n print q\n print args\n if args:\n cur.execute(q, args)\n else:\n cur.execute(q)\n ret = cur.fetchall()\n return ret\n except:\n self.db.rollback()\n raise\n finally:\n cur.close()","def _traced_graphql(func, _, args, kwargs):\n\n schema = args[0]\n\n # get the query as a string\n if len(args) > 1:\n request_string = args[1]\n else:\n request_string = kwargs.get('request_string')\n\n if isinstance(request_string, Document):\n query = request_string.loc.source.body\n else:\n query = request_string\n\n # allow schemas their own tracer with fall-back to the global\n tracer = getattr(schema, 'datadog_tracer', ddtrace.tracer)\n\n if not tracer.enabled:\n return func(*args, **kwargs)\n\n with tracer.trace(\n RES,\n span_type=TYPE,\n service=SERVICE,\n resource=_resolve_query_res(query)\n ) as span:\n span.set_tag(QUERY, query)\n result = None\n try:\n result = func(*args, **kwargs)\n return result\n finally:\n # `span.error` must be integer\n span.error = int(result is None or result.invalid)\n if result is not None:\n span.set_tag(ERRORS, result.errors)\n span.set_metric(INVALID, int(result.invalid))","def run_query(self, query, limit = None):\n if limit is not None:\n query += 'LIMIT ' + str(limit)\n query_job = self.bigquery_client.query(query) # API request\n return query_job.result() # Waits for query to finish","def execute_query():\n start_time = time.time()\n\n queries = request.json[\"queries\"]\n random_command = request.json[\"random_command\"]\n\n \"\"\" Running the queries against the pre-loaded index. \"\"\"\n output_dict = runner.run_queries(queries, random_command)\n\n \"\"\" Dumping the results to a JSON file. \"\"\"\n with open(output_location, 'w') as fp:\n json.dump(output_dict, fp)\n\n response = {\n \"Response\": output_dict,\n \"time_taken\": str(time.time() - start_time),\n \"username_hash\": username_hash\n }\n return flask.jsonify(response)","def test_psycopg_binary_query_works(instrument, postgres_connection, elasticapm_client):\n cursor = postgres_connection.cursor()\n query = b\"SELECT * FROM test WHERE name LIKE 't%'\"\n\n baked_query = query.decode()\n try:\n elasticapm_client.begin_transaction(\"web.django\")\n cursor.execute(query)\n result = cursor.fetchall()\n elasticapm_client.end_transaction(None, \"test-transaction\")\n finally:\n # make sure we've cleared out the spans for the other tests.\n assert [(2, \"two\"), (3, \"three\")] == result\n transactions = elasticapm_client.events[TRANSACTION]\n spans = elasticapm_client.spans_for_transaction(transactions[0])\n span = spans[0]\n assert span[\"name\"] == \"SELECT FROM test\"\n assert \"db\" in span[\"context\"]\n assert span[\"context\"][\"db\"][\"instance\"] == \"elasticapm_test\"\n assert span[\"context\"][\"db\"][\"type\"] == \"sql\"\n assert span[\"context\"][\"db\"][\"statement\"] == baked_query","def run_codeql_query(query, database, output, search_path):\n # --search-path is required when the CLI needs to upgrade the database scheme.\n subprocess_run([\"codeql\", \"query\", \"run\", query, \"--database\", database,\n \"--output\", output + \".bqrs\", \"--search-path\", search_path])\n subprocess_run([\"codeql\", \"bqrs\", \"decode\", output + \".bqrs\",\n \"--format=csv\", \"--no-titles\", \"--output\", output])\n os.remove(output + \".bqrs\")","def graphiql(request):\n del request\n graphiql_filepath = pathlib.Path(__file__).absolute().parent / \"graphiql.html\"\n with open(graphiql_filepath) as f:\n return django.http.response.HttpResponse(f.read())","def query(self, query):\n cursor = self.database.cursor()\n cursor.execute(query)\n # If it's a query that's expected to return a value (EG: SELECT)\n if query.strip().lower().startswith('select'): return cursor.fetchall()","def graphql_query(self, end_cursor, user_id) -> tuple[dict, list, tuple[str, bool]]:\n query_params = {\n 'query_hash': '8c2a529969ee035a5063f2fc8602a0fd',\n 'variables': json.dumps({\"id\":user_id,\"first\":8,\"after\":end_cursor})\n }\n\n url_post = 'https://www.instagram.com/graphql/query/'\n\n _, res_post = self.request_safe(url_post, params_request_safe=query_params)\n \n try:\n res_json = res_post.json()\n except json.JSONDecodeError:\n soup = BeautifulSoup(res_post.text, 'html.parser')\n elm = soup.find('div', attrs={'class':'error-container'})\n if not elm is None and \"Error\" in elm.text:\n raise Exception(elm.text)\n if res_post.json().get('message') == 'rate limited':\n raise Exception(res_post.json().get('message'))\n \n has_next_page = res_post.json()['data']['user']['edge_owner_to_timeline_media']['page_info']['has_next_page']\n end_cursor = res_post.json()['data']['user']['edge_owner_to_timeline_media']['page_info']['end_cursor']\n edges = res_post.json()['data']['user']['edge_owner_to_timeline_media']['edges']\n return (res_post.json(), edges, (end_cursor, has_next_page))","def query(\n self,\n statement, # type: str\n *options, # type: QueryOptions\n **kwargs # type: Any\n ) -> QueryResult:\n\n query = N1QLQuery.create_query_object(statement,\n *options,\n **kwargs)\n return QueryResult(N1QLRequest.generate_n1ql_request(self.connection,\n query.params,\n default_serializer=self.default_serializer))","def query(self, fieldname, value, *args, **kwargs):\n qg = self.schema.query_generator(fieldname)\n return qg(value, *args, **kwargs).connect(self)","def run_query(conn, query):\n\tcur = conn.cursor()\n\tcur.execute(query)\n\trows = cur.fetchall()\n\treturn rows","def construct_query(self):\n reader = QueryReader(filepath=self.filepath, filename=self.filename, raw_sql=self.raw_sql, params=self.params)\n return reader.sql","def __call__(self, data):\n return data.eval(self.query)","def _Dynamic_RunQuery(self, query, query_result, request_id=None):\n if query.has_transaction():\n if not query.has_ancestor():\n raise apiproxy_errors.ApplicationError(\n datastore_pb.Error.BAD_REQUEST,\n 'Only ancestor queries are allowed inside transactions.')\n (filters, orders) = datastore_index.Normalize(query.filter_list(),\n query.order_list(), [])\n \n old_datastore_stub_util.FillUsersInQuery(filters)\n\n if not query.has_app():\n query.set_app(self.project_id)\n self.__ValidateAppId(query.app())\n\n self._RemoteSend(query, query_result, \"RunQuery\", request_id)\n results = query_result.result_list()\n for result in results:\n old_datastore_stub_util.PrepareSpecialPropertiesForLoad(result)\n\n last_cursor = None\n if query_result.has_compiled_cursor():\n last_cursor = query_result.compiled_cursor()\n\n if query_result.more_results():\n new_cursor = InternalCursor(query, last_cursor, len(results))\n cursor_id = self.__getCursorID()\n cursor = query_result.mutable_cursor()\n cursor.set_app(self.project_id)\n cursor.set_cursor(cursor_id)\n self.__queries[cursor_id] = new_cursor\n\n if query.compile():\n compiled_query = query_result.mutable_compiled_query()\n compiled_query.set_keys_only(query.keys_only())\n compiled_query.mutable_primaryscan().set_index_name(query.Encode())","def do_query(self, query):\n query = query.replace('\\n', ' ')\n self.cursor.execute(query)\n return self.cursor.fetchall()","def pg_execute(pg_conn, sql):\n print sql\n # XXX execute command","def query(self, q, **kwargs):\n return self._client.query(self._db_name, q, **kwargs)","async def scalar(self, query, connection=None):\n async with self.connection(connection) as conn:\n r = await conn.execute(query)\n return await r.scalar()","def submit_query(self, username, password):\n\n #username = os.environ['NEWSREADER_USERNAME']\n #password = os.environ['NEWSREADER_PASSWORD']\n payload = {'id': self.query}\n \n endpoint_url = self.endpoint_stub_url.format(action=self.action)\n print \"\\n\\n**New CRUD query**\"\n print endpoint_url, payload\n t0 = time.time()\n try:\n response = requests.get(endpoint_url, auth=(username, password),\n params=payload)\n except Exception as e:\n print \"Query raised an exception\"\n print type(e)\n t1 = time.time()\n total = t1-t0\n raise QueryException(\"Query raised an exception: {0}\".format(type(e).__name__))\n else:\n t1 = time.time()\n total = t1-t0\n print \"Time to return from query: {0:.2f} seconds\".format(total)\n print \"Response code: {0}\".format(response.status_code)\n print \"From cache: {0}\".format(response.from_cache)\n\n #print response.content\n \n if response and (response.status_code == requests.codes.ok):\n self.json_result = {\"content\":response.content}\n self.clean_json = self.json_result\n else:\n raise QueryException(\"Response code not OK: {0}\".format(response.status_code))","def query(self):\r\n raise NotImplementedError","def swis_query_command(client: Client, args: Dict[str, Any]) -> CommandResults:\n query = args.get('query')\n if not query:\n raise ValueError(ERR_MSG['REQUIRED_ARGUMENT'])\n\n response = client.http_request(method=\"GET\", url_suffix=URL_SUFFIX[\"QUERY\"],\n params={\"query\": query})\n outputs = createContext(response.get(\"results\", []), removeNull=True)\n readable_response = convert_query_output_to_hr(outputs)\n return CommandResults(\n outputs_prefix=\"SolarWinds.Query\",\n outputs=outputs,\n readable_output=readable_response,\n raw_response=response\n )","def get_data_query(file_name):\n with open(file_name, 'r') as graphql_query:\n return graphql_query.read()","def runningwithqueries(query):\n print(\"\\nRunning Query: \" + str(query) + \"\\nResult :\\n\")\n crsr = cnxn.execute(query)\n columns = [column[0] for column in crsr.description]\n print(columns)\n for row in crsr.fetchall():\n print(row)\n crsr.close()","def gen_q_stmt(name, query):\n return \"query {} `{}`;\\n\".format(name, query)","def _handle_query(self, text, loop=False):\n \n # lazy complete\n text = line_add_lazy_return(text)\n text = line_add_lazy_describe(text)\n\n # RUN QUERY\n if not loop:\n res = self.dslobject.query(text)\n return res\n else:\n res = self.dslobject.query_iterative(text)\n return res","def inspect_query(query):\n return _parse_query(query)","def test_custom_query_basic(self):\n\n # Create a simple query statement a\n query = \"SELECT * FROM system.local\"\n statement = SimpleStatement(query)\n # Validate that various types of custom payloads are sent and received okay\n self.validate_various_custom_payloads(statement=statement)","def n1qlQueryAll(self, *args, **kwargs):\n if not self.connected:\n cb = lambda x: self.n1qlQueryAll(*args, **kwargs)\n return self.connect().addCallback(cb)\n\n kwargs['itercls'] = BatchedN1QLRequest\n o = super(RawBucket, self).n1ql_query(*args, **kwargs)\n o.start()\n return o._getDeferred()","def execute_all_templated(self, conn, query, *values, system=False):\n query_filled = query.format(*values)\n self.last_query=query_filled if not system else self.last_query\n queries = [item for item in query_filled.split(\";\") if item != \"\"]\n results = []\n if len(queries) > 1 and not system:\n self.health = Health.SICK\n self.message = \"SQL injection detected\"\n for query in queries:\n response = conn.execute(query + \";\")\n results.extend([item for item in response])\n return results","def execute(self, context):\n logging.info(f\"Running SQL :{self.sql}\")\n self.hook = TrinoHook()\n query = self.hook.run(self.sql, autocommit=self.autocommit, parameters=self.parameters)\n if self.xcom_push:\n return query","def query(self, block):\n raise NotImplementedError(\"Querying is an experimental feature\")","def run_query(cur, query, show_results=False):\n num_rows = cur.execute(query)\n print('the query returned {} rows'.format(num_rows))\n if show_results:\n for row in cur.fetchall():\n print(row)","def execute_query(\n # TODO: Passing the whole clickhouse query here is needed as long\n # as the execute method depends on it. Otherwise we can make this\n # file rely either entirely on clickhouse query or entirely on\n # the formatter.\n clickhouse_query: Union[Query, CompositeQuery[Table]],\n request_settings: RequestSettings,\n formatted_query: FormattedQuery,\n reader: Reader,\n timer: Timer,\n stats: MutableMapping[str, Any],\n query_settings: MutableMapping[str, Any],\n robust: bool,\n) -> Result:\n # Experiment, if we are going to grab more than X columns worth of data,\n # don't use uncompressed_cache in ClickHouse.\n uc_max = state.get_config(\"uncompressed_cache_max_cols\", 5)\n assert isinstance(uc_max, int)\n column_counter = ReferencedColumnsCounter()\n column_counter.visit(clickhouse_query.get_from_clause())\n if column_counter.count_columns() > uc_max:\n query_settings[\"use_uncompressed_cache\"] = 0\n\n # Force query to use the first shard replica, which\n # should have synchronously received any cluster writes\n # before this query is run.\n consistent = request_settings.get_consistent()\n stats[\"consistent\"] = consistent\n if consistent:\n query_settings[\"load_balancing\"] = \"in_order\"\n query_settings[\"max_threads\"] = 1\n\n result = reader.execute(\n formatted_query,\n query_settings,\n with_totals=clickhouse_query.has_totals(),\n robust=robust,\n )\n\n timer.mark(\"execute\")\n stats.update(\n {\"result_rows\": len(result[\"data\"]), \"result_cols\": len(result[\"meta\"])}\n )\n\n return result","def query(self, qpath):\n return data.Query(self, qpath)","def dbexecute(cxn, query, payload):\n\tcursor = cxn.cursor()\n\tif not payload:\n\t\tcursor.execute(query)\n\telse:\n\t\tcursor.execute(query, payload)","def doQuery(self, s):\n self.setQuery(s)\n\n try:\n rval = self.query()\n g = rval.convert()\n return g['results']['bindings']\n except:\n print \"doQuery failed\"\n traceback.print_exc(file=sys.stdout)"],"string":"[\n \"def query_graphql(raw_query, endpoint):\\n query = \\\" \\\".join(shlex.split(raw_query, posix=False))\\n r = requests.get(endpoint, params={\\\"query\\\": query})\\n if r.status_code == 200:\\n return r.json()\\n elif r.status_code == 400:\\n response = r.json()\\n assert \\\"errors\\\" in response\\n raise GraphQLError(\\\"\\\".join([e[\\\"message\\\"] for e in response[\\\"errors\\\"]]))\\n else:\\n raise requests.exceptions.RequestException(\\n f\\\"HTTP Status: {r.status_code}, Response Body: {r.text}\\\"\\n )\",\n \"def run_graphql(query: str, token: str):\\n response = requests.post(\\n 'https://api.github.com/graphql',\\n json={'query': query},\\n headers={'Authorization': 'Bearer ' + token})\\n response.raise_for_status()\\n return response.json()\",\n \"def run_graphql_query(\\n self,\\n query,\\n headers,\\n status_code=200):\\n request = requests.post(PH_API_URL, data=json.dumps(query), headers=headers)\\n if request.status_code == status_code:\\n return request.json()\\n else:\\n raise Exception(\\n \\\"Unexpected status code returned: {}\\\".format(\\n request.status_code)\\n )\",\n \"def raw_query(self, query: str):\\n\\n async def func():\\n result = await LemkPgUtils.get_query_result(self.dsn, query)\\n return result\\n\\n return self._run_async(func())\",\n \"async def raw_query(self, query: str):\\n result = await LemkPgUtils.get_query_result(self.dsn, query)\\n return result\",\n \"def raw_query(\\n # TODO: Passing the whole clickhouse query here is needed as long\\n # as the execute method depends on it. Otherwise we can make this\\n # file rely either entirely on clickhouse query or entirely on\\n # the formatter.\\n clickhouse_query: Union[Query, CompositeQuery[Table]],\\n request_settings: RequestSettings,\\n formatted_query: FormattedQuery,\\n reader: Reader,\\n timer: Timer,\\n query_metadata: SnubaQueryMetadata,\\n stats: MutableMapping[str, Any],\\n trace_id: Optional[str] = None,\\n robust: bool = False,\\n) -> QueryResult:\\n all_confs = state.get_all_configs()\\n query_settings: MutableMapping[str, Any] = {\\n k.split(\\\"/\\\", 1)[1]: v\\n for k, v in all_confs.items()\\n if k.startswith(\\\"query_settings/\\\")\\n }\\n\\n timer.mark(\\\"get_configs\\\")\\n\\n sql = formatted_query.get_sql()\\n\\n update_with_status = partial(\\n update_query_metadata_and_stats,\\n clickhouse_query,\\n sql,\\n timer,\\n stats,\\n query_metadata,\\n query_settings,\\n trace_id,\\n )\\n\\n execute_query_strategy = (\\n execute_query_with_readthrough_caching\\n if state.get_config(\\\"use_readthrough_query_cache\\\", 1)\\n else execute_query_with_caching\\n )\\n\\n try:\\n result = execute_query_strategy(\\n clickhouse_query,\\n request_settings,\\n formatted_query,\\n reader,\\n timer,\\n stats,\\n query_settings,\\n robust=robust,\\n )\\n except Exception as cause:\\n if isinstance(cause, RateLimitExceeded):\\n stats = update_with_status(QueryStatus.RATE_LIMITED)\\n else:\\n with configure_scope() as scope:\\n if isinstance(cause, ClickhouseError):\\n scope.fingerprint = [\\\"{{default}}\\\", str(cause.code)]\\n if scope.span:\\n if cause.code == errors.ErrorCodes.TOO_SLOW:\\n sentry_sdk.set_tag(\\\"timeout\\\", \\\"predicted\\\")\\n elif cause.code == errors.ErrorCodes.TIMEOUT_EXCEEDED:\\n sentry_sdk.set_tag(\\\"timeout\\\", \\\"query_timeout\\\")\\n elif cause.code in (\\n errors.ErrorCodes.SOCKET_TIMEOUT,\\n errors.ErrorCodes.NETWORK_ERROR,\\n ):\\n sentry_sdk.set_tag(\\\"timeout\\\", \\\"network\\\")\\n elif isinstance(cause, (TimeoutError, ExecutionTimeoutError)):\\n if scope.span:\\n sentry_sdk.set_tag(\\\"timeout\\\", \\\"cache_timeout\\\")\\n\\n logger.exception(\\\"Error running query: %s\\\\n%s\\\", sql, cause)\\n stats = update_with_status(QueryStatus.ERROR)\\n raise QueryException(\\n {\\n \\\"stats\\\": stats,\\n \\\"sql\\\": sql,\\n \\\"experiments\\\": clickhouse_query.get_experiments(),\\n }\\n ) from cause\\n else:\\n stats = update_with_status(QueryStatus.SUCCESS)\\n return QueryResult(\\n result,\\n {\\n \\\"stats\\\": stats,\\n \\\"sql\\\": sql,\\n \\\"experiments\\\": clickhouse_query.get_experiments(),\\n },\\n )\",\n \"def query(self, query: str, variables: Optional[Any] = None) -> Dict:\\n resp = self.post(\\\"graphql\\\", json={\\\"query\\\": query, \\\"variables\\\": variables})\\n if \\\"errors\\\" in resp:\\n raise Exception(resp[\\\"errors\\\"][0][\\\"message\\\"])\\n return resp[\\\"data\\\"]\",\n \"def query(self, query, authorization_required=True):\\n url = 'https://{}/api/v1/graphql'.format(self.host)\\n headers = {\\n 'Content-Type': 'application/json',\\n }\\n json = {\\n 'query': query,\\n }\\n # Login if not yet done\\n if authorization_required:\\n if not self.authorized:\\n self.login()\\n if self.token:\\n headers['Authorization'] = 'Bearer {}'.format(self.token)\\n\\n request = self.session.post(\\n url, headers=headers, json=json,\\n verify=self.verify)\\n return request\",\n \"def _run_query(self):\",\n \"def run_query(self, query: str) -> BoltStatementResult:\\n with self.neo4j_driver.driver.session() as session:\\n return session.run(query)\",\n \"async def run_query(query):\\n async with httpx.AsyncClient(timeout=None) as client:\\n response = await client.post(\\n BLAZEGRAPH_URL,\\n headers=BLAZEGRAPH_HEADERS,\\n data=query,\\n )\\n assert response.status_code < 300\\n return response.json()['results']['bindings']\",\n \"def raw(self, query: Any, data: Any = None):\\n raise NotImplementedError\",\n \"def soql_query(self, query):\\n self.builtin.log(\\\"Running SOQL Query: {}\\\".format(query))\\n return self.cumulusci.sf.query_all(query)\",\n \"def run_query(self):\\n return _run_query(self.query)\",\n \"def query():\\n query = request.json.get('query')\\n variables = request.json.get('variables') # Todo: add handling variables\\n logger.debug('Query: %s', request.json)\\n result = schema.execute(query)\\n result_hash = format_result(result)\\n return result_hash\",\n \"def execute_gql_query(\\n self, gql_name: str, **kwargs\\n ) -> Union[dict, list, int]:\\n self._query_type = \\\"query\\\"\\n data = self._exec(gql_name, kwargs)\\n return data\",\n \"def query(self, query):\",\n \"def run_sql(self, sql):\\n def mk_run_sql_q(sql):\\n return {\\n 'type' : 'run_sql',\\n 'args': {\\n 'sql' : sql\\n }\\n }\\n return self.v1q(mk_run_sql_q(sql))\",\n \"def make_query(self):\",\n \"def get_query():\\n query = \\\"\\\"\\\"{\\n repository(name: \\\"flux\\\", owner: \\\"fluxcd\\\") {\\n forkCount\\n issues {\\n totalCount\\n }\\n pullRequests {\\n totalCount\\n }\\n releases {\\n totalCount\\n }\\n stargazers {\\n totalCount\\n }\\n watchers {\\n totalCount\\n }\\n }\\n}\\n \\\"\\\"\\\"\\n return query\",\n \"def raw(self, query: Any, data: Any = None):\\n if data is None:\\n data = {}\\n assert isinstance(query, str)\\n assert isinstance(data, (dict, None))\\n\\n return self.get_connection().execute(query, data)\",\n \"def execute_graphql_request(\\n schema, # type: GraphQLSchema\\n params, # type: RequestParams\\n allow_only_query=False, # type: bool\\n backend=None, # type: GraphQLBackend\\n **kwargs # type: Any\\n):\\n if not params.query:\\n raise HttpQueryError(400, \\\"Must provide query string.\\\")\\n\\n try:\\n if not backend:\\n backend = get_default_backend()\\n document = backend.document_from_string(schema, params.query)\\n except Exception as e:\\n return ExecutionResult(errors=[e], invalid=True)\\n\\n if allow_only_query:\\n operation_type = document.get_operation_type(params.operation_name)\\n if operation_type and operation_type != \\\"query\\\":\\n raise HttpQueryError(\\n 405,\\n \\\"Can only perform a {} operation from a POST request.\\\".format(\\n operation_type\\n ),\\n headers={\\\"Allow\\\": \\\"POST\\\"},\\n )\\n\\n try:\\n return document.execute(\\n operation_name=params.operation_name, variables=params.variables, **kwargs\\n )\\n except Exception as e:\\n return ExecutionResult(errors=[e], invalid=True)\",\n \"def _raw(self, query: Any, data: Any = None):\\n raise NotImplementedError\",\n \"def sql(self, q):\\r\\n params = base.get_params(None, locals())\\r\\n url = '{0}/{1}'.format(self.get_url(), 'sql')\\r\\n\\r\\n return http.Request('POST', url, params), parsers.parse_json\",\n \"async def _run_query(query, conn = None):\\n # run() it if caller didn't do that already\\n if not inspect.isawaitable(query):\\n if not isinstance(query, r.RqlQuery):\\n raise TypeError(\\\"query is neither awaitable nor a RqlQuery\\\")\\n cn = conn or await db_conn\\n query = query.run(cn)\\n\\n return await query\",\n \"def test_raw_query(self):\\n id = get_rand_string()\\n prefix = get_rand_string()\\n\\n # Same data and user_id\\n user_id = data = prefix + \\\"-\\\" + get_rand_string()\\n\\n self.conn.add(id=id, user_id=user_id, data=data)\\n self.conn.commit()\\n\\n # Issue a prefix query, return data only (which should be equal\\n # to user_id).\\n response = self.conn.raw_query(q=\\\"user_id:%s*\\\" % prefix, fl=\\\"data\\\")\\n\\n # raw_query returns a string\\n xml = parseString(response)\\n\\n doc_elem = xml.getElementsByTagName(\\\"doc\\\")\\n\\n self.assertEquals(len(doc_elem), 1,\\n \\\"raw_query didn't return the document, id:%s, the response is:%s\\\" %\\n (id, repr(response)))\\n\\n query_data = doc_elem[0].firstChild.firstChild.nodeValue\\n\\n self.assertEquals(query_data, data,\\n (\\\"raw_query returned wrong value for data field, \\\"\\n \\\"expected %s, got:%s\\\" % (data, query_data)))\",\n \"def showGqlQuery(query):\\n proto = query._proto_query\\n kind = query._model_class.kind()\\n filters = proto.filters()\\n boundfilters = proto._GQL__bound_filters\\n orderings = proto.orderings()\\n hint = proto.hint()\\n limit = proto.limit()\\n offset = proto._GQL__offset\\n\\n select = \\\"SELECT * FROM %s\\\" % kind\\n where = []\\n order = []\\n\\n for k in sorted(filters):\\n for clause in filters[k]:\\n name, op = clause\\n if name==-1: name = 'ANCESTOR'\\n where.append(\\\"%s %s :%s\\\" % (name, op.upper(), k))\\n\\n for k in sorted(boundfilters):\\n if isinstance(k, tuple):\\n op = ' '.join(k)\\n else:\\n op = k\\n where.append(\\\"%s %r\\\" % (op, boundfilters[k]))\\n\\n for p, o in orderings:\\n order.append(\\\"%s %s\\\" % (p, 'DESC' if o==datastore.Query.DESCENDING else 'ASC'))\\n\\n gql = select\\n if where:\\n gql += ' WHERE '+' AND '.join(where)\\n if order:\\n gql += ' ORDER BY ' + ', '.join(order)\\n if limit != -1:\\n if offset != -1:\\n gql += ' LIMIT %s,%s' % (offset,limit)\\n else:\\n gql += ' LIMIT %s' % limit\\n elif offset != -1:\\n gql += ' OFFSET %s' % offset\\n return gql\",\n \"def execute_graphql_request(\\n self, request, data, query, variables, operation_name, show_graphiql=False\\n ):\\n if not query:\\n if show_graphiql:\\n return None\\n raise HttpError(HttpResponseBadRequest(\\\"Must provide query string.\\\"))\\n\\n try:\\n backend = self.get_backend(request)\\n document = backend.document_from_string(self.schema, query)\\n except Exception as e:\\n return ExecutionResult(errors=[e], invalid=True)\\n\\n if request.method.lower() == \\\"get\\\":\\n operation_type = document.get_operation_type(operation_name)\\n if operation_type and operation_type != \\\"query\\\":\\n if show_graphiql:\\n return None\\n\\n raise HttpError(\\n HttpResponseNotAllowed(\\n [\\\"POST\\\"],\\n \\\"Can only perform a {} operation from a POST request.\\\".format(\\n operation_type\\n ),\\n )\\n )\\n\\n # Check request weight\\n try:\\n if self.list_limit or self.weight_limit or self.depth_limit:\\n if document:\\n fragments = get_fragments(document.document_ast.definitions)\\n definitions_total_weight = 0\\n for definition in document.document_ast.definitions:\\n if not isinstance(definition, OperationDefinition):\\n continue\\n\\n if operation_name and definition.name != operation_name:\\n continue\\n\\n def_weight = self.calculate_action_weight(\\n definition.selection_set,\\n fragments)\\n definitions_total_weight += def_weight\\n if self.weight_limit and definitions_total_weight > self.weight_limit:\\n raise QueryWeightExceeded(\\\"Your query exceeds the maximum query weight allowed\\\")\\n except Exception as e:\\n return ExecutionResult(errors=[e], invalid=True)\\n\\n try:\\n extra_options = {}\\n if self.executor:\\n # We only include it optionally since\\n # executor is not a valid argument in all backends\\n extra_options[\\\"executor\\\"] = self.executor\\n\\n return document.execute(\\n root_value=self.get_root_value(request),\\n variable_values=variables,\\n operation_name=operation_name,\\n context_value=self.get_context(request),\\n middleware=self.get_middleware(request),\\n **extra_options\\n )\\n except Exception as e:\\n return ExecutionResult(errors=[e], invalid=True)\",\n \"def _run_query(self, query):\\n cursor = self.conn.cursor()\\n cursor.execute(query)\\n return cursor.fetchall()\",\n \"def raw_as_qs(self, raw_query, params=()):\\n cursor = connection.cursor()\\n try:\\n cursor.execute(raw_query, params)\\n return self.filter(id__in=(x[0] for x in cursor))\\n finally:\\n cursor.close()\",\n \"def execute_query(self, *, scope: Scope, params: QueryParams) -> QueryResults:\",\n \"def sql_query(self, query_text, edges = False):\\n q = QueryWrapper(self.graph, QueryString(query_text, 'sql'),\\n edges = edges, debug = self._debug)\\n return q\",\n \"def query(self, query, request_type=None):\\n\\n #encode to UTF-8\\n try: query = query.encode(\\\"utf-8\\\")\\n except: query = query.decode('raw_unicode_escape').encode(\\\"utf-8\\\")\\n\\n lowercase_query = query.lower()\\n if lowercase_query.startswith(\\\"select\\\") or \\\\\\n lowercase_query.startswith(\\\"describe\\\") or \\\\\\n lowercase_query.startswith(\\\"show\\\") or \\\\\\n request_type==\\\"GET\\\":\\n\\n return self._get(urllib.urlencode({'sql': query}))\\n\\n else:\\n return self._post(urllib.urlencode({'sql': query}))\",\n \"def run_query(query, data_only=True):\\n cmd = ['wp', 'db', 'query', '--skip-plugins', '--skip-themes', query]\\n if data_only:\\n cmd.append('--skip-column-names')\\n return subprocess.check_output(cmd).decode('utf-8').strip()\",\n \"def execute_query(self):\\n try:\\n # get query and templates\\n query = self.request.data.get(\\\"query\\\", None)\\n templates = self.request.data.get(\\\"templates\\\", \\\"[]\\\")\\n registries = self.get_registries()\\n order_by_field = self.request.data.get(\\\"order_by_field\\\", \\\"\\\")\\n\\n if order_by_field:\\n order_by_field = order_by_field.split(\\\",\\\")\\n\\n if query is None:\\n content = {\\\"message\\\": \\\"Query should be passed in parameter.\\\"}\\n return Response(content, status=status.HTTP_400_BAD_REQUEST)\\n\\n # prepare query\\n raw_query = self.build_query(query, templates, registries)\\n # execute query\\n data_list = self.execute_json_query(raw_query, order_by_field)\\n # build and return response\\n return self.build_response(data_list)\\n\\n except Exception as api_exception:\\n content = {\\\"message\\\": str(api_exception)}\\n return Response(\\n content, status=status.HTTP_500_INTERNAL_SERVER_ERROR\\n )\",\n \"def query(self, *, sparql: str) -> Result:\\n pass\",\n \"def _raw(self, query: Any, data: Any = None):\\n assert isinstance(query, str)\\n\\n conn = self._get_session()\\n try:\\n results = conn.execute(query)\\n\\n entity_items = []\\n for item in results:\\n entity = self.model_cls.to_entity(item)\\n entity.state_.mark_retrieved()\\n entity_items.append(entity)\\n\\n result = ResultSet(\\n offset=0,\\n limit=len(entity_items),\\n total=len(entity_items),\\n items=entity_items,\\n )\\n except DatabaseError as exc:\\n logger.error(f\\\"Error while running raw query: {exc}\\\")\\n raise\\n finally:\\n if not current_uow:\\n conn.commit()\\n conn.close()\\n\\n return result\",\n \"async def _perform_query(self, query, login_token):\\n data = {\\\"username\\\": self.user, \\\"query\\\": query.lower(), \\\"token\\\": login_token}\\n return await self._perform_request(\\\"query\\\", data, lambda r: r.text())\",\n \"def run_query(db, query):\\n log.debug(\\\"run query on %s: %s\\\", db, query)\\n conn = _connect(show_dbs(db)[db][\\\"uri\\\"])\\n return conn.cursor().execute(query).fetchall()\",\n \"def execute_sparql(client: NeptuneClient, query: str) -> pd.DataFrame:\\n data = client.read_sparql(query)\\n df = None\\n if \\\"results\\\" in data and \\\"bindings\\\" in data[\\\"results\\\"]:\\n df = pd.DataFrame(data[\\\"results\\\"][\\\"bindings\\\"])\\n df.applymap(lambda x: x[\\\"value\\\"])\\n else:\\n df = pd.DataFrame(data)\\n\\n return df\",\n \"def make_query(graph, ns, request_schema, response_schema):\\n @graph.route(\\\"/v1/foo/get\\\", Operation.Query, ns)\\n @qs(request_schema)\\n @response(response_schema)\\n def foo_query():\\n \\\"\\\"\\\"\\n My doc string\\n \\\"\\\"\\\"\\n request_data = load_query_string_data(request_schema)\\n response_data = dict(\\n result=True,\\n value=request_data[\\\"required_value\\\"],\\n )\\n return dump_response_data(response_schema, response_data, Operation.Query.value.default_code)\",\n \"def query(self):\\n pass\",\n \"def query(env):\\n if app.config['ENABLE_QUERY']:\\n envs = environments()\\n check_env(env, envs)\\n\\n form = QueryForm(meta={\\n 'csrf_secret': app.config['SECRET_KEY'],\\n 'csrf_context': session})\\n if form.validate_on_submit():\\n if form.endpoints.data == 'pql':\\n query = form.query.data\\n elif form.query.data[0] == '[':\\n query = form.query.data\\n else:\\n query = '[{0}]'.format(form.query.data)\\n result = get_or_abort(\\n puppetdb._query,\\n form.endpoints.data,\\n query=query)\\n return render_template('query.html',\\n form=form,\\n result=result,\\n envs=envs,\\n current_env=env)\\n return render_template('query.html',\\n form=form,\\n envs=envs,\\n current_env=env)\\n else:\\n log.warn('Access to query interface disabled by administrator..')\\n abort(403)\",\n \"def generate_query(self):\\n return\",\n \"def run_query(\\n self, project_id, partition_id, read_options=None, query=None, gql_query=None\\n ):\\n request_pb = _datastore_pb2.RunQueryRequest(\\n project_id=project_id,\\n partition_id=partition_id,\\n read_options=read_options,\\n query=query,\\n gql_query=gql_query,\\n )\\n return _rpc(\\n self.client._http,\\n project_id,\\n \\\"runQuery\\\",\\n self.client._base_url,\\n self.client._client_info,\\n request_pb,\\n _datastore_pb2.RunQueryResponse,\\n )\",\n \"def _run_query(self, inputs, state):\\n in_shape = (self._query_batch,) + self._layer.input_shape\\n queries = self._projection('Query', inputs, in_shape)\\n return self._layer.apply(queries, list(state))\",\n \"def query(self):\",\n \"def query(self, **kwargs):\",\n \"def execute_query(self, *args, **kwargs):\",\n \"async def execute(entity, query: Union[ClauseElement, str], values: Union[List, Dict] = None) -> Any:\\n return await uvicore.db.execute(query=query, values=values, connection=entity.__connection__)\",\n \"def pp_query(query):\\n print(format_query(query))\",\n \"def run_http_query(\\n schema, # type: GraphQLSchema\\n request_method, # type: str\\n data, # type: Union[Dict, List[Dict]]\\n query_data=None, # type: Optional[Dict]\\n batch_enabled=False, # type: bool\\n catch=False, # type: bool\\n **execute_options # type: Any\\n):\\n if not isinstance(schema, GraphQLSchema):\\n raise TypeError(\\\"Expected a GraphQL schema, but received {!r}.\\\".format(schema))\\n if request_method not in (\\\"get\\\", \\\"post\\\"):\\n raise HttpQueryError(\\n 405,\\n \\\"GraphQL only supports GET and POST requests.\\\",\\n headers={\\\"Allow\\\": \\\"GET, POST\\\"},\\n )\\n if catch:\\n catch_exc = (\\n HttpQueryError\\n ) # type: Union[Type[HttpQueryError], Type[_NoException]]\\n else:\\n catch_exc = _NoException\\n is_batch = isinstance(data, list)\\n\\n is_get_request = request_method == \\\"get\\\"\\n allow_only_query = is_get_request\\n\\n if not is_batch:\\n if not isinstance(data, (dict, MutableMapping)):\\n raise HttpQueryError(\\n 400, \\\"GraphQL params should be a dict. Received {!r}.\\\".format(data)\\n )\\n data = [data]\\n elif not batch_enabled:\\n raise HttpQueryError(400, \\\"Batch GraphQL requests are not enabled.\\\")\\n\\n if not data:\\n raise HttpQueryError(400, \\\"Received an empty list in the batch request.\\\")\\n\\n extra_data = {} # type: Dict[str, Any]\\n # If is a batch request, we don't consume the data from the query\\n if not is_batch:\\n extra_data = query_data or {}\\n\\n all_params = [get_graphql_params(entry, extra_data) for entry in data]\\n\\n executor = execute_options.get(\\\"executor\\\")\\n response_executor = executor if executor else SyncExecutor()\\n\\n response_promises = [\\n response_executor.execute(\\n get_response, schema, params, catch_exc, allow_only_query, **execute_options\\n )\\n for params in all_params\\n ]\\n response_executor.wait_until_finished()\\n\\n results = [\\n result.get() if is_thenable(result) else result for result in response_promises\\n ]\\n\\n return ServerResults(results, all_params)\",\n \"def _make_query(self):\\r\\n raise NotImplementedError()\",\n \"def _send_gql_request(gateway_port):\\n mutation = (\\n f'mutation {{'\\n + '''docs(data: {text: \\\"abcd\\\"}) { \\n id \\n } \\n }\\n '''\\n )\\n c = Client(host='localhost', port=gateway_port, protocol='http')\\n return c.mutate(mutation=mutation)\",\n \"def execute_query(query, params={}, transaction=True, context=\\\"\\\"):\\r\\n if transaction:\\r\\n query = \\\"g.stopTransaction(FAILURE)\\\\n\\\" + query\\r\\n\\r\\n # If we have no hosts available raise an exception\\r\\n if len(_hosts) <= 0:\\r\\n raise ThunderdomeConnectionError('Attempt to execute query before calling thunderdome.connection.setup')\\r\\n \\r\\n host = _hosts[0]\\r\\n #url = 'http://{}/graphs/{}/tp/gremlin'.format(host.name, _graph_name)\\r\\n data = json.dumps({'script':query, 'params': params})\\r\\n headers = {'Content-Type':'application/json', 'Accept':'application/json', 'Accept-Charset':'utf-8'}\\r\\n import time\\r\\n try:\\r\\n start_time = time.time()\\r\\n conn = httplib.HTTPConnection(host.name, host.port)\\r\\n conn.request(\\\"POST\\\", '/graphs/{}/tp/gremlin'.format(_graph_name), data, headers)\\r\\n response = conn.getresponse()\\r\\n content = response.read()\\r\\n\\r\\n total_time = int((time.time() - start_time) * 1000)\\r\\n\\r\\n if context and _statsd:\\r\\n _statsd.timing(\\\"{}.timer\\\".format(context), total_time)\\r\\n _statsd.incr(\\\"{}.counter\\\".format(context))\\r\\n\\r\\n\\r\\n except socket.error as sock_err:\\r\\n if _statsd:\\r\\n total_time = int((time.time() - start_time) * 1000)\\r\\n _statsd.incr(\\\"thunderdome.socket_error\\\".format(context), total_time)\\r\\n raise ThunderdomeQueryError('Socket error during query - {}'.format(sock_err))\\r\\n except:\\r\\n raise\\r\\n \\r\\n logger.info(json.dumps(data))\\r\\n logger.info(content)\\r\\n\\r\\n try:\\r\\n response_data = json.loads(content)\\r\\n except ValueError as ve:\\r\\n raise ThunderdomeQueryError('Loading Rexster results failed: \\\"{}\\\"'.format(ve))\\r\\n \\r\\n if response.status != 200:\\r\\n if 'message' in response_data and len(response_data['message']) > 0:\\r\\n graph_missing_re = r\\\"Graph \\\\[(.*)\\\\] could not be found\\\"\\r\\n if re.search(graph_missing_re, response_data['message']):\\r\\n raise ThunderdomeGraphMissingError(response_data['message'])\\r\\n else:\\r\\n raise ThunderdomeQueryError(\\r\\n response_data['message'],\\r\\n response_data\\r\\n )\\r\\n else:\\r\\n if _statsd:\\r\\n _statsd.incr(\\\"{}.error\\\".format(context))\\r\\n raise ThunderdomeQueryError(\\r\\n response_data['error'],\\r\\n response_data\\r\\n )\\r\\n\\r\\n return response_data['results']\",\n \"def get_raw_query(self, row_id):\\n cursor = self.connection.cursor()\\n cursor.execute(\\\"\\\"\\\"\\n SELECT raw_query FROM queries WHERE rowid=(?);\\n \\\"\\\"\\\", (row_id,))\\n return cursor.fetchone()[0]\",\n \"def visit_query(self, query):\\n return query\",\n \"def query(self, query, initNs=None, initBindings=None, queryGraph=None, **kwargs):\\n\\n# r_queryType = pattern.search(query).group(\\\"prefixes\\\").upper()\\n# print(r_queryType)\\n uri = self.rest_services[\\\"repository\\\"]\\n infer = kwargs.get('infer',None)\\n #timeout = kwargs.get('timeout',\\\"0\\\")\\n payload = {\\\"$\\\"+k: v.n3() for k,v in initBindings.items()}\\n\\n payload[\\\"infer\\\"] = self.infer if infer is None else infer\\n payload[\\\"infer\\\"] = str(payload[\\\"infer\\\"]).lower()\\n #payload[\\\"$\\\"+timeout]=0\\n payload[\\\"query\\\"] = query\\n r = requests.post(uri, data=payload,\\n stream=True,\\n headers= {\\\"Accept\\\" : \\\"application/sparql-results+json,application/trix\\\",\\n 'connection': 'keep-alive',\\n 'Accept-Encoding': 'gzip,deflate',\\n \\\"Content-Type\\\" :\\\"application/x-www-form-urlencoded\\\"})\\n\\n r.raw.decode_content = True\\n if r.headers['Content-Type'] == 'application/sparql-results+json;charset=UTF-8':\\n return self.__make_result(r)\\n elif r.headers['Content-Type'] == 'application/trix;charset=UTF-8':\\n return self.__make_trix_generator__(r)\\n else:\\n raise ValueError(\\\"Response content type not parsable {r}\\\".format(r=r.text))\",\n \"def execute_json_query(self, raw_query, order_by_field):\\n return oai_record_api.execute_json_query(\\n raw_query, self.request.user, order_by_field\\n )\",\n \"def executeQuery(payload, newQuery):\\r\\n\\tq = newQuery.format(**payload)\\r\\n\\tdb.query(q)\\r\\n\\tdata = db.fetchall()\\r\\n\\treturn data\",\n \"def execute(query):\\n print query\\n cursor.execute(query)\",\n \"def query(self) -> None:\\n raise NotImplementedError()\",\n \"def run_query(query):\\n conn = connection.get_db_connection()\\n cursor = conn.cursor()\\n cursor.execute(query)\\n return cursor\",\n \"def query(self, q, *args):\\n\\n if self.dbtype == 'pg':\\n print q\\n return self.db.execute(q, *args).fetchall()\\n else:\\n cur = self.db.cursor()\\n try:\\n print q\\n print args\\n if args:\\n cur.execute(q, args)\\n else:\\n cur.execute(q)\\n ret = cur.fetchall()\\n return ret\\n except:\\n self.db.rollback()\\n raise\\n finally:\\n cur.close()\",\n \"def _traced_graphql(func, _, args, kwargs):\\n\\n schema = args[0]\\n\\n # get the query as a string\\n if len(args) > 1:\\n request_string = args[1]\\n else:\\n request_string = kwargs.get('request_string')\\n\\n if isinstance(request_string, Document):\\n query = request_string.loc.source.body\\n else:\\n query = request_string\\n\\n # allow schemas their own tracer with fall-back to the global\\n tracer = getattr(schema, 'datadog_tracer', ddtrace.tracer)\\n\\n if not tracer.enabled:\\n return func(*args, **kwargs)\\n\\n with tracer.trace(\\n RES,\\n span_type=TYPE,\\n service=SERVICE,\\n resource=_resolve_query_res(query)\\n ) as span:\\n span.set_tag(QUERY, query)\\n result = None\\n try:\\n result = func(*args, **kwargs)\\n return result\\n finally:\\n # `span.error` must be integer\\n span.error = int(result is None or result.invalid)\\n if result is not None:\\n span.set_tag(ERRORS, result.errors)\\n span.set_metric(INVALID, int(result.invalid))\",\n \"def run_query(self, query, limit = None):\\n if limit is not None:\\n query += 'LIMIT ' + str(limit)\\n query_job = self.bigquery_client.query(query) # API request\\n return query_job.result() # Waits for query to finish\",\n \"def execute_query():\\n start_time = time.time()\\n\\n queries = request.json[\\\"queries\\\"]\\n random_command = request.json[\\\"random_command\\\"]\\n\\n \\\"\\\"\\\" Running the queries against the pre-loaded index. \\\"\\\"\\\"\\n output_dict = runner.run_queries(queries, random_command)\\n\\n \\\"\\\"\\\" Dumping the results to a JSON file. \\\"\\\"\\\"\\n with open(output_location, 'w') as fp:\\n json.dump(output_dict, fp)\\n\\n response = {\\n \\\"Response\\\": output_dict,\\n \\\"time_taken\\\": str(time.time() - start_time),\\n \\\"username_hash\\\": username_hash\\n }\\n return flask.jsonify(response)\",\n \"def test_psycopg_binary_query_works(instrument, postgres_connection, elasticapm_client):\\n cursor = postgres_connection.cursor()\\n query = b\\\"SELECT * FROM test WHERE name LIKE 't%'\\\"\\n\\n baked_query = query.decode()\\n try:\\n elasticapm_client.begin_transaction(\\\"web.django\\\")\\n cursor.execute(query)\\n result = cursor.fetchall()\\n elasticapm_client.end_transaction(None, \\\"test-transaction\\\")\\n finally:\\n # make sure we've cleared out the spans for the other tests.\\n assert [(2, \\\"two\\\"), (3, \\\"three\\\")] == result\\n transactions = elasticapm_client.events[TRANSACTION]\\n spans = elasticapm_client.spans_for_transaction(transactions[0])\\n span = spans[0]\\n assert span[\\\"name\\\"] == \\\"SELECT FROM test\\\"\\n assert \\\"db\\\" in span[\\\"context\\\"]\\n assert span[\\\"context\\\"][\\\"db\\\"][\\\"instance\\\"] == \\\"elasticapm_test\\\"\\n assert span[\\\"context\\\"][\\\"db\\\"][\\\"type\\\"] == \\\"sql\\\"\\n assert span[\\\"context\\\"][\\\"db\\\"][\\\"statement\\\"] == baked_query\",\n \"def run_codeql_query(query, database, output, search_path):\\n # --search-path is required when the CLI needs to upgrade the database scheme.\\n subprocess_run([\\\"codeql\\\", \\\"query\\\", \\\"run\\\", query, \\\"--database\\\", database,\\n \\\"--output\\\", output + \\\".bqrs\\\", \\\"--search-path\\\", search_path])\\n subprocess_run([\\\"codeql\\\", \\\"bqrs\\\", \\\"decode\\\", output + \\\".bqrs\\\",\\n \\\"--format=csv\\\", \\\"--no-titles\\\", \\\"--output\\\", output])\\n os.remove(output + \\\".bqrs\\\")\",\n \"def graphiql(request):\\n del request\\n graphiql_filepath = pathlib.Path(__file__).absolute().parent / \\\"graphiql.html\\\"\\n with open(graphiql_filepath) as f:\\n return django.http.response.HttpResponse(f.read())\",\n \"def query(self, query):\\n cursor = self.database.cursor()\\n cursor.execute(query)\\n # If it's a query that's expected to return a value (EG: SELECT)\\n if query.strip().lower().startswith('select'): return cursor.fetchall()\",\n \"def graphql_query(self, end_cursor, user_id) -> tuple[dict, list, tuple[str, bool]]:\\n query_params = {\\n 'query_hash': '8c2a529969ee035a5063f2fc8602a0fd',\\n 'variables': json.dumps({\\\"id\\\":user_id,\\\"first\\\":8,\\\"after\\\":end_cursor})\\n }\\n\\n url_post = 'https://www.instagram.com/graphql/query/'\\n\\n _, res_post = self.request_safe(url_post, params_request_safe=query_params)\\n \\n try:\\n res_json = res_post.json()\\n except json.JSONDecodeError:\\n soup = BeautifulSoup(res_post.text, 'html.parser')\\n elm = soup.find('div', attrs={'class':'error-container'})\\n if not elm is None and \\\"Error\\\" in elm.text:\\n raise Exception(elm.text)\\n if res_post.json().get('message') == 'rate limited':\\n raise Exception(res_post.json().get('message'))\\n \\n has_next_page = res_post.json()['data']['user']['edge_owner_to_timeline_media']['page_info']['has_next_page']\\n end_cursor = res_post.json()['data']['user']['edge_owner_to_timeline_media']['page_info']['end_cursor']\\n edges = res_post.json()['data']['user']['edge_owner_to_timeline_media']['edges']\\n return (res_post.json(), edges, (end_cursor, has_next_page))\",\n \"def query(\\n self,\\n statement, # type: str\\n *options, # type: QueryOptions\\n **kwargs # type: Any\\n ) -> QueryResult:\\n\\n query = N1QLQuery.create_query_object(statement,\\n *options,\\n **kwargs)\\n return QueryResult(N1QLRequest.generate_n1ql_request(self.connection,\\n query.params,\\n default_serializer=self.default_serializer))\",\n \"def query(self, fieldname, value, *args, **kwargs):\\n qg = self.schema.query_generator(fieldname)\\n return qg(value, *args, **kwargs).connect(self)\",\n \"def run_query(conn, query):\\n\\tcur = conn.cursor()\\n\\tcur.execute(query)\\n\\trows = cur.fetchall()\\n\\treturn rows\",\n \"def construct_query(self):\\n reader = QueryReader(filepath=self.filepath, filename=self.filename, raw_sql=self.raw_sql, params=self.params)\\n return reader.sql\",\n \"def __call__(self, data):\\n return data.eval(self.query)\",\n \"def _Dynamic_RunQuery(self, query, query_result, request_id=None):\\n if query.has_transaction():\\n if not query.has_ancestor():\\n raise apiproxy_errors.ApplicationError(\\n datastore_pb.Error.BAD_REQUEST,\\n 'Only ancestor queries are allowed inside transactions.')\\n (filters, orders) = datastore_index.Normalize(query.filter_list(),\\n query.order_list(), [])\\n \\n old_datastore_stub_util.FillUsersInQuery(filters)\\n\\n if not query.has_app():\\n query.set_app(self.project_id)\\n self.__ValidateAppId(query.app())\\n\\n self._RemoteSend(query, query_result, \\\"RunQuery\\\", request_id)\\n results = query_result.result_list()\\n for result in results:\\n old_datastore_stub_util.PrepareSpecialPropertiesForLoad(result)\\n\\n last_cursor = None\\n if query_result.has_compiled_cursor():\\n last_cursor = query_result.compiled_cursor()\\n\\n if query_result.more_results():\\n new_cursor = InternalCursor(query, last_cursor, len(results))\\n cursor_id = self.__getCursorID()\\n cursor = query_result.mutable_cursor()\\n cursor.set_app(self.project_id)\\n cursor.set_cursor(cursor_id)\\n self.__queries[cursor_id] = new_cursor\\n\\n if query.compile():\\n compiled_query = query_result.mutable_compiled_query()\\n compiled_query.set_keys_only(query.keys_only())\\n compiled_query.mutable_primaryscan().set_index_name(query.Encode())\",\n \"def do_query(self, query):\\n query = query.replace('\\\\n', ' ')\\n self.cursor.execute(query)\\n return self.cursor.fetchall()\",\n \"def pg_execute(pg_conn, sql):\\n print sql\\n # XXX execute command\",\n \"def query(self, q, **kwargs):\\n return self._client.query(self._db_name, q, **kwargs)\",\n \"async def scalar(self, query, connection=None):\\n async with self.connection(connection) as conn:\\n r = await conn.execute(query)\\n return await r.scalar()\",\n \"def submit_query(self, username, password):\\n\\n #username = os.environ['NEWSREADER_USERNAME']\\n #password = os.environ['NEWSREADER_PASSWORD']\\n payload = {'id': self.query}\\n \\n endpoint_url = self.endpoint_stub_url.format(action=self.action)\\n print \\\"\\\\n\\\\n**New CRUD query**\\\"\\n print endpoint_url, payload\\n t0 = time.time()\\n try:\\n response = requests.get(endpoint_url, auth=(username, password),\\n params=payload)\\n except Exception as e:\\n print \\\"Query raised an exception\\\"\\n print type(e)\\n t1 = time.time()\\n total = t1-t0\\n raise QueryException(\\\"Query raised an exception: {0}\\\".format(type(e).__name__))\\n else:\\n t1 = time.time()\\n total = t1-t0\\n print \\\"Time to return from query: {0:.2f} seconds\\\".format(total)\\n print \\\"Response code: {0}\\\".format(response.status_code)\\n print \\\"From cache: {0}\\\".format(response.from_cache)\\n\\n #print response.content\\n \\n if response and (response.status_code == requests.codes.ok):\\n self.json_result = {\\\"content\\\":response.content}\\n self.clean_json = self.json_result\\n else:\\n raise QueryException(\\\"Response code not OK: {0}\\\".format(response.status_code))\",\n \"def query(self):\\r\\n raise NotImplementedError\",\n \"def swis_query_command(client: Client, args: Dict[str, Any]) -> CommandResults:\\n query = args.get('query')\\n if not query:\\n raise ValueError(ERR_MSG['REQUIRED_ARGUMENT'])\\n\\n response = client.http_request(method=\\\"GET\\\", url_suffix=URL_SUFFIX[\\\"QUERY\\\"],\\n params={\\\"query\\\": query})\\n outputs = createContext(response.get(\\\"results\\\", []), removeNull=True)\\n readable_response = convert_query_output_to_hr(outputs)\\n return CommandResults(\\n outputs_prefix=\\\"SolarWinds.Query\\\",\\n outputs=outputs,\\n readable_output=readable_response,\\n raw_response=response\\n )\",\n \"def get_data_query(file_name):\\n with open(file_name, 'r') as graphql_query:\\n return graphql_query.read()\",\n \"def runningwithqueries(query):\\n print(\\\"\\\\nRunning Query: \\\" + str(query) + \\\"\\\\nResult :\\\\n\\\")\\n crsr = cnxn.execute(query)\\n columns = [column[0] for column in crsr.description]\\n print(columns)\\n for row in crsr.fetchall():\\n print(row)\\n crsr.close()\",\n \"def gen_q_stmt(name, query):\\n return \\\"query {} `{}`;\\\\n\\\".format(name, query)\",\n \"def _handle_query(self, text, loop=False):\\n \\n # lazy complete\\n text = line_add_lazy_return(text)\\n text = line_add_lazy_describe(text)\\n\\n # RUN QUERY\\n if not loop:\\n res = self.dslobject.query(text)\\n return res\\n else:\\n res = self.dslobject.query_iterative(text)\\n return res\",\n \"def inspect_query(query):\\n return _parse_query(query)\",\n \"def test_custom_query_basic(self):\\n\\n # Create a simple query statement a\\n query = \\\"SELECT * FROM system.local\\\"\\n statement = SimpleStatement(query)\\n # Validate that various types of custom payloads are sent and received okay\\n self.validate_various_custom_payloads(statement=statement)\",\n \"def n1qlQueryAll(self, *args, **kwargs):\\n if not self.connected:\\n cb = lambda x: self.n1qlQueryAll(*args, **kwargs)\\n return self.connect().addCallback(cb)\\n\\n kwargs['itercls'] = BatchedN1QLRequest\\n o = super(RawBucket, self).n1ql_query(*args, **kwargs)\\n o.start()\\n return o._getDeferred()\",\n \"def execute_all_templated(self, conn, query, *values, system=False):\\n query_filled = query.format(*values)\\n self.last_query=query_filled if not system else self.last_query\\n queries = [item for item in query_filled.split(\\\";\\\") if item != \\\"\\\"]\\n results = []\\n if len(queries) > 1 and not system:\\n self.health = Health.SICK\\n self.message = \\\"SQL injection detected\\\"\\n for query in queries:\\n response = conn.execute(query + \\\";\\\")\\n results.extend([item for item in response])\\n return results\",\n \"def execute(self, context):\\n logging.info(f\\\"Running SQL :{self.sql}\\\")\\n self.hook = TrinoHook()\\n query = self.hook.run(self.sql, autocommit=self.autocommit, parameters=self.parameters)\\n if self.xcom_push:\\n return query\",\n \"def query(self, block):\\n raise NotImplementedError(\\\"Querying is an experimental feature\\\")\",\n \"def run_query(cur, query, show_results=False):\\n num_rows = cur.execute(query)\\n print('the query returned {} rows'.format(num_rows))\\n if show_results:\\n for row in cur.fetchall():\\n print(row)\",\n \"def execute_query(\\n # TODO: Passing the whole clickhouse query here is needed as long\\n # as the execute method depends on it. Otherwise we can make this\\n # file rely either entirely on clickhouse query or entirely on\\n # the formatter.\\n clickhouse_query: Union[Query, CompositeQuery[Table]],\\n request_settings: RequestSettings,\\n formatted_query: FormattedQuery,\\n reader: Reader,\\n timer: Timer,\\n stats: MutableMapping[str, Any],\\n query_settings: MutableMapping[str, Any],\\n robust: bool,\\n) -> Result:\\n # Experiment, if we are going to grab more than X columns worth of data,\\n # don't use uncompressed_cache in ClickHouse.\\n uc_max = state.get_config(\\\"uncompressed_cache_max_cols\\\", 5)\\n assert isinstance(uc_max, int)\\n column_counter = ReferencedColumnsCounter()\\n column_counter.visit(clickhouse_query.get_from_clause())\\n if column_counter.count_columns() > uc_max:\\n query_settings[\\\"use_uncompressed_cache\\\"] = 0\\n\\n # Force query to use the first shard replica, which\\n # should have synchronously received any cluster writes\\n # before this query is run.\\n consistent = request_settings.get_consistent()\\n stats[\\\"consistent\\\"] = consistent\\n if consistent:\\n query_settings[\\\"load_balancing\\\"] = \\\"in_order\\\"\\n query_settings[\\\"max_threads\\\"] = 1\\n\\n result = reader.execute(\\n formatted_query,\\n query_settings,\\n with_totals=clickhouse_query.has_totals(),\\n robust=robust,\\n )\\n\\n timer.mark(\\\"execute\\\")\\n stats.update(\\n {\\\"result_rows\\\": len(result[\\\"data\\\"]), \\\"result_cols\\\": len(result[\\\"meta\\\"])}\\n )\\n\\n return result\",\n \"def query(self, qpath):\\n return data.Query(self, qpath)\",\n \"def dbexecute(cxn, query, payload):\\n\\tcursor = cxn.cursor()\\n\\tif not payload:\\n\\t\\tcursor.execute(query)\\n\\telse:\\n\\t\\tcursor.execute(query, payload)\",\n \"def doQuery(self, s):\\n self.setQuery(s)\\n\\n try:\\n rval = self.query()\\n g = rval.convert()\\n return g['results']['bindings']\\n except:\\n print \\\"doQuery failed\\\"\\n traceback.print_exc(file=sys.stdout)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7544899","0.68699944","0.6803751","0.67968833","0.661308","0.65708804","0.65654963","0.6560553","0.65150213","0.65003735","0.6493559","0.64276546","0.6414967","0.63659316","0.63526833","0.63463426","0.63447905","0.6304541","0.6291603","0.629144","0.627261","0.6256023","0.6243312","0.6233386","0.6124932","0.6122041","0.607239","0.60442835","0.60100925","0.60000885","0.59766424","0.59434503","0.5935973","0.59264266","0.59224856","0.590932","0.59076685","0.58862346","0.588159","0.58773655","0.5860784","0.5840499","0.58327806","0.58200336","0.58132464","0.57995933","0.57864153","0.57752365","0.57666415","0.5763448","0.57444775","0.5740678","0.5740271","0.57274157","0.57169026","0.5713286","0.57129943","0.570822","0.5694414","0.56774026","0.56690943","0.56477594","0.56432694","0.56401515","0.56327134","0.56285405","0.5621374","0.561963","0.56021446","0.5596355","0.5587982","0.5584437","0.55697304","0.5542437","0.55382985","0.5533828","0.5511129","0.5508427","0.550368","0.549996","0.54992515","0.547893","0.54777217","0.54621935","0.54607415","0.54602844","0.5449952","0.5441183","0.543115","0.5428106","0.5421768","0.54153645","0.541076","0.54092634","0.5405287","0.5405015","0.53956246","0.53953934","0.53927946","0.53922576"],"string":"[\n \"0.7544899\",\n \"0.68699944\",\n \"0.6803751\",\n \"0.67968833\",\n \"0.661308\",\n \"0.65708804\",\n \"0.65654963\",\n \"0.6560553\",\n \"0.65150213\",\n \"0.65003735\",\n \"0.6493559\",\n \"0.64276546\",\n \"0.6414967\",\n \"0.63659316\",\n \"0.63526833\",\n \"0.63463426\",\n \"0.63447905\",\n \"0.6304541\",\n \"0.6291603\",\n \"0.629144\",\n \"0.627261\",\n \"0.6256023\",\n \"0.6243312\",\n \"0.6233386\",\n \"0.6124932\",\n \"0.6122041\",\n \"0.607239\",\n \"0.60442835\",\n \"0.60100925\",\n \"0.60000885\",\n \"0.59766424\",\n \"0.59434503\",\n \"0.5935973\",\n \"0.59264266\",\n \"0.59224856\",\n \"0.590932\",\n \"0.59076685\",\n \"0.58862346\",\n \"0.588159\",\n \"0.58773655\",\n \"0.5860784\",\n \"0.5840499\",\n \"0.58327806\",\n \"0.58200336\",\n \"0.58132464\",\n \"0.57995933\",\n \"0.57864153\",\n \"0.57752365\",\n \"0.57666415\",\n \"0.5763448\",\n \"0.57444775\",\n \"0.5740678\",\n \"0.5740271\",\n \"0.57274157\",\n \"0.57169026\",\n \"0.5713286\",\n \"0.57129943\",\n \"0.570822\",\n \"0.5694414\",\n \"0.56774026\",\n \"0.56690943\",\n \"0.56477594\",\n \"0.56432694\",\n \"0.56401515\",\n \"0.56327134\",\n \"0.56285405\",\n \"0.5621374\",\n \"0.561963\",\n \"0.56021446\",\n \"0.5596355\",\n \"0.5587982\",\n \"0.5584437\",\n \"0.55697304\",\n \"0.5542437\",\n \"0.55382985\",\n \"0.5533828\",\n \"0.5511129\",\n \"0.5508427\",\n \"0.550368\",\n \"0.549996\",\n \"0.54992515\",\n \"0.547893\",\n \"0.54777217\",\n \"0.54621935\",\n \"0.54607415\",\n \"0.54602844\",\n \"0.5449952\",\n \"0.5441183\",\n \"0.543115\",\n \"0.5428106\",\n \"0.5421768\",\n \"0.54153645\",\n \"0.541076\",\n \"0.54092634\",\n \"0.5405287\",\n \"0.5405015\",\n \"0.53956246\",\n \"0.53953934\",\n \"0.53927946\",\n \"0.53922576\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6531391"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":3297,"cells":{"query":{"kind":"string","value":"passing in event_loop helps avoid 'attached to a different loop' error"},"document":{"kind":"string","value":"def test_app(event_loop):\n app.finalize()\n app.conf.store = \"memory://\"\n app.flow_control.resume()\n return app"},"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 event_loop(self):\n logging.warning('loop undefined')","def dispatch_loop(self):\n pass","def check_event_loop():\n loop = asyncio.get_event_loop()\n if loop.is_closed():\n asyncio.set_event_loop(asyncio.new_event_loop())","def _handle_loop(self):\n pass","def event_loop(request):\n loop = asyncio.get_event_loop()\n yield loop","def loop_run(self):\n super(EventLoop, self).loop_run()\n self.inq = self.cothread.EventQueue()","def _event_loop(self):\n while True:\n self.scheduler.run(blocking=True)\n time.sleep(1)","def load_event_loop():\n while True:\n try:\n async_loop = asyncio.new_event_loop()\n asyncio.set_event_loop(async_loop)\n return async_loop\n except:\n time.sleep(3)","def loop(self) -> AbstractEventLoop:","def loop(self) -> AbstractEventLoop:","def get_event_loop(*args, **kwargs):\r\n\r\n return get_loop(*args, **kwargs)","def __init__(self, loop=None):\n object.__setattr__(self, '_loop', loop or get_event_loop())","def _eventloop(self):\n logging.debug(\"%s - eventloop started\" % self.name)\n while not self.stopped:\n event = self.inqueue.get()\n if not event: break\n self.doevent(event)\n logging.debug(\"%s - eventloop stopped\" % self.name)","def _io_event_loop_thread(self):\r\n io_event_loop = asyncio.get_event_loop_policy().new_event_loop()\r\n asyncio.set_event_loop(io_event_loop)\r\n assert isinstance(io_event_loop, AbstractEventLoop)\r\n self._io_event_loop = io_event_loop\r\n self._event_loop_started.release()\r\n self._io_event_loop.run_forever()","def getLoop():\n return asyncio.get_event_loop_policy().get_event_loop()","def get_event_loop() -> KivyEventLoop:\n return asyncio.get_event_loop()","def mainloop(self, *args, **kwargs):\n if in_idle():\n return\n self._top.mainloop(*args, **kwargs)","def mainloop(self, *args, **kwargs):\n if in_idle():\n return\n self.top.mainloop(*args, **kwargs)","def set_event_loop(self, loop):\n if _in_trio_context():\n current_loop.set(loop)\n elif _faked_policy.policy is not None:\n _faked_policy.policy.set_event_loop(loop)\n else:\n super().set_event_loop(loop)","def run_message_loop(self):\n raise NotImplementedError","def test_no_sideeffects(self):\n c = EventLoop(\n lambda: None,\n lambda f, g: 1 / 0,\n lambda *args: 1 / 0,\n watchdog_thread=object(),\n reapAllProcesses=lambda: 1 / 0)\n del c","def current_event_loop(self):\n loop = current_loop.get()\n if loop is None:\n loop = super().get_event_loop()\n return loop","def mainloop(self):\n self.app.mainloop()","def event_loop():\n loop = asyncio.get_event_loop_policy().new_event_loop()\n yield loop\n loop.close()","def run_main_loop():\n mainloop = GObject.MainLoop()","def event_loop():\n loop = asyncio.get_event_loop()\n yield loop\n loop.close()","def setUp(self):\n self.loop = asyncio.new_event_loop()\n asyncio.set_event_loop(self.loop)","def setUp(self):\n self.loop = asyncio.new_event_loop()\n asyncio.set_event_loop(self.loop)","def setUp(self):\n self.loop = asyncio.new_event_loop()\n asyncio.set_event_loop(self.loop)","def setUp(self):\n self.loop = asyncio.new_event_loop()\n asyncio.set_event_loop(self.loop)","def startLoop():\n patchAsyncio()","def mainloop(self):\n self.master.mainloop()","def loop(event_loop: AbstractEventLoop) -> AbstractEventLoop:\n yield event_loop\n event_loop.close()","def setup_test_loop():\n loop = asyncio.get_event_loop()\n # asyncio.set_event_loop(None)\n return loop","def set_asyncio_event_loop_policy() -> None:\n _get_asyncio_event_loop_policy()","def loop(self):\n pass","def mainloop(self):\n self.root.mainloop()","def mainloop(self):\n self.root.mainloop()","def event_loop(self):\n for event in pg.event.get():\n if event.type == pg.QUIT:\n self.done = True\n elif event.type == pg.KEYDOWN:\n self.keys = pg.key.get_pressed()\n self.toggle_show_fps(event.key)\n elif event.type == pg.KEYUP:\n self.keys = pg.key.get_pressed()\n self.toggle_fullscreen(event.key)\n self._scene.get_event(event)","def event_loop(self) -> None:\n logging.info(\"Initializing default window opacity...\")\n self._set_all_window_opacity_to_default()\n try:\n logging.info(\"Initializing threads...\")\n for producer in self.producers:\n producer.start()\n for producer in self.producers:\n while not producer.ready:\n pass\n self.ready = True\n logging.info(\"Threads initialized, waiting for events...\")\n while self.keep_going:\n self._flash_queued_window()\n except (KeyboardInterrupt, SystemExit):\n logging.warn(\"Interrupt received, shutting down...\")\n self.shutdown()","def _run_loop(self):\n loop = asyncio.new_event_loop()\n asyncio.set_event_loop(loop)\n\n self._server = websockets.serve(self._log_message, self._host, self._port)\n\n loop.run_until_complete(self._server)\n loop.run_forever()","def pre_loop(self, event):\n self.do_sync()","def game_loop(self):\n self.interface.game_loop(self)","def mainloop(self):\n\t\tself.root.after(100, self.tkloop)\n\t\tself.root.mainloop()","def startLoop(self):\n if(self.loop is not None):\n raise Exception(\"Event loop is already started!\")\n self.loop = asyncio.new_event_loop()\n self.thread = Thread(target=start_thread_loop, args=(self.loop,))\n self.thread.setDaemon(True)\n self.thread.start()","def event_loop(self):\n for event in pygame.event.get():\n self.scene.get_event(event)","def blocking_input_loop(figure, event_names, timeout, handler):\n if figure.canvas.manager:\n figure.show() # Ensure that the figure is shown if we are managing it.\n # Connect the events to the on_event function call.\n cids = [figure.canvas.mpl_connect(name, handler) for name in event_names]\n try:\n figure.canvas.start_event_loop(timeout) # Start event loop.\n finally: # Run even on exception like ctrl-c.\n # Disconnect the callbacks.\n for cid in cids:\n figure.canvas.mpl_disconnect(cid)","def _run(self):\n while(self._loop):\n pass","def loop_run(self):\n self.log_debug(\"Running loop\")\n import cothread\n self.cothread = cothread\n self._loop_state = LState.Running\n if self.loop_event:\n # Call unbound function with a weak reference to self so that\n # garbage collector will call __del__ when we finish\n event_loop = weak_method(self.event_loop)\n loop_event = weak_method(self.loop_event)\n self.event_loop_proc = cothread.Spawn(event_loop, loop_event)\n else:\n self.event_loop_proc = cothread.Pulse()","def main():\n PanelDemo().mainloop()","def takeControl(self):\n mainloop()","def takeControl(self):\n mainloop()","def rfactor_event_loop():\n if RfactorLiveEvent.event.is_set():\n is_live = RfactorLiveEvent.get_nowait()\n # -- Update rFactor live state to front end\n if is_live is not None:\n eel.rfactor_live(is_live)\n\n if RfactorStatusEvent.event.is_set():\n status = RfactorStatusEvent.get_nowait()\n # -- Update rFactor status message in front end\n if status is not None:\n logging.debug('Updating rf2 status message: %s', status)\n eel.rfactor_status(status)\n\n RfactorStatusEvent.reset()","def get_test_event_loop():\n if not _IS_XOS_ASYNC:\n loop = _asynclib.get_event_loop()\n else:\n loop = _get_xos_async_test_event_loop()\n return loop","def set_main(self, main_loop):\n self.main_loop = main_loop","def start_call_back_loop(loop: asyncio.AbstractEventLoop) -> None:\n asyncio.set_event_loop(loop)\n loop.run_forever()","def _start_io_event_loop(self):\r\n self._event_loop_started = threading.Lock()\r\n self._event_loop_started.acquire()\r\n threading.Thread(None, self._io_event_loop_thread).start()\r\n self._event_loop_started.acquire()","def loop(self):\n raise NotImplementedError()","def main_loop(self):\n dt = 0\n self.clock.tick(FPS)\n while not self.done:\n self.event_loop()\n self.update(dt)\n self.render()\n dt = self.clock.tick(FPS) / 1000.0","def _preloop_hook(self) -> None:\n self.selectorloop = SelectorThread(daemon=True)\n self.selectorloop.start()","def test_eventloop_api(self):\n from twisted.python.log import startLoggingWithObserver\n from crochet import _shutdown\n self.assertIsInstance(_main, EventLoop)\n self.assertEqual(_main.setup, setup_crochet)\n self.assertEqual(_main.no_setup, no_setup)\n self.assertEqual(_main.run_in_reactor, run_in_reactor)\n self.assertEqual(_main.wait_for, wait_for)\n self.assertIdentical(_main._atexit_register, _shutdown.register)\n self.assertIdentical(\n _main._startLoggingWithObserver, startLoggingWithObserver)\n self.assertIdentical(_main._watchdog_thread, _shutdown._watchdog)","def loop(self):\n return self.caller.location.ndb.event_line_loop","def _spin_wx(self):\n import wx\n app = wx.GetApp()\n if app is not None and wx.Thread_IsMain():\n evtloop = wx.EventLoop()\n ea = wx.EventLoopActivator(evtloop)\n while evtloop.Pending():\n evtloop.Dispatch()\n app.ProcessIdle()\n del ea","def set_asyncio_event_loop(event_loop_path: Optional[str]) -> AbstractEventLoop:\n if event_loop_path is not None:\n event_loop_class: Type[AbstractEventLoop] = load_object(event_loop_path)\n event_loop = event_loop_class()\n asyncio.set_event_loop(event_loop)\n else:\n try:\n with catch_warnings():\n # In Python 3.10.9, 3.11.1, 3.12 and 3.13, a DeprecationWarning\n # is emitted about the lack of a current event loop, because in\n # Python 3.14 and later `get_event_loop` will raise a\n # RuntimeError in that event. Because our code is already\n # prepared for that future behavior, we ignore the deprecation\n # warning.\n filterwarnings(\n \"ignore\",\n message=\"There is no current event loop\",\n category=DeprecationWarning,\n )\n event_loop = asyncio.get_event_loop()\n except RuntimeError:\n # `get_event_loop` raises RuntimeError when called with no asyncio\n # event loop yet installed in the following scenarios:\n # - Previsibly on Python 3.14 and later.\n # https://github.com/python/cpython/issues/100160#issuecomment-1345581902\n event_loop = asyncio.new_event_loop()\n asyncio.set_event_loop(event_loop)\n return event_loop","async def _main(self):\n while True:\n time.sleep(1)","def get_event_loop():\n try:\n return asyncio.get_running_loop()\n except RuntimeError:\n return asyncio.new_event_loop()","def run(self):\n self.cmdloop()","def run():\n gui = GUI()\n gui.mainloop()","def run(self):\n if self.okay:\n ExtLoopWin32.run()","def reactor_loop():\n def on_running():\n \"\"\"\n called when the twisted reactor is running\n \"\"\"\n log.msg('reactor_loop Starting')\n try:\n conn = client.connect(reactor)\n si446x_do = Si446xComponent(conn)\n conn.addCallback(si446x_do.start)\n conn.addErrback(si446x_do.on_error)\n except error.DBusException, e:\n log.msg('reactor_loop Setup Error: {}'.format(e))\n reactor.stop()\n\n signal.signal(signal.SIGINT, SIGINT_CustomEventHandler)\n signal.signal(signal.SIGHUP, SIGINT_CustomEventHandler)\n reactor.callWhenRunning(on_running)\n reactor.run()","def run(self):\n\n while not self.done:\n\n self.event_loop()\n\n self.update()","def event_loop(self, index):\n logger.debug(\"Starting event loop \"+str(index))\n self.stop_flag = Event()\n stop_flag = self.stop_flag # Saving a reference.\n # stop_flag is an object that will signal the current input thread to exit or not exit once it's done processing a callback.\n # It'll be called just before self.stop_flag will be overwritten. However, we've got a reference to it and now can check the exact flag this thread itself constructed.\n # Praise the holy garbage collector.\n stop_flag.clear()\n while not stop_flag.isSet():\n if self.get_current_proxy() is not None:\n try:\n key = self.queue.get(False, 0.1)\n except Queue.Empty:\n # here an active event_loop spends most of the time\n sleep(0.1)\n except AttributeError:\n # typically happens upon program termination\n pass\n else:\n # here event_loop is usually busy\n self.process_key(key)\n else:\n # No current proxy set yet, not processing anything\n sleep(0.1)\n logger.debug(\"Stopping event loop \"+str(index))","def run_event_loop(async_loop, wait_tasks):\n while True:\n try:\n async_loop.run_until_complete(wait_tasks)\n break\n except RuntimeError:\n time.sleep(3)","async def test_events_handled_on_event_loop(self):\n session = _create_test_session(asyncio.get_running_loop())\n\n handle_event_spy = MagicMock(\n side_effect=session._handle_scriptrunner_event_on_event_loop\n )\n session._handle_scriptrunner_event_on_event_loop = handle_event_spy\n\n # Send a ScriptRunner event from another thread\n thread = threading.Thread(\n target=lambda: session._on_scriptrunner_event(\n sender=MagicMock(), event=ScriptRunnerEvent.SCRIPT_STARTED\n )\n )\n thread.start()\n thread.join()\n\n # _handle_scriptrunner_event_on_event_loop won't have been called\n # yet, because we haven't yielded the eventloop.\n handle_event_spy.assert_not_called()\n\n # Yield to let the AppSession's callbacks run.\n # _handle_scriptrunner_event_on_event_loop will be called here.\n await asyncio.sleep(0)\n\n handle_event_spy.assert_called_once()","def Gameloop():","def start_loop(self, loop):\n asyncio.set_event_loop(loop)\n loop.run_forever()","def update(self):\n asyncio.set_event_loop(asyncio.new_event_loop())\n self.listen(self.port)\n self.loop = IOLoop.instance()\n self.loop.start()","def main_loop(self):\n LOGGER.info('Entering main event loop...')\n try:\n while self._handle_faucet_events():\n while not self._faucet_events.event_socket_connected:\n LOGGER.info('Attempting faucet event sock connection...')\n time.sleep(1)\n try:\n self._faucet_events.connect()\n self._restore_states()\n self._faucet_collector.set_state_restored(True)\n except Exception as e:\n LOGGER.error(\"Cannot restore states or connect to faucet: %s\", e)\n self._faucet_collector.set_state_restored(False, e)\n except KeyboardInterrupt:\n LOGGER.info('Keyboard interrupt. Exiting.')\n self._faucet_events.disconnect()\n except Exception as e:\n LOGGER.error(\"Exception: %s\", e)\n raise","def mock_event_loop() -> Generator[AbstractEventLoop, Any, None]:\n loop = get_event_loop()\n yield loop\n loop.close()","def main():\n BouncyGUI().mainloop()","def postprocess(self, loop):\n return loop","def use_twisted(app):\n activity.EventLoop <<= activity.TwistedEventLoop\n REACTOR_INIT.notify(app)","def event_loop(self):\n for event in pg.event.get():\n self.keys = pg.key.get_pressed()\n if event.type == pg.QUIT or self.keys[pg.K_ESCAPE]:\n self.done = True\n self.cannon.get_event(event, self.objects)","def main_loop(self):\n try:\n self.state_machine.set_state('wait')\n\n while True:\n events = list(reversed(pygame.event.get())) # Take all events, most recent first\n\n if self.find_quit_event(events):\n break\n\n if self.find_fullscreen_event(events):\n self.window.toggle_fullscreen()\n\n event = self.find_resize_event(events)\n if event:\n self.window.resize(event.size)\n\n self.state_machine.process(events)\n\n finally:\n self.led_picture.quit()\n self.led_print.quit()\n GPIO.cleanup()\n self.camera.quit()\n self.printer.quit()\n pygame.quit()","def maybe_patch_ioloop():\n if (\n sys.platform.startswith(\"win\")\n and tornado.version_info < (6, 1)\n and sys.version_info >= (3, 8)\n ):\n try:\n from asyncio import WindowsProactorEventLoopPolicy, WindowsSelectorEventLoopPolicy\n except ImportError:\n pass\n # not affected\n else:\n from asyncio import get_event_loop_policy, set_event_loop_policy\n\n if type(get_event_loop_policy()) is WindowsProactorEventLoopPolicy:\n # WindowsProactorEventLoopPolicy is not compatible with tornado 6\n # fallback to the pre-3.8 default of Selector\n set_event_loop_policy(WindowsSelectorEventLoopPolicy())","def event_loop(self):\n while self.ack is False:\n gevent.sleep(self.loop_interval)\n output_service = self.get_directory_service_proxy().get_service(\"mock-output-service\")\n output_service.put(\"test-worker-work-result\")\n self.ack = True","def _event_loop_thread(self):\n _logger.debug(f'Started DataSource event loop thread {self._thread}.')\n self._event_loop.set_debug(True)\n asyncio.set_event_loop(self._event_loop)\n try:\n self._event_loop.call_soon(self._main_helper)\n self._event_loop.run_forever()\n finally:\n self._event_loop.close()\n _logger.info(f'Source [{(self._addr, self._port)}] closed.')","def main(self):\n self.root.mainloop()","def _get_loop(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Optional[asyncio.AbstractEventLoop]:\n if callable(self.loop_getter):\n if self.loop_getter_need_context:\n return self.loop_getter(*args, **kwargs) # pylint: disable=not-callable\n return self.loop_getter() # pylint: disable=not-callable\n return self.loop_getter","def run(self):\n self.window.mainloop()","def _hijack_tk(self):\n import Tkinter\n orig_mainloop = gtk.main\n dumb_ml = _DummyMainloop(orig_mainloop, self, GUI_TK)\n Tkinter.Misc.mainloop = dumb_ml\n Tkinter.mainloop = dumb_ml","def mainloop(duration=1):\n\n _triggered.clear()\n NSApp = _NSApp()\n _stop_after(duration)\n msg(NSApp, n(\"run\"))\n if not _triggered.is_set():\n # app closed without firing callback,\n # probably due to last window being closed.\n # Run the loop manually in this case,\n # since there may be events still to process (ipython/ipython#9734)\n CoreFoundation.CFRunLoopRun()","def loop(self):\n\n print(self.id + \" needs an overridden loop method\")","def run(self):\n self.loop.spawn_callback(self.main)\n self.loop.start()\n if self.exc_info:\n six.reraise(*self.exc_info)","async def checkNewLoop(self):\n pass","def __loop(self):\n\n self.__update_table()\n self.__update_labels()\n if self.remote_stop:\n self.__stop(\"remote telegram admin\")\n else:\n self.__main_window.after(1000, self.__loop)","def __exit__(self, exc_type, exc_val, exc_tb):\n if self.event_loop:\n self.event_loop.stop()","def postloop(self):\n print 'Bye!'","async def main(logic):\n await GLOBE.connect()\n await asyncio.wait([GLOBE.run_loop(), logic()])","def run(self):\n try:\n self.event_loop = asyncio.new_event_loop()\n asyncio.set_event_loop(self.event_loop)\n template_system = LegionTemplateEngine(self.template_path, self.output_path)\n template_system.render_loop()\n\n except Exception as exception:\n self.raised_exception = exception\n raise self.raised_exception","def __init__(self):\n self.gameloop()"],"string":"[\n \"def event_loop(self):\\n logging.warning('loop undefined')\",\n \"def dispatch_loop(self):\\n pass\",\n \"def check_event_loop():\\n loop = asyncio.get_event_loop()\\n if loop.is_closed():\\n asyncio.set_event_loop(asyncio.new_event_loop())\",\n \"def _handle_loop(self):\\n pass\",\n \"def event_loop(request):\\n loop = asyncio.get_event_loop()\\n yield loop\",\n \"def loop_run(self):\\n super(EventLoop, self).loop_run()\\n self.inq = self.cothread.EventQueue()\",\n \"def _event_loop(self):\\n while True:\\n self.scheduler.run(blocking=True)\\n time.sleep(1)\",\n \"def load_event_loop():\\n while True:\\n try:\\n async_loop = asyncio.new_event_loop()\\n asyncio.set_event_loop(async_loop)\\n return async_loop\\n except:\\n time.sleep(3)\",\n \"def loop(self) -> AbstractEventLoop:\",\n \"def loop(self) -> AbstractEventLoop:\",\n \"def get_event_loop(*args, **kwargs):\\r\\n\\r\\n return get_loop(*args, **kwargs)\",\n \"def __init__(self, loop=None):\\n object.__setattr__(self, '_loop', loop or get_event_loop())\",\n \"def _eventloop(self):\\n logging.debug(\\\"%s - eventloop started\\\" % self.name)\\n while not self.stopped:\\n event = self.inqueue.get()\\n if not event: break\\n self.doevent(event)\\n logging.debug(\\\"%s - eventloop stopped\\\" % self.name)\",\n \"def _io_event_loop_thread(self):\\r\\n io_event_loop = asyncio.get_event_loop_policy().new_event_loop()\\r\\n asyncio.set_event_loop(io_event_loop)\\r\\n assert isinstance(io_event_loop, AbstractEventLoop)\\r\\n self._io_event_loop = io_event_loop\\r\\n self._event_loop_started.release()\\r\\n self._io_event_loop.run_forever()\",\n \"def getLoop():\\n return asyncio.get_event_loop_policy().get_event_loop()\",\n \"def get_event_loop() -> KivyEventLoop:\\n return asyncio.get_event_loop()\",\n \"def mainloop(self, *args, **kwargs):\\n if in_idle():\\n return\\n self._top.mainloop(*args, **kwargs)\",\n \"def mainloop(self, *args, **kwargs):\\n if in_idle():\\n return\\n self.top.mainloop(*args, **kwargs)\",\n \"def set_event_loop(self, loop):\\n if _in_trio_context():\\n current_loop.set(loop)\\n elif _faked_policy.policy is not None:\\n _faked_policy.policy.set_event_loop(loop)\\n else:\\n super().set_event_loop(loop)\",\n \"def run_message_loop(self):\\n raise NotImplementedError\",\n \"def test_no_sideeffects(self):\\n c = EventLoop(\\n lambda: None,\\n lambda f, g: 1 / 0,\\n lambda *args: 1 / 0,\\n watchdog_thread=object(),\\n reapAllProcesses=lambda: 1 / 0)\\n del c\",\n \"def current_event_loop(self):\\n loop = current_loop.get()\\n if loop is None:\\n loop = super().get_event_loop()\\n return loop\",\n \"def mainloop(self):\\n self.app.mainloop()\",\n \"def event_loop():\\n loop = asyncio.get_event_loop_policy().new_event_loop()\\n yield loop\\n loop.close()\",\n \"def run_main_loop():\\n mainloop = GObject.MainLoop()\",\n \"def event_loop():\\n loop = asyncio.get_event_loop()\\n yield loop\\n loop.close()\",\n \"def setUp(self):\\n self.loop = asyncio.new_event_loop()\\n asyncio.set_event_loop(self.loop)\",\n \"def setUp(self):\\n self.loop = asyncio.new_event_loop()\\n asyncio.set_event_loop(self.loop)\",\n \"def setUp(self):\\n self.loop = asyncio.new_event_loop()\\n asyncio.set_event_loop(self.loop)\",\n \"def setUp(self):\\n self.loop = asyncio.new_event_loop()\\n asyncio.set_event_loop(self.loop)\",\n \"def startLoop():\\n patchAsyncio()\",\n \"def mainloop(self):\\n self.master.mainloop()\",\n \"def loop(event_loop: AbstractEventLoop) -> AbstractEventLoop:\\n yield event_loop\\n event_loop.close()\",\n \"def setup_test_loop():\\n loop = asyncio.get_event_loop()\\n # asyncio.set_event_loop(None)\\n return loop\",\n \"def set_asyncio_event_loop_policy() -> None:\\n _get_asyncio_event_loop_policy()\",\n \"def loop(self):\\n pass\",\n \"def mainloop(self):\\n self.root.mainloop()\",\n \"def mainloop(self):\\n self.root.mainloop()\",\n \"def event_loop(self):\\n for event in pg.event.get():\\n if event.type == pg.QUIT:\\n self.done = True\\n elif event.type == pg.KEYDOWN:\\n self.keys = pg.key.get_pressed()\\n self.toggle_show_fps(event.key)\\n elif event.type == pg.KEYUP:\\n self.keys = pg.key.get_pressed()\\n self.toggle_fullscreen(event.key)\\n self._scene.get_event(event)\",\n \"def event_loop(self) -> None:\\n logging.info(\\\"Initializing default window opacity...\\\")\\n self._set_all_window_opacity_to_default()\\n try:\\n logging.info(\\\"Initializing threads...\\\")\\n for producer in self.producers:\\n producer.start()\\n for producer in self.producers:\\n while not producer.ready:\\n pass\\n self.ready = True\\n logging.info(\\\"Threads initialized, waiting for events...\\\")\\n while self.keep_going:\\n self._flash_queued_window()\\n except (KeyboardInterrupt, SystemExit):\\n logging.warn(\\\"Interrupt received, shutting down...\\\")\\n self.shutdown()\",\n \"def _run_loop(self):\\n loop = asyncio.new_event_loop()\\n asyncio.set_event_loop(loop)\\n\\n self._server = websockets.serve(self._log_message, self._host, self._port)\\n\\n loop.run_until_complete(self._server)\\n loop.run_forever()\",\n \"def pre_loop(self, event):\\n self.do_sync()\",\n \"def game_loop(self):\\n self.interface.game_loop(self)\",\n \"def mainloop(self):\\n\\t\\tself.root.after(100, self.tkloop)\\n\\t\\tself.root.mainloop()\",\n \"def startLoop(self):\\n if(self.loop is not None):\\n raise Exception(\\\"Event loop is already started!\\\")\\n self.loop = asyncio.new_event_loop()\\n self.thread = Thread(target=start_thread_loop, args=(self.loop,))\\n self.thread.setDaemon(True)\\n self.thread.start()\",\n \"def event_loop(self):\\n for event in pygame.event.get():\\n self.scene.get_event(event)\",\n \"def blocking_input_loop(figure, event_names, timeout, handler):\\n if figure.canvas.manager:\\n figure.show() # Ensure that the figure is shown if we are managing it.\\n # Connect the events to the on_event function call.\\n cids = [figure.canvas.mpl_connect(name, handler) for name in event_names]\\n try:\\n figure.canvas.start_event_loop(timeout) # Start event loop.\\n finally: # Run even on exception like ctrl-c.\\n # Disconnect the callbacks.\\n for cid in cids:\\n figure.canvas.mpl_disconnect(cid)\",\n \"def _run(self):\\n while(self._loop):\\n pass\",\n \"def loop_run(self):\\n self.log_debug(\\\"Running loop\\\")\\n import cothread\\n self.cothread = cothread\\n self._loop_state = LState.Running\\n if self.loop_event:\\n # Call unbound function with a weak reference to self so that\\n # garbage collector will call __del__ when we finish\\n event_loop = weak_method(self.event_loop)\\n loop_event = weak_method(self.loop_event)\\n self.event_loop_proc = cothread.Spawn(event_loop, loop_event)\\n else:\\n self.event_loop_proc = cothread.Pulse()\",\n \"def main():\\n PanelDemo().mainloop()\",\n \"def takeControl(self):\\n mainloop()\",\n \"def takeControl(self):\\n mainloop()\",\n \"def rfactor_event_loop():\\n if RfactorLiveEvent.event.is_set():\\n is_live = RfactorLiveEvent.get_nowait()\\n # -- Update rFactor live state to front end\\n if is_live is not None:\\n eel.rfactor_live(is_live)\\n\\n if RfactorStatusEvent.event.is_set():\\n status = RfactorStatusEvent.get_nowait()\\n # -- Update rFactor status message in front end\\n if status is not None:\\n logging.debug('Updating rf2 status message: %s', status)\\n eel.rfactor_status(status)\\n\\n RfactorStatusEvent.reset()\",\n \"def get_test_event_loop():\\n if not _IS_XOS_ASYNC:\\n loop = _asynclib.get_event_loop()\\n else:\\n loop = _get_xos_async_test_event_loop()\\n return loop\",\n \"def set_main(self, main_loop):\\n self.main_loop = main_loop\",\n \"def start_call_back_loop(loop: asyncio.AbstractEventLoop) -> None:\\n asyncio.set_event_loop(loop)\\n loop.run_forever()\",\n \"def _start_io_event_loop(self):\\r\\n self._event_loop_started = threading.Lock()\\r\\n self._event_loop_started.acquire()\\r\\n threading.Thread(None, self._io_event_loop_thread).start()\\r\\n self._event_loop_started.acquire()\",\n \"def loop(self):\\n raise NotImplementedError()\",\n \"def main_loop(self):\\n dt = 0\\n self.clock.tick(FPS)\\n while not self.done:\\n self.event_loop()\\n self.update(dt)\\n self.render()\\n dt = self.clock.tick(FPS) / 1000.0\",\n \"def _preloop_hook(self) -> None:\\n self.selectorloop = SelectorThread(daemon=True)\\n self.selectorloop.start()\",\n \"def test_eventloop_api(self):\\n from twisted.python.log import startLoggingWithObserver\\n from crochet import _shutdown\\n self.assertIsInstance(_main, EventLoop)\\n self.assertEqual(_main.setup, setup_crochet)\\n self.assertEqual(_main.no_setup, no_setup)\\n self.assertEqual(_main.run_in_reactor, run_in_reactor)\\n self.assertEqual(_main.wait_for, wait_for)\\n self.assertIdentical(_main._atexit_register, _shutdown.register)\\n self.assertIdentical(\\n _main._startLoggingWithObserver, startLoggingWithObserver)\\n self.assertIdentical(_main._watchdog_thread, _shutdown._watchdog)\",\n \"def loop(self):\\n return self.caller.location.ndb.event_line_loop\",\n \"def _spin_wx(self):\\n import wx\\n app = wx.GetApp()\\n if app is not None and wx.Thread_IsMain():\\n evtloop = wx.EventLoop()\\n ea = wx.EventLoopActivator(evtloop)\\n while evtloop.Pending():\\n evtloop.Dispatch()\\n app.ProcessIdle()\\n del ea\",\n \"def set_asyncio_event_loop(event_loop_path: Optional[str]) -> AbstractEventLoop:\\n if event_loop_path is not None:\\n event_loop_class: Type[AbstractEventLoop] = load_object(event_loop_path)\\n event_loop = event_loop_class()\\n asyncio.set_event_loop(event_loop)\\n else:\\n try:\\n with catch_warnings():\\n # In Python 3.10.9, 3.11.1, 3.12 and 3.13, a DeprecationWarning\\n # is emitted about the lack of a current event loop, because in\\n # Python 3.14 and later `get_event_loop` will raise a\\n # RuntimeError in that event. Because our code is already\\n # prepared for that future behavior, we ignore the deprecation\\n # warning.\\n filterwarnings(\\n \\\"ignore\\\",\\n message=\\\"There is no current event loop\\\",\\n category=DeprecationWarning,\\n )\\n event_loop = asyncio.get_event_loop()\\n except RuntimeError:\\n # `get_event_loop` raises RuntimeError when called with no asyncio\\n # event loop yet installed in the following scenarios:\\n # - Previsibly on Python 3.14 and later.\\n # https://github.com/python/cpython/issues/100160#issuecomment-1345581902\\n event_loop = asyncio.new_event_loop()\\n asyncio.set_event_loop(event_loop)\\n return event_loop\",\n \"async def _main(self):\\n while True:\\n time.sleep(1)\",\n \"def get_event_loop():\\n try:\\n return asyncio.get_running_loop()\\n except RuntimeError:\\n return asyncio.new_event_loop()\",\n \"def run(self):\\n self.cmdloop()\",\n \"def run():\\n gui = GUI()\\n gui.mainloop()\",\n \"def run(self):\\n if self.okay:\\n ExtLoopWin32.run()\",\n \"def reactor_loop():\\n def on_running():\\n \\\"\\\"\\\"\\n called when the twisted reactor is running\\n \\\"\\\"\\\"\\n log.msg('reactor_loop Starting')\\n try:\\n conn = client.connect(reactor)\\n si446x_do = Si446xComponent(conn)\\n conn.addCallback(si446x_do.start)\\n conn.addErrback(si446x_do.on_error)\\n except error.DBusException, e:\\n log.msg('reactor_loop Setup Error: {}'.format(e))\\n reactor.stop()\\n\\n signal.signal(signal.SIGINT, SIGINT_CustomEventHandler)\\n signal.signal(signal.SIGHUP, SIGINT_CustomEventHandler)\\n reactor.callWhenRunning(on_running)\\n reactor.run()\",\n \"def run(self):\\n\\n while not self.done:\\n\\n self.event_loop()\\n\\n self.update()\",\n \"def event_loop(self, index):\\n logger.debug(\\\"Starting event loop \\\"+str(index))\\n self.stop_flag = Event()\\n stop_flag = self.stop_flag # Saving a reference.\\n # stop_flag is an object that will signal the current input thread to exit or not exit once it's done processing a callback.\\n # It'll be called just before self.stop_flag will be overwritten. However, we've got a reference to it and now can check the exact flag this thread itself constructed.\\n # Praise the holy garbage collector.\\n stop_flag.clear()\\n while not stop_flag.isSet():\\n if self.get_current_proxy() is not None:\\n try:\\n key = self.queue.get(False, 0.1)\\n except Queue.Empty:\\n # here an active event_loop spends most of the time\\n sleep(0.1)\\n except AttributeError:\\n # typically happens upon program termination\\n pass\\n else:\\n # here event_loop is usually busy\\n self.process_key(key)\\n else:\\n # No current proxy set yet, not processing anything\\n sleep(0.1)\\n logger.debug(\\\"Stopping event loop \\\"+str(index))\",\n \"def run_event_loop(async_loop, wait_tasks):\\n while True:\\n try:\\n async_loop.run_until_complete(wait_tasks)\\n break\\n except RuntimeError:\\n time.sleep(3)\",\n \"async def test_events_handled_on_event_loop(self):\\n session = _create_test_session(asyncio.get_running_loop())\\n\\n handle_event_spy = MagicMock(\\n side_effect=session._handle_scriptrunner_event_on_event_loop\\n )\\n session._handle_scriptrunner_event_on_event_loop = handle_event_spy\\n\\n # Send a ScriptRunner event from another thread\\n thread = threading.Thread(\\n target=lambda: session._on_scriptrunner_event(\\n sender=MagicMock(), event=ScriptRunnerEvent.SCRIPT_STARTED\\n )\\n )\\n thread.start()\\n thread.join()\\n\\n # _handle_scriptrunner_event_on_event_loop won't have been called\\n # yet, because we haven't yielded the eventloop.\\n handle_event_spy.assert_not_called()\\n\\n # Yield to let the AppSession's callbacks run.\\n # _handle_scriptrunner_event_on_event_loop will be called here.\\n await asyncio.sleep(0)\\n\\n handle_event_spy.assert_called_once()\",\n \"def Gameloop():\",\n \"def start_loop(self, loop):\\n asyncio.set_event_loop(loop)\\n loop.run_forever()\",\n \"def update(self):\\n asyncio.set_event_loop(asyncio.new_event_loop())\\n self.listen(self.port)\\n self.loop = IOLoop.instance()\\n self.loop.start()\",\n \"def main_loop(self):\\n LOGGER.info('Entering main event loop...')\\n try:\\n while self._handle_faucet_events():\\n while not self._faucet_events.event_socket_connected:\\n LOGGER.info('Attempting faucet event sock connection...')\\n time.sleep(1)\\n try:\\n self._faucet_events.connect()\\n self._restore_states()\\n self._faucet_collector.set_state_restored(True)\\n except Exception as e:\\n LOGGER.error(\\\"Cannot restore states or connect to faucet: %s\\\", e)\\n self._faucet_collector.set_state_restored(False, e)\\n except KeyboardInterrupt:\\n LOGGER.info('Keyboard interrupt. Exiting.')\\n self._faucet_events.disconnect()\\n except Exception as e:\\n LOGGER.error(\\\"Exception: %s\\\", e)\\n raise\",\n \"def mock_event_loop() -> Generator[AbstractEventLoop, Any, None]:\\n loop = get_event_loop()\\n yield loop\\n loop.close()\",\n \"def main():\\n BouncyGUI().mainloop()\",\n \"def postprocess(self, loop):\\n return loop\",\n \"def use_twisted(app):\\n activity.EventLoop <<= activity.TwistedEventLoop\\n REACTOR_INIT.notify(app)\",\n \"def event_loop(self):\\n for event in pg.event.get():\\n self.keys = pg.key.get_pressed()\\n if event.type == pg.QUIT or self.keys[pg.K_ESCAPE]:\\n self.done = True\\n self.cannon.get_event(event, self.objects)\",\n \"def main_loop(self):\\n try:\\n self.state_machine.set_state('wait')\\n\\n while True:\\n events = list(reversed(pygame.event.get())) # Take all events, most recent first\\n\\n if self.find_quit_event(events):\\n break\\n\\n if self.find_fullscreen_event(events):\\n self.window.toggle_fullscreen()\\n\\n event = self.find_resize_event(events)\\n if event:\\n self.window.resize(event.size)\\n\\n self.state_machine.process(events)\\n\\n finally:\\n self.led_picture.quit()\\n self.led_print.quit()\\n GPIO.cleanup()\\n self.camera.quit()\\n self.printer.quit()\\n pygame.quit()\",\n \"def maybe_patch_ioloop():\\n if (\\n sys.platform.startswith(\\\"win\\\")\\n and tornado.version_info < (6, 1)\\n and sys.version_info >= (3, 8)\\n ):\\n try:\\n from asyncio import WindowsProactorEventLoopPolicy, WindowsSelectorEventLoopPolicy\\n except ImportError:\\n pass\\n # not affected\\n else:\\n from asyncio import get_event_loop_policy, set_event_loop_policy\\n\\n if type(get_event_loop_policy()) is WindowsProactorEventLoopPolicy:\\n # WindowsProactorEventLoopPolicy is not compatible with tornado 6\\n # fallback to the pre-3.8 default of Selector\\n set_event_loop_policy(WindowsSelectorEventLoopPolicy())\",\n \"def event_loop(self):\\n while self.ack is False:\\n gevent.sleep(self.loop_interval)\\n output_service = self.get_directory_service_proxy().get_service(\\\"mock-output-service\\\")\\n output_service.put(\\\"test-worker-work-result\\\")\\n self.ack = True\",\n \"def _event_loop_thread(self):\\n _logger.debug(f'Started DataSource event loop thread {self._thread}.')\\n self._event_loop.set_debug(True)\\n asyncio.set_event_loop(self._event_loop)\\n try:\\n self._event_loop.call_soon(self._main_helper)\\n self._event_loop.run_forever()\\n finally:\\n self._event_loop.close()\\n _logger.info(f'Source [{(self._addr, self._port)}] closed.')\",\n \"def main(self):\\n self.root.mainloop()\",\n \"def _get_loop(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Optional[asyncio.AbstractEventLoop]:\\n if callable(self.loop_getter):\\n if self.loop_getter_need_context:\\n return self.loop_getter(*args, **kwargs) # pylint: disable=not-callable\\n return self.loop_getter() # pylint: disable=not-callable\\n return self.loop_getter\",\n \"def run(self):\\n self.window.mainloop()\",\n \"def _hijack_tk(self):\\n import Tkinter\\n orig_mainloop = gtk.main\\n dumb_ml = _DummyMainloop(orig_mainloop, self, GUI_TK)\\n Tkinter.Misc.mainloop = dumb_ml\\n Tkinter.mainloop = dumb_ml\",\n \"def mainloop(duration=1):\\n\\n _triggered.clear()\\n NSApp = _NSApp()\\n _stop_after(duration)\\n msg(NSApp, n(\\\"run\\\"))\\n if not _triggered.is_set():\\n # app closed without firing callback,\\n # probably due to last window being closed.\\n # Run the loop manually in this case,\\n # since there may be events still to process (ipython/ipython#9734)\\n CoreFoundation.CFRunLoopRun()\",\n \"def loop(self):\\n\\n print(self.id + \\\" needs an overridden loop method\\\")\",\n \"def run(self):\\n self.loop.spawn_callback(self.main)\\n self.loop.start()\\n if self.exc_info:\\n six.reraise(*self.exc_info)\",\n \"async def checkNewLoop(self):\\n pass\",\n \"def __loop(self):\\n\\n self.__update_table()\\n self.__update_labels()\\n if self.remote_stop:\\n self.__stop(\\\"remote telegram admin\\\")\\n else:\\n self.__main_window.after(1000, self.__loop)\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n if self.event_loop:\\n self.event_loop.stop()\",\n \"def postloop(self):\\n print 'Bye!'\",\n \"async def main(logic):\\n await GLOBE.connect()\\n await asyncio.wait([GLOBE.run_loop(), logic()])\",\n \"def run(self):\\n try:\\n self.event_loop = asyncio.new_event_loop()\\n asyncio.set_event_loop(self.event_loop)\\n template_system = LegionTemplateEngine(self.template_path, self.output_path)\\n template_system.render_loop()\\n\\n except Exception as exception:\\n self.raised_exception = exception\\n raise self.raised_exception\",\n \"def __init__(self):\\n self.gameloop()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.81281793","0.7433964","0.71915084","0.71593684","0.7092627","0.70529735","0.70341283","0.70070803","0.69741666","0.69741666","0.69633144","0.69001657","0.6889111","0.6859079","0.6846811","0.6844431","0.68335426","0.68281376","0.6722399","0.6682619","0.66650563","0.6625124","0.661982","0.66001344","0.65723383","0.65689635","0.6408248","0.6408248","0.6408248","0.6408248","0.63876116","0.63644767","0.63459575","0.6328928","0.6306496","0.63052034","0.6303287","0.6303287","0.62774456","0.6238053","0.61861664","0.61696285","0.6160671","0.61584836","0.6114627","0.61127836","0.6074787","0.6070557","0.6065858","0.606554","0.60187423","0.60187423","0.59994286","0.5994193","0.5973154","0.5955565","0.5932075","0.5930467","0.5928529","0.59139395","0.591257","0.5911105","0.58966964","0.58927506","0.5888072","0.58858407","0.58642143","0.58580196","0.5851221","0.5846065","0.583578","0.5828538","0.58175385","0.5812145","0.58116597","0.5810035","0.5808205","0.5807698","0.58030474","0.5792686","0.5784407","0.57761276","0.57671946","0.5756962","0.57500523","0.57380444","0.5736097","0.57273394","0.57204276","0.57167107","0.5716562","0.5708114","0.56995285","0.5698656","0.5695172","0.56891704","0.56885856","0.5688358","0.5678936","0.56783384","0.56728864"],"string":"[\n \"0.81281793\",\n \"0.7433964\",\n \"0.71915084\",\n \"0.71593684\",\n \"0.7092627\",\n \"0.70529735\",\n \"0.70341283\",\n \"0.70070803\",\n \"0.69741666\",\n \"0.69741666\",\n \"0.69633144\",\n \"0.69001657\",\n \"0.6889111\",\n \"0.6859079\",\n \"0.6846811\",\n \"0.6844431\",\n \"0.68335426\",\n \"0.68281376\",\n \"0.6722399\",\n \"0.6682619\",\n \"0.66650563\",\n \"0.6625124\",\n \"0.661982\",\n \"0.66001344\",\n \"0.65723383\",\n \"0.65689635\",\n \"0.6408248\",\n \"0.6408248\",\n \"0.6408248\",\n \"0.6408248\",\n \"0.63876116\",\n \"0.63644767\",\n \"0.63459575\",\n \"0.6328928\",\n \"0.6306496\",\n \"0.63052034\",\n \"0.6303287\",\n \"0.6303287\",\n \"0.62774456\",\n \"0.6238053\",\n \"0.61861664\",\n \"0.61696285\",\n \"0.6160671\",\n \"0.61584836\",\n \"0.6114627\",\n \"0.61127836\",\n \"0.6074787\",\n \"0.6070557\",\n \"0.6065858\",\n \"0.606554\",\n \"0.60187423\",\n \"0.60187423\",\n \"0.59994286\",\n \"0.5994193\",\n \"0.5973154\",\n \"0.5955565\",\n \"0.5932075\",\n \"0.5930467\",\n \"0.5928529\",\n \"0.59139395\",\n \"0.591257\",\n \"0.5911105\",\n \"0.58966964\",\n \"0.58927506\",\n \"0.5888072\",\n \"0.58858407\",\n \"0.58642143\",\n \"0.58580196\",\n \"0.5851221\",\n \"0.5846065\",\n \"0.583578\",\n \"0.5828538\",\n \"0.58175385\",\n \"0.5812145\",\n \"0.58116597\",\n \"0.5810035\",\n \"0.5808205\",\n \"0.5807698\",\n \"0.58030474\",\n \"0.5792686\",\n \"0.5784407\",\n \"0.57761276\",\n \"0.57671946\",\n \"0.5756962\",\n \"0.57500523\",\n \"0.57380444\",\n \"0.5736097\",\n \"0.57273394\",\n \"0.57204276\",\n \"0.57167107\",\n \"0.5716562\",\n \"0.5708114\",\n \"0.56995285\",\n \"0.5698656\",\n \"0.5695172\",\n \"0.56891704\",\n \"0.56885856\",\n \"0.5688358\",\n \"0.5678936\",\n \"0.56783384\",\n \"0.56728864\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3298,"cells":{"query":{"kind":"string","value":"Updates x, y (memoryshared) coordinates with actual mouse position with a given frequency."},"document":{"kind":"string","value":"def stream(bus, address, frequency, x, y, stop_trigger):\n mouse = Mouse.list_connected(bus=bus, address=address)[0]\n delay = 1./frequency\n\n while not stop_trigger:\n x1, y1 = mouse.get_position_change()\n x.value += x1\n y.value += y1\n\n time.sleep(delay)"},"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 follow(self):\n\t\tpos = pygame.mouse.get_pos()\n\t\tself.x = pos[0]\n\t\tself.y = pos[1]\n\t\tself.draw()","def mouse_position_event(self, x: int, y: int):\n pass","def update_pointer(self):\n pointer_length = -self.pointer_frac * self.radius\n # Add pi/2 to the angle because we consider 0 radians to be pi/2 in standard position.\n x = pointer_length * math.cos(self._radians + math.pi / 2)\n y = pointer_length * math.sin(self._radians + math.pi / 2)\n self.coords(self.pointer, 0, 0, x, y)","def update(self):\n # Get the current mouse position. This returns the position\n # as a list of two numbers.\n pos = pygame.mouse.get_pos()\n \n # Set the player x position to the mouse x position\n self.rect.x = pos[0]","def on_mouse_motion(self, x, y, delta_x, delta_y):\r\n pass","def update(self):\n # Get the current mouse position. This returns the position\n # as a list of two numbers.\n pos = pygame.mouse.get_pos()\n\n # Set the player x position to the mouse x position\n self.rect.x = pos[0]","def update(self):\r\n self.x = games.mouse.x\r\n self.y = games.mouse.y\r\n self.check_collide()","def update(self):\n self.x = games.mouse.x\n #self.y = games.mouse.y\n self.check_collide()","def set_position(self, updated):\n self.buff_x = updated[0]\n self.buff_y = updated[1]","def update(self):\n self.x = games.mouse.x\n self.y = games.mouse.y\n self.check_collide()","def handle_mouse(self, x, y):\n self.x = x\n self.y = y\n global _pending_handle_mouse\n if not _pending_handle_mouse:\n _pending_handle_mouse = True\n if self.fig.document is not None:\n self.fig.document.add_timeout_callback(self.handle_mouse_callback, 100)\n else:\n self.handle_mouse_callback()","def mousePosition(self):","def mousePositionRaw(self):","def mousePositionRaw(self):","def handle_mouse(self, x, y):\n pass","def on_mouse_motion(self, x, y, delta_x, delta_y):\n\n print(x)\n print(y)\n print(delta_x)\n print(delta_y)\n\n\n #self.manage_crosshair()\n \n \n\n #self.crosshair_sprite.center_x += delta_x\n #self.crosshair_sprite.center_y += delta_y\n\n\n self.crosshair_relative_xoffset += delta_x\n self.crosshair_relative_yoffset += delta_y","def update(self):\n\n\t\tself.x = games.mouse.x\n\t\tself.y = games.mouse.y\n\t\tself.check_collide()","def __master_cursor_pos_callback(self, glfw_window, xpos, ypos):\n # flip glfw window space to match OGL space(like texture that has bottom left origin)\n ypos = self.window.glyph.size[1] - ypos\n\n # update values\n self.__pos_instant = Vec(xpos, ypos, 0)\n self.__accel = self.__pos_instant - self.__pos_prev\n self.__pos_prev = self.__pos_instant\n\n # call registered callbacks\n self.call_cursor_pos_callback(glfw_window, *self.__pos_instant.xy, mouse=self)","def update(self, delta_time):\r\n #for pixels in self.pixel:\r\n for line in self.cursor:\r\n line.draw()\r\n \r\n self.check_keys()","def update(self):\r\n self.x = 60\r\n self.y = games.mouse.y\r\n self.check_collide()","def on_mouse_motion(self, x, y, delta_x, delta_y):\n \n pass","def on_mouse_move(self, event: PointEvent):\n self.x = event.x\n self.y = event.y\n self.handle_mouse(self.x, self.y)","def xy(self, xy_position):\n print(f\"xy: {xy_position}\")\n self.device_control.xy = xy_position\n yield","def OnMouseMotion(self, evt):\n if evt.Dragging() and evt.LeftIsDown():\n self.lastx, self.lasty = self.x, self.y\n self.x, self.y = evt.GetPosition()\n self.Refresh(False)","def handle_mouse(self, x, y):\n # we are in aperture mode\n if self.aperture_id:\n if self.aperture_id not in self.aperture_model.aperture_models.keys():\n pass\n model = self.aperture_model.aperture_models[self.aperture_id]\n location = model.source.data['location'][0]\n\n if self.mode == 'width':\n width = abs(location - x)\n model.update_values(start=location - width,\n end=location + width)\n elif self.mode == 'left':\n if x < location:\n model.update_values(start=x)\n elif self.mode == 'right':\n if x > location:\n model.update_values(end=x)\n elif self.mode == 'location':\n diff = x - location\n model.update_values(location=x,\n start=model.source.data['start'][0] + diff,\n end=model.source.data['end'][0] + diff)\n\n self.last_x = x\n self.last_y = y\n return False","def on_mouse_move(self, event):\n self.mouse = [event.xdata, event.ydata]\n\n # Update pan view on mouse move\n if self.panning is True:\n for a in self.pan_axes:\n a.drag_pan(1, event.key, event.x, event.y)\n\n # Async re-draw (redraws only on thread idle state, uses timer on backend)\n self.canvas.draw_idle()\n\n ##### Temporary place-holder for cached update #####\n self.update_screen_request.emit([0, 0, 0, 0, 0])","def update_tempLists(self):\n self.current_position = self.mediaPlayer.position()\n\n # I add the current value, calculates its index, and removes it. This method is used to know which index the pointer is at.\n bisect.insort(self.xValues,self.current_position)\n self.position_index = self.xValues.index(self.current_position)\n self.xValues.remove(self.current_position)\n\n n = 120\n if self.position_index < n: \n self.tempXList = self.xValues[:self.position_index + n]\n self.tempYList = self.yValues[:self.position_index + n]\n self.tempCList = self.colors[:self.position_index + n]\n else:\n self.tempXList = self.xValues[self.position_index - n :self.position_index + n]\n self.tempYList = self.yValues[self.position_index - n :self.position_index + n]\n self.tempCList = self.colors[self.position_index - n :self.position_index + n]","def handle_motion(self, x, y):\n if self.pressed_flag:\n self.last_point = (x, y)\n\n # trigger canvas to redraw itself\n self.redraw()","def move_to_point(self, destination, frequency):\r\n # index 0 represents x, index 1 represents y\r\n if frequency > 1:\r\n x_towards = int(round((destination[0] - current_position[0]) / frequency))\r\n if x_towards > 1:\r\n x_towards -= 1\r\n y_towards = int(round((destination[1] - current_position[1]) / frequency))\r\n if y_towards > 1:\r\n y_towards -= 1\r\n current_position = list(self.current_position)\r\n if current_position[0] < destination[0]: # if x is west\r\n current_position[0] = current_position[0] + x_towards\r\n x_change = int(frequency)\r\n if current_position[0] >= destination[0]: # if this overshoots:\r\n current_position[0] = destination[0]\r\n elif current_position[0] == destination[0]:\r\n pass # don't move\r\n else:\r\n current_position[0] = current_position[0] - x_towards\r\n x_change = 0 - int(frequency)\r\n if current_position[0] <= destination[0]: # if this overshoots:\r\n current_position[0] = destination[0]\r\n if current_position[1] < destination[1]:\r\n current_position[1] = current_position[1] + y_towards\r\n y_change = int(frequency)\r\n if current_position[1] >= destination[1]: # if this overshoots:\r\n current_position[1] = destination[1]\r\n elif current_position[1] == destination[1]:\r\n pass\r\n else:\r\n current_position[1] = current_position[1] - y_towards\r\n y_change = 0 - int(frequency)\r\n if current_position[1] <= destination[1]: # if this overshoots:\r\n current_position[1] = destination[1]\r\n\r\n current_position = tuple(current_position)\r\n self.move_to(current_position)\r\n for i in list(range(1, int(frequency))):\r\n human_avoidance_list.append((current_position[0] + x_change, current_position[1] + y_change))\r\n self.current_position = current_position\r\n if current_position[0] == destination[0] and current_position[1] == destination[1]:\r\n self.resource_check = 1\r\n else:\r\n self.resource_frequency += self.resource_frequency / 6 # 6 * 5 days in a step = 30 days in a month\r\n # resource frequency is listed monthly in the source file\r\n # this indicates time passing each step until the gatherer can move\r","def track_point(self, flags, x, y):\n ret_val, x.value, y.value = self._track_point(flags, x.value, y.value)\n return ret_val","def _updateOnMouseState(self, state):\n x = state.X.abs\n y = state.Y.abs\n \n mscale = self.mouse_icon.getScale() \n \n if (x + mscale[0] + self.mouse_offset) > render_engine.Window.width:\n x = x - mscale[0] - 10\n else:\n x += self.mouse_offset\n \n if (y + mscale[1] + self.mouse_offset) > render_engine.Window.height:\n y = y - mscale[1] - 10\n else:\n y += self.mouse_offset\n \n self.mouse_icon.setPosition((x, y))","def click_action(event, ax):\n global newcoords, oldcoords, count\n\n if count % 2 == 0:\n newcoords.append((event.xdata, event.ydata))\n print('NEW', event.xdata, event.ydata)\n else:\n oldcoords.append((event.xdata, event.ydata))\n print('OLD', event.xdata, event.ydata)\n # update count\n count += 1","def grab(self, event):\n self.ypos = event.y\n self.xpos = event.x\n self.config(cursor='fleur')","def update(self):\n self.mousePos = pygame.mouse.get_pos()\n self.update_button_hover_status()","def update(self):\n self.bpos_x += 3","def _motion(self, event):\n if self.current:\n # modify the current line by changing the end coordinates\n # to be the current mouse position\n coords = event.widget.coords(self.current)\n coords[2] = event.x\n coords[3] = event.y\n\n event.widget.coords(self.current, *coords)","def cmdMouse(self, dev):\n self.hitsMouses[dev] = False\n f = open(self.inputPath + dev, 'rb')\n while self.live:\n f.read(500) # 144 kan eigenlijk alles zijn, behalve absurbt hoge waarden..\n self.hitsMouses[dev] = True\n time.sleep(0.1)","def on_mousemove(event, x, y, flags, userparam):\n global mouse_pos\n global source_img, source_msk, display_img\n global DRAW_MODE\n\n if event == cv.EVENT_MOUSEMOVE:\n mouse_pos = (x, y)\n\n if flags & cv.EVENT_FLAG_SHIFTKEY:\n current_label = LABEL_BACKGROUND\n else:\n current_label = CURRENT_LABEL\n\n if DRAW_MODE == \"point\":\n if flags & cv.EVENT_FLAG_CTRLKEY:\n cv.circle(source_msk, (x, y), SHAPE_SIZE, current_label, -1)\n elif DRAW_MODE == \"line\":\n # line drawing is done in the line-mode keypress handler (keydown())\n pass","def update(self, xdata=[], ydata=[]):\n for i in range(4):\n self.lines[i].set_data(xdata[i], ydata[i])\n\n self.blit()","def set_new_location(self, xPos, yPos):","def update_position_and_spike_frame(self, step=0):\n if self._spk_pos_ax is not None:\n # print(self._pos_x)\n # print(self._pos_y)\n # TODO: Add colors based on which cluster the spikes are coming from\n self._spk_pos_frame[0].set_data((self._spk_pos_x, self._spk_pos_y))\n # self._spk_pos_frame[0].set_color(self._spk_clusters)\n self._spk_pos_frame[1].set_data((self._pos_x, self._pos_y))\n if len(self._speed) > 0:\n self._spk_pos_frame[2].set_text('speed = %.2fcm/s'%self._speed[-1])\n return self._spk_pos_frame","def changespeed(self, x, y):\n self.change_x += x\n self.change_y += 200","def changespeed(self, x, y):\n self.change_x += x\n self.change_y += y","def changespeed(self, x, y):\n self.change_x += x\n self.change_y += y","def changespeed(self, x, y):\n self.change_x += x\n self.change_y += y","def update(self, i):\n\n self.current_position = self.mediaPlayer.position()\n \t\n \n\n \"\"\"\n \"Record mode\" and \"wide x-axis mode\" shouls not work together. Wide mode is only for reading data, not writing data. \n The user is not allowed to write data when 16 000 points are displayed (wide mode) on tha diagram. If he does so, the frequency of the graph points decreases with time. \n \"\"\"\n \n if self.checkbox.isChecked():\n self.wideRadio.setEnabled(False)\n if not self.checkbox.isChecked():\n self.wideRadio.setEnabled(True)\n if self.wideRadio.isChecked():\n self.checkbox.setEnabled(False)\n if not self.wideRadio.isChecked():\n self.checkbox.setEnabled(True)\n \n\n\n if self.checkbox.isChecked() and self.mediaPlayer.state() == QMediaPlayer.PlayingState:\n \n self.savedRecently = False\n\n\n self.current_position = self.mediaPlayer.position()\n\n \n if self.xValues == []:\n # \"If the list of xValues is empty\". This happens only in the start of the plotting process.\n self.xValues.append(self.current_position)\n self.yValues.append(self.mouseY)\n self.colors.append(self.currentColor)\n\n #self.position_index = self.xValues.index(self.current_position)\n \n\n if self.xValues != []:\n\n if self.current_position > max(self.xValues):\n # \"If the point is bigger than the last point\". I.e if the point will be plotted in the end of the current graph.\n\n self.xValues.append(self.current_position)\n self.yValues.append(self.mouseY)\n self.colors.append(self.currentColor)\n\n self.position_index = self.xValues.index(self.current_position)\n\n if self.current_position < max(self.xValues):\n # \"If the point is smaller than the last point\". I.e if the point will be plotted in the middle of the current graph.\n\n \n if self.mediaPlayer.position() < 100:\n # The program has a problem of removing a point if x=0. This if-statement solves the problem.\n self.xValues.pop(0)\n self.yValues.pop(0)\n self.colors.pop(0)\n \n\n\n # Clearing all the points that are 100 ms (or less) in front of the current position. \n for number in range(self.current_position, self.current_position + 100):\n if number in self.xValues:\n self.yValues.pop(self.xValues.index(number))\n self.colors.pop(self.xValues.index(number))\n self.xValues.remove(number)\n \n \n \n # Plot new points\n bisect.insort(self.xValues,self.current_position) # Through this method, the element is inserted in order.\n self.yValues.insert(self.xValues.index(self.current_position), self.mouseY)\n self.colors.insert(self.xValues.index(self.current_position), self.currentColor)\n\n self.position_index = self.xValues.index(self.current_position)\n \n\n\n # View modes: zoom or wide.\n\n if self.zoomRadio.isChecked():\n self.canvas.axes.set_ylim(0, 100)\n self.canvas.axes.set_xlim(self.current_position-5000, self.current_position+5000)\n\n self.update_tempLists()\n\n self.curve = self.canvas.axes.scatter(self.tempXList, self.tempYList, s=10 , c=self.tempCList)\n\n\n\n if self.wideRadio.isChecked():\n self.canvas.axes.set_ylim(0, 100)\n\n if self.mediaPlayer.duration() != 0:\n self.canvas.axes.set_xlim(0, self.mediaPlayer.duration())\n elif self.xValues != []:\n self.canvas.axes.set_xlim(0, max(self.xValues))\n\n self.curve = self.canvas.axes.scatter(self.xValues, self.yValues, s=10 , c=self.colors)\n\n \n\n # I remove the previous vertical and horizontal lines. If I do not remove them, the program gets slower and slower, and the frequency of the points decreases with time.\n self.hline.remove()\n self.vline.remove()\n \n # New vertical and horizontal lines are created and updated to the correct values.\n self.vline = self.canvas.axes.axvline(x=self.mediaPlayer.position(), color='gray',linestyle=\":\")\n self.hline = self.canvas.axes.axhline(y=self.mouseY, color='gray',linestyle=\":\")\n\n\n\n return [self.curve] + [self.vline] + [self.hline]","def ev_mousemotion(self, event: MouseMotion) -> None:","def update(self):\n self.t = time()\n self.frame += 1\n self.loop(self)\n self.draw_bg()\n self.draw_C()\n if self.cursor:\n self.draw_rect(*self.pos, RED, 2)\n self.draw_grid()\n self.draw_T()\n self.show_info()\n for (surf, rect) in self.surf_list:\n self.screen.blit(surf, rect)\n pygame.display.update()\n self.clock.tick(self.fps)","def normal_mouse_move(self, event):\n plot = self.component\n if plot is not None:\n if isinstance(plot, BaseXYPlot):\n ndx = plot.map_index((event.x, event.y), index_only = True)\n x = plot.index.get_data()[ndx]\n y = plot.value.get_data()[ndx]\n print self.format % (x,y)\n else:\n print \"dataprinter: don't know how to handle plots of type\",\n print plot.__class__.__name__\n return","def ev_MOUSEMOTION(self, event):","def mouse_move(self, pos):\n if (self.setup_type == \"position\"):\n x, y = pos\n self.canvas.move(x, y)","def report_mouse_position(x_pos=0, y_pos=0):\n print('x-axis:', x_pos, ' Y-axis: ', y_pos, flush=True)","def update():\n\n # Get last new x value as last x value + 1\n x_n0 = data_source.data['x'][-1]\n x_n1 = x_n0 + 0.1\n\n # Assign a new y value\n y_n1 = param_source.data['amp_sine'][0] * np.sin(x_n1) +\\\n param_source.data['amp_rand'][0] * np.random.rand(1)\n\n # Get old last average and use to calculate new average\n avg_n1 = _get_new_avg(data_source,\n y_n1,\n param_source.data['rollover'][0])\n\n # Make a dict of data to add on to the end of the source\n additional_data = dict(x=[x_n1], y=[y_n1], avg=[avg_n1])\n\n # Stream the new data with a rollover value of 10\n data_source.stream(additional_data,\n rollover=param_source.data['rollover'][0])\n\n # logger.debug(param_source.data['update_delay'][0])","def update():\n global dragon, x, y, position, angle_left, angle_right, size, new\n x, y, position, angle_left, angle_right, new = modify_pos(x, y, position,\n angle_left,\n angle_right,\n size, new)\n dragon.setData(x, y) # update plot","def pointer_notify_motion(\n self, time_msec: int, surface_x: float, surface_y: float\n ) -> None:\n lib.wlr_seat_pointer_notify_motion(self._ptr, time_msec, surface_x, surface_y)","def handle_mouse(obj, event):\n if event:\n x = event.globalX()\n y = event.globalY()\n x_w = obj.offset.x()\n y_w = obj.offset.y()\n obj.move(x - x_w, y - y_w)","def follow_mouse(self, mouse):\n half_width = self.width() / 2\n self.left = mouse.get_x() - half_width\n self.right = mouse.get_x() + half_width","def onMove(self, event):\n\t\tif (event.xdata != None and event.ydata != None and event.xdata != self.xdata and event.ydata != self.ydata):\n\n\t\t\tself.xdata = event.xdata\n\t\t\tself.ydata = event.ydata\n\n\t\t\tfor loop in range(4):\n\t\t\t\tself.stokesFig.canvas.restore_region(self.background[loop])\n\t\t\t\tself.obsStokes[loop].set_ydata(self.stokes[loop][event.ydata, event.xdata, :])\n\t\t\t\tself.axStokes[loop].draw_artist(self.obsStokes[loop])\n\t\t\t\tself.axStokes[loop].draw_artist(self.axStokes[loop].get_yaxis())\n\t\t\t\tself.stokesFig.canvas.blit(self.axStokes[loop].bbox.expanded(1.4, 1.1))","def trackMouse(self, mouse_event):\n if self.kinect.DepthFrameRaw.any() != 0:\n u = mouse_event.pos().x()\n v = mouse_event.pos().y()\n d = self.kinect.DepthFrameRaw[v,u]\n self.ui.rdoutMousePixels.setText(\"(\"+str(u)+\",\"+str(v)+\",\"+str(d)+\")\")\n worldCoords = self.kinect.pix2Glob(np.array([u,v,1])) * 1000 #1000 for mm\n self.ui.rdoutMouseWorld.setText(f\"({np.round(worldCoords[0])},{np.round(worldCoords[1])},{np.round(worldCoords[2])})\")","def cambiovelocidad(self,x,y):\n self.change_x += x\n self.change_y += y","def move_mouse(kf_x, m, img): \n exponent = 1.6\n x, y, x_vel, y_vel = (int(kf_x[0]), int(kf_x[1]), kf_x[2], kf_x[3])\n mx, my = m.position()\n win_height, win_width, channel = img.shape\n x_screen, y_screen = m.screen_size()\n min_x, max_x = 0, x_screen\n min_y, max_y = 0, y_screen \n\n #Calculations\n speed = np.sqrt(x_vel**2 + y_vel**2) \n power = math.pow(speed, exponent) \n ratio = speed / power\n theta = math.atan2(y_vel, x_vel) \n x_comp = power * math.cos(theta) \n y_comp = power * math.sin(theta) \n xf, yf = mx + x_comp, my + y_comp\n\n if xf < min_x: \n xf = min_x\n elif xf > max_x: \n xf = max_x\n elif yf < min_y: \n yf = min_y\n elif yf > max_y: \n yf = max_y\n m.move(xf, yf)\n return speed","def mouseReleaseEvent(self, event):\n width = self.frameGeometry().width()\n height = self.frameGeometry().height()\n cursor = QtGui.QCursor()\n new_pos = self.mapFromGlobal(cursor.pos())\n x = new_pos.x()\n y = new_pos.y()\n self.__selector_y = y/float(height) # normalized value of the y position\n \tself.__selector_x = x/float(width) #normalised value of the x position\n self.updatePixelColor()\n self.repaint()","def mouseDragged(self, point, delta):\n pass","def update_position(self, time_step):\n if not self.gpu:\n self.psi_hat[...] = fft.fftn(self.psi)\n update_position(self.psi_hat, time_step, self.m)\n self.psi[...] = fft.ifftn(self.psi_hat)\n else:\n cufft.cufftExecZ2Z(self.psi_plan, self.g_psi.ptr, self.g_psi_hat.ptr, cufft.CUFFT_FORWARD)\n self.g_psi_hat /= self.N\n self.g_mom_func(self.g_psi_hat, np.float64(time_step), np.int64(self.psi_hat.shape[0]), np.int64(self.psi_hat.shape[1]), np.int64(self.psi_hat.shape[2]), block=(8,8,8), grid=tuple([(i+7)/8 for i in self.psi_hat.shape]))\n cufft.cufftExecZ2Z(self.psi_plan, self.g_psi_hat.ptr, self.g_psi.ptr, cufft.CUFFT_INVERSE)","def seek(self,event):\r\n if self.app.controlLock.locked():\r\n return\r\n self.app.controlLock.acquire()\r\n x = event.x\r\n scalex,_ = self.getScale()\r\n scalex_secs = [scalex[0]/self.samplerate,scalex[1]/self.samplerate]# Get x scale in seconds\r\n seekTo = (x/self.w) * (scalex_secs[1]-scalex_secs[0]) + scalex_secs[0]# Transform pixel coordinates to represented time\r\n self.app.videoPlayer.pause()\r\n self.app.videoPlayer.seek(seekTo-self.app.dataOffset)\r\n self.app.videoPlayer.pause()# Restart audio to sync\r\n self.update(self.app.videoPlayer.startTimestamp)\r\n self.draw()\r\n self.app.videoPlayer.play()\r\n self.app.controlLock.release()","def updateAccelList():\n # Get new sensor update/s\n x, y, z = getSensorAccel()\n \n # Pop out old values (idx 0)\n listAccelX.pop(0) # ignore outgoing value\n listAccelY.pop(0) # ignore outgoing value\n listAccelZ.pop(0) # ignore outgoing value\n \n # Append the new values\n listAccelX.append(x)\n listAccelY.append(y)\n listAccelZ.append(z)","def getPoslbFFmpeg(self, event):\n # if self.measurement_w:\n\n if hasattr(self, \"measurement_w\") and self.measurement_w is not None and self.measurement_w.isVisible():\n x = event.pos().x()\n y = event.pos().y()\n\n # distance\n if self.measurement_w.rbDistance.isChecked():\n if event.button() == 1: # left\n self.draw_point(x, y, \"lime\")\n self.memx, self.memy = x, y\n\n if event.button() == 2 and self.memx != -1 and self.memy != -1:\n self.draw_point(x, y, \"lime\")\n self.draw_line(self.memx, self.memy, x, y, \"lime\")\n\n if self.FFmpegGlobalFrame in self.measurement_w.draw_mem:\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame].append([\"line\", self.memx, self.memy, x, y])\n else:\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame] = [[\"line\", self.memx, self.memy, x, y]]\n\n d = ((x - self.memx) ** 2 + (y - self.memy) ** 2) ** 0.5\n try:\n d = d / float(self.measurement_w.lePx.text()) * float(self.measurement_w.leRef.text())\n except:\n QMessageBox.critical(self, programName,\n \"Check reference and pixel values! Values must be numeric.\",\n QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton)\n\n self.measurement_w.pte.appendPlainText(\"Time: {}\\tFrame: {}\\tDistance: {}\".format(self.getLaps(),\n self.FFmpegGlobalFrame,\n round(d, 1)))\n self.measurement_w.flagSaved = False\n self.memx, self.memy = -1, -1\n\n # angle 1st clic -> vertex\n if self.measurement_w.rbAngle.isChecked():\n if event.button() == 1: # left for vertex\n self.draw_point(x, y, \"lime\")\n self.memPoints = [(x, y)]\n\n if event.button() == 2 and len(self.memPoints):\n self.draw_point(x, y, \"lime\")\n self.draw_line(self.memPoints[0][0], self.memPoints[0][1], x, y, \"lime\")\n\n self.memPoints.append((x, y))\n\n if len(self.memPoints) == 3:\n self.measurement_w.pte.appendPlainText(\"Time: {}\\tFrame: {}\\tAngle: {}\".format(self.getLaps(),\n self.FFmpegGlobalFrame,\n round(angle(\n self.memPoints[\n 0],\n self.memPoints[\n 1],\n self.memPoints[\n 2]),\n 1)\n ))\n self.measurement_w.flagSaved = False\n if self.FFmpegGlobalFrame in self.measurement_w.draw_mem:\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame].append([\"angle\", self.memPoints])\n else:\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame] = [[\"angle\", self.memPoints]]\n\n self.memPoints = []\n\n # Area\n if self.measurement_w.rbArea.isChecked():\n if event.button() == 1: # left\n self.draw_point(x, y, \"lime\")\n if len(self.memPoints):\n self.draw_line(self.memPoints[-1][0], self.memPoints[-1][1], x, y, \"lime\")\n self.memPoints.append((x, y))\n\n if event.button() == 2 and len(self.memPoints) >= 2:\n self.draw_point(x, y, \"lime\")\n self.draw_line(self.memPoints[-1][0], self.memPoints[-1][1], x, y, \"lime\")\n self.memPoints.append((x, y))\n # close polygon\n self.draw_line(self.memPoints[-1][0], self.memPoints[-1][1], self.memPoints[0][0],\n self.memPoints[0][1], \"lime\")\n a = polygon_area(self.memPoints)\n\n if self.FFmpegGlobalFrame in self.measurement_w.draw_mem:\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame].append([\"polygon\", self.memPoints])\n else:\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame] = [[\"polygon\", self.memPoints]]\n try:\n a = a / (float(self.measurement_w.lePx.text()) ** 2) * float(\n self.measurement_w.leRef.text()) ** 2\n except:\n QMessageBox.critical(self, programName,\n \"Check reference and pixel values! Values must be numeric.\",\n QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton)\n\n self.measurement_w.pte.appendPlainText(\"Time: {}\\tFrame: {}\\tArea: {}\".format(self.getLaps(),\n self.FFmpegGlobalFrame,\n round(a, 1)))\n\n self.memPoints = []","def emulate_mouse(self, key_code, x_val, y_val, data):\n # Once again ignore Windows' relative time (since system\n # startup) and use the absolute time (since epoch i.e. 1st Jan\n # 1970).\n self.update_timeval()\n\n events = []\n\n if key_code == 0x0200:\n # We have a mouse move alone.\n # So just pass through to below\n pass\n elif key_code == 0x020A:\n # We have a vertical mouse wheel turn\n events.append(self.emulate_wheel(data, 'y', self.timeval))\n elif key_code == 0x020E:\n # We have a horizontal mouse wheel turn\n # https://msdn.microsoft.com/en-us/library/windows/desktop/\n # ms645614%28v=vs.85%29.aspx\n events.append(self.emulate_wheel(data, 'x', self.timeval))\n else:\n # We have a button press.\n\n # Distinguish the second extra button\n if key_code == 0x020B and data == 2:\n key_code = 0x020B2\n elif key_code == 0x020C and data == 2:\n key_code = 0x020C2\n\n # Get the mouse codes\n code, value, scan_code = self.mouse_codes[key_code]\n # Add in the press events\n scan_event, key_event = self.emulate_press(\n code, scan_code, value, self.timeval)\n events.append(scan_event)\n events.append(key_event)\n\n # Add in the absolute position of the mouse cursor\n x_event, y_event = self.emulate_abs(x_val, y_val, self.timeval)\n events.append(x_event)\n events.append(y_event)\n\n # End with a sync marker\n events.append(self.sync_marker(self.timeval))\n\n # We are done\n self.write_to_pipe(events)","def update(self, *args):\n self.last_chunk += 1\n if self.last_chunk >= len(self.chunk0):\n # self.queue.put(\"Stop\")\n self.last_chunk = 0\n\n i = self.last_chunk\n i0, i1 = self.chunk0[i], self.chunk1[i]\n self.queue.put(self.audio_dat[i0:i1])\n t0, t1 = i0*self.to_t, i1*self.to_t\n print(t0, t1)\n for line_artist in args:\n line_artist.set_xdata([t1, t1])\n args[0].figure.canvas.draw()","def on_mouse_move(self, win, xpos, ypos):\n old = self.mouse\n self.mouse = (xpos, glfw.get_window_size(win)[1] - ypos)\n if glfw.get_mouse_button(win, glfw.MOUSE_BUTTON_LEFT):\n self.drag(old, self.mouse, glfw.get_window_size(win))\n if glfw.get_mouse_button(win, glfw.MOUSE_BUTTON_RIGHT):\n self.pan(old, self.mouse)","def on_mouse_move(self, win, xpos, ypos):\n old = self.mouse\n self.mouse = (xpos, glfw.get_window_size(win)[1] - ypos)\n if glfw.get_mouse_button(win, glfw.MOUSE_BUTTON_LEFT):\n self.drag(old, self.mouse, glfw.get_window_size(win))\n if glfw.get_mouse_button(win, glfw.MOUSE_BUTTON_RIGHT):\n self.pan(old, self.mouse)","def position(self, x, y):\n self.x = x \n self.y = y\n self.pos[0] = x \n self.pos[1] = y","def update(self):\n pygame.event.pump()\n self.pos_x += 0\n if (pygame.key.get_pressed()[pygame.K_w]) and self.pos_y > 0:\n self.pos_y -= 1\n if (pygame.key.get_pressed()[pygame.K_a]) and self.pos_x > 0:\n self.pos_x -= 1\n if (pygame.key.get_pressed()[pygame.K_d]) and self.pos_x < 1080:\n self.pos_x += 1\n if (pygame.key.get_pressed()[pygame.K_s]) and self.pos_y < 360:\n self.pos_y += 1","def track_user_inputs(\n self,\n window,\n movement_speed: float = 1.0,\n yaw_speed: float = 2.0,\n pitch_speed: float = 2.0,\n hold_key=None,\n ):\n front = (self.curr_lookat - self.curr_position).normalized()\n position_change = Vector([0.0, 0.0, 0.0])\n left = self.curr_up.cross(front)\n up = self.curr_up\n\n if self.last_time is None:\n self.last_time = time.perf_counter_ns()\n time_elapsed = (time.perf_counter_ns() - self.last_time) * 1e-9\n self.last_time = time.perf_counter_ns()\n\n movement_speed *= time_elapsed * 60.0\n if window.is_pressed(\"w\"):\n position_change += front * movement_speed\n if window.is_pressed(\"s\"):\n position_change -= front * movement_speed\n if window.is_pressed(\"a\"):\n position_change += left * movement_speed\n if window.is_pressed(\"d\"):\n position_change -= left * movement_speed\n if window.is_pressed(\"e\"):\n position_change += up * movement_speed\n if window.is_pressed(\"q\"):\n position_change -= up * movement_speed\n self.position(*(self.curr_position + position_change))\n\n curr_mouse_x, curr_mouse_y = window.get_cursor_pos()\n\n if (hold_key is None) or window.is_pressed(hold_key):\n if (self.last_mouse_x is None) or (self.last_mouse_y is None):\n self.last_mouse_x, self.last_mouse_y = curr_mouse_x, curr_mouse_y\n dx = curr_mouse_x - self.last_mouse_x\n dy = curr_mouse_y - self.last_mouse_y\n\n yaw, pitch = vec_to_euler(front)\n\n yaw -= dx * yaw_speed * time_elapsed * 60.0\n pitch += dy * pitch_speed * time_elapsed * 60.0\n\n pitch_limit = pi / 2 * 0.99\n if pitch > pitch_limit:\n pitch = pitch_limit\n elif pitch < -pitch_limit:\n pitch = -pitch_limit\n\n front = euler_to_vec(yaw, pitch)\n\n self.lookat(*(self.curr_position + front))\n self.last_mouse_x, self.last_mouse_y = curr_mouse_x, curr_mouse_y","def apply_changes(self):\n self.x = self.buff_x\n self.y = self.buff_y\n self.buff_x = None\n self.buff_y = None","def update(self):\n pygame.event.pump()\n self.pos_x -= 1.5","def set_speed_x(self, new_speed):\n self.__speed_x = new_speed","def OnMouseDown(self, evt):\n self.CaptureMouse()\n self.x, self.y = self.lastx, self.lasty = evt.GetPosition()","def changespeed(self, x1, y1):\n self.change_x += x1\n self.change_y += y1","def tick(self, dt):\n self.x += dt * self.x_speed\n self.y += dt * self.y_speed","def update_gps(\n self,\n x_m,\n y_m,\n x_accuracy_m,\n y_accuracy_m,\n heading_d,\n speed_m_s\n ):\n self.GPS_MEASUREMENT_NOISE[0].itemset(0, x_accuracy_m)\n self.GPS_MEASUREMENT_NOISE[1].itemset(1, y_accuracy_m)\n\n now = time.time()\n time_diff_s = now - self._last_observation_s\n self._last_observation_s = now\n\n if heading_d is None:\n heading_d = 0.0\n if speed_m_s is None:\n matrix = self.GPS_NO_HEADING_SPEED_OBSERVER_MATRIX\n speed_m_s = 0.0\n else:\n matrix = self.GPS_NO_HEADING_OBSERVER_MATRIX\n elif speed_m_s is None:\n matrix = self.GPS_NO_SPEED_OBSERVER_MATRIX\n speed_m_s = 0.0\n else:\n matrix = self.GPS_OBSERVER_MATRIX\n\n measurements = numpy.matrix(\n [x_m, y_m, heading_d, speed_m_s]\n ).transpose() # z\n\n self._update(\n measurements,\n matrix,\n self.GPS_MEASUREMENT_NOISE,\n time_diff_s\n )","def on_mouse_motion(self, x, y, dx, dy):\n # hazlo aparecer donde este mi jugador en el mouse\n self.player_sprite.center_x = x\n self.player_sprite.center_y = y","def getMouse(self):\n self.mouseX = None\n self.mouseY = None\n while self.mouseX == None or self.mouseY == None:\n #self.update()\n _tkCall(self.update)\n if self.isClosed(): raise GraphicsError, \"getMouse in closed window\"\n time.sleep(.1) # give up thread\n x,y = self.toWorld(self.mouseX, self.mouseY)\n self.mouseX = None\n self.mouseY = None\n return Point(x,y)","def setXY(self, x, y):\n self.x = x\n self.y = y","def pointer_notify_axis(\n self,\n time_msec: int,\n orientation: AxisOrientation,\n value: float,\n value_discrete: int,\n source: AxisSource,\n ) -> None:\n lib.wlr_seat_pointer_notify_axis(\n self._ptr, time_msec, orientation.value, value, value_discrete, source.value\n )","def update(self, *args):\n\n # change picture every 100 milliseconds\n now = pygame.time.get_ticks()\n if now - self.last_update > 100:\n self.index = self.index ^ 1\n self.image = self.images[self.index]\n self.last_update = now\n prom = self.rect.center\n self.rect = self.image.get_rect()\n self.rect.center = prom\n\n self.rect.x -= args[0]","def emit_mouse(self, report):\n for name, attr in self.layout.mouse.items():\n # If the attr is a tuple like (left_analog_y, \"-\")\n # then set the attr to just be the first item\n attr, modifier = attr\n\n if attr.startswith(\"trackpad_touch\"):\n active_attr = attr[:16] + \"active\"\n if not getattr(report, active_attr):\n self.mouse_pos.pop(name, None)\n continue\n\n pos = getattr(report, attr)\n if name not in self.mouse_pos:\n self.mouse_pos[name] = pos\n\n sensitivity = 0.5\n self.mouse_rel[name] += (pos - self.mouse_pos[name]) * sensitivity\n self.mouse_pos[name] = pos\n\n elif \"analog\" in attr:\n pos = getattr(report, attr)\n if (pos > (128 + self.mouse_analog_deadzone)\n or pos < (128 - self.mouse_analog_deadzone)):\n accel = (pos - 128) / 10\n else:\n continue\n\n # If a minus modifier has been given then minus the acceleration\n # to invert the direction.\n if (modifier and modifier == \"-\"):\n accel = -accel\n\n sensitivity = self.mouse_analog_sensitivity\n self.mouse_rel[name] += accel * sensitivity\n\n # Emulate mouse wheel (needs special handling)\n if name in (ecodes.REL_WHEELUP, ecodes.REL_WHEELDOWN):\n ecode = ecodes.REL_WHEEL # The real event we need to emit\n write = False\n if getattr(report, attr):\n self._scroll_details['direction'] = name\n now = time.time()\n last_write = self._scroll_details.get('last_write')\n if not last_write:\n # No delay for the first button press for fast feedback\n write = True\n self._scroll_details['count'] = 0\n if name == ecodes.REL_WHEELUP:\n value = 1\n elif name == ecodes.REL_WHEELDOWN:\n value = -1\n if last_write:\n # Delay at least one cycle before continual scrolling\n if self._scroll_details['count'] > 1:\n if now - last_write > self.scroll_delay:\n write = True\n elif now - last_write > self.scroll_repeat_delay:\n write = True\n if write:\n self.device.write(ecodes.EV_REL, ecode, value)\n self._scroll_details['last_write'] = now\n self._scroll_details['count'] += 1\n continue # No need to proceed further\n else:\n # Reset so you can quickly tap the button to scroll\n if self._scroll_details.get('direction') == name:\n self._scroll_details['last_write'] = 0\n self._scroll_details['count'] = 0\n\n rel = int(self.mouse_rel[name])\n self.mouse_rel[name] = self.mouse_rel[name] - rel\n self.device.write(ecodes.EV_REL, name, rel)\n\n self.device.syn()","def show_mouse_position_with_px(self):\n self.main_menu_greets_fonts = pygame.font.Font(os.path.join(PATH_TO_RESOURCE, 'font_forever.ttf'), 10)\n self.positiontext(f'Mouse position {pygame.mouse.get_pos()}', (770, 20))\n self.mouse = pygame.mouse.get_pos()\n return self.mouse","def Update(self, ticks=0):","def handleMousePositionCallback(self, xy):\n\n if self.mouse_position_callback:\n (x, y) = xy\n posn = self.convertView2Geo(x, y)\n self.mouse_position_callback(posn)","def set_global_coordinates(self):\r\n\r\n # alias:\r\n F = Turbine.F\r\n t = Turbine.t\r\n \r\n self.x = -F*np.sin(t) + self.x0\r\n self.y = +F*np.cos(t) + self.y0","def mc_update_xy(self):\n i = random.randint(0,self.N-1)\n return self.mc_update_fixed(i,xy = True)","def update_points(self, *args):\n points = [Window.width / 2, Window.height / 2, .5, .5]\n i = 0\n while i < 2 * pi:\n i += 0.01 * pi\n points.extend([\n Window.width / 2 + cos(i) * (self.radius + self.sin_wobble *\n sin(i * self.sin_wobble_speed)),\n Window.height / 2 + sin(i) * (self.radius + self.sin_wobble *\n sin(i * self.sin_wobble_speed)),\n self.offset_x + sin(i),\n self.offset_y + cos(i)])\n\n self.mesh_points = points","def update(self):\n pos = pygame.mouse.get_pos()\n self.rect.midtop = pos\n if self.punching:\n self.rect.move_ip(5, 10) # move fist position in place","def mouse_move_callback(self, event):\n # TODO drag and drop figuriek\n print(\"moving at \", event.x + self.offset_x, event.y + self.offset_y)","def mouse_motion_current_mouse_position() -> EventType:\n x, y = pygame.mouse.get_pos()\n return pygame.event.Event(pygame.MOUSEMOTION, {'pos': (int(x), int(y))})","def tick(self, dt: float):\n self.x_pos += dt * self.x_velocity\n self.y_pos += dt * self.y_velocity\n\n self.x_velocity += dt * self.x_acceleration\n self.y_velocity += dt * self.y_velocity","def start(self, x, y):\n self.last_x = x\n self.last_y = y\n self.aperture_id = None","def update(self):\r\n # Get where the mouse is\r\n pos = pygame.mouse.get_pos()\r\n # Set the left side of the player bar to the mouse position\r\n self.rect.x = pos[0]\r\n # Make sure we don't push the player paddle\r\n # off the right side of the screen\r\n if self.rect.x > self.screenwidth - self.width:\r\n self.rect.x = self.screenwidth - self.width","def pos(self, x, y):\n\n if isinstance(x, float):\n x = int(x)\n\n self.screen.write(colorama.Cursor.POS(x, y), ansi=True)\n self.x = x\n self.y = y\n\n return x, y"],"string":"[\n \"def follow(self):\\n\\t\\tpos = pygame.mouse.get_pos()\\n\\t\\tself.x = pos[0]\\n\\t\\tself.y = pos[1]\\n\\t\\tself.draw()\",\n \"def mouse_position_event(self, x: int, y: int):\\n pass\",\n \"def update_pointer(self):\\n pointer_length = -self.pointer_frac * self.radius\\n # Add pi/2 to the angle because we consider 0 radians to be pi/2 in standard position.\\n x = pointer_length * math.cos(self._radians + math.pi / 2)\\n y = pointer_length * math.sin(self._radians + math.pi / 2)\\n self.coords(self.pointer, 0, 0, x, y)\",\n \"def update(self):\\n # Get the current mouse position. This returns the position\\n # as a list of two numbers.\\n pos = pygame.mouse.get_pos()\\n \\n # Set the player x position to the mouse x position\\n self.rect.x = pos[0]\",\n \"def on_mouse_motion(self, x, y, delta_x, delta_y):\\r\\n pass\",\n \"def update(self):\\n # Get the current mouse position. This returns the position\\n # as a list of two numbers.\\n pos = pygame.mouse.get_pos()\\n\\n # Set the player x position to the mouse x position\\n self.rect.x = pos[0]\",\n \"def update(self):\\r\\n self.x = games.mouse.x\\r\\n self.y = games.mouse.y\\r\\n self.check_collide()\",\n \"def update(self):\\n self.x = games.mouse.x\\n #self.y = games.mouse.y\\n self.check_collide()\",\n \"def set_position(self, updated):\\n self.buff_x = updated[0]\\n self.buff_y = updated[1]\",\n \"def update(self):\\n self.x = games.mouse.x\\n self.y = games.mouse.y\\n self.check_collide()\",\n \"def handle_mouse(self, x, y):\\n self.x = x\\n self.y = y\\n global _pending_handle_mouse\\n if not _pending_handle_mouse:\\n _pending_handle_mouse = True\\n if self.fig.document is not None:\\n self.fig.document.add_timeout_callback(self.handle_mouse_callback, 100)\\n else:\\n self.handle_mouse_callback()\",\n \"def mousePosition(self):\",\n \"def mousePositionRaw(self):\",\n \"def mousePositionRaw(self):\",\n \"def handle_mouse(self, x, y):\\n pass\",\n \"def on_mouse_motion(self, x, y, delta_x, delta_y):\\n\\n print(x)\\n print(y)\\n print(delta_x)\\n print(delta_y)\\n\\n\\n #self.manage_crosshair()\\n \\n \\n\\n #self.crosshair_sprite.center_x += delta_x\\n #self.crosshair_sprite.center_y += delta_y\\n\\n\\n self.crosshair_relative_xoffset += delta_x\\n self.crosshair_relative_yoffset += delta_y\",\n \"def update(self):\\n\\n\\t\\tself.x = games.mouse.x\\n\\t\\tself.y = games.mouse.y\\n\\t\\tself.check_collide()\",\n \"def __master_cursor_pos_callback(self, glfw_window, xpos, ypos):\\n # flip glfw window space to match OGL space(like texture that has bottom left origin)\\n ypos = self.window.glyph.size[1] - ypos\\n\\n # update values\\n self.__pos_instant = Vec(xpos, ypos, 0)\\n self.__accel = self.__pos_instant - self.__pos_prev\\n self.__pos_prev = self.__pos_instant\\n\\n # call registered callbacks\\n self.call_cursor_pos_callback(glfw_window, *self.__pos_instant.xy, mouse=self)\",\n \"def update(self, delta_time):\\r\\n #for pixels in self.pixel:\\r\\n for line in self.cursor:\\r\\n line.draw()\\r\\n \\r\\n self.check_keys()\",\n \"def update(self):\\r\\n self.x = 60\\r\\n self.y = games.mouse.y\\r\\n self.check_collide()\",\n \"def on_mouse_motion(self, x, y, delta_x, delta_y):\\n \\n pass\",\n \"def on_mouse_move(self, event: PointEvent):\\n self.x = event.x\\n self.y = event.y\\n self.handle_mouse(self.x, self.y)\",\n \"def xy(self, xy_position):\\n print(f\\\"xy: {xy_position}\\\")\\n self.device_control.xy = xy_position\\n yield\",\n \"def OnMouseMotion(self, evt):\\n if evt.Dragging() and evt.LeftIsDown():\\n self.lastx, self.lasty = self.x, self.y\\n self.x, self.y = evt.GetPosition()\\n self.Refresh(False)\",\n \"def handle_mouse(self, x, y):\\n # we are in aperture mode\\n if self.aperture_id:\\n if self.aperture_id not in self.aperture_model.aperture_models.keys():\\n pass\\n model = self.aperture_model.aperture_models[self.aperture_id]\\n location = model.source.data['location'][0]\\n\\n if self.mode == 'width':\\n width = abs(location - x)\\n model.update_values(start=location - width,\\n end=location + width)\\n elif self.mode == 'left':\\n if x < location:\\n model.update_values(start=x)\\n elif self.mode == 'right':\\n if x > location:\\n model.update_values(end=x)\\n elif self.mode == 'location':\\n diff = x - location\\n model.update_values(location=x,\\n start=model.source.data['start'][0] + diff,\\n end=model.source.data['end'][0] + diff)\\n\\n self.last_x = x\\n self.last_y = y\\n return False\",\n \"def on_mouse_move(self, event):\\n self.mouse = [event.xdata, event.ydata]\\n\\n # Update pan view on mouse move\\n if self.panning is True:\\n for a in self.pan_axes:\\n a.drag_pan(1, event.key, event.x, event.y)\\n\\n # Async re-draw (redraws only on thread idle state, uses timer on backend)\\n self.canvas.draw_idle()\\n\\n ##### Temporary place-holder for cached update #####\\n self.update_screen_request.emit([0, 0, 0, 0, 0])\",\n \"def update_tempLists(self):\\n self.current_position = self.mediaPlayer.position()\\n\\n # I add the current value, calculates its index, and removes it. This method is used to know which index the pointer is at.\\n bisect.insort(self.xValues,self.current_position)\\n self.position_index = self.xValues.index(self.current_position)\\n self.xValues.remove(self.current_position)\\n\\n n = 120\\n if self.position_index < n: \\n self.tempXList = self.xValues[:self.position_index + n]\\n self.tempYList = self.yValues[:self.position_index + n]\\n self.tempCList = self.colors[:self.position_index + n]\\n else:\\n self.tempXList = self.xValues[self.position_index - n :self.position_index + n]\\n self.tempYList = self.yValues[self.position_index - n :self.position_index + n]\\n self.tempCList = self.colors[self.position_index - n :self.position_index + n]\",\n \"def handle_motion(self, x, y):\\n if self.pressed_flag:\\n self.last_point = (x, y)\\n\\n # trigger canvas to redraw itself\\n self.redraw()\",\n \"def move_to_point(self, destination, frequency):\\r\\n # index 0 represents x, index 1 represents y\\r\\n if frequency > 1:\\r\\n x_towards = int(round((destination[0] - current_position[0]) / frequency))\\r\\n if x_towards > 1:\\r\\n x_towards -= 1\\r\\n y_towards = int(round((destination[1] - current_position[1]) / frequency))\\r\\n if y_towards > 1:\\r\\n y_towards -= 1\\r\\n current_position = list(self.current_position)\\r\\n if current_position[0] < destination[0]: # if x is west\\r\\n current_position[0] = current_position[0] + x_towards\\r\\n x_change = int(frequency)\\r\\n if current_position[0] >= destination[0]: # if this overshoots:\\r\\n current_position[0] = destination[0]\\r\\n elif current_position[0] == destination[0]:\\r\\n pass # don't move\\r\\n else:\\r\\n current_position[0] = current_position[0] - x_towards\\r\\n x_change = 0 - int(frequency)\\r\\n if current_position[0] <= destination[0]: # if this overshoots:\\r\\n current_position[0] = destination[0]\\r\\n if current_position[1] < destination[1]:\\r\\n current_position[1] = current_position[1] + y_towards\\r\\n y_change = int(frequency)\\r\\n if current_position[1] >= destination[1]: # if this overshoots:\\r\\n current_position[1] = destination[1]\\r\\n elif current_position[1] == destination[1]:\\r\\n pass\\r\\n else:\\r\\n current_position[1] = current_position[1] - y_towards\\r\\n y_change = 0 - int(frequency)\\r\\n if current_position[1] <= destination[1]: # if this overshoots:\\r\\n current_position[1] = destination[1]\\r\\n\\r\\n current_position = tuple(current_position)\\r\\n self.move_to(current_position)\\r\\n for i in list(range(1, int(frequency))):\\r\\n human_avoidance_list.append((current_position[0] + x_change, current_position[1] + y_change))\\r\\n self.current_position = current_position\\r\\n if current_position[0] == destination[0] and current_position[1] == destination[1]:\\r\\n self.resource_check = 1\\r\\n else:\\r\\n self.resource_frequency += self.resource_frequency / 6 # 6 * 5 days in a step = 30 days in a month\\r\\n # resource frequency is listed monthly in the source file\\r\\n # this indicates time passing each step until the gatherer can move\\r\",\n \"def track_point(self, flags, x, y):\\n ret_val, x.value, y.value = self._track_point(flags, x.value, y.value)\\n return ret_val\",\n \"def _updateOnMouseState(self, state):\\n x = state.X.abs\\n y = state.Y.abs\\n \\n mscale = self.mouse_icon.getScale() \\n \\n if (x + mscale[0] + self.mouse_offset) > render_engine.Window.width:\\n x = x - mscale[0] - 10\\n else:\\n x += self.mouse_offset\\n \\n if (y + mscale[1] + self.mouse_offset) > render_engine.Window.height:\\n y = y - mscale[1] - 10\\n else:\\n y += self.mouse_offset\\n \\n self.mouse_icon.setPosition((x, y))\",\n \"def click_action(event, ax):\\n global newcoords, oldcoords, count\\n\\n if count % 2 == 0:\\n newcoords.append((event.xdata, event.ydata))\\n print('NEW', event.xdata, event.ydata)\\n else:\\n oldcoords.append((event.xdata, event.ydata))\\n print('OLD', event.xdata, event.ydata)\\n # update count\\n count += 1\",\n \"def grab(self, event):\\n self.ypos = event.y\\n self.xpos = event.x\\n self.config(cursor='fleur')\",\n \"def update(self):\\n self.mousePos = pygame.mouse.get_pos()\\n self.update_button_hover_status()\",\n \"def update(self):\\n self.bpos_x += 3\",\n \"def _motion(self, event):\\n if self.current:\\n # modify the current line by changing the end coordinates\\n # to be the current mouse position\\n coords = event.widget.coords(self.current)\\n coords[2] = event.x\\n coords[3] = event.y\\n\\n event.widget.coords(self.current, *coords)\",\n \"def cmdMouse(self, dev):\\n self.hitsMouses[dev] = False\\n f = open(self.inputPath + dev, 'rb')\\n while self.live:\\n f.read(500) # 144 kan eigenlijk alles zijn, behalve absurbt hoge waarden..\\n self.hitsMouses[dev] = True\\n time.sleep(0.1)\",\n \"def on_mousemove(event, x, y, flags, userparam):\\n global mouse_pos\\n global source_img, source_msk, display_img\\n global DRAW_MODE\\n\\n if event == cv.EVENT_MOUSEMOVE:\\n mouse_pos = (x, y)\\n\\n if flags & cv.EVENT_FLAG_SHIFTKEY:\\n current_label = LABEL_BACKGROUND\\n else:\\n current_label = CURRENT_LABEL\\n\\n if DRAW_MODE == \\\"point\\\":\\n if flags & cv.EVENT_FLAG_CTRLKEY:\\n cv.circle(source_msk, (x, y), SHAPE_SIZE, current_label, -1)\\n elif DRAW_MODE == \\\"line\\\":\\n # line drawing is done in the line-mode keypress handler (keydown())\\n pass\",\n \"def update(self, xdata=[], ydata=[]):\\n for i in range(4):\\n self.lines[i].set_data(xdata[i], ydata[i])\\n\\n self.blit()\",\n \"def set_new_location(self, xPos, yPos):\",\n \"def update_position_and_spike_frame(self, step=0):\\n if self._spk_pos_ax is not None:\\n # print(self._pos_x)\\n # print(self._pos_y)\\n # TODO: Add colors based on which cluster the spikes are coming from\\n self._spk_pos_frame[0].set_data((self._spk_pos_x, self._spk_pos_y))\\n # self._spk_pos_frame[0].set_color(self._spk_clusters)\\n self._spk_pos_frame[1].set_data((self._pos_x, self._pos_y))\\n if len(self._speed) > 0:\\n self._spk_pos_frame[2].set_text('speed = %.2fcm/s'%self._speed[-1])\\n return self._spk_pos_frame\",\n \"def changespeed(self, x, y):\\n self.change_x += x\\n self.change_y += 200\",\n \"def changespeed(self, x, y):\\n self.change_x += x\\n self.change_y += y\",\n \"def changespeed(self, x, y):\\n self.change_x += x\\n self.change_y += y\",\n \"def changespeed(self, x, y):\\n self.change_x += x\\n self.change_y += y\",\n \"def update(self, i):\\n\\n self.current_position = self.mediaPlayer.position()\\n \\t\\n \\n\\n \\\"\\\"\\\"\\n \\\"Record mode\\\" and \\\"wide x-axis mode\\\" shouls not work together. Wide mode is only for reading data, not writing data. \\n The user is not allowed to write data when 16 000 points are displayed (wide mode) on tha diagram. If he does so, the frequency of the graph points decreases with time. \\n \\\"\\\"\\\"\\n \\n if self.checkbox.isChecked():\\n self.wideRadio.setEnabled(False)\\n if not self.checkbox.isChecked():\\n self.wideRadio.setEnabled(True)\\n if self.wideRadio.isChecked():\\n self.checkbox.setEnabled(False)\\n if not self.wideRadio.isChecked():\\n self.checkbox.setEnabled(True)\\n \\n\\n\\n if self.checkbox.isChecked() and self.mediaPlayer.state() == QMediaPlayer.PlayingState:\\n \\n self.savedRecently = False\\n\\n\\n self.current_position = self.mediaPlayer.position()\\n\\n \\n if self.xValues == []:\\n # \\\"If the list of xValues is empty\\\". This happens only in the start of the plotting process.\\n self.xValues.append(self.current_position)\\n self.yValues.append(self.mouseY)\\n self.colors.append(self.currentColor)\\n\\n #self.position_index = self.xValues.index(self.current_position)\\n \\n\\n if self.xValues != []:\\n\\n if self.current_position > max(self.xValues):\\n # \\\"If the point is bigger than the last point\\\". I.e if the point will be plotted in the end of the current graph.\\n\\n self.xValues.append(self.current_position)\\n self.yValues.append(self.mouseY)\\n self.colors.append(self.currentColor)\\n\\n self.position_index = self.xValues.index(self.current_position)\\n\\n if self.current_position < max(self.xValues):\\n # \\\"If the point is smaller than the last point\\\". I.e if the point will be plotted in the middle of the current graph.\\n\\n \\n if self.mediaPlayer.position() < 100:\\n # The program has a problem of removing a point if x=0. This if-statement solves the problem.\\n self.xValues.pop(0)\\n self.yValues.pop(0)\\n self.colors.pop(0)\\n \\n\\n\\n # Clearing all the points that are 100 ms (or less) in front of the current position. \\n for number in range(self.current_position, self.current_position + 100):\\n if number in self.xValues:\\n self.yValues.pop(self.xValues.index(number))\\n self.colors.pop(self.xValues.index(number))\\n self.xValues.remove(number)\\n \\n \\n \\n # Plot new points\\n bisect.insort(self.xValues,self.current_position) # Through this method, the element is inserted in order.\\n self.yValues.insert(self.xValues.index(self.current_position), self.mouseY)\\n self.colors.insert(self.xValues.index(self.current_position), self.currentColor)\\n\\n self.position_index = self.xValues.index(self.current_position)\\n \\n\\n\\n # View modes: zoom or wide.\\n\\n if self.zoomRadio.isChecked():\\n self.canvas.axes.set_ylim(0, 100)\\n self.canvas.axes.set_xlim(self.current_position-5000, self.current_position+5000)\\n\\n self.update_tempLists()\\n\\n self.curve = self.canvas.axes.scatter(self.tempXList, self.tempYList, s=10 , c=self.tempCList)\\n\\n\\n\\n if self.wideRadio.isChecked():\\n self.canvas.axes.set_ylim(0, 100)\\n\\n if self.mediaPlayer.duration() != 0:\\n self.canvas.axes.set_xlim(0, self.mediaPlayer.duration())\\n elif self.xValues != []:\\n self.canvas.axes.set_xlim(0, max(self.xValues))\\n\\n self.curve = self.canvas.axes.scatter(self.xValues, self.yValues, s=10 , c=self.colors)\\n\\n \\n\\n # I remove the previous vertical and horizontal lines. If I do not remove them, the program gets slower and slower, and the frequency of the points decreases with time.\\n self.hline.remove()\\n self.vline.remove()\\n \\n # New vertical and horizontal lines are created and updated to the correct values.\\n self.vline = self.canvas.axes.axvline(x=self.mediaPlayer.position(), color='gray',linestyle=\\\":\\\")\\n self.hline = self.canvas.axes.axhline(y=self.mouseY, color='gray',linestyle=\\\":\\\")\\n\\n\\n\\n return [self.curve] + [self.vline] + [self.hline]\",\n \"def ev_mousemotion(self, event: MouseMotion) -> None:\",\n \"def update(self):\\n self.t = time()\\n self.frame += 1\\n self.loop(self)\\n self.draw_bg()\\n self.draw_C()\\n if self.cursor:\\n self.draw_rect(*self.pos, RED, 2)\\n self.draw_grid()\\n self.draw_T()\\n self.show_info()\\n for (surf, rect) in self.surf_list:\\n self.screen.blit(surf, rect)\\n pygame.display.update()\\n self.clock.tick(self.fps)\",\n \"def normal_mouse_move(self, event):\\n plot = self.component\\n if plot is not None:\\n if isinstance(plot, BaseXYPlot):\\n ndx = plot.map_index((event.x, event.y), index_only = True)\\n x = plot.index.get_data()[ndx]\\n y = plot.value.get_data()[ndx]\\n print self.format % (x,y)\\n else:\\n print \\\"dataprinter: don't know how to handle plots of type\\\",\\n print plot.__class__.__name__\\n return\",\n \"def ev_MOUSEMOTION(self, event):\",\n \"def mouse_move(self, pos):\\n if (self.setup_type == \\\"position\\\"):\\n x, y = pos\\n self.canvas.move(x, y)\",\n \"def report_mouse_position(x_pos=0, y_pos=0):\\n print('x-axis:', x_pos, ' Y-axis: ', y_pos, flush=True)\",\n \"def update():\\n\\n # Get last new x value as last x value + 1\\n x_n0 = data_source.data['x'][-1]\\n x_n1 = x_n0 + 0.1\\n\\n # Assign a new y value\\n y_n1 = param_source.data['amp_sine'][0] * np.sin(x_n1) +\\\\\\n param_source.data['amp_rand'][0] * np.random.rand(1)\\n\\n # Get old last average and use to calculate new average\\n avg_n1 = _get_new_avg(data_source,\\n y_n1,\\n param_source.data['rollover'][0])\\n\\n # Make a dict of data to add on to the end of the source\\n additional_data = dict(x=[x_n1], y=[y_n1], avg=[avg_n1])\\n\\n # Stream the new data with a rollover value of 10\\n data_source.stream(additional_data,\\n rollover=param_source.data['rollover'][0])\\n\\n # logger.debug(param_source.data['update_delay'][0])\",\n \"def update():\\n global dragon, x, y, position, angle_left, angle_right, size, new\\n x, y, position, angle_left, angle_right, new = modify_pos(x, y, position,\\n angle_left,\\n angle_right,\\n size, new)\\n dragon.setData(x, y) # update plot\",\n \"def pointer_notify_motion(\\n self, time_msec: int, surface_x: float, surface_y: float\\n ) -> None:\\n lib.wlr_seat_pointer_notify_motion(self._ptr, time_msec, surface_x, surface_y)\",\n \"def handle_mouse(obj, event):\\n if event:\\n x = event.globalX()\\n y = event.globalY()\\n x_w = obj.offset.x()\\n y_w = obj.offset.y()\\n obj.move(x - x_w, y - y_w)\",\n \"def follow_mouse(self, mouse):\\n half_width = self.width() / 2\\n self.left = mouse.get_x() - half_width\\n self.right = mouse.get_x() + half_width\",\n \"def onMove(self, event):\\n\\t\\tif (event.xdata != None and event.ydata != None and event.xdata != self.xdata and event.ydata != self.ydata):\\n\\n\\t\\t\\tself.xdata = event.xdata\\n\\t\\t\\tself.ydata = event.ydata\\n\\n\\t\\t\\tfor loop in range(4):\\n\\t\\t\\t\\tself.stokesFig.canvas.restore_region(self.background[loop])\\n\\t\\t\\t\\tself.obsStokes[loop].set_ydata(self.stokes[loop][event.ydata, event.xdata, :])\\n\\t\\t\\t\\tself.axStokes[loop].draw_artist(self.obsStokes[loop])\\n\\t\\t\\t\\tself.axStokes[loop].draw_artist(self.axStokes[loop].get_yaxis())\\n\\t\\t\\t\\tself.stokesFig.canvas.blit(self.axStokes[loop].bbox.expanded(1.4, 1.1))\",\n \"def trackMouse(self, mouse_event):\\n if self.kinect.DepthFrameRaw.any() != 0:\\n u = mouse_event.pos().x()\\n v = mouse_event.pos().y()\\n d = self.kinect.DepthFrameRaw[v,u]\\n self.ui.rdoutMousePixels.setText(\\\"(\\\"+str(u)+\\\",\\\"+str(v)+\\\",\\\"+str(d)+\\\")\\\")\\n worldCoords = self.kinect.pix2Glob(np.array([u,v,1])) * 1000 #1000 for mm\\n self.ui.rdoutMouseWorld.setText(f\\\"({np.round(worldCoords[0])},{np.round(worldCoords[1])},{np.round(worldCoords[2])})\\\")\",\n \"def cambiovelocidad(self,x,y):\\n self.change_x += x\\n self.change_y += y\",\n \"def move_mouse(kf_x, m, img): \\n exponent = 1.6\\n x, y, x_vel, y_vel = (int(kf_x[0]), int(kf_x[1]), kf_x[2], kf_x[3])\\n mx, my = m.position()\\n win_height, win_width, channel = img.shape\\n x_screen, y_screen = m.screen_size()\\n min_x, max_x = 0, x_screen\\n min_y, max_y = 0, y_screen \\n\\n #Calculations\\n speed = np.sqrt(x_vel**2 + y_vel**2) \\n power = math.pow(speed, exponent) \\n ratio = speed / power\\n theta = math.atan2(y_vel, x_vel) \\n x_comp = power * math.cos(theta) \\n y_comp = power * math.sin(theta) \\n xf, yf = mx + x_comp, my + y_comp\\n\\n if xf < min_x: \\n xf = min_x\\n elif xf > max_x: \\n xf = max_x\\n elif yf < min_y: \\n yf = min_y\\n elif yf > max_y: \\n yf = max_y\\n m.move(xf, yf)\\n return speed\",\n \"def mouseReleaseEvent(self, event):\\n width = self.frameGeometry().width()\\n height = self.frameGeometry().height()\\n cursor = QtGui.QCursor()\\n new_pos = self.mapFromGlobal(cursor.pos())\\n x = new_pos.x()\\n y = new_pos.y()\\n self.__selector_y = y/float(height) # normalized value of the y position\\n \\tself.__selector_x = x/float(width) #normalised value of the x position\\n self.updatePixelColor()\\n self.repaint()\",\n \"def mouseDragged(self, point, delta):\\n pass\",\n \"def update_position(self, time_step):\\n if not self.gpu:\\n self.psi_hat[...] = fft.fftn(self.psi)\\n update_position(self.psi_hat, time_step, self.m)\\n self.psi[...] = fft.ifftn(self.psi_hat)\\n else:\\n cufft.cufftExecZ2Z(self.psi_plan, self.g_psi.ptr, self.g_psi_hat.ptr, cufft.CUFFT_FORWARD)\\n self.g_psi_hat /= self.N\\n self.g_mom_func(self.g_psi_hat, np.float64(time_step), np.int64(self.psi_hat.shape[0]), np.int64(self.psi_hat.shape[1]), np.int64(self.psi_hat.shape[2]), block=(8,8,8), grid=tuple([(i+7)/8 for i in self.psi_hat.shape]))\\n cufft.cufftExecZ2Z(self.psi_plan, self.g_psi_hat.ptr, self.g_psi.ptr, cufft.CUFFT_INVERSE)\",\n \"def seek(self,event):\\r\\n if self.app.controlLock.locked():\\r\\n return\\r\\n self.app.controlLock.acquire()\\r\\n x = event.x\\r\\n scalex,_ = self.getScale()\\r\\n scalex_secs = [scalex[0]/self.samplerate,scalex[1]/self.samplerate]# Get x scale in seconds\\r\\n seekTo = (x/self.w) * (scalex_secs[1]-scalex_secs[0]) + scalex_secs[0]# Transform pixel coordinates to represented time\\r\\n self.app.videoPlayer.pause()\\r\\n self.app.videoPlayer.seek(seekTo-self.app.dataOffset)\\r\\n self.app.videoPlayer.pause()# Restart audio to sync\\r\\n self.update(self.app.videoPlayer.startTimestamp)\\r\\n self.draw()\\r\\n self.app.videoPlayer.play()\\r\\n self.app.controlLock.release()\",\n \"def updateAccelList():\\n # Get new sensor update/s\\n x, y, z = getSensorAccel()\\n \\n # Pop out old values (idx 0)\\n listAccelX.pop(0) # ignore outgoing value\\n listAccelY.pop(0) # ignore outgoing value\\n listAccelZ.pop(0) # ignore outgoing value\\n \\n # Append the new values\\n listAccelX.append(x)\\n listAccelY.append(y)\\n listAccelZ.append(z)\",\n \"def getPoslbFFmpeg(self, event):\\n # if self.measurement_w:\\n\\n if hasattr(self, \\\"measurement_w\\\") and self.measurement_w is not None and self.measurement_w.isVisible():\\n x = event.pos().x()\\n y = event.pos().y()\\n\\n # distance\\n if self.measurement_w.rbDistance.isChecked():\\n if event.button() == 1: # left\\n self.draw_point(x, y, \\\"lime\\\")\\n self.memx, self.memy = x, y\\n\\n if event.button() == 2 and self.memx != -1 and self.memy != -1:\\n self.draw_point(x, y, \\\"lime\\\")\\n self.draw_line(self.memx, self.memy, x, y, \\\"lime\\\")\\n\\n if self.FFmpegGlobalFrame in self.measurement_w.draw_mem:\\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame].append([\\\"line\\\", self.memx, self.memy, x, y])\\n else:\\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame] = [[\\\"line\\\", self.memx, self.memy, x, y]]\\n\\n d = ((x - self.memx) ** 2 + (y - self.memy) ** 2) ** 0.5\\n try:\\n d = d / float(self.measurement_w.lePx.text()) * float(self.measurement_w.leRef.text())\\n except:\\n QMessageBox.critical(self, programName,\\n \\\"Check reference and pixel values! Values must be numeric.\\\",\\n QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton)\\n\\n self.measurement_w.pte.appendPlainText(\\\"Time: {}\\\\tFrame: {}\\\\tDistance: {}\\\".format(self.getLaps(),\\n self.FFmpegGlobalFrame,\\n round(d, 1)))\\n self.measurement_w.flagSaved = False\\n self.memx, self.memy = -1, -1\\n\\n # angle 1st clic -> vertex\\n if self.measurement_w.rbAngle.isChecked():\\n if event.button() == 1: # left for vertex\\n self.draw_point(x, y, \\\"lime\\\")\\n self.memPoints = [(x, y)]\\n\\n if event.button() == 2 and len(self.memPoints):\\n self.draw_point(x, y, \\\"lime\\\")\\n self.draw_line(self.memPoints[0][0], self.memPoints[0][1], x, y, \\\"lime\\\")\\n\\n self.memPoints.append((x, y))\\n\\n if len(self.memPoints) == 3:\\n self.measurement_w.pte.appendPlainText(\\\"Time: {}\\\\tFrame: {}\\\\tAngle: {}\\\".format(self.getLaps(),\\n self.FFmpegGlobalFrame,\\n round(angle(\\n self.memPoints[\\n 0],\\n self.memPoints[\\n 1],\\n self.memPoints[\\n 2]),\\n 1)\\n ))\\n self.measurement_w.flagSaved = False\\n if self.FFmpegGlobalFrame in self.measurement_w.draw_mem:\\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame].append([\\\"angle\\\", self.memPoints])\\n else:\\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame] = [[\\\"angle\\\", self.memPoints]]\\n\\n self.memPoints = []\\n\\n # Area\\n if self.measurement_w.rbArea.isChecked():\\n if event.button() == 1: # left\\n self.draw_point(x, y, \\\"lime\\\")\\n if len(self.memPoints):\\n self.draw_line(self.memPoints[-1][0], self.memPoints[-1][1], x, y, \\\"lime\\\")\\n self.memPoints.append((x, y))\\n\\n if event.button() == 2 and len(self.memPoints) >= 2:\\n self.draw_point(x, y, \\\"lime\\\")\\n self.draw_line(self.memPoints[-1][0], self.memPoints[-1][1], x, y, \\\"lime\\\")\\n self.memPoints.append((x, y))\\n # close polygon\\n self.draw_line(self.memPoints[-1][0], self.memPoints[-1][1], self.memPoints[0][0],\\n self.memPoints[0][1], \\\"lime\\\")\\n a = polygon_area(self.memPoints)\\n\\n if self.FFmpegGlobalFrame in self.measurement_w.draw_mem:\\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame].append([\\\"polygon\\\", self.memPoints])\\n else:\\n self.measurement_w.draw_mem[self.FFmpegGlobalFrame] = [[\\\"polygon\\\", self.memPoints]]\\n try:\\n a = a / (float(self.measurement_w.lePx.text()) ** 2) * float(\\n self.measurement_w.leRef.text()) ** 2\\n except:\\n QMessageBox.critical(self, programName,\\n \\\"Check reference and pixel values! Values must be numeric.\\\",\\n QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton)\\n\\n self.measurement_w.pte.appendPlainText(\\\"Time: {}\\\\tFrame: {}\\\\tArea: {}\\\".format(self.getLaps(),\\n self.FFmpegGlobalFrame,\\n round(a, 1)))\\n\\n self.memPoints = []\",\n \"def emulate_mouse(self, key_code, x_val, y_val, data):\\n # Once again ignore Windows' relative time (since system\\n # startup) and use the absolute time (since epoch i.e. 1st Jan\\n # 1970).\\n self.update_timeval()\\n\\n events = []\\n\\n if key_code == 0x0200:\\n # We have a mouse move alone.\\n # So just pass through to below\\n pass\\n elif key_code == 0x020A:\\n # We have a vertical mouse wheel turn\\n events.append(self.emulate_wheel(data, 'y', self.timeval))\\n elif key_code == 0x020E:\\n # We have a horizontal mouse wheel turn\\n # https://msdn.microsoft.com/en-us/library/windows/desktop/\\n # ms645614%28v=vs.85%29.aspx\\n events.append(self.emulate_wheel(data, 'x', self.timeval))\\n else:\\n # We have a button press.\\n\\n # Distinguish the second extra button\\n if key_code == 0x020B and data == 2:\\n key_code = 0x020B2\\n elif key_code == 0x020C and data == 2:\\n key_code = 0x020C2\\n\\n # Get the mouse codes\\n code, value, scan_code = self.mouse_codes[key_code]\\n # Add in the press events\\n scan_event, key_event = self.emulate_press(\\n code, scan_code, value, self.timeval)\\n events.append(scan_event)\\n events.append(key_event)\\n\\n # Add in the absolute position of the mouse cursor\\n x_event, y_event = self.emulate_abs(x_val, y_val, self.timeval)\\n events.append(x_event)\\n events.append(y_event)\\n\\n # End with a sync marker\\n events.append(self.sync_marker(self.timeval))\\n\\n # We are done\\n self.write_to_pipe(events)\",\n \"def update(self, *args):\\n self.last_chunk += 1\\n if self.last_chunk >= len(self.chunk0):\\n # self.queue.put(\\\"Stop\\\")\\n self.last_chunk = 0\\n\\n i = self.last_chunk\\n i0, i1 = self.chunk0[i], self.chunk1[i]\\n self.queue.put(self.audio_dat[i0:i1])\\n t0, t1 = i0*self.to_t, i1*self.to_t\\n print(t0, t1)\\n for line_artist in args:\\n line_artist.set_xdata([t1, t1])\\n args[0].figure.canvas.draw()\",\n \"def on_mouse_move(self, win, xpos, ypos):\\n old = self.mouse\\n self.mouse = (xpos, glfw.get_window_size(win)[1] - ypos)\\n if glfw.get_mouse_button(win, glfw.MOUSE_BUTTON_LEFT):\\n self.drag(old, self.mouse, glfw.get_window_size(win))\\n if glfw.get_mouse_button(win, glfw.MOUSE_BUTTON_RIGHT):\\n self.pan(old, self.mouse)\",\n \"def on_mouse_move(self, win, xpos, ypos):\\n old = self.mouse\\n self.mouse = (xpos, glfw.get_window_size(win)[1] - ypos)\\n if glfw.get_mouse_button(win, glfw.MOUSE_BUTTON_LEFT):\\n self.drag(old, self.mouse, glfw.get_window_size(win))\\n if glfw.get_mouse_button(win, glfw.MOUSE_BUTTON_RIGHT):\\n self.pan(old, self.mouse)\",\n \"def position(self, x, y):\\n self.x = x \\n self.y = y\\n self.pos[0] = x \\n self.pos[1] = y\",\n \"def update(self):\\n pygame.event.pump()\\n self.pos_x += 0\\n if (pygame.key.get_pressed()[pygame.K_w]) and self.pos_y > 0:\\n self.pos_y -= 1\\n if (pygame.key.get_pressed()[pygame.K_a]) and self.pos_x > 0:\\n self.pos_x -= 1\\n if (pygame.key.get_pressed()[pygame.K_d]) and self.pos_x < 1080:\\n self.pos_x += 1\\n if (pygame.key.get_pressed()[pygame.K_s]) and self.pos_y < 360:\\n self.pos_y += 1\",\n \"def track_user_inputs(\\n self,\\n window,\\n movement_speed: float = 1.0,\\n yaw_speed: float = 2.0,\\n pitch_speed: float = 2.0,\\n hold_key=None,\\n ):\\n front = (self.curr_lookat - self.curr_position).normalized()\\n position_change = Vector([0.0, 0.0, 0.0])\\n left = self.curr_up.cross(front)\\n up = self.curr_up\\n\\n if self.last_time is None:\\n self.last_time = time.perf_counter_ns()\\n time_elapsed = (time.perf_counter_ns() - self.last_time) * 1e-9\\n self.last_time = time.perf_counter_ns()\\n\\n movement_speed *= time_elapsed * 60.0\\n if window.is_pressed(\\\"w\\\"):\\n position_change += front * movement_speed\\n if window.is_pressed(\\\"s\\\"):\\n position_change -= front * movement_speed\\n if window.is_pressed(\\\"a\\\"):\\n position_change += left * movement_speed\\n if window.is_pressed(\\\"d\\\"):\\n position_change -= left * movement_speed\\n if window.is_pressed(\\\"e\\\"):\\n position_change += up * movement_speed\\n if window.is_pressed(\\\"q\\\"):\\n position_change -= up * movement_speed\\n self.position(*(self.curr_position + position_change))\\n\\n curr_mouse_x, curr_mouse_y = window.get_cursor_pos()\\n\\n if (hold_key is None) or window.is_pressed(hold_key):\\n if (self.last_mouse_x is None) or (self.last_mouse_y is None):\\n self.last_mouse_x, self.last_mouse_y = curr_mouse_x, curr_mouse_y\\n dx = curr_mouse_x - self.last_mouse_x\\n dy = curr_mouse_y - self.last_mouse_y\\n\\n yaw, pitch = vec_to_euler(front)\\n\\n yaw -= dx * yaw_speed * time_elapsed * 60.0\\n pitch += dy * pitch_speed * time_elapsed * 60.0\\n\\n pitch_limit = pi / 2 * 0.99\\n if pitch > pitch_limit:\\n pitch = pitch_limit\\n elif pitch < -pitch_limit:\\n pitch = -pitch_limit\\n\\n front = euler_to_vec(yaw, pitch)\\n\\n self.lookat(*(self.curr_position + front))\\n self.last_mouse_x, self.last_mouse_y = curr_mouse_x, curr_mouse_y\",\n \"def apply_changes(self):\\n self.x = self.buff_x\\n self.y = self.buff_y\\n self.buff_x = None\\n self.buff_y = None\",\n \"def update(self):\\n pygame.event.pump()\\n self.pos_x -= 1.5\",\n \"def set_speed_x(self, new_speed):\\n self.__speed_x = new_speed\",\n \"def OnMouseDown(self, evt):\\n self.CaptureMouse()\\n self.x, self.y = self.lastx, self.lasty = evt.GetPosition()\",\n \"def changespeed(self, x1, y1):\\n self.change_x += x1\\n self.change_y += y1\",\n \"def tick(self, dt):\\n self.x += dt * self.x_speed\\n self.y += dt * self.y_speed\",\n \"def update_gps(\\n self,\\n x_m,\\n y_m,\\n x_accuracy_m,\\n y_accuracy_m,\\n heading_d,\\n speed_m_s\\n ):\\n self.GPS_MEASUREMENT_NOISE[0].itemset(0, x_accuracy_m)\\n self.GPS_MEASUREMENT_NOISE[1].itemset(1, y_accuracy_m)\\n\\n now = time.time()\\n time_diff_s = now - self._last_observation_s\\n self._last_observation_s = now\\n\\n if heading_d is None:\\n heading_d = 0.0\\n if speed_m_s is None:\\n matrix = self.GPS_NO_HEADING_SPEED_OBSERVER_MATRIX\\n speed_m_s = 0.0\\n else:\\n matrix = self.GPS_NO_HEADING_OBSERVER_MATRIX\\n elif speed_m_s is None:\\n matrix = self.GPS_NO_SPEED_OBSERVER_MATRIX\\n speed_m_s = 0.0\\n else:\\n matrix = self.GPS_OBSERVER_MATRIX\\n\\n measurements = numpy.matrix(\\n [x_m, y_m, heading_d, speed_m_s]\\n ).transpose() # z\\n\\n self._update(\\n measurements,\\n matrix,\\n self.GPS_MEASUREMENT_NOISE,\\n time_diff_s\\n )\",\n \"def on_mouse_motion(self, x, y, dx, dy):\\n # hazlo aparecer donde este mi jugador en el mouse\\n self.player_sprite.center_x = x\\n self.player_sprite.center_y = y\",\n \"def getMouse(self):\\n self.mouseX = None\\n self.mouseY = None\\n while self.mouseX == None or self.mouseY == None:\\n #self.update()\\n _tkCall(self.update)\\n if self.isClosed(): raise GraphicsError, \\\"getMouse in closed window\\\"\\n time.sleep(.1) # give up thread\\n x,y = self.toWorld(self.mouseX, self.mouseY)\\n self.mouseX = None\\n self.mouseY = None\\n return Point(x,y)\",\n \"def setXY(self, x, y):\\n self.x = x\\n self.y = y\",\n \"def pointer_notify_axis(\\n self,\\n time_msec: int,\\n orientation: AxisOrientation,\\n value: float,\\n value_discrete: int,\\n source: AxisSource,\\n ) -> None:\\n lib.wlr_seat_pointer_notify_axis(\\n self._ptr, time_msec, orientation.value, value, value_discrete, source.value\\n )\",\n \"def update(self, *args):\\n\\n # change picture every 100 milliseconds\\n now = pygame.time.get_ticks()\\n if now - self.last_update > 100:\\n self.index = self.index ^ 1\\n self.image = self.images[self.index]\\n self.last_update = now\\n prom = self.rect.center\\n self.rect = self.image.get_rect()\\n self.rect.center = prom\\n\\n self.rect.x -= args[0]\",\n \"def emit_mouse(self, report):\\n for name, attr in self.layout.mouse.items():\\n # If the attr is a tuple like (left_analog_y, \\\"-\\\")\\n # then set the attr to just be the first item\\n attr, modifier = attr\\n\\n if attr.startswith(\\\"trackpad_touch\\\"):\\n active_attr = attr[:16] + \\\"active\\\"\\n if not getattr(report, active_attr):\\n self.mouse_pos.pop(name, None)\\n continue\\n\\n pos = getattr(report, attr)\\n if name not in self.mouse_pos:\\n self.mouse_pos[name] = pos\\n\\n sensitivity = 0.5\\n self.mouse_rel[name] += (pos - self.mouse_pos[name]) * sensitivity\\n self.mouse_pos[name] = pos\\n\\n elif \\\"analog\\\" in attr:\\n pos = getattr(report, attr)\\n if (pos > (128 + self.mouse_analog_deadzone)\\n or pos < (128 - self.mouse_analog_deadzone)):\\n accel = (pos - 128) / 10\\n else:\\n continue\\n\\n # If a minus modifier has been given then minus the acceleration\\n # to invert the direction.\\n if (modifier and modifier == \\\"-\\\"):\\n accel = -accel\\n\\n sensitivity = self.mouse_analog_sensitivity\\n self.mouse_rel[name] += accel * sensitivity\\n\\n # Emulate mouse wheel (needs special handling)\\n if name in (ecodes.REL_WHEELUP, ecodes.REL_WHEELDOWN):\\n ecode = ecodes.REL_WHEEL # The real event we need to emit\\n write = False\\n if getattr(report, attr):\\n self._scroll_details['direction'] = name\\n now = time.time()\\n last_write = self._scroll_details.get('last_write')\\n if not last_write:\\n # No delay for the first button press for fast feedback\\n write = True\\n self._scroll_details['count'] = 0\\n if name == ecodes.REL_WHEELUP:\\n value = 1\\n elif name == ecodes.REL_WHEELDOWN:\\n value = -1\\n if last_write:\\n # Delay at least one cycle before continual scrolling\\n if self._scroll_details['count'] > 1:\\n if now - last_write > self.scroll_delay:\\n write = True\\n elif now - last_write > self.scroll_repeat_delay:\\n write = True\\n if write:\\n self.device.write(ecodes.EV_REL, ecode, value)\\n self._scroll_details['last_write'] = now\\n self._scroll_details['count'] += 1\\n continue # No need to proceed further\\n else:\\n # Reset so you can quickly tap the button to scroll\\n if self._scroll_details.get('direction') == name:\\n self._scroll_details['last_write'] = 0\\n self._scroll_details['count'] = 0\\n\\n rel = int(self.mouse_rel[name])\\n self.mouse_rel[name] = self.mouse_rel[name] - rel\\n self.device.write(ecodes.EV_REL, name, rel)\\n\\n self.device.syn()\",\n \"def show_mouse_position_with_px(self):\\n self.main_menu_greets_fonts = pygame.font.Font(os.path.join(PATH_TO_RESOURCE, 'font_forever.ttf'), 10)\\n self.positiontext(f'Mouse position {pygame.mouse.get_pos()}', (770, 20))\\n self.mouse = pygame.mouse.get_pos()\\n return self.mouse\",\n \"def Update(self, ticks=0):\",\n \"def handleMousePositionCallback(self, xy):\\n\\n if self.mouse_position_callback:\\n (x, y) = xy\\n posn = self.convertView2Geo(x, y)\\n self.mouse_position_callback(posn)\",\n \"def set_global_coordinates(self):\\r\\n\\r\\n # alias:\\r\\n F = Turbine.F\\r\\n t = Turbine.t\\r\\n \\r\\n self.x = -F*np.sin(t) + self.x0\\r\\n self.y = +F*np.cos(t) + self.y0\",\n \"def mc_update_xy(self):\\n i = random.randint(0,self.N-1)\\n return self.mc_update_fixed(i,xy = True)\",\n \"def update_points(self, *args):\\n points = [Window.width / 2, Window.height / 2, .5, .5]\\n i = 0\\n while i < 2 * pi:\\n i += 0.01 * pi\\n points.extend([\\n Window.width / 2 + cos(i) * (self.radius + self.sin_wobble *\\n sin(i * self.sin_wobble_speed)),\\n Window.height / 2 + sin(i) * (self.radius + self.sin_wobble *\\n sin(i * self.sin_wobble_speed)),\\n self.offset_x + sin(i),\\n self.offset_y + cos(i)])\\n\\n self.mesh_points = points\",\n \"def update(self):\\n pos = pygame.mouse.get_pos()\\n self.rect.midtop = pos\\n if self.punching:\\n self.rect.move_ip(5, 10) # move fist position in place\",\n \"def mouse_move_callback(self, event):\\n # TODO drag and drop figuriek\\n print(\\\"moving at \\\", event.x + self.offset_x, event.y + self.offset_y)\",\n \"def mouse_motion_current_mouse_position() -> EventType:\\n x, y = pygame.mouse.get_pos()\\n return pygame.event.Event(pygame.MOUSEMOTION, {'pos': (int(x), int(y))})\",\n \"def tick(self, dt: float):\\n self.x_pos += dt * self.x_velocity\\n self.y_pos += dt * self.y_velocity\\n\\n self.x_velocity += dt * self.x_acceleration\\n self.y_velocity += dt * self.y_velocity\",\n \"def start(self, x, y):\\n self.last_x = x\\n self.last_y = y\\n self.aperture_id = None\",\n \"def update(self):\\r\\n # Get where the mouse is\\r\\n pos = pygame.mouse.get_pos()\\r\\n # Set the left side of the player bar to the mouse position\\r\\n self.rect.x = pos[0]\\r\\n # Make sure we don't push the player paddle\\r\\n # off the right side of the screen\\r\\n if self.rect.x > self.screenwidth - self.width:\\r\\n self.rect.x = self.screenwidth - self.width\",\n \"def pos(self, x, y):\\n\\n if isinstance(x, float):\\n x = int(x)\\n\\n self.screen.write(colorama.Cursor.POS(x, y), ansi=True)\\n self.x = x\\n self.y = y\\n\\n return x, y\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5839249","0.57032055","0.5696799","0.56878513","0.5680848","0.56477594","0.5643513","0.56162447","0.5613641","0.56051666","0.558602","0.55699193","0.5541605","0.5541605","0.5534065","0.5533534","0.5528136","0.5512954","0.5495194","0.54931223","0.548661","0.5484529","0.5472189","0.5459849","0.54550296","0.54440284","0.5431041","0.5381656","0.53808516","0.53771603","0.5350924","0.53425384","0.5342128","0.5341712","0.53349406","0.5310174","0.5307245","0.53021187","0.5278707","0.52759093","0.52631426","0.52097136","0.5205697","0.5205697","0.5205697","0.5205302","0.5198206","0.5188511","0.51882607","0.51860654","0.515826","0.515426","0.5144423","0.5104018","0.5103439","0.50818425","0.5070548","0.507045","0.5064747","0.50631535","0.5052534","0.5046333","0.5016433","0.5001794","0.49904716","0.49771985","0.4976581","0.49676645","0.49652517","0.49640688","0.49640688","0.49429524","0.49325722","0.49303797","0.49284643","0.49273118","0.4922813","0.49207786","0.4919838","0.49190274","0.49133068","0.49034247","0.4900723","0.48952404","0.48894283","0.48868567","0.48865172","0.4879298","0.4869098","0.48689216","0.4855089","0.48512068","0.4846988","0.4841186","0.48409376","0.48408723","0.4833692","0.48321015","0.48240182","0.48214075"],"string":"[\n \"0.5839249\",\n \"0.57032055\",\n \"0.5696799\",\n \"0.56878513\",\n \"0.5680848\",\n \"0.56477594\",\n \"0.5643513\",\n \"0.56162447\",\n \"0.5613641\",\n \"0.56051666\",\n \"0.558602\",\n \"0.55699193\",\n \"0.5541605\",\n \"0.5541605\",\n \"0.5534065\",\n \"0.5533534\",\n \"0.5528136\",\n \"0.5512954\",\n \"0.5495194\",\n \"0.54931223\",\n \"0.548661\",\n \"0.5484529\",\n \"0.5472189\",\n \"0.5459849\",\n \"0.54550296\",\n \"0.54440284\",\n \"0.5431041\",\n \"0.5381656\",\n \"0.53808516\",\n \"0.53771603\",\n \"0.5350924\",\n \"0.53425384\",\n \"0.5342128\",\n \"0.5341712\",\n \"0.53349406\",\n \"0.5310174\",\n \"0.5307245\",\n \"0.53021187\",\n \"0.5278707\",\n \"0.52759093\",\n \"0.52631426\",\n \"0.52097136\",\n \"0.5205697\",\n \"0.5205697\",\n \"0.5205697\",\n \"0.5205302\",\n \"0.5198206\",\n \"0.5188511\",\n \"0.51882607\",\n \"0.51860654\",\n \"0.515826\",\n \"0.515426\",\n \"0.5144423\",\n \"0.5104018\",\n \"0.5103439\",\n \"0.50818425\",\n \"0.5070548\",\n \"0.507045\",\n \"0.5064747\",\n \"0.50631535\",\n \"0.5052534\",\n \"0.5046333\",\n \"0.5016433\",\n \"0.5001794\",\n \"0.49904716\",\n \"0.49771985\",\n \"0.4976581\",\n \"0.49676645\",\n \"0.49652517\",\n \"0.49640688\",\n \"0.49640688\",\n \"0.49429524\",\n \"0.49325722\",\n \"0.49303797\",\n \"0.49284643\",\n \"0.49273118\",\n \"0.4922813\",\n \"0.49207786\",\n \"0.4919838\",\n \"0.49190274\",\n \"0.49133068\",\n \"0.49034247\",\n \"0.4900723\",\n \"0.48952404\",\n \"0.48894283\",\n \"0.48868567\",\n \"0.48865172\",\n \"0.4879298\",\n \"0.4869098\",\n \"0.48689216\",\n \"0.4855089\",\n \"0.48512068\",\n \"0.4846988\",\n \"0.4841186\",\n \"0.48409376\",\n \"0.48408723\",\n \"0.4833692\",\n \"0.48321015\",\n \"0.48240182\",\n \"0.48214075\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6736627"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3299,"cells":{"query":{"kind":"string","value":"Returns the focal length of the telescope."},"document":{"kind":"string","value":"def focal_length(self):\n\n return self.f * self.diameter"},"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 estimate_focal_length(self):\n fl = (self.fiber_diameter / 2) / np.tan(np.deg2rad(self.fov / 2))\n\n return fl","def length(self) -> ir.FloatingValue:\n return ops.GeoLength(self).to_expr()","def bspb_focalLength():\n shotCam = pm.PyNode('shot_cam').getShape()\n return str(shotCam.focalLength.get())","def getLength(self):\n return self.geometry.length","def getLength(self) -> float:\n return self.length","def get_length(self) -> int:\n return (self.pivot_departure_fix.timestamp - self.pivot_arrival_fix.timestamp).total_seconds()","def focallengthFromFOV(self, view_x=None, view_y=None): # pragma: no cover\n # to be overloaded by the child class.\n return 0","def focal_point(self):\n return self._focal_point","def length(self):\n return _property_op(arctern.ST_Length, self)","def length(self) -> float:\n n = self.geodesic.extrinsicDimension()\n third = 1.0/3.0\n def distance(x,y):\n cp0 = x[:n]\n cp1 = self.geodesic.integrate(cp0,vectorops.mul(x[n:],third))\n cp3 = y[:n]\n cp2 = self.geodesic.integrate(cp3,vectorops.mul(y[n:],-third))\n return self.geodesic.distance(cp0,cp1) + self.geodesic.distance(cp1,cp2) + self.geodesic.distance(cp2,cp3)\n return Trajectory.length(self,distance)","def obs_length(self):\n return self.lc.time[-1] - self.lc.time[0]","def getVocalized(self,):\n\t\treturn self.vocalized;","def get_length(self):\n\n return self.length","def auxiliary_trail_length(self):\n return self.attributes[\"_aux_length\"]","def _get_length(self):\n return self._length","def total_length(self):\n # YOUR CODE HERE\n return abs(self.radius*self.angle)","def getLength(self):\n return self.length","def getLength(self):\n return self.sideLength","def time_length(self):\n return self._time_length","def get_length(self):\n return self._length","def get_length(self):\n return self._length","def __len__(self):\n return len(self.focals)","def getLength(self):\n flength = 0\n for quad in self._quadrilaterals:\n flength = flength + get_quad_length(quad)\n return flength","def get_length(self):\n\n return self._length","def _get_length(self):\n from math import sqrt\n\n if self._length is None:\n sum1 = 0\n for a in self.diff:\n sum1 += a * a\n self._length = sqrt(sum1)\n return self._length","def length(self):\n self.convert_window(\"Length\", \"meters\", [\"Scandinavian mile\", \"angstroms\", \"au\", \"barleycorns\", \"cables\", \"centimeters\", \"chains\", \"decimeters\", \"ells\", \"ems\", \"fathoms\", \"feet(UK & US)\", \"feet(US survey)\", \"furlongs\", \"hands\", \"hectometers\", \"inches\", \"kilometers\", \"links\", \"light years\", \"meters\", \"micrometers\", \"mil\", \"miles(UK & US)\", \"miles(nautical, UK)\", \"miles(nautical, international)\", \"millimeters\", \"nanometers\", \"parsecs\", \"pica\", \"picometers\", \"rods\", \"spans\", \"thou\", \"yards\"])","def length(self):\n return self.get_delta_value(self.Z_INDEX)","def length(self) -> float:\n return pos.distance(self.start, self.end)","def get_length(self):\n if(type(self._length) != float):\n self._logger.write(\"Error! length must be of type float\")\n elif(self._length == None):\n self._logger.write(\"Error! length contains no value\")\n else:\n try:\n return self._length\n except Exception as e:\n self._logger.write(\"Error! Could not fetch the value of length: \\n %s\" % e)","def length(self):\n return math.sqrt(self.x**2 + self.y**2 + self.z**2)","def get_length(self):\n return math.sqrt(self.x**2 + self.y**2)","def lfn(self):\n if self.precision:\n return self.evaluations.exposedWing.edges[1].point1.z - self.evaluations.chordIntersected.edges[1].length\n else:\n return (self.acW + self.longPosW) / 2 # first guess for a faster evaluation","def length(self):\n return self.length2 ** 0.5","def get_unstr_length(self):\n if self.unstr_length is None:\n return self.length()\n\n elif isinstance(self.unstr_length, str):\n return self.length() + float(self.unstr_length)\n\n return self.unstr_length","def get_road_length(self):\r\n if self.road_length is None:\r\n return self.container.get_road_length()\r\n \r\n return self.road_length","def get_length(self, ak_tpl: BKT) -> Optional[float]:\n ...","def total_length(self):\n return abs(self.length)","def length(self):\n return pyvista.Box(self.bounds).length","def Length(self):\n return math.sqrt(self.x**2 + self.y**2 + self.z**2)","def get_list_length(self):\r\n s = self.query('LIST:FREQ:POIN?')\r\n if s == None: return None\r\n return int(s)","def length(self) -> float:\n n = len(self.milestones[0])//2\n third = 1.0/3.0\n def distance(x,y):\n cp0 = x[:n]\n cp1 = vectorops.madd(cp0,x[n:],third)\n cp3 = y[:n]\n cp2 = vectorops.madd(cp3,y[n:],-third)\n return third*vectorops.norm(x[n:]) + vectorops.distance(cp1,cp2) + third*vectorops.norm(y[n:])\n return Trajectory.length(self,distance)","def maximumORFLength(self):\n return max(len(orf) for orf in self.ORFs())","def length(self):\n return self.endpoints[0].distance_to(self.endpoints[1])","def filmHeight(self):\r\n cls = mxs.classof(self._nativePointer)\r\n height = None\r\n if cls == mxs.VRayPhysicalCamera:\r\n\r\n # TODO: Why is that wrapped in a try except?\r\n try:\r\n height = self._nativePointer.film_height\r\n except AttributeError:\r\n pass\r\n\r\n elif cls == mxs.Physical:\r\n height = self._nativePointer.film_height_mm\r\n\r\n if not height:\r\n # If we failed to get a width from a camera, return the scene aperture setting.\r\n height = self.filmWidth() * (mxs.renderPixelAspect / mxs.getRendImageAspect())\r\n\r\n return height","def getLength(self):\n return None","def getLength(self):\n return None","def TF_wavelength(self):\n return int(self.ask(self.headStr('TF')+'TWL?'))","def edge_length(self):\n if self.edge_length_l is not None:\n return self.edge_length_l\n else:\n self.edge_length_l = (2 * self.radius * math.sin(math.pi / self.vert_count))\n return self.edge_length_l","def length(self):\n if self._length_cache is None:\n cls = type(self)\n func = cls._length_extraction_fn()\n preprocessed_func = cls.preprocess_func(func)\n self._length_cache = self.apply(preprocessed_func)\n return self._length_cache","def length(self):\n return self.length","def get_path_length(self) :\n return self.path_length","def length(self):\n if self.running:\n return ZERO_TIME\n else:\n return self.end - self.start","def getFar(self):\n return self.light.node().getLens().getFar()","def filmWidth(self):\r\n cls = mxs.classof(self._nativePointer)\r\n width = None\r\n if cls == mxs.VRayPhysicalCamera:\r\n width = self._nativePointer.film_width\r\n\r\n elif cls == mxs.Physical:\r\n width = self._nativePointer.film_width_mm\r\n\r\n if not width:\r\n \r\n # If we failed to get a width from a camera, return the scene aperture setting.\r\n width = mxs.getRendApertureWidth()\r\n\r\n return width","def length(self):\n return float(np.max([self.width(),self.height()]))","def calculate_length(self):\n raise NotImplementedError","def get_length(self):\r\n return len(self.tweets)","def TL_wavelength(self):\n return int(self.ask(self.headStr('TL')+'TWL?'))","def get_length(self, ak_spec: Union[str, BKT]) -> Optional[float]:\n ...","def get_angle_of_view(focal_length, crop_factor=FULL_FRAME):\n d = 36 # mm, full-frame\n d /= crop_factor\n alpha = 2 * math.atan(d/(2*focal_length))\n return alpha","def length(self):\n return math.sqrt(self.x * self.x + self.y * self.y)","def length(self):\n return self._length","def length(self):\n return self._length","def get_list_length(self):\r\n s = self.query('SOUR1:LIST:FREQ:POIN?')\r\n if s == None: return None\r\n return int(s)","def get_list_length(self):\r\n s = self.query('SOUR1:LIST:FREQ:POIN?')\r\n if s == None: return None\r\n return int(s)","def get_length(self):\n return self.run_command('get_length')[0]","def _set_length(self):\n if self.nb_points <= 1:\n self.length = 0\n else:\n ldiff_degree = self.coord_list[1:] - self.coord_list[:-1]\n ldiff_meter = ldiff_degree * np.pi * EQUATORIAL_EARTH_RADIUS / 180\n ldiff_meter[:, 0] *= np.cos(self.mean_pos[1] * np.pi / 180)\n self.length = np.sum(\n np.sqrt(ldiff_meter[:, 0] ** 2 + ldiff_meter[:, 1] ** 2)\n )","def Length(self):\n xyza = self.ga_ref.get_position() + self.wa\n xyzb = self.gb_ref.get_position() + self.wb\n if self.gc is not None:\n xyzc = self.gc_ref.get_position() + self.wc\n xa, ya, za = xyza\n length = self._integrate(\n xyza - xa,\n xyzb - ya,\n xyzc - za,\n )\n else:\n length = np.linalg.norm(xyzb - xyza)\n return length","def length(self):\n return self._info.length # pylint: disable=E1101","def getLengthAlien(self):\n return len(self._aliens)","def length(self):\r\n\r\n return math.sqrt(self*self)","def getLength(self):\n return self.vector.norm","def length(self):\n return self.__length","def length(self):\n return self.__length","def zone_width(self):\n return self._zone_width","def length(self):\n\n return self._length","def getLength(self):\n return _libsbml.XMLAttributes_getLength(self)","def getLen(self):\n return self.len","def bspb_focalLengthUpdate():\n if pm.windows.headsUpDisplay('focalLengthUpdateEXP', q=True, ex=True):\n pm.delete('focalLengthUpdateEXP')\n pm.expression(s='headsUpDisplay -r \"focalLengthHUD\";', n='focalLengthUpdateEXP', ae=1, uc='all')","def getFov(self):\n return self.light.node().getLens().getFov()","def length(self):\n if not hasattr(self, '_length'):\n lengths = np.linalg.norm(np.diff(self.points, axis=0), axis=1)\n self._segment_lengths = lengths\n self._length = lengths.sum()\n return self._length","def calc_length(self):\n return AtomMath.length(self.atom1.position - self.atom2.position)","def length(self):\n return math.sqrt(\n (self.endpoint_a.northing - self.endpoint_b.northing) ** 2 +\n (self.endpoint_a.easting - self.endpoint_b.easting) ** 2\n )","def computeDirLength(self):\n self.length , uv = dirAndLength(self.pointN, self.point1)\n self.unitv = uv\n return uv","def getTotalLength(self):\n return self.length","def full_frame_length(self):\n return self.height * self.width * 3","def namelength(self):\n return self[\"namelength\"]","def get_track_length(track_path):\n track_extension = os.path.splitext(track_path)[1]\n if track_extension:\n try:\n mutagen_track = File(track_path)\n track_total_length = mutagen_track.info.length\n except:\n track_total_length = 0\n tkinter.messagebox.showwarning(\n title=\"Warning!\", message=f\"Audio file incorrect : {track_path}\")\n finally:\n track_length_formated = strftime(\n '%M:%S', gmtime(track_total_length))\n track_length_label.configure(text=track_length_formated)\n track_pos_slider.configure(to=track_total_length)\n return track_total_length","def get_length(self):\n return self._select_interface(self._rc_get_length,\n self._http_get_length)","def ft(self):\n return self._ft","def total_length(self):\n return self.length","def get_list_length(self):\r\n _debug('simq03b_api.get_list_length')\r\n \r\n s = self.query('SOUR1:LIST:FREQ:POIN?')\r\n if s == None: return None\r\n return int(s)","def length(self):\n return self.n * self.t.length()","def length(self) -> ir.IntegerValue:\n return ops.MapLength(self).to_expr()","def __abs__(self):\n return self.length","def get_length(self, px, py):\n idx = px + py * self.width\n return len(self._rotations_buffer[idx])","def Length(self) -> int:","def Length(self) -> int:","def getWindowLength(f0=10e3, fs=2.5e6, windfunc='blackman', error=0.1):\n # lowest detectable frequency by window\n ldf = f0 * error\n\n if windfunc == 'Rectangular':\n M = int(fs / ldf)\n elif windfunc in ('Bartlett', 'Hanning', 'Hamming'):\n M = int(4 * (fs / ldf))\n elif windfunc == 'blackman':\n M = int(6 * (fs / ldf))\n else:\n raise ValueError('Not a valid windowing function.')\n\n return M","def getLength(self):\n return self.n"],"string":"[\n \"def estimate_focal_length(self):\\n fl = (self.fiber_diameter / 2) / np.tan(np.deg2rad(self.fov / 2))\\n\\n return fl\",\n \"def length(self) -> ir.FloatingValue:\\n return ops.GeoLength(self).to_expr()\",\n \"def bspb_focalLength():\\n shotCam = pm.PyNode('shot_cam').getShape()\\n return str(shotCam.focalLength.get())\",\n \"def getLength(self):\\n return self.geometry.length\",\n \"def getLength(self) -> float:\\n return self.length\",\n \"def get_length(self) -> int:\\n return (self.pivot_departure_fix.timestamp - self.pivot_arrival_fix.timestamp).total_seconds()\",\n \"def focallengthFromFOV(self, view_x=None, view_y=None): # pragma: no cover\\n # to be overloaded by the child class.\\n return 0\",\n \"def focal_point(self):\\n return self._focal_point\",\n \"def length(self):\\n return _property_op(arctern.ST_Length, self)\",\n \"def length(self) -> float:\\n n = self.geodesic.extrinsicDimension()\\n third = 1.0/3.0\\n def distance(x,y):\\n cp0 = x[:n]\\n cp1 = self.geodesic.integrate(cp0,vectorops.mul(x[n:],third))\\n cp3 = y[:n]\\n cp2 = self.geodesic.integrate(cp3,vectorops.mul(y[n:],-third))\\n return self.geodesic.distance(cp0,cp1) + self.geodesic.distance(cp1,cp2) + self.geodesic.distance(cp2,cp3)\\n return Trajectory.length(self,distance)\",\n \"def obs_length(self):\\n return self.lc.time[-1] - self.lc.time[0]\",\n \"def getVocalized(self,):\\n\\t\\treturn self.vocalized;\",\n \"def get_length(self):\\n\\n return self.length\",\n \"def auxiliary_trail_length(self):\\n return self.attributes[\\\"_aux_length\\\"]\",\n \"def _get_length(self):\\n return self._length\",\n \"def total_length(self):\\n # YOUR CODE HERE\\n return abs(self.radius*self.angle)\",\n \"def getLength(self):\\n return self.length\",\n \"def getLength(self):\\n return self.sideLength\",\n \"def time_length(self):\\n return self._time_length\",\n \"def get_length(self):\\n return self._length\",\n \"def get_length(self):\\n return self._length\",\n \"def __len__(self):\\n return len(self.focals)\",\n \"def getLength(self):\\n flength = 0\\n for quad in self._quadrilaterals:\\n flength = flength + get_quad_length(quad)\\n return flength\",\n \"def get_length(self):\\n\\n return self._length\",\n \"def _get_length(self):\\n from math import sqrt\\n\\n if self._length is None:\\n sum1 = 0\\n for a in self.diff:\\n sum1 += a * a\\n self._length = sqrt(sum1)\\n return self._length\",\n \"def length(self):\\n self.convert_window(\\\"Length\\\", \\\"meters\\\", [\\\"Scandinavian mile\\\", \\\"angstroms\\\", \\\"au\\\", \\\"barleycorns\\\", \\\"cables\\\", \\\"centimeters\\\", \\\"chains\\\", \\\"decimeters\\\", \\\"ells\\\", \\\"ems\\\", \\\"fathoms\\\", \\\"feet(UK & US)\\\", \\\"feet(US survey)\\\", \\\"furlongs\\\", \\\"hands\\\", \\\"hectometers\\\", \\\"inches\\\", \\\"kilometers\\\", \\\"links\\\", \\\"light years\\\", \\\"meters\\\", \\\"micrometers\\\", \\\"mil\\\", \\\"miles(UK & US)\\\", \\\"miles(nautical, UK)\\\", \\\"miles(nautical, international)\\\", \\\"millimeters\\\", \\\"nanometers\\\", \\\"parsecs\\\", \\\"pica\\\", \\\"picometers\\\", \\\"rods\\\", \\\"spans\\\", \\\"thou\\\", \\\"yards\\\"])\",\n \"def length(self):\\n return self.get_delta_value(self.Z_INDEX)\",\n \"def length(self) -> float:\\n return pos.distance(self.start, self.end)\",\n \"def get_length(self):\\n if(type(self._length) != float):\\n self._logger.write(\\\"Error! length must be of type float\\\")\\n elif(self._length == None):\\n self._logger.write(\\\"Error! length contains no value\\\")\\n else:\\n try:\\n return self._length\\n except Exception as e:\\n self._logger.write(\\\"Error! Could not fetch the value of length: \\\\n %s\\\" % e)\",\n \"def length(self):\\n return math.sqrt(self.x**2 + self.y**2 + self.z**2)\",\n \"def get_length(self):\\n return math.sqrt(self.x**2 + self.y**2)\",\n \"def lfn(self):\\n if self.precision:\\n return self.evaluations.exposedWing.edges[1].point1.z - self.evaluations.chordIntersected.edges[1].length\\n else:\\n return (self.acW + self.longPosW) / 2 # first guess for a faster evaluation\",\n \"def length(self):\\n return self.length2 ** 0.5\",\n \"def get_unstr_length(self):\\n if self.unstr_length is None:\\n return self.length()\\n\\n elif isinstance(self.unstr_length, str):\\n return self.length() + float(self.unstr_length)\\n\\n return self.unstr_length\",\n \"def get_road_length(self):\\r\\n if self.road_length is None:\\r\\n return self.container.get_road_length()\\r\\n \\r\\n return self.road_length\",\n \"def get_length(self, ak_tpl: BKT) -> Optional[float]:\\n ...\",\n \"def total_length(self):\\n return abs(self.length)\",\n \"def length(self):\\n return pyvista.Box(self.bounds).length\",\n \"def Length(self):\\n return math.sqrt(self.x**2 + self.y**2 + self.z**2)\",\n \"def get_list_length(self):\\r\\n s = self.query('LIST:FREQ:POIN?')\\r\\n if s == None: return None\\r\\n return int(s)\",\n \"def length(self) -> float:\\n n = len(self.milestones[0])//2\\n third = 1.0/3.0\\n def distance(x,y):\\n cp0 = x[:n]\\n cp1 = vectorops.madd(cp0,x[n:],third)\\n cp3 = y[:n]\\n cp2 = vectorops.madd(cp3,y[n:],-third)\\n return third*vectorops.norm(x[n:]) + vectorops.distance(cp1,cp2) + third*vectorops.norm(y[n:])\\n return Trajectory.length(self,distance)\",\n \"def maximumORFLength(self):\\n return max(len(orf) for orf in self.ORFs())\",\n \"def length(self):\\n return self.endpoints[0].distance_to(self.endpoints[1])\",\n \"def filmHeight(self):\\r\\n cls = mxs.classof(self._nativePointer)\\r\\n height = None\\r\\n if cls == mxs.VRayPhysicalCamera:\\r\\n\\r\\n # TODO: Why is that wrapped in a try except?\\r\\n try:\\r\\n height = self._nativePointer.film_height\\r\\n except AttributeError:\\r\\n pass\\r\\n\\r\\n elif cls == mxs.Physical:\\r\\n height = self._nativePointer.film_height_mm\\r\\n\\r\\n if not height:\\r\\n # If we failed to get a width from a camera, return the scene aperture setting.\\r\\n height = self.filmWidth() * (mxs.renderPixelAspect / mxs.getRendImageAspect())\\r\\n\\r\\n return height\",\n \"def getLength(self):\\n return None\",\n \"def getLength(self):\\n return None\",\n \"def TF_wavelength(self):\\n return int(self.ask(self.headStr('TF')+'TWL?'))\",\n \"def edge_length(self):\\n if self.edge_length_l is not None:\\n return self.edge_length_l\\n else:\\n self.edge_length_l = (2 * self.radius * math.sin(math.pi / self.vert_count))\\n return self.edge_length_l\",\n \"def length(self):\\n if self._length_cache is None:\\n cls = type(self)\\n func = cls._length_extraction_fn()\\n preprocessed_func = cls.preprocess_func(func)\\n self._length_cache = self.apply(preprocessed_func)\\n return self._length_cache\",\n \"def length(self):\\n return self.length\",\n \"def get_path_length(self) :\\n return self.path_length\",\n \"def length(self):\\n if self.running:\\n return ZERO_TIME\\n else:\\n return self.end - self.start\",\n \"def getFar(self):\\n return self.light.node().getLens().getFar()\",\n \"def filmWidth(self):\\r\\n cls = mxs.classof(self._nativePointer)\\r\\n width = None\\r\\n if cls == mxs.VRayPhysicalCamera:\\r\\n width = self._nativePointer.film_width\\r\\n\\r\\n elif cls == mxs.Physical:\\r\\n width = self._nativePointer.film_width_mm\\r\\n\\r\\n if not width:\\r\\n \\r\\n # If we failed to get a width from a camera, return the scene aperture setting.\\r\\n width = mxs.getRendApertureWidth()\\r\\n\\r\\n return width\",\n \"def length(self):\\n return float(np.max([self.width(),self.height()]))\",\n \"def calculate_length(self):\\n raise NotImplementedError\",\n \"def get_length(self):\\r\\n return len(self.tweets)\",\n \"def TL_wavelength(self):\\n return int(self.ask(self.headStr('TL')+'TWL?'))\",\n \"def get_length(self, ak_spec: Union[str, BKT]) -> Optional[float]:\\n ...\",\n \"def get_angle_of_view(focal_length, crop_factor=FULL_FRAME):\\n d = 36 # mm, full-frame\\n d /= crop_factor\\n alpha = 2 * math.atan(d/(2*focal_length))\\n return alpha\",\n \"def length(self):\\n return math.sqrt(self.x * self.x + self.y * self.y)\",\n \"def length(self):\\n return self._length\",\n \"def length(self):\\n return self._length\",\n \"def get_list_length(self):\\r\\n s = self.query('SOUR1:LIST:FREQ:POIN?')\\r\\n if s == None: return None\\r\\n return int(s)\",\n \"def get_list_length(self):\\r\\n s = self.query('SOUR1:LIST:FREQ:POIN?')\\r\\n if s == None: return None\\r\\n return int(s)\",\n \"def get_length(self):\\n return self.run_command('get_length')[0]\",\n \"def _set_length(self):\\n if self.nb_points <= 1:\\n self.length = 0\\n else:\\n ldiff_degree = self.coord_list[1:] - self.coord_list[:-1]\\n ldiff_meter = ldiff_degree * np.pi * EQUATORIAL_EARTH_RADIUS / 180\\n ldiff_meter[:, 0] *= np.cos(self.mean_pos[1] * np.pi / 180)\\n self.length = np.sum(\\n np.sqrt(ldiff_meter[:, 0] ** 2 + ldiff_meter[:, 1] ** 2)\\n )\",\n \"def Length(self):\\n xyza = self.ga_ref.get_position() + self.wa\\n xyzb = self.gb_ref.get_position() + self.wb\\n if self.gc is not None:\\n xyzc = self.gc_ref.get_position() + self.wc\\n xa, ya, za = xyza\\n length = self._integrate(\\n xyza - xa,\\n xyzb - ya,\\n xyzc - za,\\n )\\n else:\\n length = np.linalg.norm(xyzb - xyza)\\n return length\",\n \"def length(self):\\n return self._info.length # pylint: disable=E1101\",\n \"def getLengthAlien(self):\\n return len(self._aliens)\",\n \"def length(self):\\r\\n\\r\\n return math.sqrt(self*self)\",\n \"def getLength(self):\\n return self.vector.norm\",\n \"def length(self):\\n return self.__length\",\n \"def length(self):\\n return self.__length\",\n \"def zone_width(self):\\n return self._zone_width\",\n \"def length(self):\\n\\n return self._length\",\n \"def getLength(self):\\n return _libsbml.XMLAttributes_getLength(self)\",\n \"def getLen(self):\\n return self.len\",\n \"def bspb_focalLengthUpdate():\\n if pm.windows.headsUpDisplay('focalLengthUpdateEXP', q=True, ex=True):\\n pm.delete('focalLengthUpdateEXP')\\n pm.expression(s='headsUpDisplay -r \\\"focalLengthHUD\\\";', n='focalLengthUpdateEXP', ae=1, uc='all')\",\n \"def getFov(self):\\n return self.light.node().getLens().getFov()\",\n \"def length(self):\\n if not hasattr(self, '_length'):\\n lengths = np.linalg.norm(np.diff(self.points, axis=0), axis=1)\\n self._segment_lengths = lengths\\n self._length = lengths.sum()\\n return self._length\",\n \"def calc_length(self):\\n return AtomMath.length(self.atom1.position - self.atom2.position)\",\n \"def length(self):\\n return math.sqrt(\\n (self.endpoint_a.northing - self.endpoint_b.northing) ** 2 +\\n (self.endpoint_a.easting - self.endpoint_b.easting) ** 2\\n )\",\n \"def computeDirLength(self):\\n self.length , uv = dirAndLength(self.pointN, self.point1)\\n self.unitv = uv\\n return uv\",\n \"def getTotalLength(self):\\n return self.length\",\n \"def full_frame_length(self):\\n return self.height * self.width * 3\",\n \"def namelength(self):\\n return self[\\\"namelength\\\"]\",\n \"def get_track_length(track_path):\\n track_extension = os.path.splitext(track_path)[1]\\n if track_extension:\\n try:\\n mutagen_track = File(track_path)\\n track_total_length = mutagen_track.info.length\\n except:\\n track_total_length = 0\\n tkinter.messagebox.showwarning(\\n title=\\\"Warning!\\\", message=f\\\"Audio file incorrect : {track_path}\\\")\\n finally:\\n track_length_formated = strftime(\\n '%M:%S', gmtime(track_total_length))\\n track_length_label.configure(text=track_length_formated)\\n track_pos_slider.configure(to=track_total_length)\\n return track_total_length\",\n \"def get_length(self):\\n return self._select_interface(self._rc_get_length,\\n self._http_get_length)\",\n \"def ft(self):\\n return self._ft\",\n \"def total_length(self):\\n return self.length\",\n \"def get_list_length(self):\\r\\n _debug('simq03b_api.get_list_length')\\r\\n \\r\\n s = self.query('SOUR1:LIST:FREQ:POIN?')\\r\\n if s == None: return None\\r\\n return int(s)\",\n \"def length(self):\\n return self.n * self.t.length()\",\n \"def length(self) -> ir.IntegerValue:\\n return ops.MapLength(self).to_expr()\",\n \"def __abs__(self):\\n return self.length\",\n \"def get_length(self, px, py):\\n idx = px + py * self.width\\n return len(self._rotations_buffer[idx])\",\n \"def Length(self) -> int:\",\n \"def Length(self) -> int:\",\n \"def getWindowLength(f0=10e3, fs=2.5e6, windfunc='blackman', error=0.1):\\n # lowest detectable frequency by window\\n ldf = f0 * error\\n\\n if windfunc == 'Rectangular':\\n M = int(fs / ldf)\\n elif windfunc in ('Bartlett', 'Hanning', 'Hamming'):\\n M = int(4 * (fs / ldf))\\n elif windfunc == 'blackman':\\n M = int(6 * (fs / ldf))\\n else:\\n raise ValueError('Not a valid windowing function.')\\n\\n return M\",\n \"def getLength(self):\\n return self.n\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7237808","0.6786899","0.6465912","0.63727885","0.6352939","0.62659967","0.61646885","0.616444","0.61160403","0.6020924","0.5934602","0.5932981","0.59197545","0.5891779","0.588042","0.58679926","0.584611","0.58384174","0.58230686","0.5822641","0.5822641","0.5792508","0.5785025","0.57838994","0.5760595","0.5746466","0.57397634","0.57205796","0.571677","0.5704886","0.5702491","0.56714946","0.5665451","0.5645467","0.56437665","0.56348485","0.56137687","0.55941147","0.5590532","0.5571991","0.55626273","0.55620104","0.55570215","0.5546112","0.5532551","0.5532551","0.55304664","0.5523874","0.552371","0.5508641","0.54942715","0.54661185","0.54656863","0.54496455","0.5430939","0.5427295","0.54236674","0.5417234","0.5402647","0.5394534","0.5393492","0.5383069","0.5383069","0.5382589","0.5382589","0.5382035","0.5356461","0.535187","0.5348069","0.5338397","0.5337886","0.5317383","0.53170526","0.53170526","0.53149885","0.53026015","0.5295603","0.52830654","0.5276201","0.52734417","0.527062","0.52702105","0.52632165","0.52553546","0.52446485","0.5241493","0.52375567","0.5209648","0.5202467","0.51955056","0.5193148","0.5179871","0.5177486","0.51762414","0.51704115","0.5165728","0.51638186","0.51638186","0.5162487","0.5161589"],"string":"[\n \"0.7237808\",\n \"0.6786899\",\n \"0.6465912\",\n \"0.63727885\",\n \"0.6352939\",\n \"0.62659967\",\n \"0.61646885\",\n \"0.616444\",\n \"0.61160403\",\n \"0.6020924\",\n \"0.5934602\",\n \"0.5932981\",\n \"0.59197545\",\n \"0.5891779\",\n \"0.588042\",\n \"0.58679926\",\n \"0.584611\",\n \"0.58384174\",\n \"0.58230686\",\n \"0.5822641\",\n \"0.5822641\",\n \"0.5792508\",\n \"0.5785025\",\n \"0.57838994\",\n \"0.5760595\",\n \"0.5746466\",\n \"0.57397634\",\n \"0.57205796\",\n \"0.571677\",\n \"0.5704886\",\n \"0.5702491\",\n \"0.56714946\",\n \"0.5665451\",\n \"0.5645467\",\n \"0.56437665\",\n \"0.56348485\",\n \"0.56137687\",\n \"0.55941147\",\n \"0.5590532\",\n \"0.5571991\",\n \"0.55626273\",\n \"0.55620104\",\n \"0.55570215\",\n \"0.5546112\",\n \"0.5532551\",\n \"0.5532551\",\n \"0.55304664\",\n \"0.5523874\",\n \"0.552371\",\n \"0.5508641\",\n \"0.54942715\",\n \"0.54661185\",\n \"0.54656863\",\n \"0.54496455\",\n \"0.5430939\",\n \"0.5427295\",\n \"0.54236674\",\n \"0.5417234\",\n \"0.5402647\",\n \"0.5394534\",\n \"0.5393492\",\n \"0.5383069\",\n \"0.5383069\",\n \"0.5382589\",\n \"0.5382589\",\n \"0.5382035\",\n \"0.5356461\",\n \"0.535187\",\n \"0.5348069\",\n \"0.5338397\",\n \"0.5337886\",\n \"0.5317383\",\n \"0.53170526\",\n \"0.53170526\",\n \"0.53149885\",\n \"0.53026015\",\n \"0.5295603\",\n \"0.52830654\",\n \"0.5276201\",\n \"0.52734417\",\n \"0.527062\",\n \"0.52702105\",\n \"0.52632165\",\n \"0.52553546\",\n \"0.52446485\",\n \"0.5241493\",\n \"0.52375567\",\n \"0.5209648\",\n \"0.5202467\",\n \"0.51955056\",\n \"0.5193148\",\n \"0.5179871\",\n \"0.5177486\",\n \"0.51762414\",\n \"0.51704115\",\n \"0.5165728\",\n \"0.51638186\",\n \"0.51638186\",\n \"0.5162487\",\n \"0.5161589\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8241378"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":32,"numItemsPerPage":100,"numTotalItems":95772,"offset":3200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3MzcwNTk2NSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM3MDk1NjUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.xwi7MUuOayYLWsHqheQCTvlGQXcf7bWGlC5W7E9k6-cN7GCdVNCyLX9BlW7cOK-jggKYfjzNtN-eXwHYujwgBw","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 |
|---|---|---|---|---|---|---|
WAV file is loaded and transformed into Fourier Series. This Fourier Series is limited. | def wav_to_fourier(wav_file,
rate_limit=6000.0,
step=1.0):
rate, aud_data = read(wav_file)
# Should be mono
if len(aud_data) != len(aud_data.ravel()):
aud_data = np.mean(aud_data, axis=1)
# Zero padding
len_data = aud_data.shape[0]
channel_1 = np.zeros(2 ** (int(np.ceil(np.log2(len_data)))))
channel_1[0:len_data] = aud_data
# Fourier analysis
fourier = np.abs(np.fft.fft(channel_1))
freq = np.linspace(0, rate, fourier.shape[0])
freq, fourier = limit_by_freq(freq,
fourier,
upper_limit=rate_limit)
freq, fourier = group_by_freq(freq,
fourier,
step=step)
# Max frequency should be 100.0
a = np.max(np.abs(fourier)) / 100.0
fourier = fourier / a
return freq, fourier | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_wav(file_name):\n fs, signal = wavfile.read(file_name)\n signal = np.float32(signal) / (2**(16)/2-1)\n return fs, signal",
"def analyzeWAV(inputFile):\n data, fs, nbits = audiolab.wavread(inputFile)\n samplingRate = fs\n return [data, samplingRate]",
"def inputwav(filename):\n dat... | [
"0.6820377",
"0.6551853",
"0.65371555",
"0.649495",
"0.6372757",
"0.6339702",
"0.63110816",
"0.6309993",
"0.63011295",
"0.6290294",
"0.62898475",
"0.62364256",
"0.62239075",
"0.62043417",
"0.61933094",
"0.61776847",
"0.61596906",
"0.6157661",
"0.6120229",
"0.60863763",
"0.606... | 0.6188984 | 15 |
Limit arrays of frequency and features by maximum frequency and bottom frequency. | def limit_by_freq(freq, features, upper_limit, lower_limit=None):
# Copy into arrays, in order to apply mask
freq = np.array(freq, dtype=np.float)
features = np.array(features, dtype=np.float)
# Mask for bottom limit
if lower_limit is not None:
bottom_mask = freq >= lower_limit
features = features[bottom_mask]
freq = freq[bottom_mask]
# Mask for upper limit
upper_mask = freq <= upper_limit
features = features[upper_mask]
freq = freq[upper_mask]
return freq, features | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def findMaximal(freqSet):",
"def __restrict_features_freq(self, min_count=1):\n col_idx = self.X.tocsc().nonzero()[1]\n counter = np.bincount(col_idx)\n print(\"Counter:\", len(counter))\n include_cols = np.where(counter > min_count)[0]\n return include_cols",
"def fit_featur... | [
"0.6321469",
"0.5905518",
"0.5899971",
"0.5845656",
"0.5827781",
"0.5711425",
"0.55240804",
"0.5505938",
"0.54641736",
"0.5451525",
"0.5440867",
"0.5408901",
"0.5367295",
"0.53634137",
"0.5352045",
"0.5324692",
"0.53187746",
"0.53122324",
"0.5303038",
"0.52815557",
"0.5275447... | 0.72728205 | 0 |
Check if song is already transformed into temp. | def check_wav(song, source_folder, temp_folder, encoder='mpg123'):
# Name of files
song_name, extension = os.path.splitext(song)
mp3_file = os.path.join(source_folder, song)
if '.wav' != extension:
wav_file = os.path.join(temp_folder, song_name + '.wav')
try:
if not os.path.isfile(wav_file):
mp3_to_wav(
mp3_file=mp3_file,
wav_file=wav_file,
encoder=encoder)
else:
pass
except MemoryError:
logger.error('MemoryError: %s MP3 couldn\'t be transformed into WAV', song_name)
else: # Already a wav file
copyfile(mp3_file, os.path.join(temp_folder, song_name)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isTemp(self,object):\n return (object in self.tempObjects)",
"def test_transform_track_album_based_on_album_title_no_match_album(self):\n track = Track(artist='Artist', album='Album 3', title='Title',\n tracknum=1, seconds=60)\n transform = Transform(1,\n cond_album... | [
"0.56140214",
"0.54819727",
"0.542196",
"0.5414857",
"0.5397536",
"0.5393968",
"0.5390524",
"0.53878826",
"0.53857505",
"0.5385733",
"0.5346858",
"0.5340154",
"0.53382695",
"0.5315191",
"0.5310992",
"0.53011787",
"0.52986276",
"0.5296976",
"0.5272015",
"0.5269272",
"0.5257539... | 0.5619942 | 0 |
Return a dictionary with memory information. | def get_mem_info():
MemInfoEntry = namedtuple('MemInfoEntry', ['value', 'unit'])
mem_info = {}
with open('/proc/meminfo') as file:
for line in file:
key, value, *unit = line.strip().split()
mem_info[key.rstrip(':')] = MemInfoEntry(value, unit)
return mem_info | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MemoryInfo(cls):\n\t\tres = {}\n\t\tfor line in cat(\"/proc/meminfo\").split(\"\\n\")[:-1]:\n\t\t\tline = RE_SPACES.sub(\" \", line).strip().split(\" \")\n\t\t\tname, value = line[:2]\n\t\t\tres[name.replace(\"(\", \"_\").replace(\")\", \"_\").replace(\":\", \"\")] = int(value)\n\t\treturn res",
"def get_mem... | [
"0.83256704",
"0.8320725",
"0.8266024",
"0.8175442",
"0.8164575",
"0.800875",
"0.79796195",
"0.7837153",
"0.778341",
"0.77577746",
"0.7723628",
"0.76374567",
"0.7615092",
"0.75794065",
"0.75041574",
"0.7460927",
"0.7370262",
"0.7370262",
"0.7370262",
"0.7370262",
"0.7370262",... | 0.79375446 | 7 |
Return the free space in Gigabits. | def get_free_gb():
mem_info = get_mem_info()
free_gb = float(mem_info['MemAvailable'].value) / 10**6
return free_gb | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cgts_vg_free_space():\n\n try:\n # Determine space in cgts-vg in GiB\n vg_free_str = subprocess.check_output( # pylint: disable=not-callable\n ['vgdisplay', '-C', '--noheadings', '--nosuffix',\n '-o', 'vg_free', '--units', 'g', 'cgts-vg'],\n close_fds=Tru... | [
"0.7192137",
"0.6909616",
"0.690619",
"0.68786997",
"0.6813705",
"0.67277247",
"0.66669893",
"0.6577275",
"0.6504887",
"0.65012854",
"0.64604944",
"0.6451814",
"0.6396979",
"0.63525146",
"0.63032967",
"0.6267119",
"0.6259522",
"0.62487036",
"0.6246622",
"0.62347066",
"0.62068... | 0.75012624 | 0 |
True if it can't run, else otherwise. Condition is Gb of RAM memory available. | def ram_condition(min_gb=3):
return get_free_gb() < min_gb | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_if_sufficient_memory():\n percent_memory = psutil.virtual_memory().percent\n if percent_memory > 75:\n raise ValueError('Please use a device with more CPU ram or a smaller dataset')",
"def memory_check(self) -> bool:\n available_bytes = psutil.virtual_memory().available\... | [
"0.7269116",
"0.68143415",
"0.66817755",
"0.64842796",
"0.6442835",
"0.6359018",
"0.6243431",
"0.6243431",
"0.62134373",
"0.61970484",
"0.58983666",
"0.58968914",
"0.5888447",
"0.5873215",
"0.58724576",
"0.57852805",
"0.5777731",
"0.57357985",
"0.57344395",
"0.5731109",
"0.56... | 0.6852558 | 1 |
True if it can't run, else otherwise. Condition is a proportion of RAM memory available. | def ram_prop_condition(prop=0.25):
mem_info = get_mem_info()
total_mem = float(mem_info['MemTotal'].value) / 10**6
min_gb = prop * total_mem
return ram_condition(min_gb=min_gb) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_if_sufficient_memory():\n percent_memory = psutil.virtual_memory().percent\n if percent_memory > 75:\n raise ValueError('Please use a device with more CPU ram or a smaller dataset')",
"def memory_check(self) -> bool:\n available_bytes = psutil.virtual_memory().available\... | [
"0.7295557",
"0.6686275",
"0.6624224",
"0.63968927",
"0.62839794",
"0.623324",
"0.6183667",
"0.61706424",
"0.6126043",
"0.6126043",
"0.5933436",
"0.5923849",
"0.5857149",
"0.58338654",
"0.58319116",
"0.5819135",
"0.5796401",
"0.5792657",
"0.5691452",
"0.5668905",
"0.5658324",... | 0.60934323 | 10 |
Transform a MP3 song into WAV format, and then into Fourier series. | def time_to_frequency(song,
temp_folder,
output_folder,
rate_limit=6000.0,
overwrite=True,
plot=True,
image_folder=None,
step=5.0):
# Name of files
song_name = os.path.splitext(song)[0]
json_name = os.path.join(output_folder, song_name + '.json')
wav_file = os.path.join(temp_folder, song_name + '.wav')
if not os.path.isfile(json_name) or overwrite is True:
# Fourier transformation
try:
if ram_prop_condition(prop=0.1):
logger.error('Song %s is waiting until more memory is available', song_name)
while ram_prop_condition(prop=0.2):
pass # It consumes cpu, but we assure it doesn't go to sleep indefinitely
frequencies, fourier_series = wav_to_fourier(wav_file=wav_file,
rate_limit=rate_limit,
step=step)
# Save as JSON
json_to_save = {song: {str(x): y for x, y in
zip(frequencies, fourier_series)}}
with open(json_name, 'w') as output:
json.dump(json_to_save, output)
# Plotting
if plot is True:
fourier_plot(freq=frequencies,
features=fourier_series,
folder=image_folder,
filename=song_name)
logger.debug('%s transformed', song_name)
except MemoryError:
logger.error('MemoryError: %s couldn\'t be Fourier transformed', song_name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_wav_to_mp3(self):\n for each_file, artist in self.past_songs_db_data:\n self.convert_wav_to_mp3(each_file)",
"def mp3_to_wav(show_progress=True):\n\n # Define a devnull var to supress subprocess output\n devnull = open(os.devnull, 'w')\n\n # Get a list of the filepath for each ... | [
"0.6867949",
"0.6767562",
"0.6552796",
"0.64654547",
"0.62336755",
"0.6104877",
"0.6079277",
"0.6008433",
"0.59922224",
"0.5926576",
"0.589333",
"0.58891535",
"0.58476907",
"0.5833807",
"0.5785292",
"0.56830513",
"0.5678468",
"0.5659172",
"0.56562704",
"0.5653985",
"0.5649063... | 0.5470141 | 29 |
Transform a directory full of MP3 files into WAV files, and then into Fourier series, working with directories. | def transform_folder(source_folder,
output_folder,
temp_folder,
rate_limit=6000.0,
overwrite=True,
plot=False,
image_folder=None,
multiprocess=False,
encoder='mpg123',
step=5.0):
merged_file = os.path.join(output_folder, 'merged_file.json')
os.makedirs(temp_folder, exist_ok=True)
os.makedirs(output_folder, exist_ok=True)
if os.path.isfile(merged_file):
os.remove(merged_file)
if plot:
os.makedirs(image_folder, exist_ok=True)
# Check if mp3 is already transformed into wav. Right
# now, foucluster doesn't have a direct read from mp3
logger.info('Checking if songs are in WAV format...')
if source_folder != temp_folder:
[check_wav(song=song,
source_folder=source_folder,
temp_folder=temp_folder,
encoder=encoder)
for song in os.listdir(source_folder)]
if multiprocess is True:
logger.debug('Fourier is applied in multiprocess')
songs = [(song, temp_folder, output_folder, rate_limit,
overwrite, plot, image_folder, step)
for song in os.listdir(source_folder)]
# with mp.Pool(processes=max(int(mp.cpu_count() / 2.0), 1)) as p:
with mp.Pool(processes=mp.cpu_count(), maxtasksperchild=1) as p:
p.starmap(time_to_frequency, songs)
else:
logger.debug('Fourier is applied in single core')
[time_to_frequency(song=song,
temp_folder=temp_folder,
output_folder=output_folder,
rate_limit=rate_limit,
overwrite=overwrite,
plot=plot,
image_folder=image_folder,
step=step)
for song in os.listdir(source_folder)]
# read_files = glob.glob(os.path.join(output_folder, '*.json'))
# with open(merged_file, 'w') as outfile:
# file_contents = [open(f).read() for f in read_files]
# outfile.write('[{}]'.format(','.join(file_contents))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_wav_to_mp3(self):\n for each_file, artist in self.past_songs_db_data:\n self.convert_wav_to_mp3(each_file)",
"def mp3_to_wav(show_progress=True):\n\n # Define a devnull var to supress subprocess output\n devnull = open(os.devnull, 'w')\n\n # Get a list of the filepath for each ... | [
"0.7115496",
"0.6985259",
"0.67233366",
"0.6686839",
"0.65235364",
"0.64989144",
"0.63002807",
"0.6277914",
"0.6166281",
"0.61311907",
"0.61195964",
"0.606834",
"0.6029333",
"0.60196835",
"0.6009603",
"0.5915913",
"0.5896318",
"0.5880936",
"0.58191925",
"0.5811102",
"0.581042... | 0.6515147 | 5 |
Initialize the SingleImage object | def __init__(self, camera):
self.__camera = camera
self.__innerOrientationParameters = None
self.__isSolved = False
self.__exteriorOrientationParameters = np.array([0, 0, 0, 0, 0, 0], 'f')
self.__rotationMatrix = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, image):\n self.image = image",
"def __init__(self, img):\n self.img = img",
"def initImages(self):\n pass",
"def initImages(self):\n pass",
"def initImages(self):\n pass",
"def __init__(self, image: np.ndarray) -> None:\n self.image = image",
... | [
"0.7476075",
"0.72321916",
"0.70613927",
"0.70613927",
"0.70613927",
"0.70282173",
"0.7005531",
"0.7002043",
"0.7002043",
"0.7002043",
"0.7002043",
"0.7002043",
"0.6960504",
"0.69188726",
"0.6878795",
"0.67705446",
"0.6648267",
"0.6634296",
"0.6630021",
"0.6602309",
"0.654855... | 0.0 | -1 |
The camera that took the image | def camera(self):
return self.__camera | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def camera(self):\n return self._camera",
"def camera(self):\n return self._camera",
"def query_camera(self):\n ok, orig_pic = self.vs.read() # Read video stream\n if ok: # If no errors\n orig_pic = imutils.rotate(orig_pic, angle=self.camera_rot)\n curr_pic =... | [
"0.8029401",
"0.8029401",
"0.7391439",
"0.7336508",
"0.7180209",
"0.711195",
"0.711195",
"0.71046424",
"0.70813036",
"0.70528156",
"0.69937193",
"0.69860065",
"0.69809467",
"0.68731916",
"0.6841381",
"0.6825675",
"0.68190277",
"0.680215",
"0.6788457",
"0.6687622",
"0.66858554... | 0.81577206 | 0 |
r""" Property for the exterior orientation parameters | def exteriorOrientationParameters(self):
return self.__exteriorOrientationParameters | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def orient(self):\n return self.__ph.get('orient', PH_ORIENT_HORZ)",
"def get_orientation(self):\r\n return self.__orientation",
"def Orientation(self, *args):\n return _Adaptor3d.Adaptor3d_TopolTool_Orientation(self, *args)",
"def orientation(self):\n return self._orientation",
... | [
"0.61678284",
"0.61665916",
"0.61640745",
"0.60078",
"0.60078",
"0.5891339",
"0.5885623",
"0.58542037",
"0.5838997",
"0.5836636",
"0.5822891",
"0.58147955",
"0.5795377",
"0.57695895",
"0.57024115",
"0.56947505",
"0.56763643",
"0.5612986",
"0.5593346",
"0.5587369",
"0.5578711"... | 0.80023855 | 0 |
The rotation matrix of the image Relates to the exterior orientation | def rotationMatrix(self):
R = Compute3DRotationMatrix(self.exteriorOrientationParameters[3], self.exteriorOrientationParameters[4],
self.exteriorOrientationParameters[5])
return R | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_rotation_angle(self, image):\n \n # TODO: Make real functionality\n return 0",
"def rotation_matrix(self):\n return self.affine_matrix[0:3][:, 0:3]",
"def rotation(self):\n\t\treturn self.piv.a.rotate.v",
"def matrix(self):\n return self._rotation",
"def rotation(... | [
"0.7759922",
"0.77279866",
"0.7530842",
"0.7502491",
"0.7206852",
"0.71904266",
"0.7162689",
"0.71563435",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7005358",
"0.6981667",
... | 0.77768993 | 0 |
The rotation matrix of the image Relates to the exterior orientation | def rotationMatrix_RzRyRz(self):
R = Compute3DRotationMatrix_RzRyRz(self.exteriorOrientationParameters[3], self.exteriorOrientationParameters[4],
self.exteriorOrientationParameters[5])
return R | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rotationMatrix(self):\n\n R = Compute3DRotationMatrix(self.exteriorOrientationParameters[3], self.exteriorOrientationParameters[4],\n self.exteriorOrientationParameters[5])\n\n return R",
"def get_rotation_angle(self, image):\n \n # TODO: Make re... | [
"0.77768993",
"0.7759922",
"0.77279866",
"0.7530842",
"0.7502491",
"0.7206852",
"0.71904266",
"0.7162689",
"0.71563435",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7058655",
"0.7005358",... | 0.6058148 | 93 |
True if the exterior orientation is solved | def isSolved(self):
return self.__isSolved | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_versor(self) -> bool:\n return np.isclose(np.linalg.norm(self.A), 1.0)",
"def is_hom_alt(self) -> bool:\n return self.is_hom() and (self.allele1 > 0 or self.allele2 > 0)",
"def solved(self):\n return all(cell == 1 for row in self.faces for cell in row) or all(cell == 0 for row in se... | [
"0.645655",
"0.63614464",
"0.62675583",
"0.62624866",
"0.62122506",
"0.6185279",
"0.6101881",
"0.60985523",
"0.605189",
"0.6042637",
"0.6027129",
"0.6021935",
"0.6013572",
"0.6010895",
"0.59998566",
"0.5995052",
"0.5970132",
"0.5969842",
"0.5943013",
"0.59369075",
"0.59358853... | 0.0 | -1 |
r""" Compute inner orientation parameters | def ComputeInnerOrientation(self, imagePoints):
# implementing observation vectors
imagePoints = imagePoints.reshape(np.size(imagePoints), 1)
fMarks = self.camera.fiducialMarks.reshape(np.size(self.camera.fiducialMarks), 1)
n = int(len(imagePoints)) # number of observations
u = 6 # 6 orientation parameters
A = np.zeros((n, u)) # A matrix (n,u)
j = 0
for i in range(len(imagePoints)):
if i % 2 == 0:
A[i, 0] = 1;
A[i, 1] = 0;
A[i, 2] = fMarks[j];
A[i, 3] = fMarks[j + 1];
A[i, 4] = 0
A[i, 5] = 0
else:
A[i, 0] = 0;
A[i, 1] = 1;
A[i, 2] = 0;
A[i, 3] = 0;
A[i, 4] = fMarks[j];
A[i, 5] = fMarks[j + 1]
j += 2
X = np.dot(la.inv(np.dot(np.transpose(A), A)), np.dot(np.transpose(A), imagePoints))
v = np.dot(A, X) - imagePoints
adjustment_results = {"params": X, "residuals": v, "N": np.dot(np.transpose(A), A)}
self.__innerOrientationParameters = X # updating the inner orientation params
return adjustment_results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ComputeInverseInnerOrientation(self):\n a0 = self.innerOrientationParameters[0]\n b0 = self.innerOrientationParameters[1]\n a1 = self.innerOrientationParameters[2]\n a2 = self.innerOrientationParameters[3]\n b1 = self.innerOrientationParameters[4]\n b2 = self.innerOrie... | [
"0.687762",
"0.6436624",
"0.58278096",
"0.578275",
"0.57705504",
"0.5755263",
"0.5649262",
"0.5623161",
"0.5620293",
"0.5616361",
"0.55939484",
"0.55838054",
"0.5497484",
"0.54887134",
"0.54881567",
"0.54828835",
"0.54536176",
"0.5438182",
"0.5438182",
"0.54221433",
"0.541117... | 0.7024464 | 0 |
Computes the geometric inner orientation parameters | def ComputeGeometricParameters(self):
# extracting inner orientation params
a0 = self.innerOrientationParameters[0]
b0 = self.innerOrientationParameters[1]
a1 = self.innerOrientationParameters[2]
a2 = self.innerOrientationParameters[3]
b1 = self.innerOrientationParameters[4]
b2 = self.innerOrientationParameters[5]
# computing algebric params
tx = a0;
ty = b0
theta = np.arctan(b1 / b2)
gamma = np.arctan((a1 * np.sin(theta) + a2 * np.cos(theta)) / (b1 * np.sin(theta) + b2 * np.cos(theta)))
sx = a1 * np.cos(theta) - a2 * np.sin(theta)
sy = (a1 * np.sin(theta) + a2 * np.cos(theta)) / np.sin(gamma)
return {"translationX": tx, "translationY": ty, "rotationAngle": np.rad2deg(theta), "scaleFactorX": sx,
"scaleFactorY": sy, "shearAngle": np.rad2deg(gamma)} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def magnitude_orientation(gx, gy):\n \n magnitude = np.sqrt(gx**2 + gy**2)\n orientation = (np.arctan2(gy, gx) * 180 / np.pi) % 180\n \n return magnitude, orientation",
"def ComputeInverseInnerOrientation(self):\n a0 = self.innerOrientationParameters[0]\n b0 = self.... | [
"0.6358747",
"0.6289955",
"0.626587",
"0.6029137",
"0.5908361",
"0.5868645",
"0.5784191",
"0.57483953",
"0.5706465",
"0.5689375",
"0.5624956",
"0.5610132",
"0.5609869",
"0.560806",
"0.5597778",
"0.5587196",
"0.5573857",
"0.5553297",
"0.55513024",
"0.55361223",
"0.5525677",
... | 0.740137 | 0 |
Computes the parameters of the inverse inner orientation transformation | def ComputeInverseInnerOrientation(self):
a0 = self.innerOrientationParameters[0]
b0 = self.innerOrientationParameters[1]
a1 = self.innerOrientationParameters[2]
a2 = self.innerOrientationParameters[3]
b1 = self.innerOrientationParameters[4]
b2 = self.innerOrientationParameters[5]
mat = np.array([[a1[0], a2[0]], [b1[0], b2[0]]])
mat = la.inv(mat)
return np.array([a0[0], b0[0], mat[0, 0], mat[0, 1], mat[1, 0], mat[1, 1]]).T | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inverse(self):\n def inv(v):\n v[0], v[1] = v[1] , v[0]\n for v in [self.point1 , self.pointN , self.unitv, self.normalv]:\n inv(v)\n\n self.points = numpy.roll(self.points,1,axis=1)\n self.a, self.b = self.b, self.a\n self.angle = numpy.arccos( self.uni... | [
"0.63808596",
"0.6343662",
"0.63060564",
"0.6252362",
"0.61781716",
"0.61693305",
"0.61612785",
"0.61262125",
"0.61208826",
"0.6098615",
"0.609339",
"0.60388464",
"0.59626293",
"0.59568155",
"0.5946826",
"0.5945765",
"0.59148675",
"0.5901364",
"0.5894338",
"0.5879606",
"0.586... | 0.7558201 | 0 |
Transforms camera points to image points | def CameraToImage(self, cameraPoints):
# setting up the required matrices
a0 = self.innerOrientationParameters[0]
b0 = self.innerOrientationParameters[1]
a1 = self.innerOrientationParameters[2]
a2 = self.innerOrientationParameters[3]
b1 = self.innerOrientationParameters[4]
b2 = self.innerOrientationParameters[5]
if np.isscalar(a0):
R = np.array([[a1, a2], [b1, b2]])
T = np.array([[a0], [b0]])
else:
R = np.array([[a1[0], a2[0]], [b1[0], b2[0]]])
T = np.array([[a0[0]], [b0[0]]])
cameraPoints = cameraPoints.T
# computing the transformation to the image system
return (T + np.dot(R, cameraPoints)).T | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def imageFromCamera(self, points, hide_backpoints=True):\n points = np.array(points)\n # set small z distances to 0\n points[np.abs(points[..., 2]) < 1e-10] = 0\n # transform the points\n with np.errstate(divide='ignore', invalid='ignore'):\n transformed_points = np.ar... | [
"0.75200397",
"0.7221418",
"0.72199947",
"0.71426326",
"0.71409965",
"0.7138931",
"0.7127518",
"0.7100937",
"0.70733917",
"0.6988374",
"0.69729286",
"0.69044685",
"0.6830623",
"0.6829222",
"0.6822007",
"0.6778279",
"0.67171186",
"0.6710748",
"0.66177326",
"0.661222",
"0.65576... | 0.73480624 | 1 |
Transforms image points to ideal camera points | def ImageToCamera(self, imagePoints):
inverse_pars = self.ComputeInverseInnerOrientation()
imagePoints = imagePoints.T
if imagePoints.size == 2:
imagePoints = np.reshape(np.array(imagePoints), (np.size(imagePoints), 1))
T = np.array([[inverse_pars[0]], [inverse_pars[1]]])
R = np.array([[inverse_pars[2], inverse_pars[3]], [inverse_pars[4], inverse_pars[5]]])
return (np.dot(R, imagePoints - T)).T | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def camera_transform(image):\n img = np.zeros((image.shape[0], image.shape[1], 3))\n for y in range(image.shape[0]):\n for x in range(image.shape[1]):\n img[y][x] = (x - 320) / 575.5 * image[y, x], (240 - y) / 575.5 * image[y, x], image[\n y, x]\n return img",
"def image... | [
"0.74925107",
"0.72041154",
"0.7066651",
"0.7043059",
"0.7004196",
"0.69641924",
"0.69523805",
"0.6926867",
"0.6857847",
"0.6825331",
"0.67971975",
"0.6750294",
"0.6734582",
"0.663383",
"0.65459144",
"0.65373534",
"0.65190524",
"0.65055305",
"0.6471489",
"0.6462659",
"0.64615... | 0.70939386 | 2 |
Compute exterior orientation parameters. This function can be used in conjecture with ``self.__ComputeDesignMatrix(groundPoints)`` and ``self__ComputeObservationVector(imagePoints)`` | def ComputeExteriorOrientation(self, imagePoints, groundPoints, epsilon):
# cameraPoints = self.ImageToCamera(imagePoints)
cameraPoints = imagePoints
self.__ComputeApproximateVals(cameraPoints, groundPoints)
l0 = self.__ComputeObservationVector(groundPoints.T)
l0 = np.reshape(l0, (-1, 1))
l = cameraPoints.reshape(np.size(cameraPoints), 1) - l0
A = self.__ComputeDesignMatrix(groundPoints.T)
N = np.dot(A.T, A)
u = np.dot(A.T, l)
deltaX = np.dot(la.inv(N), u)
# update orientation pars
self.__exteriorOrientationParameters = np.add(self.__exteriorOrientationParameters, np.reshape(deltaX, 6))
while la.norm(deltaX) > epsilon:
l0 = self.__ComputeObservationVector(groundPoints.T)
l0 = np.reshape(l0, (-1, 1))
l = cameraPoints.reshape(np.size(cameraPoints), 1) - l0
A = self.__ComputeDesignMatrix(groundPoints.T)
N = np.dot(A.T, A)
u = np.dot(A.T, l)
deltaX = np.dot(la.inv(N), u)
# update orientation pars
self.__exteriorOrientationParameters = np.add(self.__exteriorOrientationParameters, np.reshape(deltaX, 6))
# compute residuals
l_a = np.reshape(self.__ComputeObservationVector(groundPoints.T), (-1, 1))
v = l_a - cameraPoints.reshape(np.size(cameraPoints), 1)
if (np.size(A, 0) - np.size(deltaX)) != 0:
sig = np.dot(v.T, v) / (np.size(A, 0) - np.size(deltaX))
sigmaX = sig[0] * la.inv(N)
else:
sigmaX = None
return [self.exteriorOrientationParameters, sigmaX, v] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exteriorOrientationParameters(self):\n return self.__exteriorOrientationParameters",
"def ComputeInnerOrientation(self, imagePoints):\n # implementing observation vectors\n imagePoints = imagePoints.reshape(np.size(imagePoints), 1)\n\n fMarks = self.camera.fiducialMarks.reshape(n... | [
"0.71254003",
"0.68282026",
"0.6420376",
"0.61255026",
"0.61024475",
"0.5787343",
"0.57387304",
"0.5717728",
"0.5698031",
"0.567763",
"0.5626359",
"0.55450577",
"0.5525408",
"0.5507461",
"0.54807997",
"0.54278624",
"0.5404268",
"0.53900427",
"0.5351375",
"0.5299402",
"0.52918... | 0.69500554 | 1 |
Compute exterior orientation parameters. This function can be used in conjecture with ``self.__ComputeDesignMatrix(groundPoints)`` and ``self__ComputeObservationVector(imagePoints)`` | def ComputeExteriorOrientation_RzRyRz(self, imagePoints, groundPoints, epsilon):
# cameraPoints = self.ImageToCamera(imagePoints)
cameraPoints = imagePoints
self.exteriorOrientationParameters[0:3] = np.dot(self.rotationMatrix_RzRyRz, self.exteriorOrientationParameters[0:3])
self.exteriorOrientationParameters = np.add(self.exteriorOrientationParameters, np.random.normal(0, 0.01, self.exteriorOrientationParameters.shape))
l0 = self.__ComputeObservationVector_RzRyRz(groundPoints.T)
l0 = np.reshape(l0, (-1, 1))
l = cameraPoints.reshape(np.size(cameraPoints), 1) - l0
A = self.__ComputeDesignMatrix_RzRyRz(groundPoints.T)
N = np.dot(A.T, A)
u = np.dot(A.T, l)
deltaX = np.dot(la.inv(N), u)
# update orientation pars
self.__exteriorOrientationParameters = np.add(self.__exteriorOrientationParameters, np.reshape(deltaX, 6))
while la.norm(deltaX) > epsilon:
l0 = self.__ComputeObservationVector_RzRyRz(groundPoints.T)
l0 = np.reshape(l0, (-1, 1))
l = cameraPoints.reshape(np.size(cameraPoints), 1) - l0
A = self.__ComputeDesignMatrix_RzRyRz(groundPoints.T)
N = np.dot(A.T, A)
u = np.dot(A.T, l)
deltaX = np.dot(la.inv(N), u)
# update orientation pars
self.__exteriorOrientationParameters = np.add(self.__exteriorOrientationParameters, np.reshape(deltaX, 6))
# compute residuals
l_a = np.reshape(self.__ComputeObservationVector_RzRyRz(groundPoints.T), (-1, 1))
v = l_a - cameraPoints.reshape(np.size(cameraPoints), 1)
if (np.size(A, 0) - np.size(deltaX)) != 0:
sig = np.dot(v.T, v) / (np.size(A, 0) - np.size(deltaX))
sigmaX = sig[0] * la.inv(N)
else:
sigmaX = None
return [self.exteriorOrientationParameters, sigmaX, v] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exteriorOrientationParameters(self):\n return self.__exteriorOrientationParameters",
"def ComputeExteriorOrientation(self, imagePoints, groundPoints, epsilon):\n # cameraPoints = self.ImageToCamera(imagePoints)\n cameraPoints = imagePoints\n self.__ComputeApproximateVals(cameraPoi... | [
"0.71254003",
"0.69500554",
"0.68282026",
"0.61255026",
"0.61024475",
"0.5787343",
"0.57387304",
"0.5717728",
"0.5698031",
"0.567763",
"0.5626359",
"0.55450577",
"0.5525408",
"0.5507461",
"0.54807997",
"0.54278624",
"0.5404268",
"0.53900427",
"0.5351375",
"0.5299402",
"0.5291... | 0.6420376 | 3 |
Transforming ground points to image points | def GroundToImage(self, groundPoints):
X0 = float(self.exteriorOrientationParameters[0])
Y0 = float(self.exteriorOrientationParameters[1])
Z0 = float(self.exteriorOrientationParameters[2])
xp = float(self.camera.principalPoint[0])
yp = float(self.camera.principalPoint[1])
R = self.rotationMatrix
r11 = float(R[0, 0])
r12 = float(R[0, 1])
r13 = float(R[0, 2])
r21 = float(R[1, 0])
r22 = float(R[1, 1])
r23 = float(R[1, 2])
r31 = float(R[2, 0])
r32 = float(R[2, 1])
r33 = float(R[2, 2])
f = self.camera.focalLength
camPoints = []
for i in range(groundPoints.shape[0]):
x = xp - (f) * (((r11 * (groundPoints[i, 0] - X0) + r21 * (groundPoints[i, 1] - Y0) + r31 * (
groundPoints[i, 2] - Z0)) / (r13 * (groundPoints[i, 0] - X0) + r23 * (
groundPoints[i, 1] - Y0) + r33 * (groundPoints[i, 2] - Z0))))
y = yp - (f) * (((r12 * (groundPoints[i, 0] - X0) + r22 * (groundPoints[i, 1] - Y0) + r32 * (
groundPoints[i, 2] - Z0)) / (r13 * (groundPoints[i, 0] - X0) + r23 * (
groundPoints[i, 1] - Y0) + r33 * (groundPoints[i, 2] - Z0))))
camPoints.append([x, y])
# return self.CameraToImage(np.array(camPoints))
return (np.array(camPoints)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GroundToImage_RzRyRz(self, groundPoints):\n X0 = float(self.exteriorOrientationParameters[0])\n Y0 = float(self.exteriorOrientationParameters[1])\n Z0 = float(self.exteriorOrientationParameters[2])\n\n xp = float(self.camera.principalPoint[0])\n yp = float(self.camera.princip... | [
"0.647679",
"0.6467655",
"0.6214912",
"0.61901563",
"0.61635965",
"0.60568637",
"0.6051804",
"0.6028781",
"0.60097945",
"0.5999861",
"0.5963049",
"0.59306324",
"0.5910674",
"0.5894894",
"0.5861491",
"0.5838941",
"0.58371437",
"0.5833094",
"0.58130443",
"0.58091205",
"0.580821... | 0.7286386 | 0 |
Transforming ground points to image points | def GroundToImage_RzRyRz(self, groundPoints):
X0 = float(self.exteriorOrientationParameters[0])
Y0 = float(self.exteriorOrientationParameters[1])
Z0 = float(self.exteriorOrientationParameters[2])
xp = float(self.camera.principalPoint[0])
yp = float(self.camera.principalPoint[1])
R = self.rotationMatrix_RzRyRz
r11 = float(R[0, 0])
r12 = float(R[0, 1])
r13 = float(R[0, 2])
r21 = float(R[1, 0])
r22 = float(R[1, 1])
r23 = float(R[1, 2])
r31 = float(R[2, 0])
r32 = float(R[2, 1])
r33 = float(R[2, 2])
f = self.camera.focalLength
camPoints = []
for i in range(groundPoints.shape[0]):
x = xp - (f) * (((r11 * (groundPoints[i, 0] - X0) + r21 * (groundPoints[i, 1] - Y0) + r31 * (
groundPoints[i, 2] - Z0)) / (r13 * (groundPoints[i, 0] - X0) + r23 * (
groundPoints[i, 1] - Y0) + r33 * (groundPoints[i, 2] - Z0))))
y = yp - (f) * (((r12 * (groundPoints[i, 0] - X0) + r22 * (groundPoints[i, 1] - Y0) + r32 * (
groundPoints[i, 2] - Z0)) / (r13 * (groundPoints[i, 0] - X0) + r23 * (
groundPoints[i, 1] - Y0) + r33 * (groundPoints[i, 2] - Z0))))
camPoints.append([x, y])
# return self.CameraToImage(np.array(camPoints))
return (np.array(camPoints)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GroundToImage(self, groundPoints):\n X0 = float(self.exteriorOrientationParameters[0])\n Y0 = float(self.exteriorOrientationParameters[1])\n Z0 = float(self.exteriorOrientationParameters[2])\n\n xp = float(self.camera.principalPoint[0])\n yp = float(self.camera.principalPoint... | [
"0.7286386",
"0.6467655",
"0.6214912",
"0.61901563",
"0.61635965",
"0.60568637",
"0.6051804",
"0.6028781",
"0.60097945",
"0.5999861",
"0.5963049",
"0.59306324",
"0.5910674",
"0.5894894",
"0.5861491",
"0.5838941",
"0.58371437",
"0.5833094",
"0.58130443",
"0.58091205",
"0.58082... | 0.647679 | 1 |
Transforms Image point to a Ray in world system | def ImageToRay(self, imagePoints):
pass # delete after implementations | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pointToWorld( nImageX, nImageY, rDepth, rMaxX = 320, rMaxY = 240, rFieldOfViewX = 60, rFieldOfViewY = 40 ):\n # convert to [-0.5,0.5]\n rCenteredX = ( nImageX / rMaxX ) - 0.5;\n rCenteredY = ( nImageY / rMaxY ) - 0.5;",
"def project_to_image_plane(self, point_in_world, timestamp):\n\n camera_... | [
"0.69458926",
"0.6836335",
"0.633762",
"0.62048507",
"0.6087586",
"0.6003151",
"0.5976462",
"0.5972177",
"0.5914467",
"0.58434325",
"0.58393484",
"0.58110195",
"0.57184476",
"0.5707809",
"0.570757",
"0.5687363",
"0.5659299",
"0.56507516",
"0.5646074",
"0.5632133",
"0.5627521"... | 0.7174655 | 0 |
Compute corresponding ground point given the height in world system | def ImageToGround_GivenZ(self, imagePoints, Z_values):
cameraPoints = self.ImageToCamera(imagePoints)
cameraPoints = cameraPoints.T
pars = self.exteriorOrientationParameters
X0 = pars[0]
Y0 = pars[1]
Z0 = pars[2]
T = np.array([[X0], [Y0], [Z0]])
omega = pars[3]
phi = pars[4]
kappa = pars[5]
R = Compute3DRotationMatrix(omega, phi, kappa)
f = self.camera.focalLength
# allocating memory for return array
groundPoints = []
for i in range(len(cameraPoints[1])):
camVec = np.insert(cameraPoints[:, i], np.size(cameraPoints), -f)
lam = (Z_values - Z0) / (np.dot(R[2, :], camVec))
X = X0 + lam * np.dot(R[0, :], camVec)
Y = Y0 + lam * np.dot(R[1, :], camVec)
xy = [X, Y, Z_values]
groundPoints.append(xy)
groundPoints = np.array(groundPoints)
return groundPoints | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def template_height(self, x, y):\n\n tx = float(x) / self.world_size\n tx = tx * self.global_template.size\n\n ty = float(y) / self.world_size\n ty = ty * self.global_template.size\n\n tx1 = int(tx)\n dx = tx - tx1\n tx2 = tx1 + 1\n\n ty1 = int(ty)\n d... | [
"0.6243619",
"0.5950408",
"0.5930064",
"0.5907398",
"0.5722841",
"0.5635606",
"0.56119394",
"0.55470324",
"0.5499355",
"0.5497724",
"0.5488828",
"0.547526",
"0.5454269",
"0.5429254",
"0.5421403",
"0.5410944",
"0.5403357",
"0.53891635",
"0.5388756",
"0.5382602",
"0.5380469",
... | 0.0 | -1 |
calculates area of the footprint on the ground focalLength and sensorsize in mm | def castSize(self, scale):
return self.camera.sensorSize * scale | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def area(self):\n return (self.baselength1 + self.baselength2)*self.height/2",
"def surfaceArea(self):\n surfaceArea = self.sideLength**2 * 6\n return surfaceArea",
"def area(self):\n return self.length*self.length",
"def calculateDetectorArea(self):\n area = 0.0\n r = s... | [
"0.68501455",
"0.6728362",
"0.67006356",
"0.66854936",
"0.6640243",
"0.6634641",
"0.66335106",
"0.6622647",
"0.6602097",
"0.6584502",
"0.65486264",
"0.6531883",
"0.65018195",
"0.6479644",
"0.6479644",
"0.6473053",
"0.6473053",
"0.6473053",
"0.646595",
"0.646595",
"0.646595",
... | 0.0 | -1 |
Generating grid of points biased by ppa (principal point delta) | def GeneratePointsImg(self, n, ppa):
x = np.linspace(0,self.camera.sensorSize,n)+ppa[0]
y = np.linspace(0,self.camera.sensorSize,n)+ppa[1]
return np.meshgrid(x, y) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def modify_pt(pt=None,):\n global dim\n mod_rand_pt = []\n\n for i_ in range(dim):\n for j_ in range(i_, dim):\n mod_rand_pt.append(pt[i_] * pt[j_])\n\n mod_rand_pt.append(1.)\n return mod_rand_pt",
"def projection_P(P_prime):\n sorted_prime = -np.sort(-P_prime, axis=1) # Des... | [
"0.60559386",
"0.59712946",
"0.59704006",
"0.595379",
"0.5917291",
"0.58962584",
"0.58279955",
"0.582432",
"0.5792295",
"0.57677454",
"0.5709391",
"0.5696328",
"0.56858194",
"0.56748235",
"0.5633881",
"0.5615407",
"0.56149656",
"0.560475",
"0.560267",
"0.5601162",
"0.5589663"... | 0.6255561 | 0 |
Calculates ray intersection point with plane | def LinePlaneCollision(planeNormal, planePoint, rayDirection, rayPoint, epsilon=1e-12):
ndotu = planeNormal.dot(rayDirection)
if abs(ndotu) < epsilon:
raise RuntimeError("no intersection or line is within plane")
w = rayPoint - planePoint
si = -planeNormal.dot(w) / ndotu
Psi = w + si * rayDirection + planePoint
return Psi | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersects(self, ray):\n theta = 45\n H = 512\n W = 512\n A = self.origin\n B = Point(W, A.y, A.z)\n C = Point(B.x, (int)(H * math.sin(theta * math.pi / 180)), (int)(H * math.cos(math.pi * theta / 180)))\n D = Point(A.x, (int)(H * math.sin(theta * math.pi / 180)... | [
"0.75932515",
"0.7466053",
"0.7187562",
"0.7109652",
"0.71037644",
"0.70618355",
"0.7053688",
"0.70142746",
"0.6986311",
"0.6911706",
"0.691073",
"0.68320477",
"0.6821069",
"0.6723013",
"0.6722326",
"0.6714333",
"0.66570723",
"0.6611767",
"0.6607392",
"0.6602498",
"0.6568937"... | 0.69176984 | 9 |
Compute exterior orientation approximate values via 2D conform transformation | def __ComputeApproximateVals(self, cameraPoints, groundPoints):
# Find approximate values
cameraPoints = cameraPoints.reshape(np.size(cameraPoints), 1)
groundPointsXY = groundPoints[0:2, :].T
groundPointsXY = groundPointsXY.reshape(np.size(groundPointsXY), 1)
groundPointsZ = groundPoints[2, :].T
n = int(len(cameraPoints)) # number of observations
u = 4 # 4 conform parameters
A = np.zeros((n, u)) # A matrix (n,u)
j = 0
for i in range(len(cameraPoints)):
if i % 2 == 0:
A[i, 0] = 1
A[i, 1] = 0
A[i, 2] = cameraPoints[j]
A[i, 3] = cameraPoints[j + 1]
else:
A[i, 0] = 0
A[i, 1] = 1
A[i, 2] = cameraPoints[j + 1]
A[i, 3] = -cameraPoints[j]
j += 2
X = np.dot(la.inv(np.dot(np.transpose(A), A)), np.dot(np.transpose(A), groundPointsXY))
# now we can compute the rest of the params
X0 = X[0]
Y0 = X[1]
kappa = np.arctan2(-X[3], X[2])
lam = np.sqrt(X[2] ** 2 + X[3] ** 2)
Z0 = np.average(groundPointsZ) + (lam) * self.camera.focalLength
adjustment_results = {"X0": X0[0], "Y0": Y0[0], "Z0": Z0[0], "omega": 0, "phi": 0,
"kappa": np.rad2deg(kappa[0])}
self.__exteriorOrientationParameters = np.array(
[X0[0], Y0[0], Z0[0], 0, 0, kappa[0]]).T # updating the exterior orientation params
# self.__exteriorOrientationParameters = np.array([202225, 742447, 657.81, 0, 0, kappa[0]]).T
#return adjustment_results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ComputeInnerOrientation(self, imagePoints):\n # implementing observation vectors\n imagePoints = imagePoints.reshape(np.size(imagePoints), 1)\n\n fMarks = self.camera.fiducialMarks.reshape(np.size(self.camera.fiducialMarks), 1)\n\n n = int(len(imagePoints)) # number of observation... | [
"0.6454401",
"0.63721627",
"0.63071674",
"0.6261199",
"0.6196916",
"0.6190799",
"0.61566526",
"0.60925615",
"0.60682034",
"0.6002589",
"0.59904027",
"0.5930793",
"0.5907026",
"0.5904838",
"0.5902323",
"0.58778685",
"0.58416617",
"0.58258176",
"0.58110034",
"0.5757958",
"0.574... | 0.0 | -1 |
Compute exterior orientation approximate values via 2D conform transformation | def __ComputeApproximateVals_RzRyRz(self, cameraPoints, groundPoints):
# Find approximate values
cameraPoints = cameraPoints.reshape(np.size(cameraPoints), 1)
groundPointsXY = groundPoints[0:2, :].T
groundPointsXY = groundPointsXY.reshape(np.size(groundPointsXY), 1)
groundPointsZ = groundPoints[2, :].T
n = int(len(cameraPoints)) # number of observations
u = 4 # 4 conform parameters
A = np.zeros((n, u)) # A matrix (n,u)
j = 0
for i in range(len(cameraPoints)):
if i % 2 == 0:
A[i, 0] = 1
A[i, 1] = 0
A[i, 2] = cameraPoints[j]
A[i, 3] = cameraPoints[j + 1]
else:
A[i, 0] = 0
A[i, 1] = 1
A[i, 2] = cameraPoints[j + 1]
A[i, 3] = -cameraPoints[j]
j += 2
X = np.dot(la.inv(np.dot(np.transpose(A), A)), np.dot(np.transpose(A), groundPointsXY))
# now we can compute the rest of the params
X0 = X[0]
Y0 = X[1]
kappa = np.arctan2(-X[3], X[2])
lam = np.sqrt(X[2] ** 2 + X[3] ** 2)
Z0 = np.average(groundPointsZ) + (lam) * self.camera.focalLength
adjustment_results = {"X0": X0[0], "Y0": Y0[0], "Z0": Z0[0], "omega": 0, "phi": 0,
"kappa": np.rad2deg(kappa[0])}
self.__exteriorOrientationParameters = np.array(
[X0[0], Y0[0], Z0[0], 0.2, 0.2, kappa[0]]).T # updating the exterior orientation params
# self.__exteriorOrientationParameters = np.array([202225, 742447, 657.81, 0, 0, kappa[0]]).T
#return adjustment_results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ComputeInnerOrientation(self, imagePoints):\n # implementing observation vectors\n imagePoints = imagePoints.reshape(np.size(imagePoints), 1)\n\n fMarks = self.camera.fiducialMarks.reshape(np.size(self.camera.fiducialMarks), 1)\n\n n = int(len(imagePoints)) # number of observation... | [
"0.6454401",
"0.63721627",
"0.63071674",
"0.6261199",
"0.6196916",
"0.6190799",
"0.61566526",
"0.60925615",
"0.60682034",
"0.6002589",
"0.59904027",
"0.5930793",
"0.5907026",
"0.5904838",
"0.5902323",
"0.58778685",
"0.58416617",
"0.58258176",
"0.58110034",
"0.5757958",
"0.574... | 0.0 | -1 |
Compute observation vector for solving the exterior orientation parameters of a single image based on their approximate values | def __ComputeObservationVector(self, groundPoints):
n = groundPoints.shape[0] # number of points
# Coordinates subtraction
dX = groundPoints[:, 0] - self.exteriorOrientationParameters[0]
dY = groundPoints[:, 1] - self.exteriorOrientationParameters[1]
dZ = groundPoints[:, 2] - self.exteriorOrientationParameters[2]
dXYZ = np.vstack([dX, dY, dZ])
rotated_XYZ = np.dot(self.rotationMatrix.T, dXYZ).T
l0 = np.empty(n * 2)
# Computation of the observation vector based on approximate exterior orientation parameters:
l0[::2] = -self.camera.focalLength * rotated_XYZ[:, 0] / rotated_XYZ[:, 2]
l0[1::2] = -self.camera.focalLength * rotated_XYZ[:, 1] / rotated_XYZ[:, 2]
return l0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ev2vi(eV,mu): \n return cv*np.sqrt( eV*(eV+2.e0*mu*mpc2))/(eV+mu*mpc2)",
"def ComputeInnerOrientation(self, imagePoints):\n # implementing observation vectors\n imagePoints = imagePoints.reshape(np.size(imagePoints), 1)\n\n fMarks = self.camera.fiducialMarks.reshape(np.size(self.c... | [
"0.60023314",
"0.5932807",
"0.5920514",
"0.5843368",
"0.58112794",
"0.57958204",
"0.5776637",
"0.573947",
"0.5736349",
"0.5707544",
"0.5702388",
"0.5691359",
"0.5680941",
"0.5660144",
"0.5651713",
"0.5644874",
"0.56244063",
"0.55701184",
"0.55645734",
"0.5539961",
"0.5539685"... | 0.56527215 | 14 |
Compute observation vector for solving the exterior orientation parameters of a single image based on their approximate values | def __ComputeObservationVector_RzRyRz(self, groundPoints):
n = groundPoints.shape[0] # number of points
# Coordinates subtraction
dX = groundPoints[:, 0] - self.exteriorOrientationParameters[0]
dY = groundPoints[:, 1] - self.exteriorOrientationParameters[1]
dZ = groundPoints[:, 2] - self.exteriorOrientationParameters[2]
dXYZ = np.vstack([dX, dY, dZ])
rotated_XYZ = np.dot(self.rotationMatrix_RzRyRz.T, dXYZ).T
l0 = np.empty(n * 2)
# Computation of the observation vector based on approximate exterior orientation parameters:
l0[::2] = -self.camera.focalLength * rotated_XYZ[:, 0] / rotated_XYZ[:, 2]
l0[1::2] = -self.camera.focalLength * rotated_XYZ[:, 1] / rotated_XYZ[:, 2]
return l0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ev2vi(eV,mu): \n return cv*np.sqrt( eV*(eV+2.e0*mu*mpc2))/(eV+mu*mpc2)",
"def ComputeInnerOrientation(self, imagePoints):\n # implementing observation vectors\n imagePoints = imagePoints.reshape(np.size(imagePoints), 1)\n\n fMarks = self.camera.fiducialMarks.reshape(np.size(self.c... | [
"0.600269",
"0.5934908",
"0.5921452",
"0.58419925",
"0.58109325",
"0.5797084",
"0.5777378",
"0.57385683",
"0.57354975",
"0.57078993",
"0.5702315",
"0.5689945",
"0.5679907",
"0.5660313",
"0.5653539",
"0.5650662",
"0.56459534",
"0.5623185",
"0.55718786",
"0.55647194",
"0.553900... | 0.0 | -1 |
Compute the derivatives of the collinear law (design matrix) | def __ComputeDesignMatrix(self, groundPoints):
# initialization for readability
omega = self.exteriorOrientationParameters[3]
phi = self.exteriorOrientationParameters[4]
kappa = self.exteriorOrientationParameters[5]
# Coordinates subtraction
dX = groundPoints[:, 0] - self.exteriorOrientationParameters[0]
dY = groundPoints[:, 1] - self.exteriorOrientationParameters[1]
dZ = groundPoints[:, 2] - self.exteriorOrientationParameters[2]
dXYZ = np.vstack([dX, dY, dZ])
rotationMatrixT = self.rotationMatrix.T
rotatedG = rotationMatrixT.dot(dXYZ)
rT1g = rotatedG[0, :]
rT2g = rotatedG[1, :]
rT3g = rotatedG[2, :]
focalBySqauredRT3g = self.camera.focalLength / rT3g ** 2
dxdg = rotationMatrixT[0, :][None, :] * rT3g[:, None] - rT1g[:, None] * rotationMatrixT[2, :][None, :]
dydg = rotationMatrixT[1, :][None, :] * rT3g[:, None] - rT2g[:, None] * rotationMatrixT[2, :][None, :]
dgdX0 = np.array([-1, 0, 0], 'f')
dgdY0 = np.array([0, -1, 0], 'f')
dgdZ0 = np.array([0, 0, -1], 'f')
# Derivatives with respect to X0
dxdX0 = -focalBySqauredRT3g * np.dot(dxdg, dgdX0)
dydX0 = -focalBySqauredRT3g * np.dot(dydg, dgdX0)
# Derivatives with respect to Y0
dxdY0 = -focalBySqauredRT3g * np.dot(dxdg, dgdY0)
dydY0 = -focalBySqauredRT3g * np.dot(dydg, dgdY0)
# Derivatives with respect to Z0
dxdZ0 = -focalBySqauredRT3g * np.dot(dxdg, dgdZ0)
dydZ0 = -focalBySqauredRT3g * np.dot(dydg, dgdZ0)
dRTdOmega = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'omega').T
dRTdPhi = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'phi').T
dRTdKappa = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'kappa').T
gRT3g = dXYZ * rT3g
# Derivatives with respect to Omega
dxdOmega = -focalBySqauredRT3g * (dRTdOmega[0, :][None, :].dot(gRT3g) -
rT1g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]
dydOmega = -focalBySqauredRT3g * (dRTdOmega[1, :][None, :].dot(gRT3g) -
rT2g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]
# Derivatives with respect to Phi
dxdPhi = -focalBySqauredRT3g * (dRTdPhi[0, :][None, :].dot(gRT3g) -
rT1g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]
dydPhi = -focalBySqauredRT3g * (dRTdPhi[1, :][None, :].dot(gRT3g) -
rT2g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]
# Derivatives with respect to Kappa
dxdKappa = -focalBySqauredRT3g * (dRTdKappa[0, :][None, :].dot(gRT3g) -
rT1g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]
dydKappa = -focalBySqauredRT3g * (dRTdKappa[1, :][None, :].dot(gRT3g) -
rT2g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]
# all derivatives of x and y
dd = np.array([np.vstack([dxdX0, dxdY0, dxdZ0, dxdOmega, dxdPhi, dxdKappa]).T,
np.vstack([dydX0, dydY0, dydZ0, dydOmega, dydPhi, dydKappa]).T])
a = np.zeros((2 * dd[0].shape[0], 6))
a[0::2] = dd[0]
a[1::2] = dd[1]
return a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def derivatives(x_p, y_p):\r\n # set up the matrix equation\r\n n = x_p.shape[0]\r\n M = np.zeros( [n,n] )\r\n d = np.zeros( [n,1] )\r\n \r\n # fill in the constants where they can be\r\n for i in np.arange(1,n-1 ): # for all but the first and last row\r\n M[i,i-1 ] = ( x_p[i] - x_p[i-... | [
"0.6885692",
"0.65035003",
"0.62627643",
"0.62573814",
"0.6247173",
"0.6219265",
"0.6201201",
"0.619879",
"0.6149196",
"0.6138502",
"0.60837907",
"0.6081997",
"0.6081997",
"0.6045166",
"0.6043331",
"0.6040035",
"0.6020596",
"0.6014159",
"0.600143",
"0.59920883",
"0.59908885",... | 0.0 | -1 |
Compute the derivatives of the collinear law (design matrix) | def __ComputeDesignMatrix_RzRyRz(self, groundPoints):
# initialization for readability
azimuth = self.exteriorOrientationParameters[3]
phi = self.exteriorOrientationParameters[4]
kappa = self.exteriorOrientationParameters[5]
# Coordinates subtraction
dX = groundPoints[:, 0] - self.exteriorOrientationParameters[0]
dY = groundPoints[:, 1] - self.exteriorOrientationParameters[1]
dZ = groundPoints[:, 2] - self.exteriorOrientationParameters[2]
dXYZ = np.vstack([dX, dY, dZ])
rotationMatrixT = self.rotationMatrix_RzRyRz.T
rotatedG = rotationMatrixT.dot(dXYZ)
rT1g = rotatedG[0, :]
rT2g = rotatedG[1, :]
rT3g = rotatedG[2, :]
focalBySqauredRT3g = self.camera.focalLength / rT3g ** 2
dxdg = rotationMatrixT[0, :][None, :] * rT3g[:, None] - rT1g[:, None] * rotationMatrixT[2, :][None, :]
dydg = rotationMatrixT[1, :][None, :] * rT3g[:, None] - rT2g[:, None] * rotationMatrixT[2, :][None, :]
dgdX0 = np.array([-1, 0, 0], 'f')
dgdY0 = np.array([0, -1, 0], 'f')
dgdZ0 = np.array([0, 0, -1], 'f')
# Derivatives with respect to X0
dxdX0 = -focalBySqauredRT3g * np.dot(dxdg, dgdX0)
dydX0 = -focalBySqauredRT3g * np.dot(dydg, dgdX0)
# Derivatives with respect to Y0
dxdY0 = -focalBySqauredRT3g * np.dot(dxdg, dgdY0)
dydY0 = -focalBySqauredRT3g * np.dot(dydg, dgdY0)
# Derivatives with respect to Z0
dxdZ0 = -focalBySqauredRT3g * np.dot(dxdg, dgdZ0)
dydZ0 = -focalBySqauredRT3g * np.dot(dydg, dgdZ0)
dRTdOmega = Compute3DRotationDerivativeMatrix_RzRyRz(azimuth, phi, kappa, 'azimuth').T
dRTdPhi = Compute3DRotationDerivativeMatrix_RzRyRz(azimuth, phi, kappa, 'phi').T
dRTdKappa = Compute3DRotationDerivativeMatrix_RzRyRz(azimuth, phi, kappa, 'kappa').T
gRT3g = dXYZ * rT3g
# Derivatives with respect to Omega
dxdOmega = -focalBySqauredRT3g * (dRTdOmega[0, :][None, :].dot(gRT3g) -
rT1g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]
dydOmega = -focalBySqauredRT3g * (dRTdOmega[1, :][None, :].dot(gRT3g) -
rT2g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]
# Derivatives with respect to Phi
dxdPhi = -focalBySqauredRT3g * (dRTdPhi[0, :][None, :].dot(gRT3g) -
rT1g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]
dydPhi = -focalBySqauredRT3g * (dRTdPhi[1, :][None, :].dot(gRT3g) -
rT2g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]
# Derivatives with respect to Kappa
dxdKappa = -focalBySqauredRT3g * (dRTdKappa[0, :][None, :].dot(gRT3g) -
rT1g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]
dydKappa = -focalBySqauredRT3g * (dRTdKappa[1, :][None, :].dot(gRT3g) -
rT2g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]
# all derivatives of x and y
dd = np.array([np.vstack([dxdX0, dxdY0, dxdZ0, dxdOmega, dxdPhi, dxdKappa]).T,
np.vstack([dydX0, dydY0, dydZ0, dydOmega, dydPhi, dydKappa]).T])
a = np.zeros((2 * dd[0].shape[0], 6))
a[0::2] = dd[0]
a[1::2] = dd[1]
return a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def derivatives(x_p, y_p):\r\n # set up the matrix equation\r\n n = x_p.shape[0]\r\n M = np.zeros( [n,n] )\r\n d = np.zeros( [n,1] )\r\n \r\n # fill in the constants where they can be\r\n for i in np.arange(1,n-1 ): # for all but the first and last row\r\n M[i,i-1 ] = ( x_p[i] - x_p[i-... | [
"0.6885692",
"0.65035003",
"0.62627643",
"0.62573814",
"0.6247173",
"0.6219265",
"0.6201201",
"0.619879",
"0.6149196",
"0.6138502",
"0.60837907",
"0.6081997",
"0.6081997",
"0.6045166",
"0.6043331",
"0.6040035",
"0.6020596",
"0.6014159",
"0.600143",
"0.59920883",
"0.59908885",... | 0.0 | -1 |
Map label to name. | def label_to_name(label):
return "Tree" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def label_to_name(self, label):\n\t\t\treturn self.labels[label]",
"def label_to_name(self, label):\n\t\treturn self.labels[label]",
"def label_to_name(self, label):\n return self.labels[label]",
"def label_name(self) -> str:\n return pulumi.get(self, \"label_name\")",
"def get_label_name(lab... | [
"0.8264281",
"0.82229835",
"0.8194375",
"0.71729356",
"0.70556575",
"0.6895756",
"0.6878515",
"0.6878004",
"0.68344384",
"0.682798",
"0.6825429",
"0.6815113",
"0.68029517",
"0.6751829",
"0.67418474",
"0.6715094",
"0.6705865",
"0.6690326",
"0.666572",
"0.66346323",
"0.65997976... | 0.7184514 | 3 |
Predict invidiual tree crown bounding boxes for a single image | def predict_image(model, image_path, score_threshold = 0.1, max_detections= 200, return_plot=True):
#predict
raw_image = cv2.imread(image_path)
image = preprocess(raw_image)
image, scale = keras_retinanet_image.resize_image(image)
if keras.backend.image_data_format() == 'channels_first':
image = image.transpose((2, 0, 1))
# run network
boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))[:3]
# correct boxes for image scale
boxes /= scale
# select indices which have a score above the threshold
indices = np.where(scores[0, :] > score_threshold)[0]
# select those scores
scores = scores[0][indices]
# find the order with which to sort the scores
scores_sort = np.argsort(-scores)[:max_detections]
# select detections
image_boxes = boxes[0, indices[scores_sort], :]
image_scores = scores[scores_sort]
image_labels = labels[0, indices[scores_sort]]
image_detections = np.concatenate([image_boxes, np.expand_dims(image_scores, axis=1), np.expand_dims(image_labels, axis=1)], axis=1)
if return_plot:
draw_detections(raw_image, image_boxes, image_scores, image_labels, label_to_name=label_to_name, score_threshold=score_threshold)
return raw_image
else:
return image_boxes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_trees(deepforest_model, rgb_path, bounds, expand=10):\n #DeepForest is trained on 400m crops, easiest to mantain this approximate size centered on points\n left, bottom, right, top = bounds\n expand_width = (40 - (right - left))/2\n left = left - expand_width\n right = right + expand_wid... | [
"0.6780052",
"0.6780052",
"0.66179",
"0.66036594",
"0.6570653",
"0.6464624",
"0.6442197",
"0.6430756",
"0.63636744",
"0.63617635",
"0.629576",
"0.6279707",
"0.62130153",
"0.6206307",
"0.61893594",
"0.61628205",
"0.61508197",
"0.6141496",
"0.61407137",
"0.61125773",
"0.6096678... | 0.0 | -1 |
loop through a dir and run all images | def predict_all_images():
#Read config
config = read_config()
#read model
model = read_model(config["model_path"], config)
tifs = glob.glob(os.path.join("data","**","*.tif"))
for tif in tifs:
print(tif)
prediction = predict_image(model, tif, score_threshold = 0.1, max_detections= 200,return_plot=False)
#reshape and save to csv
df = pd.DataFrame(prediction)
df.columns = ["xmin","ymin","xmax","ymax"]
#save boxes
file_path = os.path.splitext(tif)[0] + ".csv"
df.to_csv(file_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_images():\n create_dirs()\n for root, dirs, files in os.walk(IN):\n for name in files:\n if name[0] == '.':\n continue\n process_image(name)",
"def processImages(self):\n for file in os.listdir(self.config[\"tempPath\"]):\n self.logger.debug(\"Calling generateI... | [
"0.78397024",
"0.7330907",
"0.7104293",
"0.7006195",
"0.691466",
"0.68556714",
"0.6756341",
"0.66847354",
"0.6673864",
"0.6630209",
"0.6581177",
"0.65660363",
"0.6560143",
"0.6554627",
"0.65188265",
"0.6516782",
"0.65092206",
"0.65087897",
"0.6484184",
"0.6457262",
"0.6429507... | 0.0 | -1 |
Fixture to clean up logging output before each test. | def before_and_after_each_test(self, caplog):
#before each test
# Set to capture logs above INFO
caplog.set_level(logging.INFO)
caplog.clear()
yield
#after each test | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n clean_temlogger_config()",
"def setUp(self):\n clean_temlogger_config()",
"def setUp(self):\n clean_temlogger_config()",
"def setUp(self):\n clean_temlogger_config()",
"def setUp(self):\n self.path = tempfile.mkdtemp()\n self.log = log.Log(self.p... | [
"0.7646536",
"0.7646536",
"0.7646536",
"0.7646536",
"0.7533063",
"0.7408682",
"0.73239565",
"0.73239565",
"0.73239565",
"0.73239565",
"0.73239565",
"0.7239843",
"0.7204147",
"0.7201381",
"0.7155247",
"0.69071877",
"0.6867982",
"0.68438387",
"0.6788774",
"0.675041",
"0.6707021... | 0.6735152 | 20 |
Description When is given a directory name that exist Expected Result returns True | def test_has_directory(self, check_fn_true):
#setup
has_directory = extractor.make_has_directory(os.path.isdir)
#when
test1 = has_directory("./data/observed")
#result
assert test1 is True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_dir_exist():\n if os.path.isdir(path_structure):\n return True\n else:\n return False",
"def test_doesnt_have_directory(self, check_fn_false):\n\n # setup\n has_directory = extractor.make_has_directory(os.path.isdir)\n\n # when\n test2 = has_directory(\".... | [
"0.7946343",
"0.774155",
"0.7725892",
"0.7708306",
"0.75825566",
"0.749166",
"0.7445757",
"0.74027336",
"0.73993707",
"0.73776567",
"0.73469585",
"0.7326901",
"0.7297167",
"0.7291639",
"0.7277154",
"0.7249648",
"0.72335654",
"0.72275263",
"0.72248363",
"0.71985984",
"0.718994... | 0.7547904 | 5 |
Description When is given a directory name that exist Expected Result Shows log that directory was found | def test_has_directory_log(self, check_fn_true, caplog):
#setup
records = caplog.records
has_directory = extractor.make_has_directory(os.path.isdir)
directory_path = "./data/observed"
#when
test1 = has_directory(directory_path)
#result
assert len(records) == 1
assert records[0].message == f"It was found directory {directory_path}" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_doesnt_have_directory_log(self, check_fn_false, caplog):\n\n #setup\n records = caplog.records\n has_directory = extractor.make_has_directory(os.path.isdir)\n directory_path = \"./data/tests\"\n \n #when\n test2 = has_directory(directory_path)\n\n #r... | [
"0.74612963",
"0.66516936",
"0.6648649",
"0.6637668",
"0.6592905",
"0.65451527",
"0.6507091",
"0.6476768",
"0.6445445",
"0.64397144",
"0.641731",
"0.6323137",
"0.6317305",
"0.6291415",
"0.6287829",
"0.6264551",
"0.62638617",
"0.62398607",
"0.6232754",
"0.6224753",
"0.62079227... | 0.7359447 | 1 |
Description When is given a directory name that doesnt exist Expected Result returns False | def test_doesnt_have_directory(self, check_fn_false):
# setup
has_directory = extractor.make_has_directory(os.path.isdir)
# when
test2 = has_directory("./data/tests")
# result
assert test2 is False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_dir_exist():\n if os.path.isdir(path_structure):\n return True\n else:\n return False",
"def __is_directory_name(filename):\n return filename[-1] == '/'",
"def is_valid_directory(args):\n if args.directory is not None:\n return True\n return False",
"def is_d... | [
"0.7637506",
"0.7587286",
"0.75317335",
"0.7509946",
"0.7493378",
"0.74204826",
"0.74024594",
"0.7333082",
"0.7327076",
"0.7321167",
"0.73203564",
"0.72724897",
"0.7250266",
"0.7245775",
"0.7242602",
"0.7218288",
"0.7178371",
"0.71603537",
"0.71599776",
"0.714316",
"0.7106386... | 0.7918296 | 0 |
Description When is given a directory name that doesnt exist Expected Result Shows log that directory wasn't found | def test_doesnt_have_directory_log(self, check_fn_false, caplog):
#setup
records = caplog.records
has_directory = extractor.make_has_directory(os.path.isdir)
directory_path = "./data/tests"
#when
test2 = has_directory(directory_path)
#result
assert len(records) == 1
assert records[0].message == f"It wasn't found directory {directory_path}" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testNoSuchDirectory(self):\n\n self.assertRaises(OSError,\n parse_package,\n \"no_such_directory\")",
"def test_ensure_dir_exists(self):\n pass",
"def check_dir(directory: str, err_string: str) -> None:\n if not pathlib.Path(directory).is_d... | [
"0.7097761",
"0.69815487",
"0.6958049",
"0.69345635",
"0.68600756",
"0.6768691",
"0.67403984",
"0.67001784",
"0.66480124",
"0.65875924",
"0.6568089",
"0.6561216",
"0.6556799",
"0.6535799",
"0.6534498",
"0.6532836",
"0.6514325",
"0.65090376",
"0.64824975",
"0.6481356",
"0.6477... | 0.7614185 | 0 |
Description When is given a directory path that exist and has csv files Expected Result returns array with paths of files | def test_get_filepaths(self):
#setup
get_filepaths = extractor.make_get_filepaths(self.mock_get_files_fn)
#when
test1 = get_filepaths("./dir1", ".csv")
#result
assert len(test1) == 2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_csv_in_path(self, path):\n files = os.listdir((path))\n return files",
"def get_file_list(rootdir): #{{{\n file_list = []\n for f in os.listdir(rootdir):\n if f == None or not f.endswith(\".csv\"):\n continue\n file_list.append(os.path.join(rootdir, f))\n ... | [
"0.73693734",
"0.70882964",
"0.6973099",
"0.69681597",
"0.6596682",
"0.6555726",
"0.6549086",
"0.6546537",
"0.64897746",
"0.64868534",
"0.6455237",
"0.64520305",
"0.63143605",
"0.6301336",
"0.62846804",
"0.62800604",
"0.6277007",
"0.62760013",
"0.62456584",
"0.6236947",
"0.62... | 0.6765397 | 4 |
Description When is given a directory path that exist and doesn't have csv files Expected Result returns array with paths of files | def test_get_filepaths_empty(self):
#setup
get_filepaths = extractor.make_get_filepaths(self.mock_get_files_fn)
#when
test2 = get_filepaths("./dir2", ".c")
#result
assert len(test2) == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_file_list(rootdir): #{{{\n file_list = []\n for f in os.listdir(rootdir):\n if f == None or not f.endswith(\".csv\"):\n continue\n file_list.append(os.path.join(rootdir, f))\n \n return file_list",
"def get_csv_in_path(self, path):\n files = os.listdir((pa... | [
"0.70320946",
"0.67621905",
"0.6713793",
"0.6638676",
"0.66279495",
"0.65001047",
"0.6399279",
"0.63733476",
"0.63562477",
"0.6341865",
"0.63009876",
"0.6289475",
"0.6229904",
"0.62287295",
"0.6151689",
"0.61245257",
"0.61133426",
"0.61005086",
"0.60860026",
"0.60531443",
"0.... | 0.6132733 | 15 |
Description When is given a directory path that has observed as parent folder and csv file with desired name Expected Result returns dictionary with right data | def test_observed_folder_path(self):
#setup
filepath = ".data/observed/Abadia-BA_-11.56_-37.52.csv"
expected_result = {
"type": "observed",
"city": "Abadia",
"state": "BA",
"coordinates": ['-11.56', '-37.52'],
"observed": {}
}
#result
assert extractor.get_metadata_from_filepath(filepath) == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_descendant_file_path(parent_path):\n csv_relative_path = []\n for root, dirs, files in os.walk(parent_path):\n for file in files:\n words = file.split(r'.')\n if words[-1] == 'csv':\n file_path = os.path.join(parent_path, file)\n ... | [
"0.64571184",
"0.64260465",
"0.62206316",
"0.5949646",
"0.5880635",
"0.5827373",
"0.5811057",
"0.57590806",
"0.57238656",
"0.5693332",
"0.56806904",
"0.56777036",
"0.5620818",
"0.55884403",
"0.55691016",
"0.55604094",
"0.5549872",
"0.55385315",
"0.55111617",
"0.5508465",
"0.5... | 0.5314282 | 43 |
Description When is given a directory path that has forecast as parent folder and csv file with desired name Expected Result returns dictionary with right data | def test_forecast_folder_path(self):
#setup
filepath = ".data/forecast/Kano-KN_-9.09_7.39.json"
expected_result = {
"type": "forecast",
"city": "Kano",
"state": "KN",
"coordinates": ['-9.09', '7.39'],
"forecast": {}
}
#result
assert extractor.get_metadata_from_filepath(filepath) == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_isys_output(path_to_csv,directory_details):\n isys_results=open(path_to_csv).readlines()\n partial_paths_list=[]\n #below we are starting with the second row because the first row has the column\n # headings \n start=1\n for item in isys_results[start:]:\n partial_path=item.split... | [
"0.60329616",
"0.5951354",
"0.5933117",
"0.59185493",
"0.5806007",
"0.57351774",
"0.5663706",
"0.5627654",
"0.562072",
"0.55951595",
"0.55628073",
"0.55555654",
"0.5554841",
"0.5539798",
"0.5537601",
"0.5528273",
"0.5500308",
"0.5499843",
"0.54943573",
"0.54920584",
"0.548131... | 0.6474041 | 0 |
Description When is given a directory path that has no forecast or observed as parent folder and csv file with not desired name Expected Result returns dictionary with values empty | def test_invalid_file_path(self):
# Test with an invalid file path
#setup
filepath = ".data/kano/test.txt"
expected_result = {
"type": "",
"city": "",
"state": "",
"coordinates": ["", ""],
'': {}
}
#result
assert extractor.get_metadata_from_filepath(filepath) == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_observed_folder_path(self):\n\n #setup\n filepath = \".data/observed/Abadia-BA_-11.56_-37.52.csv\"\n expected_result = {\n \"type\": \"observed\",\n \"city\": \"Abadia\",\n \"state\": \"BA\",\n \"coordinates\": ['-11.56', '-37.52'],\n ... | [
"0.65036917",
"0.6375648",
"0.6118687",
"0.59009016",
"0.5858981",
"0.5716339",
"0.5682048",
"0.551454",
"0.5508633",
"0.55065745",
"0.5505938",
"0.54979366",
"0.54892653",
"0.5485146",
"0.5470703",
"0.54683197",
"0.5457055",
"0.54512775",
"0.5430467",
"0.5412322",
"0.5408284... | 0.5297656 | 33 |
Description When is given a csv_filepath and output_filepath and its the first time reading it Expected Result creates a json file with right values | def test_first_time_reading_csv_file(self):
# Create a temporary directory for test files
temp_dir = "test_files/observed"
os.makedirs(temp_dir, exist_ok=True)
# Create a test CSV file
csv_filepath = os.path.join(temp_dir, "Abadia-BA_-11.56_-37.52.csv")
with open(csv_filepath, "w", newline="") as csv_file:
writer = csv.writer(csv_file, delimiter=";")
writer.writerow(["periods", "precipitation", "temperature", "max_temperature"])
writer.writerow(["2023-01-01", "5", "25", "30"])
writer.writerow(["2023-01-02", "10", "23", "28"])
# Define the expected output JSON file path
expected_output_filepath = os.path.join(temp_dir, "BA_Abadia.json")
# Call the function under test
extractor.csv_to_json(csv_filepath, temp_dir)
# Verify that the output JSON file exists
assert os.path.exists(expected_output_filepath)
# Load the output JSON file
with open(expected_output_filepath, "r") as json_file:
json_data = json.load(json_file)
# Verify the contents of the JSON file
expected_data = {
"city": "Abadia",
"state": "BA",
"coordinates": ["-11.56", "-37.52"],
"observed": {
"periods": ["2023-01-01", "2023-01-02"],
"precipitation": ["5", "10"],
"temperature": ["25", "23"],
"max_temperature": ["30", "28"]
}
}
assert json_data == expected_data
# Clean up the temporary directory and files
os.remove(csv_filepath)
os.remove(expected_output_filepath)
os.rmdir(temp_dir) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_json_from_csv(csv_file, delimiter, cols_delimiter, keep, dic_types, infer_types, max_docs, json_file, per_line):\n\n # Get header of csv\n header_csv = get_header_csv(csv_file, cols_delimiter)\n\n # Create structure of json\n print(' [INFO] Creating json\\'s structure')\n jstruct = creat... | [
"0.711705",
"0.6895903",
"0.6818029",
"0.6596224",
"0.6538705",
"0.6498996",
"0.647413",
"0.64032245",
"0.632765",
"0.63111657",
"0.6258295",
"0.62576884",
"0.62437224",
"0.6213409",
"0.6196973",
"0.6165735",
"0.6092725",
"0.6078405",
"0.607367",
"0.60391676",
"0.6012014",
... | 0.7492845 | 0 |
Description When is given a csv_filepath and output_filepath and already exists the file Expected Result concatenate the old json file with the values found in 2nd reading. | def test_when_file_already_exist(self):
# Create a temporary directory for test files
temp_dir = ["test_files/observed", "test_files/forecast", "test_files/output"]
for dir in temp_dir:
os.makedirs(dir, exist_ok=True)
# Create the 1st csv file
first_csv_filepath = os.path.join(temp_dir[0], "Abadia-BA_-11.56_-37.52.csv")
with open(first_csv_filepath, "w", newline="") as csv_file:
writer = csv.writer(csv_file, delimiter=";")
writer.writerow(["periods", "precipitation", "temperature", "max_temperature"])
writer.writerow(["2023-01-01", "5", "25", "30"])
writer.writerow(["2023-01-02", "10", "23", "28"])
# Creating the 2nd csv file in different directory
second_csv_filepath = os.path.join(temp_dir[1], "Abadia-BA_-11.56_-37.52.csv")
with open(second_csv_filepath, "w", newline="") as csv_file:
writer = csv.writer(csv_file, delimiter=";")
writer.writerow(["periods", "precipitation", "temperature", "max_temperature"])
writer.writerow(["2023-01-01", "5", "25", "30"])
writer.writerow(["2023-01-02", "10", "23", "28"])
# Define the expected output JSON file path
expected_output_filepath = os.path.join(temp_dir[2], "BA_Abadia.json")
# Call the function under test
extractor.csv_to_json(first_csv_filepath, temp_dir[2])
extractor.csv_to_json(second_csv_filepath, temp_dir[2])
# Verify that the output JSON file exists
assert os.path.exists(expected_output_filepath)
# Load the output JSON file
with open(expected_output_filepath, "r") as json_file:
json_data = json.load(json_file)
# Verify the contents of the JSON file
expected_data = {
"city": "Abadia",
"state": "BA",
"coordinates": ["-11.56", "-37.52"],
"observed": {
"periods": ["2023-01-01", "2023-01-02"],
"precipitation": ["5", "10"],
"temperature": ["25", "23"],
"max_temperature": ["30", "28"]
},
"forecast": {
"periods": ["2023-01-01", "2023-01-02"],
"precipitation": ["5", "10"],
"temperature": ["25", "23"],
"max_temperature": ["30", "28"]
},
}
# Assertion
assert json_data == expected_data
# Clean up the temporary directory and files
os.remove(first_csv_filepath)
os.remove(second_csv_filepath)
os.remove(expected_output_filepath)
for dir in temp_dir:
os.rmdir(dir) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def collate_similar_data(input_csv_file_path, output_csv_file_path):\n if not input_csv_file_path or not output_csv_file_path:\n return\n with open(output_csv_file_path, 'w') as file_object:\n csv_writer = csv.writer(file_object, delimiter=',')\n csv_writer.writerow(\n (... | [
"0.66875005",
"0.65311",
"0.64833546",
"0.6277665",
"0.6257637",
"0.5997841",
"0.5968701",
"0.58972067",
"0.5896129",
"0.5890339",
"0.58322793",
"0.5827144",
"0.580506",
"0.57693833",
"0.5767864",
"0.5731467",
"0.57120144",
"0.56666887",
"0.56376743",
"0.5627514",
"0.5622011"... | 0.69841707 | 0 |
Description When is given a csv_filepath and output_filepath and one of the columns has blank character Expected Result creates a json file ignoring blank column | def test_blank_column(self):
# Create a temporary directory for test files
temp_dir = "test_files/observed"
os.makedirs(temp_dir, exist_ok=True)
# Create a test CSV file
csv_filepath = os.path.join(temp_dir, "Abadia-BA_-11.56_-37.52.csv")
with open(csv_filepath, "w", newline="") as csv_file:
writer = csv.writer(csv_file, delimiter=";")
writer.writerow(["periods", "precipitation", "temperature", ""])
writer.writerow(["2023-01-01", "5", "25", ""])
writer.writerow(["2023-01-02", "10", "23", ""])
# Define the expected output JSON file path
expected_output_filepath = os.path.join(temp_dir, "BA_Abadia.json")
# Call the function under test
extractor.csv_to_json(csv_filepath, temp_dir)
# Verify that the output JSON file exists
assert os.path.exists(expected_output_filepath)
# Load the output JSON file
with open(expected_output_filepath, "r") as json_file:
json_data = json.load(json_file)
# Verify the contents of the JSON file
expected_data = {
"city": "Abadia",
"state": "BA",
"coordinates": ["-11.56", "-37.52"],
"observed": {
"periods": ["2023-01-01", "2023-01-02"],
"precipitation": ["5", "10"],
"temperature": ["25", "23"]
}
}
assert json_data == expected_data
# Clean up the temporary directory and files
os.remove(csv_filepath)
os.remove(expected_output_filepath)
os.rmdir(temp_dir) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_to_csv_with_no_rows_returns_none(self):\n output = row_handling.to_csv(rows=[], csv_path=self.csv_path)\n assert output is None",
"def write_csv_file(csv_output_file, full_data):\n j = 0\n csv_file_path = make_dir(csv_output_file)\n\n # csv_file_path = os.path.join(csv_file_path, ... | [
"0.6778147",
"0.66215456",
"0.6587748",
"0.6419415",
"0.6071375",
"0.60661834",
"0.6063572",
"0.6040226",
"0.60079324",
"0.59419805",
"0.5918246",
"0.5916295",
"0.5871361",
"0.58706796",
"0.58664465",
"0.5850558",
"0.5849682",
"0.5848059",
"0.5840836",
"0.58217335",
"0.577176... | 0.6656623 | 1 |
builds the test suite. | def test_suite():
suite = unittest.TestSuite()
suite.addTests(unittest.makeSuite(PrimesTests))
suite.addTests(unittest.makeSuite(OtherTests))
return suite | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUpSuite():\n global _output_dir\n global _suite_configured\n\n if _suite_configured:\n return\n\n def remove_output_dir():\n global _output_dir\n if _output_dir != '':\n try:\n shutil.rmtree(_output_dir)\n except FileNotFoundError:\n ... | [
"0.72579163",
"0.70755035",
"0.69487077",
"0.693024",
"0.68874764",
"0.6838446",
"0.67889327",
"0.6781857",
"0.6769531",
"0.67448074",
"0.6737396",
"0.67239064",
"0.6713449",
"0.67040795",
"0.6690259",
"0.6676821",
"0.6676821",
"0.66717535",
"0.66633546",
"0.66531706",
"0.665... | 0.6828355 | 6 |
Plots the path from start node to goal region as well as the graph (or tree) searched with the Sampling Based Algorithms. | def draw_results(algo_name, path, V, E, env, bounds, object_radius, resolution, start_pose, goal_region, elapsed_time):
graph_size = len(V)
path_size = len(path)
# Calculate path length
path_length = 0.0
for i in xrange(len(path)-1):
path_length += euclidian_dist(path[i], path[i+1])
# Create title with descriptive information based on environment, path length, and elapsed_time
title = algo_name + "\n" + str(graph_size) + " Nodes. " + str(len(env.obstacles)) + " Obstacles. Path Size: " + str(path_size) + "\n Path Length: " + str(path_length) + "\n Runtime(s)= " + str(elapsed_time)
# Plot environment
env_plot = plot_environment(env, bounds)
# Add title
env_plot.set_title(title)
# Plot goal
plot_poly(env_plot, goal_region, 'green')
# Plot start
buffered_start_vertex = Point(start_pose).buffer(object_radius, resolution)
plot_poly(env_plot, buffered_start_vertex, 'red')
# Plot Edges explored by ploting lines between each edge
for edge in E:
line = LineString([edge[0], edge[1]])
plot_line(env_plot, line)
# Plot path
plot_path(env_plot, path, object_radius) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_global_path(start, goal, path, occupancy_grid):\n # Displaying the map\n fig_astar, ax_astar = display_map(occupancy_grid)\n\n # Plot the best path found and the list of visited nodes\n ax_astar.plot(path[0], path[1], marker=\"o\", color='blue');\n ax_astar.scatter(start[0], start[1], ma... | [
"0.66848135",
"0.6656645",
"0.65066147",
"0.6478617",
"0.64643204",
"0.6413952",
"0.63114595",
"0.630562",
"0.6239466",
"0.61826295",
"0.61755365",
"0.61461246",
"0.611502",
"0.6114483",
"0.6070725",
"0.60319483",
"0.6004294",
"0.5978453",
"0.5932531",
"0.58990204",
"0.585567... | 0.5336481 | 80 |
Delete a log file. | def delete_log(file_path):
if os.path.exists(file_path):
print('Deleting log %s...' % file_path)
os.remove(file_path)
else:
raise ValueError("File %r doesn't exists - cannot delete." % file_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_log():\n log_path = Path.cwd() / \"premise.log\"\n if log_path.exists():\n log_path.unlink()",
"def delete_file(fileName):\n os.remove(fileName)\n print (\"Deleteing file: \" + str(fileName))\n write_log()\n read_log()",
"def delete_log(filename):\n log_di... | [
"0.77605826",
"0.7727856",
"0.73945826",
"0.7313134",
"0.72794944",
"0.7045915",
"0.7009386",
"0.6897459",
"0.6797494",
"0.6758738",
"0.6743915",
"0.6732991",
"0.671415",
"0.66890925",
"0.6686626",
"0.6566584",
"0.6561632",
"0.6561151",
"0.65555596",
"0.6545941",
"0.6545941",... | 0.8215973 | 0 |
Create a new Logger. | def __init__(self, file_path, print_too=True, override=False):
self.file_path = file_path
self.print_too = print_too
if override:
if os.path.exists(file_path):
print('Overriding - deleting previous log...')
os.remove(file_path)
os.makedirs(os.path.dirname(file_path), exist_ok=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_logger() -> logging.Logger:\n pass # TODO: Replace with implementation!",
"def create_logger():\r\n global logger\r\n logger = logging.getLogger(logger_name)\r\n\r\n formatter = logging.Formatter(fmt='%(asctime)s %(levelname)s %(message)s')\r\n \r\n handler = logging.StreamHandler()... | [
"0.82856834",
"0.7896472",
"0.77731115",
"0.7539057",
"0.7495882",
"0.7493682",
"0.7396028",
"0.73747236",
"0.7198107",
"0.71252424",
"0.71039444",
"0.7093442",
"0.7016825",
"0.69982064",
"0.6978802",
"0.69182163",
"0.6911099",
"0.6907273",
"0.6900183",
"0.6848638",
"0.683535... | 0.0 | -1 |
retorna o valor de graus Farenheit convertido para Celsius | def toCelsius(farenheit):
return (farenheit - 32)*5 / 9 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_f_to_c(temp_in_farenheit): ## ##\n celsiustemp = round((temp_in_farenheit - 32) * 5/9, 1) ##\n return celsiustemp ##",
"def convert_f_to_c(temp_in_f... | [
"0.8010471",
"0.7904015",
"0.7749893",
"0.7748052",
"0.77476305",
"0.77396774",
"0.76843536",
"0.7657182",
"0.76182777",
"0.7557405",
"0.74652946",
"0.72664905",
"0.7263454",
"0.7263454",
"0.7261374",
"0.72476894",
"0.7239142",
"0.72153395",
"0.7209384",
"0.7199643",
"0.71753... | 0.8065382 | 0 |
Return github API URL as string | def get_api_url(self):
url = 'https://api.{}/repos/{}/{}/git/'.format(HOST_GITHUB, \
self.repo, self.product)
return url | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def github_url(self):\n return self.github.replace('.git', '')",
"def github_link(self):\n if self.test_type == TestType.commit:\n test_type = 'commit'\n test_id = self.commit\n else:\n test_type = 'pull'\n test_id = self.pr_nr\n\n return f\... | [
"0.79492223",
"0.72487265",
"0.7181632",
"0.7154561",
"0.7106888",
"0.6985907",
"0.6885024",
"0.68606704",
"0.682998",
"0.6809253",
"0.6746705",
"0.67292404",
"0.6727469",
"0.67142564",
"0.6706738",
"0.66876775",
"0.66692704",
"0.66497993",
"0.6614878",
"0.6613082",
"0.658479... | 0.83484757 | 0 |
Get all tags as json from Github API. | def get_tags(self):
return self.get_url_data(self.api_url + 'refs/tags') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_tags():\n try:\n data = ReadTag().run()\n except Exception as ex:\n return jsonify({'code': '500','message':'Internal server error'})\n else:\n return jsonify({'code': '200','data': data})",
"def tags(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'tags')\r\n\r... | [
"0.7320748",
"0.71714383",
"0.7113308",
"0.6959439",
"0.69185",
"0.6898857",
"0.6868199",
"0.6557756",
"0.63590163",
"0.63203824",
"0.630982",
"0.63082796",
"0.62603027",
"0.61560315",
"0.61486876",
"0.6137396",
"0.60915667",
"0.60803205",
"0.60155445",
"0.5989724",
"0.595926... | 0.6558411 | 7 |
Get a specific tag's data from Github API. | def get_tag(self, sha):
return self.get_url_data(self.api_url + 'tags/' + sha) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tag(self, tag):\n resp = self.get(_u.build_uri(\"tag\", domain=self.domain),\n data={'tag': tag})\n return utils.handle_response(resp)",
"def find_by_id(self, tag, params={}, **options):\n path = \"/tags/%s\" % (tag)\n return self.client.get(path, params... | [
"0.67847025",
"0.6460267",
"0.63765323",
"0.6361611",
"0.6254757",
"0.6193532",
"0.6165435",
"0.5924588",
"0.5913108",
"0.5913108",
"0.5889115",
"0.58397275",
"0.5831963",
"0.58196306",
"0.581669",
"0.57963234",
"0.57881856",
"0.57807654",
"0.57554406",
"0.57134587",
"0.56990... | 0.65368634 | 1 |
Github API can only return all tags, but we only want the latest. | def get_latest_tags(self):
start = len(self.tags) - self.num_comparisons
tags = self.tags
latest = []
for i in xrange(len(tags)):
if i >= start:
parts = tags[i]['ref'].split('/')
release_num = parts[2]
sha = tags[i]['object']['sha']
tag = [release_num, sha]
latest.append(tag)
return latest | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def latest_github_tag():\n release_tags_github_url = \"https://api.github.com/repos/rackerlabs/openstack-guest-agents-unix/tags\"\n release_tags_json = urllib2.urlopen(release_tags_github_url)\n release_tags_data = json.load(release_tags_json)\n return str(release_tags_data[0]['name'])[1:]",
"def do_... | [
"0.7582535",
"0.67998123",
"0.65141267",
"0.64969236",
"0.6446542",
"0.640628",
"0.6393738",
"0.6162547",
"0.5983191",
"0.5975903",
"0.59552914",
"0.5918902",
"0.5868156",
"0.58608156",
"0.5853621",
"0.58516884",
"0.5850484",
"0.5837113",
"0.5833859",
"0.5821743",
"0.5812356"... | 0.6986198 | 1 |
Return github tag release URL as string | def get_url_tag_release(self, release_num):
url = 'https://{}/{}/{}/releases/tag/{}'.format(
HOST_GITHUB,
self.repo,
self.product,
release_num
)
return url | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def git_url(fp: str) -> str:\n return f\"https://github.com/pantsbuild/pants/blob/release_{PANTS_SEMVER}/{fp}\"",
"def get_url_tag_commit(self, git_sha):\n\n url = 'https://{}/{}/{}/commit/{}'.format(\n HOST_GITHUB,\n self.repo,\n self.product,\n git_sha\n ... | [
"0.7346837",
"0.7119125",
"0.6906928",
"0.6849196",
"0.6814661",
"0.6633057",
"0.6601647",
"0.65425444",
"0.65085566",
"0.6498361",
"0.6480949",
"0.6473229",
"0.63616604",
"0.63453585",
"0.63183016",
"0.62817633",
"0.62013495",
"0.6147767",
"0.61303365",
"0.61104536",
"0.6100... | 0.7984513 | 0 |
Return github tag commit SHA URL as string | def get_url_tag_commit(self, git_sha):
url = 'https://{}/{}/{}/commit/{}'.format(
HOST_GITHUB,
self.repo,
self.product,
git_sha
)
return url | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def git_url(fp: str) -> str:\n return f\"https://github.com/pantsbuild/pants/blob/release_{PANTS_SEMVER}/{fp}\"",
"def github_url(self):\n return self.github.replace('.git', '')",
"def repo_link(repo):\n return \"https://github.com/\" + repo",
"def url_for(self: Self, commit_sha: str, path: str,... | [
"0.71973187",
"0.69282585",
"0.6792901",
"0.6748358",
"0.66634905",
"0.6656634",
"0.6605502",
"0.6590671",
"0.65770376",
"0.6560338",
"0.6532101",
"0.65264523",
"0.6505128",
"0.6500491",
"0.6499007",
"0.64897436",
"0.63229996",
"0.6280397",
"0.6262036",
"0.6240915",
"0.619329... | 0.8073723 | 0 |
Return github compare URL as string | def get_comparison(self, start, end):
return 'https://{}/{}/{}/compare/{}...{}'.format(HOST_GITHUB, \
self.repo, self.product, start, end) + '\n' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def github_url(self):\n return self.github.replace('.git', '')",
"def github_link(self):\n if self.test_type == TestType.commit:\n test_type = 'commit'\n test_id = self.commit\n else:\n test_type = 'pull'\n test_id = self.pr_nr\n\n return f\... | [
"0.7844604",
"0.739291",
"0.73613286",
"0.73068553",
"0.69562215",
"0.6901379",
"0.6821557",
"0.6768966",
"0.671453",
"0.6567272",
"0.65653217",
"0.6540621",
"0.6515569",
"0.6500115",
"0.6459063",
"0.64307237",
"0.63972664",
"0.63898844",
"0.63744414",
"0.6369827",
"0.6300801... | 0.701876 | 4 |
Parse CHANGELOG for latest tag. | def get_changelog(self, commit_sha):
url = 'https://{}/{}/{}/' + commit_sha + '/CHANGELOG'
url = url.format(HOST_GITHUB_RAW, self.repo, self.product)
req = requests.get(url)
lines = req.text
first = self.latest_tags[self.num_comparisons - 1][VERS]
last = self.latest_tags[self.num_comparisons - 2][VERS]
flag = False
log = ''
for line in lines.splitlines():
if first in line:
flag = True
if last in line:
flag = False
if flag:
log += line + '\n'
return log | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_latest_update(self, resp: Dict[str, Any], latest_version: str) -> str:\n latest_release = resp.get(\"releases\", {}).get(latest_version)\n if latest_release is not None and isinstance(latest_release, list):\n release_artifact_dates = []\n for artifact in latest_releas... | [
"0.616343",
"0.6080337",
"0.6000073",
"0.59245783",
"0.58972937",
"0.5849398",
"0.58468693",
"0.57212126",
"0.569988",
"0.56685996",
"0.5651651",
"0.5609761",
"0.5598691",
"0.5501291",
"0.549835",
"0.54694337",
"0.5457894",
"0.5446662",
"0.5412487",
"0.53381616",
"0.53150606"... | 0.6108666 | 1 |
Constructs release notes for Bugzilla service deployment ticket. | def get_release_notes(self):
notes = self.output.get_header('RELEASE NOTES')
notes += 'https://{}/{}/{}/releases'.format(HOST_GITHUB, \
self.repo, self.product) + '\n'
notes += self.output.get_sub_header('COMPARISONS')
notes += self.get_comparison(self.latest_tags[0][VERS],
self.latest_tags[1][VERS])
if len(self.latest_tags) >= (MAX_COMPARISONS_TO_SHOW - 1):
notes += self.get_comparison(self.latest_tags[1][VERS],
self.latest_tags[2][VERS])
if len(self.latest_tags) >= MAX_COMPARISONS_TO_SHOW:
notes += self.get_comparison(self.latest_tags[2][VERS],
self.latest_tags[3][VERS])
tag_data = self.get_tag(self.latest_tags[3][SHA])
notes += self.output.get_sub_header('TAGS')
notes += self.get_url_tag_release(self.latest_tags[3][VERS]) + '\n'
notes += self.get_url_tag_commit(tag_data["object"]["sha"]) + '\n'
changelog = self.get_changelog(tag_data["object"]["sha"])
if changelog:
notes += self.output.get_sub_header('CHANGELOG')
notes += changelog
return notes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def release_notes(version, author, git_ref_target, git_ref_source, build_type):\n print('generating release notes')\n if git_ref_source:\n if git_ref_source != 'HEAD':\n git_ref_source = 'origin/{}'.format(git_ref_source)\n changelog = run('git log origin/{}..{}'.format(git_ref_targe... | [
"0.7133973",
"0.62649",
"0.6180011",
"0.61652756",
"0.57979625",
"0.5698693",
"0.56655735",
"0.56425494",
"0.55498487",
"0.55108356",
"0.5495176",
"0.5493605",
"0.5473608",
"0.54344285",
"0.5391342",
"0.5365955",
"0.5322172",
"0.5317257",
"0.5311151",
"0.52918744",
"0.5264947... | 0.6374402 | 1 |
Gets the confidence of this PcrTestRecordResult. | def confidence(self):
return self._confidence | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def confidence(self) -> float:\n return self._confidence",
"def confidence(self) -> float:\n return float(self.class_scores[self.class_num])",
"def detection_confidence(self):\n return self._detection_confidence",
"def get_medie_confidence(self):\n return self.__medie_confidence",... | [
"0.74183095",
"0.695079",
"0.6752761",
"0.62172127",
"0.6101365",
"0.59268916",
"0.59007055",
"0.58964837",
"0.58102906",
"0.5795349",
"0.5786901",
"0.57829434",
"0.5746195",
"0.56174123",
"0.56115687",
"0.5601758",
"0.55095553",
"0.55019873",
"0.545608",
"0.5437329",
"0.5400... | 0.7580267 | 1 |
Sets the confidence of this PcrTestRecordResult. | def confidence(self, confidence):
self._confidence = confidence | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def confidence(self, confidence: float):\n\n self._confidence = confidence",
"def confidence(self, confidence):\n\n self._confidence = confidence",
"def confidence(self, confidence):\n\n self._confidence = confidence",
"def confidence(self) -> float:\n return self._confidence",
... | [
"0.73178154",
"0.72186536",
"0.72186536",
"0.64052767",
"0.624179",
"0.624179",
"0.6131234",
"0.6131234",
"0.60332805",
"0.60332805",
"0.5945399",
"0.59088707",
"0.5768737",
"0.5661176",
"0.51978236",
"0.5128352",
"0.5126153",
"0.5094373",
"0.5067891",
"0.50525135",
"0.501097... | 0.72880876 | 2 |
Returns the model properties as a dict | def to_dict(self):
result = {}
for attr, _ in six.iteritems(self.openapi_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
if attr in self.sensitive_list:
result[attr] = "****"
else:
result[attr] = value
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(self):\n return self.properties",
"def to_dict(self):\n return self.properties",
"def get_properties(self):\n return self.properties",
"def asdict(self):\n return self._prop_dict",
"def json(self):\n rv = {\n prop: getattr(self, prop)\n f... | [
"0.7751993",
"0.7751993",
"0.73391134",
"0.7334895",
"0.7297356",
"0.727818",
"0.7159078",
"0.71578115",
"0.71494967",
"0.71494967",
"0.71283495",
"0.71275014",
"0.7122587",
"0.71079814",
"0.7060394",
"0.7043251",
"0.7034103",
"0.70233124",
"0.69635814",
"0.69586295",
"0.6900... | 0.0 | -1 |
Returns the string representation of the model | def to_str(self):
import simplejson as json
if six.PY2:
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
return json.dumps(sanitize_for_serialization(self), ensure_ascii=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return super().__str__() + self.model.__str__()",
"def __str__(self) -> str:\n # noinspection PyUnresolvedReferences\n opts = self._meta\n if self.name_field:\n result = str(opts.get_field(self.name_field).value_from_object(self))\n else:\n ... | [
"0.85856134",
"0.7814518",
"0.77898884",
"0.7751367",
"0.7751367",
"0.7712228",
"0.76981676",
"0.76700574",
"0.7651133",
"0.7597206",
"0.75800353",
"0.7568254",
"0.7538184",
"0.75228703",
"0.7515832",
"0.7498764",
"0.74850684",
"0.74850684",
"0.7467648",
"0.74488163",
"0.7442... | 0.0 | -1 |
Returns true if both objects are equal | def __eq__(self, other):
if not isinstance(other, PcrTestRecordResult):
return False
return self.__dict__ == other.__dict__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self,other):\n try: return self.object==other.object and isinstance(self,type(other))\n except: return False",
"def __eq__(self, other):\n if i... | [
"0.8088132",
"0.8088132",
"0.8054589",
"0.7982687",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
... | 0.0 | -1 |
Returns true if both objects are not equal | def __ne__(self, other):
return not self == other | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __ne__(self, other: object) -> bool:\n if self.__eq__(other):\n return False\n return True",
"def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)",
"def __ne__(self, other) -> bool:\n return not self.__eq__(other)",
"def __eq__(self, other):\n ... | [
"0.845611",
"0.8391477",
"0.8144138",
"0.81410587",
"0.8132492",
"0.8093973",
"0.80920255",
"0.80920255",
"0.80920255",
"0.8085325",
"0.8085325",
"0.8076365",
"0.8076365",
"0.8065748"
] | 0.0 | -1 |
Set the angle of the servo motor to input angle in degrees | def set_angle(self, angle):
new_angle = angle
# Declaring conversion constants
angle_min = 0
angle_max = 180
angle_range = angle_max - angle_min
dc_range = self._dc_max - self._dc_min
# Enforcing angle range
if new_angle > angle_max:
new_angle = angle_max
elif new_angle < angle_min:
new_angle = angle_min
# Scaling input angle to an appropriate duty cycle
duty_cycle = ((dc_range / angle_range) * (new_angle - angle_min)) + self._dc_min
self._servo_pwm.changeDutyCycle(duty_cycle) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_angle(self, value):\n if not -90 <= value <= 90:\n raise ValueError('Servo angle must be between -90 and 90 degrees')\n self.duty_cycle = ...",
"def set_angle(self, ang):\n if ang < 0:\n ang = 0\n elif ang > 180:\n ang = 180\n dutyCycle ... | [
"0.8180504",
"0.78847355",
"0.7495005",
"0.733505",
"0.7213522",
"0.71889293",
"0.71747357",
"0.7051908",
"0.7026474",
"0.70241266",
"0.69745034",
"0.6967439",
"0.6912899",
"0.6871412",
"0.6827222",
"0.681534",
"0.67669934",
"0.674949",
"0.6662368",
"0.66219145",
"0.6615597",... | 0.7820531 | 2 |
Will be called before every test | def setUp(self):
# Create table
db.create_all()
#Create test registree
mcdonalds = Store(name='mcdonalds', shop_address='63 Northbrook st', shop_postcode='rg14 1ae', takeaway=True)
tesco = Store(name='tesco', shop_address='London rd, Newbury', shop_postcode='rg14 2bp', takeaway=False)
coop = Store(name='coop', shop_address='Andover rd', shop_postcode='rg19 3bp', takeaway=False)
#adding test receipts to db
receipt1 = Receipts(most_expensive=5.09, cost_of_alcohol=0, receipt_total=11.36, takeaway=True, delivery_fee=1.99, delivery_time_mins=28, store_id=1, shop=mcdonalds)
receipt2 = Receipts(most_expensive=2.80, cost_of_alcohol=16, receipt_total=11.90, store_id=2, shop=tesco)
receipt3 = Receipts(most_expensive=3.00, cost_of_alcohol=0, receipt_total=18.76, store_id=2, shop=tesco)
receipt4 = Receipts(most_expensive=2.00, cost_of_alcohol=0, receipt_total=20.91, store_id=2, shop=tesco)
#Add and save to database
store_list = [mcdonalds, tesco, coop]
receipt_list = [receipt1, receipt2, receipt3, receipt4]
for i in store_list:
db.session.add(i)
for i in receipt_list:
db.session.add(i)
db.session.commit() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def before_run_tests(cls):\n pass",
"def setUp(self):\r\n # nothing to do, all tests use different things\r\n pass",
"def setUp(self):\n self",
"def setUp(self):\n self",
"def setUp(self):\n\n pass",
"def setUp(self):\n\n pass",
"def setUp(self):\n ... | [
"0.8457524",
"0.83148706",
"0.82529396",
"0.82529396",
"0.81978506",
"0.81978506",
"0.81887835",
"0.81887835",
"0.81887835",
"0.81887835",
"0.81887835",
"0.81887835",
"0.81887835",
"0.81887835",
"0.81887835",
"0.81887835",
"0.81887835",
"0.81887835",
"0.81887835",
"0.81887835",... | 0.0 | -1 |
Will be called after every test | def teardown(self):
db.session.remove()
db.drop_all() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def after_test(self, test_results):\n pass",
"def after_all(self) -> None:",
"def tearDown(self):\n pass",
"def teardown(self):",
"def teardown(self):",
"def teardown(self):",
"def tearDown(self):\r\n pass",
"def tearDown(self):\r\n pass",
"def tearDown(self):\r\n ... | [
"0.84368247",
"0.8336089",
"0.82743084",
"0.8255529",
"0.8255529",
"0.8255529",
"0.8220987",
"0.8220987",
"0.8220987",
"0.8220987",
"0.8220987",
"0.8202792",
"0.81971264",
"0.81971264",
"0.81971264",
"0.81971264",
"0.81971264",
"0.81971264",
"0.81971264",
"0.81971264",
"0.819... | 0.0 | -1 |
Prompt user for input and continue to do so until input is valid. This function takes two required inputs, the message to display, and the limit of characters required. If the user enters something too long, they are prompted again until the input is correct. If the optional isNumber parameter is True, then it will also continue to prompt the user until a valid number is input. | def LimitedInput(message, limit, isNumber=False):
keepAsking = True
while keepAsking:
answer = input(message)
if len(answer) > limit:
print("The input must be", limit, "characters or less.")
else:
keepAsking = False
if isNumber is True and CheckNumber(answer) is False:
print("The input must be a number.")
keepAsking = True
return answer | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ask_number(message: str) -> int:\n global number\n assert isinstance(message, str), \"message should be a string\"\n stop_condition2 = False\n while not stop_condition2:\n try:\n number = int(input(message))\n if number < lower_range:\n print(\"Please pic... | [
"0.6210186",
"0.60945845",
"0.6090262",
"0.59687257",
"0.5932961",
"0.5927148",
"0.59168947",
"0.58883595",
"0.5841568",
"0.58019143",
"0.5782949",
"0.5775905",
"0.5761319",
"0.5716825",
"0.57102144",
"0.5705627",
"0.5701563",
"0.5696017",
"0.56239253",
"0.5619944",
"0.556302... | 0.83368486 | 0 |
This function returns True if userInput can be converted to a number and returns False if it cannot. | def CheckNumber(userInput):
try:
float(userInput)
return True
except(ValueError):
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_number(value_if_allowed):\n if value_if_allowed == '':\n return True\n try:\n float(value_if_allowed)\n return True\n except ValueError:\n return False",
"def __checkInput(self, var):\n try:\n int(var)\n\n except:\n return Fals... | [
"0.7273646",
"0.710573",
"0.70342",
"0.700277",
"0.6989638",
"0.69800496",
"0.6931918",
"0.68965924",
"0.68937594",
"0.68852633",
"0.6882689",
"0.68496823",
"0.6842476",
"0.6823968",
"0.68192196",
"0.68040407",
"0.679756",
"0.6784865",
"0.67602575",
"0.6758838",
"0.673784",
... | 0.86746126 | 0 |
This function prompts the user for a date using the message variable. User will continue to be prompted until the format is correct. The date format is very specific in the format DD/MM/YYYYY This function will confirm there are the right number of characters, the / are in the right place, the input are numbers, the days are between 1 and 31, the months are between 1 and 12, and the year is between 2000 and 3000 (roll on year 3k bug!) | def DateInput(message):
askAgainMessage = "The date must be in the format DD/MM/YYYY"
keepAsking = True
while keepAsking:
answer = input(message)
# First we check if there are two / by splitting using / and looking
# for 3 items in the returned list.
dateCheck = answer.split(sep="/")
if len(dateCheck) is not 3:
print(askAgainMessage)
else:
# If all is order, we can assign the 3 items to day, month, year
day = dateCheck[0]
month = dateCheck[1]
year = dateCheck[2]
# Next we check each item has the right amount of characters
# and they can all be converted into numbers.
if (len(day) == 2 and len(month) == 2 and len(year) == 4 and
CheckNumber(day) and CheckNumber(month) and
CheckNumber(year)):
day = int(day)
month = int(month)
year = int(year)
if (day > 0 and day < 32 and month > 0 and month < 13 and
year > 2000 and year < 3000):
keepAsking = False
else:
print(askAgainMessage)
else:
print(askAgainMessage)
return answer | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_date(message, param):\n while True:\n try:\n day, month, year = input(message).split(param)\n return str(datetime.datetime(int(year), int(month), int(day)).strftime(\"%d/%m/%Y\"))\n except ValueError:\n continue",
"def enter_date... | [
"0.7718624",
"0.74047714",
"0.7254131",
"0.6943424",
"0.681888",
"0.6775938",
"0.6571638",
"0.65667284",
"0.6505889",
"0.6504818",
"0.6378474",
"0.6291643",
"0.6249938",
"0.61674076",
"0.61129284",
"0.61053425",
"0.6080972",
"0.6056492",
"0.60186255",
"0.5945199",
"0.5924336"... | 0.8515413 | 0 |
Unicode representation of Match History | def __str__(self):
return f"{str(self.team1)} vs {str(self.team2)} on {str(self.date)}" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toString(self) -> unicode:\n ...",
"def toString(self) -> unicode:\n ...",
"def __str__(self):\n return \"{}\".format(self._matches.keys())",
"def unicode(self, irc, msg, args, query):\n url = \"http://unicodelookup.com/lookup?\"\n url = url + urlencode({\"q\": query, \... | [
"0.5806015",
"0.5806015",
"0.5598331",
"0.5412658",
"0.53824925",
"0.53676164",
"0.5249685",
"0.5227061",
"0.51851416",
"0.5137522",
"0.5127437",
"0.51141953",
"0.5091751",
"0.50783116",
"0.50761265",
"0.50514686",
"0.5038033",
"0.50119203",
"0.50102234",
"0.4991699",
"0.4987... | 0.0 | -1 |
takes first row of tworow belief np array and converts it to dict indexed by label of positive beliefs | def np_to_belief(np_array,labels):
return dict((l,np_array[0,i]) for i,l in enumerate(labels)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_to_original_labels(array, threshold=0.5, initialization_value=999):\r\n \r\n binarized, belief = get_binarized_and_belief(array=array, threshold=threshold)\r\n \r\n #sanity check\r\n if binarized.shape != belief.shape:\r\n raise ValueError('Sanity check did not pass.')\r\n ... | [
"0.6541998",
"0.6310633",
"0.5895067",
"0.566295",
"0.5637139",
"0.5578173",
"0.55679846",
"0.55309737",
"0.54985076",
"0.5497383",
"0.54970396",
"0.5491054",
"0.5483852",
"0.5483852",
"0.54637516",
"0.54519457",
"0.5446611",
"0.5395349",
"0.53934413",
"0.53921664",
"0.538463... | 0.78097486 | 0 |
takes a list of votes and predicts based on threshold returns true iff fraction of true votes >= f | def thresh_vote(lst, f):
if len(lst) == 0: # guess 0 by default (appropriate for our dataset)
q = 0
else:
q = float(sum(lst)) / len(lst)
return q >= f | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def binary_predict(probs, threshold = 0.5):\n return (probs >= threshold) * np.ones(len(probs))",
"def sensitivity(\n targets: List[int], preds: List[float], threshold: float = 0.5\n) -> float:\n return recall(targets, preds, threshold)",
"def get_predict(prediction, threshold):\n\n prediction[predic... | [
"0.6548085",
"0.6381974",
"0.6354342",
"0.6264731",
"0.6184546",
"0.6126238",
"0.61081564",
"0.60839015",
"0.6067138",
"0.60335726",
"0.5974422",
"0.59717226",
"0.5970143",
"0.59656197",
"0.5960877",
"0.5954389",
"0.59533507",
"0.5947933",
"0.5928161",
"0.5925397",
"0.5925221... | 0.7472907 | 0 |
Takes dictionaries of predicted and ground truth and returns confusion matrix | def confusion_matrix(predicted, gt):
tp = [k for k in predicted if predicted[k] and gt[k]]
tn = [k for k in predicted if not predicted[k] and not gt[k]]
fp = [k for k in predicted if predicted[k] and not gt[k]]
fn = [k for k in predicted if not predicted [k] and gt[k]]
return tp, tn, fp, fn | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_confusion_matrix_intersection_mats(groundtruth, predicted):\n\n confusion_matrix_arrs = {}\n\n groundtruth_inverse = np.logical_not(groundtruth)\n predicted_inverse = np.logical_not(predicted)\n\n confusion_matrix_arrs['tp'] = np.logical_and(groundtruth, predicted)\n confusion_matrix_arrs['t... | [
"0.7215619",
"0.71285826",
"0.7120823",
"0.70471257",
"0.70212066",
"0.6992223",
"0.696946",
"0.6948753",
"0.6921117",
"0.69178545",
"0.6913209",
"0.69081",
"0.68527514",
"0.6760738",
"0.675917",
"0.6750563",
"0.6734669",
"0.6700748",
"0.6682267",
"0.6672295",
"0.66603005",
... | 0.72815716 | 0 |
Returns argmax, max of dictionary | def argmax(d):
return max(d.iteritems(), key=operator.itemgetter(1)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def argMax(self):\n if len(self.keys()) == 0: return None\n all = list(self.items())\n values = [x[1] for x in all]\n maxIndex = values.index(max(values))\n return all[maxIndex][0]",
"def argMax(self):\n if len(list(self.keys())) == 0:\n return None\n a... | [
"0.7893945",
"0.7893012",
"0.78599966",
"0.7807235",
"0.7397014",
"0.7194823",
"0.7194823",
"0.7194823",
"0.7170892",
"0.7158785",
"0.7147766",
"0.71402246",
"0.71295154",
"0.71241313",
"0.7121471",
"0.7005879",
"0.6961847",
"0.6961493",
"0.69519615",
"0.68631655",
"0.6839727... | 0.83839536 | 0 |
Produce nboot bootstrap samples from applying func to data | def bootstrap(data,func,nboot):
n = len(data)
resamples = np.array([[random.choice(data) for i in range(n)]
for j in range(nboot)])
return np.apply_along_axis(func, 1, resamples) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bootstrap(data):\r\n size = int(len(data))\r\n train = resample(data, n_samples=size, replace=True)\r\n test = data.drop(train.index) \r\n return train[encoded_features], train[target], test[encoded_features], test[target]",
"def bootstrap_replicate_1d(data, func):\r\n bs_sample = np.rand... | [
"0.7176311",
"0.71086556",
"0.7089425",
"0.7087817",
"0.7020718",
"0.68657595",
"0.6752474",
"0.6727999",
"0.6657717",
"0.63728184",
"0.62784743",
"0.62304413",
"0.62304413",
"0.61555386",
"0.60460633",
"0.6008815",
"0.6005979",
"0.6003459",
"0.59947544",
"0.5991532",
"0.5978... | 0.8077993 | 0 |
Split the dataset by features and labels | def split(
self,
df,
iteration_col,
episode_col,
iteration_order,
lagger_str,
current_row,
feature_cols,
label_cols,
augmented_cols,
):
logger.info(
f"Iteration order set to {iteration_order} so using {current_row} from {lagger_str} {iteration_order} row"
)
# We group by episode and iteration indices to make dataset episodic
df = df.sort_values(by=[episode_col, iteration_col])
# Create a lagged dataframe for capturing inputs and outputs
# when iteration_order < 0, this will consist of the features
# since we are doing a shift-backwards
# when iteration_order > 0, this will consist of labels
# since we are doing a shift-forward
lagged_df = df.groupby(by=episode_col, as_index=False).shift(
iteration_order * -1
)
lagged_df = lagged_df.drop([iteration_col], axis=1)
# if iteration order is less than 1
# then the actions, configs should not be lagged
# only states should be lagged
# features = lagged_df[states] + df[actions, configs]
# labels = df[states]
if iteration_order < 0:
features_df = lagged_df[feature_cols]
features_df[augmented_cols] = df[augmented_cols]
# if iteration order is greater than 1
# then features = states, actions, configs from current row (df)
# labels = states from next row (lagged_df)
else:
features_df = df[feature_cols]
# TODO: check, is this always redundant?
# i.e., is feature_cols is supset of augmented_cols
features_df[augmented_cols] = df[augmented_cols]
# eventually we will join the labels_df with the features_df
# if any columns are matching then rename them
if bool(set(feature_cols) & set(label_cols)):
features_df = features_df.rename(
columns=lambda x: "prev_" + x if x in label_cols else x
)
self.feature_cols = list(features_df.columns.values)
self.label_cols = list(label_cols)
logger.info(f"Feature columns are: {self.feature_cols}")
logger.info(f"Label columns are: {self.label_cols}")
# joined_df = df.join(features_df)
vars_to_keep = (
[episode_col, iteration_col] + self.feature_cols + self.label_cols
)
if iteration_order < 0:
labels_df = df[[episode_col, iteration_col] + self.label_cols]
else:
labels_df = df[[episode_col, iteration_col]].join(lagged_df[self.label_cols])
return labels_df.join(features_df)[vars_to_keep] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_data(data, labels):\r\n # Split the data into train and test\r\n X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.30, random_state = 42)\r\n return(X_train, y_train, X_test, y_test)",
"def split_dataset(instances, labels, train_split=0.8):\n split = int(train_sp... | [
"0.7630744",
"0.75351566",
"0.72341454",
"0.72143763",
"0.7188007",
"0.7188007",
"0.71554524",
"0.70676637",
"0.70484245",
"0.6948134",
"0.6905886",
"0.69033486",
"0.68980664",
"0.68860745",
"0.687833",
"0.687833",
"0.6874963",
"0.68439305",
"0.6804945",
"0.6803974",
"0.67803... | 0.0 | -1 |
Read episodic data where each row contains either inputs and its preceding output output or the causal inputs/outputs relationship | def read(
self,
df: pd.DataFrame,
iteration_order: int = -1,
episode_col: str = "episode",
iteration_col: str = "iteration",
feature_cols: List[str] = ["state_x_position"],
label_cols: List[str] = ["state_x_position"],
augmented_cols: List[str] = ["action_command"],
):
# CASE 1: rows are of the form {st+1, at}
# Append st into next row
# if iteration_order < 0 then drop the iteration - iteration_order iteration from each episode
# and append previous state columns into each row: {st+1, at} -> {st, at, st+1}
if all([episode_col, iteration_col, iteration_order < 0]):
lagger_str = "previous"
current_row = "inputs"
joined_df = self.split(
df,
iteration_col,
episode_col,
iteration_order,
lagger_str,
current_row,
feature_cols,
label_cols,
augmented_cols,
)
# skip the first row of each episode since we do not have its st
joined_df = (
joined_df.groupby(by=episode_col, as_index=False)
.apply(lambda x: x.iloc[iteration_order * -1 :])
.reset_index()
)
return joined_df.drop(["level_0", "level_1"], axis=1)
# CASE 2: rows of the form {st, at}
# Append st+1 from next row into current row {st, at, st+1}
elif all([episode_col, iteration_col, iteration_order > 0]):
lagger_str = "next"
current_row = "outputs"
joined_df = self.split(
df,
iteration_col,
episode_col,
iteration_order,
lagger_str,
current_row,
feature_cols,
label_cols,
augmented_cols,
)
# truncate before the end of iteration_order for complete observations only
joined_df = (
joined_df.groupby(by=episode_col, as_index=False)
.apply(lambda x: x.iloc[: iteration_order * -1])
.reset_index()
)
return joined_df.drop(["level_0", "level_1"], axis=1)
else:
return df | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_iers_EOP(input_file):\n #-- read data file splitting at line breaks\n with open(input_file,'r') as f:\n file_contents = f.read().splitlines()\n #-- number of data lines\n n_lines = len(file_contents)\n dinput = {}\n dinput['MJD'] = np.zeros((n_lines))\n dinput['x'] = np.zeros((... | [
"0.59410346",
"0.567626",
"0.5638466",
"0.55620134",
"0.55526614",
"0.5529649",
"0.54932714",
"0.54829437",
"0.5475036",
"0.5426845",
"0.5419794",
"0.5365769",
"0.5346987",
"0.5330866",
"0.5302111",
"0.52904403",
"0.5289346",
"0.527683",
"0.5269207",
"0.5269175",
"0.52437896"... | 0.55652803 | 3 |
trace finds the line, the filename and error message and returns it to the user | def trace():
import traceback
tb = sys.exc_info()[2]
tbinfo = traceback.format_tb(tb)[0]
# script name + line number
line = tbinfo.split(", ")[1]
# Get Python syntax error
#
synerror = traceback.format_exc().splitlines()[-1]
return line, __file__, synerror | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trace():\n import traceback, inspect\n tb = sys.exc_info()[2]\n tbinfo = traceback.format_tb(tb)[0]\n filename = inspect.getfile(inspect.currentframe())\n # script name + line number\n line = tbinfo.split(\", \")[1]\n # Get Python syntax error\n #\n synerror = traceback.format_exc().... | [
"0.7392801",
"0.7135186",
"0.6529018",
"0.63906014",
"0.6296253",
"0.6159555",
"0.6074369",
"0.6055162",
"0.6053701",
"0.60512197",
"0.60511047",
"0.60449284",
"0.6025194",
"0.5981327",
"0.5965538",
"0.592666",
"0.5902943",
"0.5831507",
"0.580618",
"0.5780158",
"0.57784814",
... | 0.7310826 | 1 |
Validates and ensures output workspace exists | def validate_workspace(wrksp):
try:
if wrksp.lower().endswith('.gdb') and \
os.path.isdir(wrksp) == False:
return arcpy.CreateFileGDB_management(out_folder_path=os.path.dirname(wrksp),
out_name=os.path.basename(wrksp))[0]
elif wrksp.lower().endswith('.sde') and \
os.path.isfile(wrksp) == False:
raise ValueError("SDE workspace must exist before using it.")
elif os.path.isdir(wrksp) == False:
os.makedirs(wrksp)
return wrksp
else:
return wrksp
except:
line, filename, synerror = trace()
raise FunctionError(
{
"function": "validate_workspace",
"line": line,
"filename": filename,
"synerror": synerror,
"arc" : str(arcpy.GetMessages(2))
}
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_missing_output_workspace(self):\n manifest = copy.deepcopy(job_test_utils.COMPLETE_MANIFEST)\n config = copy.deepcopy(self.configuration)\n config['output_workspaces'] = {}\n json_data = {\n 'manifest': manifest,\n 'configuration': config\n }\n\n ... | [
"0.6972508",
"0.65746725",
"0.65183914",
"0.6397043",
"0.6383192",
"0.6307421",
"0.60515106",
"0.60397726",
"0.5996995",
"0.5954663",
"0.5945204",
"0.59358025",
"0.58788586",
"0.58496416",
"0.58496416",
"0.577803",
"0.572291",
"0.56724334",
"0.5628311",
"0.56132805",
"0.55874... | 0.6396854 | 4 |
Adds the required columns to the table and appends new records if given. | def extend_table(table, rows=None):
try:
if rows is None:
rows = []
dtypes = np.dtype(
[
('_ID', np.int),
('MEAN_DEF_CNT', np.float64),
('MEDIAN_DEF_CNT', np.int32),
('MIN_DEF_CNT', np.int32),
('MAX_DEF_CNT', np.int32),
#STandard deviation
('PRI_NUM_DEF', np.int32),
('SEC_NUM_DEF', np.int32),
('PER_PRI', np.float64),
('PER_SEC', np.float64),
("PRI_ATTR_DEF", '|S20'), # pri_attr
("SEC_ATTR_DEF", '|S20'),
('PRI_ATTR_DEF_PER', np.float64),
('SEC_ATTR_DEF_PER', np.float64),
('FEATURE_CNT', np.int32),
('PRI_ATTR_DEF_CNT', np.float64),
('SEC_ATTR_DEF_CNT', np.float64),
('LC_SCORE', np.int32)
]
)
array = np.array(rows, dtypes)
da.ExtendTable(table, "OID@", array, "_ID", False)
return table
except:
line, filename, synerror = trace()
raise FunctionError(
{
"function": "extend_table",
"line": line,
"filename": filename,
"synerror": synerror,
"arc" : str(arcpy.GetMessages(2))
}
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_cols(self, source) :\n\n cols = source.get_cols()\n types = source.get_types()\n\n new_cols = []\n new_types = []\n for i in range(len(cols)) :\n if cols[i] not in self.cols :\n new_cols.append(cols[i])\n new_types.append(typ... | [
"0.6977524",
"0.66601425",
"0.6458155",
"0.63593054",
"0.6348672",
"0.63241756",
"0.63117015",
"0.62366897",
"0.62343997",
"0.6218119",
"0.61731595",
"0.61588264",
"0.60610455",
"0.6052164",
"0.6035236",
"0.60302246",
"0.5991479",
"0.59869546",
"0.5986548",
"0.5966985",
"0.58... | 0.0 | -1 |
main driver of program | def main(*argv):
try:
attr_features = argv[0]
sql_clause = argv[1]
polygon_grid = argv[2]
error_field_count = str(argv[3]) #'NULL_COUNT'#
error_field_def = str(argv[4]) #'NULL_COLUMNS'#
output_fc = argv[5]
out_fc_exists = arcpy.Exists(output_fc)
# Local Variable
#
scratchFolder = env.scratchFolder
scratchGDB = env.scratchGDB
results = []
# Logic
#
if not out_fc_exists:
output_gdb = validate_workspace(os.path.dirname(output_fc))
# Create the grid
#
out_grid = arcpy.CopyFeatures_management(polygon_grid, output_fc)[0]
out_grid = extend_table(out_grid)
where_clause=None
else:
arcpy.MakeFeatureLayer_management(output_fc, "lyr")
arcpy.SelectLayerByLocation_management("lyr", "HAVE_THEIR_CENTER_IN", polygon_grid)
oids = [row[0] for row in arcpy.da.SearchCursor("lyr", "OID@")]
if len(oids) >1:
oids_string = str(tuple(oids))
else:
oids_string = str('('+ str(oids[0]) + ')')
where_clause = 'OBJECTID IN ' + oids_string
error_field = (error_field_def, error_field_count)
# Process the Data
#
poly_desc = arcpy.Describe(output_fc)
fc_desc = arcpy.Describe(attr_features)
if poly_desc.extent.within(fc_desc.extent):
temp_fc = 'in_memory/clip'
arcpy.AddMessage('Clipping features to polygon')
arcpy.Clip_analysis(attr_features, output_fc, temp_fc)
arcpy.AddMessage('Created in_memory fc')
#data_sdf = geomotion.SpatialDataFrame.from_featureclass(temp_fc,
# fields=[value_field])
if sql_clause:
attr_sdf = SpatialDataFrame.from_featureclass(temp_fc,
fields=error_field,
where_clause=sql_clause)
else:
attr_sdf = SpatialDataFrame.from_featureclass(temp_fc,
fields=error_field)
arcpy.AddMessage('features read into spatial dataframe after clipping')
else:
#data_sdf = geomotion.SpatialDataFrame.from_featureclass(, fields=[value_field])
arcpy.AddMessage('features read into spatial dataframe without clipping')
if sql_clause:
attr_sdf = SpatialDataFrame.from_featureclass(attr_features,
fields=error_field,
where_clause=sql_clause)
else:
attr_sdf = SpatialDataFrame.from_featureclass(attr_features,
fields=error_field)
grid_sdf = SpatialDataFrame.from_featureclass(filename=output_fc,
where_clause=where_clause)
index = attr_sdf.sindex
for idx, row in enumerate(grid_sdf.iterrows()):
errors = []
attrs = []
geom = row[1].SHAPE
oid = row[1].OBJECTID
print(str(oid))
ext = [geom.extent.lowerLeft.X, geom.extent.lowerLeft.Y,
geom.extent.upperRight.X, geom.extent.upperRight.Y]
row_oids = list(index.intersect(ext))
df_current = attr_sdf.loc[row_oids]#.copy()
sq = df_current.geometry.disjoint(geom) == False
fcount = len(df_current[sq]) # Total Count
q2 = df_current[error_field_count] > 0
#& q2
df_current = df_current[sq].copy() # Get the # of features with deficiency_cnt > 0
#print("here")
if fcount>0: #len(df_current) > 0:
errors += df_current[error_field_count].tolist()
arcpy.AddMessage(str(errors))
def process(x):
print(x)
return [va for va in x.replace(' ', '').split('|')[-1].split(',') if len(va) > 1]
for e in df_current[error_field_def].apply(process).tolist():
attrs += e
del e
row = get_answers(oid=oid,
err=errors,
attr=attrs,
feature_count=fcount)
results.append(row)
if len(results) > 250:
extend_table(table=output_fc, rows=results)
results = []
del idx
del row
del errors
del attrs
del geom
del oid
del ext
del row_oids
del df_current
del sq
del q2
if len(results) > 0:
extend_table(table=output_fc, rows=results)
del index
del results
del grid_sdf
del attr_sdf
except arcpy.ExecuteError:
line, filename, synerror = trace()
arcpy.AddError("error on line: %s" % line)
arcpy.AddError("error in file name: %s" % filename)
arcpy.AddError("with error message: %s" % synerror)
arcpy.AddError("ArcPy Error Message: %s" % arcpy.GetMessages(2))
except FunctionError as f_e:
messages = f_e.args[0]
arcpy.AddError("error in function: %s" % messages["function"])
arcpy.AddError("error on line: %s" % messages["line"])
arcpy.AddError("error in file name: %s" % messages["filename"])
arcpy.AddError("with error message: %s" % messages["synerror"])
arcpy.AddError("ArcPy Error Message: %s" % messages["arc"])
except:
line, filename, synerror = trace()
arcpy.AddError("error on line: %s" % line)
arcpy.AddError("error in file name: %s" % filename)
arcpy.AddError("with error message: %s" % synerror) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n pass",
"def main():\n run_program()",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main()... | [
"0.8577987",
"0.85386586",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
"0.8478492",
... | 0.0 | -1 |
The constructor of the class. Here you will need to create the attributes ("instance variables") that were described in the docstring. Note that some of the attributes are defined by parameters passed to this constructor method, but others are not. | def __init__(self, name, full_name, team, eye_color, hair_color, base):
self.name = name
self.full_name = full_name
self.team = team
self.eye_color = eye_color
self.hair_color = hair_color
self.base = base
self.powers = []
self.nemeses = [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, **kwds):\n raise NotImplementedError",
"def __init__(self) -> None:\n # TODO: Provide the complete constructor for this object",
"def __init__(self, *args, **kwargs) -> None:\n pass",
"def __init__(self, *args, **kwargs) -> None:\n pass",
"def __init__(self, *... | [
"0.795267",
"0.78457487",
"0.7731138",
"0.7731138",
"0.7643051",
"0.76117766",
"0.7513325",
"0.7513325",
"0.7513325",
"0.7513325",
"0.7501279",
"0.7501279",
"0.7501279",
"0.7375516",
"0.73525584",
"0.7352199",
"0.73369604",
"0.7306995",
"0.7306995",
"0.7306995",
"0.7300619",
... | 0.0 | -1 |
This is the string method for the class. Whenever an instance of is passed to the str() or print() functions, the return string from this method will be returned. Fill in the instance attributes that are outlined by the characters in the variable. | def __str__(self):
description = f"{self.name} is a member of the {self.team} and possesses the following powers:\n{self.powers}"
return description | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n # print(self.get_string())\n return self.get_string()",
"def __str__(self):\n # print(self.get_string())\n return self.get_string()",
"def __str__(self):\n return self.printable()",
"def __str__(self):\n if self.f_has_range():\n lenstr... | [
"0.77815866",
"0.77815866",
"0.7584849",
"0.74873406",
"0.7468666",
"0.74566126",
"0.7438483",
"0.7398238",
"0.73615706",
"0.7347233",
"0.7347233",
"0.7347233",
"0.7347233",
"0.7336336",
"0.7325533",
"0.7299921",
"0.7297643",
"0.7283104",
"0.72561014",
"0.72357535",
"0.723286... | 0.0 | -1 |
This method will modify the attribute by appending the parameter to it. | def add_power(self, power):
self.powers.append(power) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __setattr__(self, name, value):\n if name in ['parameters', 'program_name']: # Allowed attributes\n self.__dict__[name] = value\n else:\n self.set_parameter(name, value) # treat as a parameter",
"def put_param(self, attr_name, val):\n self._params[attr_name] = val"... | [
"0.6987088",
"0.6885637",
"0.6829756",
"0.6731595",
"0.67283607",
"0.67017716",
"0.66079473",
"0.6570364",
"0.6501009",
"0.64624107",
"0.6447641",
"0.64455295",
"0.64400303",
"0.64285815",
"0.6388802",
"0.6383218",
"0.637725",
"0.63599354",
"0.63599354",
"0.63599354",
"0.6348... | 0.0 | -1 |
This method will modify the attribute by appending the parameter to it. | def add_nemesis(self, nemesis):
self.nemeses.append(nemesis) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __setattr__(self, name, value):\n if name in ['parameters', 'program_name']: # Allowed attributes\n self.__dict__[name] = value\n else:\n self.set_parameter(name, value) # treat as a parameter",
"def put_param(self, attr_name, val):\n self._params[attr_name] = val"... | [
"0.6987088",
"0.6885637",
"0.6829756",
"0.6731595",
"0.67283607",
"0.67017716",
"0.66079473",
"0.6570364",
"0.6501009",
"0.64624107",
"0.6447641",
"0.64455295",
"0.64400303",
"0.64285815",
"0.6388802",
"0.6383218",
"0.637725",
"0.63599354",
"0.63599354",
"0.63599354",
"0.6348... | 0.0 | -1 |
THIS SHOULD LOOK FAMILIAR, SO WE PROVIDED IT FOR YOU. This function reads a .csv file and parses it into a list of dictionaries, where each dictionary is formed from the data on one line of the .csv file. This function takes one argument , which is the path of the file to be read. You will need to use the "csv" module in this function. | def read_csv_file(input_filepath):
out_list = []
with open(input_filepath, 'r', encoding = 'utf-8') as f:
reader = csv.reader(f)
for i,row in enumerate(reader):
if i == 0:
labels = row
else:
new_dict = {}
for j,value in enumerate(row):
new_dict[labels[j]] = value
out_list.append(new_dict)
return out_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_csv_as_dicts(csv_input_file_name):\n input_table = read_csv_as_table(csv_input_file_name, skip_first_line=False)\n\n # first line should contain headers\n header = input_table[0]\n # rest lines would contain actual data\n data = input_table[1:]\n\n output = []\n # process all lines wi... | [
"0.7621891",
"0.7575346",
"0.74887645",
"0.7393947",
"0.7317759",
"0.73076624",
"0.7262524",
"0.72616434",
"0.71987087",
"0.71802855",
"0.71753365",
"0.7114956",
"0.7059726",
"0.70039433",
"0.6988675",
"0.6970228",
"0.6970228",
"0.6946911",
"0.694326",
"0.6926613",
"0.690651"... | 0.67380226 | 40 |
This function takes any , converts it into a string via the str() function (if possible), and then writes it to a file located at . Note that this function is a general writing function. It should not use the .csv module, but rather the python write() function. This is because we want this function to write ANYTHING we give it as the parameter (in the case of this assignement, you will actually use it to write string representations of the class instances you create). | def write_to_file(filepath, data):
with open(filepath, 'w') as f:
f.write(str(data)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def writeToCSV(self, filepath):\r\n\t\twith open(filepath, 'w') as outputFile:\r\n\t\t\toutputFile.write(str(self))",
"def export_to_file(data, filename='class_data.txt', mode='a'):\n with open (filename, mode) as f:\n if mode == \"w\":\n for record in data:\n line = \",\".joi... | [
"0.6876169",
"0.6498835",
"0.63612753",
"0.6353106",
"0.633464",
"0.62842685",
"0.61852163",
"0.60895437",
"0.6051628",
"0.6050783",
"0.60384357",
"0.60274184",
"0.59963906",
"0.5985917",
"0.59784335",
"0.5975056",
"0.596307",
"0.59575045",
"0.59389687",
"0.5937647",
"0.59298... | 0.5933413 | 20 |
In this function, you will instantiate several times, given the data provided. Then, you will open "sh_additional_info.csv" and for each line in that file, perform an operation using one of the methods of one of your classes. Follow the commented instructions in this main() function. Refer to Problem Set 07 README.md for instructions and tips. | def main():
# Refer to Problem Set 07 README.md for instructions and tips.
# 6.1: Read in < sh_basic_info.csv >
basic_info = read_csv_file('sh_basic_info.csv')
# 6.2: Create instances of < SuperHeroine >
heroines = {}
for hero in basic_info:
heroines[hero['name']] = SuperHeroine(hero['name'], hero['full_name'], hero['team'],
hero['eye_color'], hero['hair_color'], hero['base'])
print(heroines)
# 6.3: Read in < sh_additional_info.csv >
additional_info = read_csv_file('sh_additional_info.csv')
# 6.4: Add powers and nemesis
for row in additional_info:
name = row["Heroine Name"]
instance_affected = heroines[name]
how_affected = row["Category"]
value = row['Value']
if how_affected == 'power':
instance_affected.add_power(value)
else:
instance_affected.add_nemesis(value)
# 6.5: Write to file
write_to_file('storm.txt',heroines['Storm'])
write_to_file('scarlet_witch.txt',heroines['Scarlet Witch'])
write_to_file('jessica_jones.txt',heroines['Jessica Jones']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n raw_data = pd.read_csv('data/raw_hospital_data.csv')\n\n fe_data = new_features(raw_data)\n fe_data = compressing_admission_type(data)\n fe_data = age_to_cat(fe_data)\n fe_data = compressing_careunit(fe_data)\n fe_data = compressing_curr_serv(fe_data)\n fe_data = compressing_ethn... | [
"0.6210108",
"0.60456717",
"0.60032433",
"0.5947413",
"0.5876277",
"0.58508295",
"0.58461136",
"0.5834677",
"0.57999545",
"0.57364744",
"0.5730089",
"0.57000756",
"0.5691697",
"0.5639754",
"0.5626317",
"0.56223726",
"0.55977935",
"0.55886185",
"0.5551414",
"0.55287653",
"0.55... | 0.6953013 | 0 |
Run a raw GraphQL query | def query(output, query):
gqlapi = gql.get_api()
print_output(output, gqlapi.query(query)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_graphql(raw_query, endpoint):\n query = \" \".join(shlex.split(raw_query, posix=False))\n r = requests.get(endpoint, params={\"query\": query})\n if r.status_code == 200:\n return r.json()\n elif r.status_code == 400:\n response = r.json()\n assert \"errors\" in response\... | [
"0.7544899",
"0.68699944",
"0.6803751",
"0.67968833",
"0.661308",
"0.65708804",
"0.65654963",
"0.6560553",
"0.65150213",
"0.65003735",
"0.6493559",
"0.64276546",
"0.6414967",
"0.63659316",
"0.63526833",
"0.63463426",
"0.63447905",
"0.6304541",
"0.6291603",
"0.629144",
"0.6272... | 0.6531391 | 8 |
passing in event_loop helps avoid 'attached to a different loop' error | def test_app(event_loop):
app.finalize()
app.conf.store = "memory://"
app.flow_control.resume()
return app | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def event_loop(self):\n logging.warning('loop undefined')",
"def dispatch_loop(self):\n pass",
"def check_event_loop():\n loop = asyncio.get_event_loop()\n if loop.is_closed():\n asyncio.set_event_loop(asyncio.new_event_loop())",
"def _handle_loop(self):\n pass",
"... | [
"0.81281793",
"0.7433964",
"0.71915084",
"0.71593684",
"0.7092627",
"0.70529735",
"0.70341283",
"0.70070803",
"0.69741666",
"0.69741666",
"0.69633144",
"0.69001657",
"0.6889111",
"0.6859079",
"0.6846811",
"0.6844431",
"0.68335426",
"0.68281376",
"0.6722399",
"0.6682619",
"0.6... | 0.0 | -1 |
Updates x, y (memoryshared) coordinates with actual mouse position with a given frequency. | def stream(bus, address, frequency, x, y, stop_trigger):
mouse = Mouse.list_connected(bus=bus, address=address)[0]
delay = 1./frequency
while not stop_trigger:
x1, y1 = mouse.get_position_change()
x.value += x1
y.value += y1
time.sleep(delay) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def follow(self):\n\t\tpos = pygame.mouse.get_pos()\n\t\tself.x = pos[0]\n\t\tself.y = pos[1]\n\t\tself.draw()",
"def mouse_position_event(self, x: int, y: int):\n pass",
"def update_pointer(self):\n pointer_length = -self.pointer_frac * self.radius\n # Add pi/2 to the angle because we con... | [
"0.5839249",
"0.57032055",
"0.5696799",
"0.56878513",
"0.5680848",
"0.56477594",
"0.5643513",
"0.56162447",
"0.5613641",
"0.56051666",
"0.558602",
"0.55699193",
"0.5541605",
"0.5541605",
"0.5534065",
"0.5533534",
"0.5528136",
"0.5512954",
"0.5495194",
"0.54931223",
"0.548661"... | 0.6736627 | 0 |
Returns the focal length of the telescope. | def focal_length(self):
return self.f * self.diameter | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def estimate_focal_length(self):\n fl = (self.fiber_diameter / 2) / np.tan(np.deg2rad(self.fov / 2))\n\n return fl",
"def length(self) -> ir.FloatingValue:\n return ops.GeoLength(self).to_expr()",
"def bspb_focalLength():\n shotCam = pm.PyNode('shot_cam').getShape()\n return str(shot... | [
"0.7237808",
"0.6786899",
"0.6465912",
"0.63727885",
"0.6352939",
"0.62659967",
"0.61646885",
"0.616444",
"0.61160403",
"0.6020924",
"0.5934602",
"0.5932981",
"0.59197545",
"0.5891779",
"0.588042",
"0.58679926",
"0.584611",
"0.58384174",
"0.58230686",
"0.5822641",
"0.5822641"... | 0.8241378 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.