1e-10 :\\n print 'difference in hamiltonian row: ' , det[0]+'|'+det[1] , \\\" col: \\\" , det2[0]+'|'+det2[1] , 'fci: ', ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) , 'fciaddres: ' , ciffcipar.get_mat_element(det[0]+'|'+det[1],det2[0]+'|'+det2[1]) \\n count += 1\\n print 'There were ' , count , ' different elements'\",\n \"def main():\\n # First grab data from db\\n engine = create_engine(\\\"sqlite:///cities.db\\\")\\n session = Session(bind=engine)\\n # Grab all data from flat stats table\\n query = session.query(FlatStat).all()\\n\\n X = transform_to_np_array(query)\\n\\n # Run dbscan now\\n results = DBSCAN(eps=2, min_samples=10).fit(X)\\n\\n # TODO: get matplotlib in here, but for now, just print all properties of dbscan\\n print(results.__dict__)\",\n \"def qa_test():\\r\\n # Reads Code and Runs Code Metrics\\r\\n with open(\\\"BrainDataVisualiser.py\\\",\\\"r\\\") as file:\\r\\n code = file.read()\\r\\n with open(\\\"QA_LOGS.txt\\\",\\\"a\\\") as file:\\r\\n # Timestamp and append metric results to log\\r\\n file.write(datetime.date.today().strftime(\\\"%b-%d-%Y\\\")+\\\"\\\\n\\\\t\\\")\\r\\n file.write(\\\"General Analysis\\\\n\\\\t\\\\t\\\")\\r\\n file.write(str(analyze(code))+\\\"\\\\n\\\\t\\\")\\r\\n file.write(\\\"Cyclomatic Complexity\\\\n\\\")\\r\\n for i in cc_visit(code):\\r\\n file.write(\\\"\\\\t\\\\t\\\"+cc_rank(i.complexity)+\\\" \\\"+str(i)+\\\"\\\\n\\\")\",\n \"def analyse ( self ) :\\n odin = self.get( self.RootInTES + 'DAQ/ODIN' )\\n \\n ## Check for PVs\\n PVs = self.get( self.RootInTES + self.InputPrimaryVertices )\\n if not PVs or PVs.size() == 0:\\n self.setFilterPassed( False )\\n return SUCCESS\\n\\n ## get recontructed B+ mesons\\n Bs = self.select ( 'B' , eval( self._cut % self._selection ) )\\n \\n if not Bs or Bs.size() == 0:\\n self.setFilterPassed( False )\\n return SUCCESS \\n\\n ## Select random candidate\\n r = self.random( odin )\\n n = Bs.size()\\n for i in xrange( n ):\\n if r <= ( float( i ) / float( n ) ): break\\n B = Bs[ i ]\\n \\n tisTos = self.tisTosSignal( B, \\\"Hlt1Track(AllL0|Muon)Decision\\\" )\\n if tisTos.tos():\\n ## This has to be a clone, otherwise it doesn't work...\\n self.markParticle( B.clone() )\\n self.setFilterPassed( True )\\n else:\\n self.setFilterPassed( False )\\n\\n return SUCCESS\",\n \"def main(args):\\n \\n ## Load & Preprocess data \\n if args.data_name == 'amsterdam': \\n file_name = '../data/amsterdam/test_longitudinal_data.csv'\\n ori_data = data_preprocess(file_name, args.max_seq_len)\\n \\n # Divide the data into training and testing\\n divided_data, _ = data_division(ori_data, seed = args.seed, divide_rates = [args.train_rate, 1-args.train_rate])\\n \\n train_data = np.asarray(divided_data[0])\\n test_data = np.asarray(divided_data[1])\\n\\n print('Finish data loading: ' + str(args.data_name)) \\n \\n ## Run hider algorithm\\n if args.hider_model == 'timegan':\\n generated_data = timegan.timegan(train_data)\\n elif args.hider_model == 'add_noise':\\n generated_data = add_noise.add_noise(train_data, args.noise_size) \\n print('Finish hider algorithm training') \\n \\n ## Define enlarge data and its labels\\n enlarge_data = np.concatenate((train_data, test_data), axis = 0)\\n enlarge_data_label = np.concatenate((np.ones([train_data.shape[0],]), np.zeros([test_data.shape[0],])), axis = 0)\\n \\n # Mix the order\\n idx = np.random.permutation(enlarge_data.shape[0])\\n enlarge_data = enlarge_data[idx]\\n enlarge_data_label = enlarge_data_label[idx]\\n \\n ## Run seeker algorithm\\n reidentified_data = knn_seeker(generated_data, enlarge_data)\\n \\n print('Finish seeker algorithm training') \\n \\n ## Evaluate the performance\\n # 1. Feature prediction\\n feat_idx = np.random.permutation(train_data.shape[2])[:args.feature_prediction_no]\\n ori_feat_pred_perf = feature_prediction(train_data, test_data, feat_idx)\\n new_feat_pred_perf = feature_prediction(generated_data, test_data, feat_idx)\\n \\n feat_pred = [ori_feat_pred_perf, new_feat_pred_perf]\\n \\n print('Feature prediction results: ' + \\n '(1) Ori: ' + str(np.round(ori_feat_pred_perf, 4)) + \\n '(2) New: ' + str(np.round(new_feat_pred_perf, 4)))\\n \\n # 2. One step ahead prediction\\n ori_step_ahead_pred_perf = one_step_ahead_prediction(train_data, test_data)\\n new_step_ahead_pred_perf = one_step_ahead_prediction(generated_data, test_data)\\n \\n step_ahead_pred = [ori_step_ahead_pred_perf, new_step_ahead_pred_perf]\\n \\n print('One step ahead prediction results: ' + \\n '(1) Ori: ' + str(np.round(ori_step_ahead_pred_perf, 4)) + \\n '(2) New: ' + str(np.round(new_step_ahead_pred_perf, 4)))\\n \\n # 3. Reidentification score\\n reidentification_score = reidentify_score(enlarge_data_label, reidentified_data)\\n \\n print('Reidentification score: ' + str(np.round(reidentification_score, 4)))\\n \\n shutil.rmtree('tmp')\\n \\n return feat_pred, step_ahead_pred, reidentification_score\",\n \"def analyze(self, event):\\n jets = self.inputCollection(event)\\n \\n predictionsPerCtauAndClass = {ctau: {className: [] for className in self.predictionLabels} for ctau in self.logctauValues}\\n for ijet,jet in enumerate(jets):\\n if not hasattr(jet,self.taggerName):\\n print \\\"WARNING - jet \\\",jet,\\\" has no \\\",self.taggerName,\\\" result stored for \\\",self.outputName,\\\" -> skip\\\"\\n continue\\n predictions = getattr(jet,self.taggerName)\\n for ctau in self.logctauValues:\\n for label in self.predictionLabels:\\n predictionsPerCtauAndClass[ctau][label].append(predictions[ctau][label])\\n \\n for ctau in self.logctauValues:\\n for label in self.predictionLabels:\\n predictionsPerCtauAndClass[ctau][label] = sorted(predictionsPerCtauAndClass[ctau][label],reverse=True)\\n\\n for m in self.multiplicities:\\n if m<len(predictionsPerCtauAndClass[ctau][label]):\\n self.out.fillBranch(self.outputName+\\\"_\\\"+getCtauLabel(ctau)+\\\"_\\\"+label+\\\"_min\\\"+str(m),predictionsPerCtauAndClass[ctau][label][m])\\n else:\\n self.out.fillBranch(self.outputName+\\\"_\\\"+getCtauLabel(ctau)+\\\"_\\\"+label+\\\"_min\\\"+str(m),0)\\n \\n \\n return True\",\n \"def main():\\n \\n Y1, Y2 = 2005, 2017 ### range with coordinates supplied in pre-2018 generated archive\\n\\n if len(sys.argv) > 1 and int(sys.argv[1]) > 0:\\n Y1 = int(sys.argv[1])\\n \\n if len(sys.argv) > 2 and int(sys.argv[2]) > Y1:\\n Y2 = int(sys.argv[2])\\n \\n with open('data/audit.log','w') as output:\\n for Y in range(Y1, Y2):\\n df = pd.read_csv('data/{}.csv'.format(Y), low_memory = False)\\n output.write('\\\\n--- {} --------------------\\\\n'.format(Y))\\n\\n # remove `deleted` records\\n df['deleted'] = df['deleted'].apply(yes_no)\\n df = df[df['deleted'] == 0]\\n\\n # remove misc misdemeanors\\n df = df[~df['category'].isin(drop)]\\n\\n # validate date and expand into Y,N,D,W,H\\n df['dt'] = df['incident_date'].apply(extract)\\n df = df[~df['dt'].isnull()]\\n\\n # convert from plane state to longitude-latitude\\n df['ll'] = df.apply(to_lnglat, axis = 1)\\n\\n # init features\\n features = df.loc[:,['category','stat','address','city','zip']]\\n features['id'] = df['incident_id']\\n dt = ['year','month','day','weekday','hour']\\n for i in range(len(dt)):\\n features[dt[i]] = df['dt'].apply(lambda x: x[i] )\\n\\n features['lng'] = df['ll'].apply(lambda x: x[0])\\n features['lat'] = df['ll'].apply(lambda x: x[1])\\n\\n features['gang'] = df['gang_related'].apply(yes_no)\\n features['category'] = df['category'].apply(collapse)\\n cat = set(features.groupby(['category']).size().reset_index(name='count')['category'].tolist())\\n output.write('Categories: {}\\\\n'.format(len(cat)))\\n\\n output.write('Date miss: {:.4f}%\\\\n'\\\\\\n .format(100 * (1 - len(features[(features['year'] > 2000) & (~features['weekday'].isnull())])/len(features))))\\n output.write('Location miss: {:.4f}%\\\\n'\\\\\\n .format(100 * (1 - len(features[(features['zip'] > 0) | (features['lat'] > 0)])/len(features))))\\n\\n # keep records with valid date\\n features['date'] = df['dt'].apply(lambda x: datetime.date(x[0], x[1], x[2]))\\n features = features[(features['year'] > 2000) & (~features['weekday'].isnull())]\\n output.write('Time miss: {:.4f}%\\\\n'.format(100 * len(features[features['hour'] == -1])/len(features)))\\n\\n # potential `time-unknown` issue\\n output.write('Hour ZERO: {:.4f}%\\\\n'.format(100 * len(features[features['hour'] == 0])/len(features)))\\n output.write('Hour NOON: {:.4f}%\\\\n'.format(100 * len(features[features['hour'] == 12])/len(features)))\\n\\n features = features[(features['zip'] > 0) | (features['lat'] > 0)]\\n\\n # get the best possible coordinates + zipcode assessment\\n features[['zip','lng','lat']] = features[['zip','lng','lat']].apply(fix_location, axis = 1)\\n output.write('Failed location: {:.4f}%\\\\n'.format(100 * len(features[features['zip'].isnull()])/len(features)))\\n features = features[~features['zip'].isnull()]\\n features['zip'] = df['zip'].apply(lambda x: str(x)[:5])\\n \\n # normalize city attr\\n features = features.join(zipcodes[['zip','city']].set_index('zip'), on = 'zip', lsuffix = '_orig', rsuffix = '')\\n features.loc[features['city'].isnull(), 'city'] = features.loc[features['city'].isnull(), 'city_orig']\\\\\\n .apply(lambda x: x if type(x) == float else ' '.join([l[0].upper() + l[1:] for l in x.split()]))\\n\\n # reduce to LA bounding-box\\n features = features[(features['lng'] > -119) & (features['lng'] < -116)]\\n features = features[(features['lat'] > 32) & (features['lat'] < 35)]\\n\\n # save csv\\n features[fields].to_csv('data/F{}.csv'.format(Y), index = False)\\n features[fields].to_json('data/F{}.json'.format(Y), orient = 'records')\\n output.close()\",\n \"def test_output(self, test_data):\\n for finput in test_data[\\\"EKFSLAM.EKFSLAM.h_jac\\\"]:\\n params = tuple(finput.values())\\n\\n self_1, eta_1 = deepcopy(params)\\n\\n self_2, eta_2 = deepcopy(params)\\n\\n H_1 = EKFSLAM.EKFSLAM.h_jac(self_1, eta_1)\\n\\n H_2 = solution.EKFSLAM.EKFSLAM.h_jac(self_2, eta_2)\\n \\n assert compare(H_1, H_2)\\n \\n assert compare(self_1, self_2)\\n assert compare(eta_1, eta_2)\",\n \"def test(indices_to_visit = None):\\n ##0 Chicago\\n ##1 New York City\\n ##2 Los Angeles\\n ##3 Minneapolis\\n ##4 Denver\\n ##5 Dallas\\n ##6 Seattle\\n ##7 Boston\\n ##8 San Francisco\\n ##9 St. Louis\\n ##10 Houston\\n ##11 Phoenix\\n ##12 Salt Lake City\\n ##13 Miami\\n ##14 Atlanta\\n ##15 Kansas City\\n home_index = 15 # Kansas city\\n # 15x15 matrix with main diagonal consisting of 0s and to which data is mirrored along\\n # (values are derived from external resource and multiplied by 1000 for higher accuracy)\\n matrix = np.array([[0.0, 1148413.3550047704, 2813453.6297408855, 572861.4368351421, 1483440.7452179305, 1296355.2188721865, 2801269.1215845253, 1370943.3069385102, 2996683.256068982, 422589.4697157836, 1515737.0196676727, 2343639.7107855356, 2031500.319603397, 1913900.3015914203, 946854.1020487415, 665894.0336505901],\\n [1148413.3550047704, 0.0, 3949451.153672887, 1642119.4792808082, 2628946.6435325537, 2212019.1209020815, 3882177.952930788, 306997.0343229422, 4144977.810718553, 1408454.3261387087, 2286054.8575902223, 3455343.3108375454, 3179102.5335818897, 1754834.3710577146, 1202616.154562711, 1766599.1336905772],\\n [2813453.6297408855, 3949451.153672887, 0.0, 2455296.3791196346, 1339227.410707824, 1998182.1420783552, 1545364.434045008, 4184394.186016967, 559978.4273194656, 2560790.9591738936, 2212581.51715849, 575975.8749662543, 933602.6426595236, 3767490.41517038, 3120118.850020503, 2186473.1552241463],\\n [572861.4368351421, 1642119.4792808082, 2455296.3791196346, 0.0, 1127312.7583590776, 1390159.7734006236, 2249169.1308160927, 1811513.5290266906, 2554165.8167895717, 750916.7305340832, 1701189.1538312144, 2062079.2399570548, 1590460.9488364782, 2434801.332310659, 1462408.5353501518, 662752.1291133759],\\n [1483440.7452179305, 2628946.6435325537, 1339227.410707824, 1127312.7583590776, 0.0, 1067257.7993323756, 1646308.7967673023, 2852307.4164419994, 1530510.2790658756, 1283707.511393525, 1414308.8805983758, 943721.1931707633, 598728.757362067, 2779561.192116527, 1952618.0544916363, 899656.1020173575],\\n [1296355.2188721865, 2212019.1209020815, 1998182.1420783552, 1390159.7734006236, 1067257.7993323756, 0.0, 2709804.112590561, 2500314.4507069485, 2390841.4329337194, 882457.80942383, 361482.7025425731, 1427995.4150203674, 1610768.421819668, 1788903.6065106322, 1161480.3557326929, 730446.8613086065],\\n [2801269.1215845253, 3882177.952930788, 1545364.434045008, 2249169.1308160927, 1646308.7967673023, 2709804.112590561, 0.0, 4018059.834330202, 1093104.7332788548, 2778905.575804111, 3046648.362755992, 1794989.6453295103, 1129464.5539648102, 4404737.747850686, 3516794.375197078, 2427457.036285458],\\n [1370943.3069385102, 306997.0343229422, 4184394.186016967, 1811513.5290266906, 2852307.4164419994, 2500314.4507069485, 4018059.834330202, 0.0, 4350710.853063807, 1673216.4080939887, 2586942.3262796295, 3706392.097841614, 3382851.415271485, 2022974.6418062754, 1509585.60107986, 2015770.1390589625],\\n [2996683.256068982, 4144977.810718553, 559978.4273194656, 2554165.8167895717, 1530510.2790658756, 2390841.4329337194, 1093104.7332788548, 4350710.853063807, 0.0, 2812916.3098878833, 2650547.941880299, 1053620.7288649315, 967859.8344376946, 4179636.203479384, 3448359.745690545, 2428862.4239271535],\\n [422589.4697157836, 1408454.3261387087, 2560790.9591738936, 750916.7305340832, 1283707.511393525, 882457.80942383, 2778905.575804111, 1673216.4080939887, 2812916.3098878833, 0.0, 1093601.4408876144, 2050115.5214378452, 1872971.1741522516, 1708236.6189296674, 752855.8488125347, 384122.2000072272],\\n [1515737.0196676727, 2286054.8575902223, 2212581.51715849, 1701189.1538312144, 1414308.8805983758, 361482.7025425731, 3046648.362755992, 2586942.3262796295, 2650547.941880299, 1093601.4408876144, 0.0, 1636770.4499809493, 1932616.2801687205, 1559260.024532222, 1130480.278513877, 1039856.4844335921],\\n [2343639.7107855356, 3455343.3108375454, 575975.8749662543, 2062079.2399570548, 943721.1931707633, 1427995.4150203674, 1794989.6453295103, 3706392.097841614, 1053620.7288649315, 2050115.5214378452, 1636770.4499809493, 0.0, 812548.5062332726, 3191662.5092484164, 2564665.4531581327, 1690942.142157212],\\n [2031500.319603397, 3179102.5335818897, 933602.6426595236, 1590460.9488364782, 598728.757362067, 1610768.421819668, 1129464.5539648102, 3382851.415271485, 967859.8344376946, 1872971.1741522516, 1932616.2801687205, 812548.5062332726, 0.0, 3364908.7076308434, 2551338.215149899, 1490589.7393085626],\\n [1913900.3015914203, 1754834.3710577146, 3767490.41517038, 2434801.332310659, 2779561.192116527, 1788903.6065106322, 4404737.747850686, 2022974.6418062754, 4179636.203479384, 1708236.6189296674, 1559260.024532222, 3191662.5092484164, 3364908.7076308434, 0.0, 973244.7750437199, 2000112.4162614697],\\n [946854.1020487415, 1202616.154562711, 3120118.850020503, 1462408.5353501518, 1952618.0544916363, 1161480.3557326929, 3516794.375197078, 1509585.60107986, 3448359.745690545, 752855.8488125347, 1130480.278513877, 2564665.4531581327, 2551338.215149899, 973244.7750437199, 0.0, 1089830.6426635552],\\n [665894.0336505901, 1766599.1336905772, 2186473.1552241463, 662752.1291133759, 899656.1020173575, 730446.8613086065, 2427457.036285458, 2015770.1390589625, 2428862.4239271535, 384122.2000072272, 1039856.4844335921, 1690942.142157212, 1490589.7393085626, 2000112.4162614697, 1089830.6426635552, 0.0]])\\n\\n solver = FacilityOrderSolver(matrix, home_index)\\n \\n return solver.solve(indices_to_visit)\",\n \"def main():\\r\\n test = TesterNeighbour()\\r\\n test.setUp()\\r\\n test.test_result_n()\\r\\n print(\\\"result_of_algorithm_test - passed\\\")\",\n \"def build_all_analysis(self, matrix_handler, trajectory_handler):\\n distance_matrix = matrix_handler.distance_matrix\\n\\n self.all_possible_analysis = {}\\n\\n # Pure queries\\n self.all_possible_analysis[\\\"Details\\\"] = Analysis(\\\"Details\\\", self.analysis_function_details)\\n self.all_possible_analysis[\\\"NumClusters\\\"] = Analysis(\\\"Number of clusters\\\", self.analysis_function_num_clusters)\\n self.all_possible_analysis[\\\"NumClusteredElems\\\"] = Analysis(\\\"Number of clustered elements\\\", self.analysis_function_total_elements)\\n self.all_possible_analysis[\\\"MeanClusterSize\\\"] = Analysis(\\\"Mean cluster size\\\", self.analysis_function_mean_cluster_size)\\n self.all_possible_analysis[\\\"PercentInTop4\\\"] = Analysis(\\\"Percent in top 4 clusters\\\", self.analysis_function_top_4)\\n self.all_possible_analysis[\\\"PercentInTop\\\"] = Analysis(\\\"Percent in top cluster\\\", self.analysis_function_top_percent)\\n self.all_possible_analysis[\\\"ClustersTo90\\\"] = Analysis(\\\"Clusters to 90\\\", self.analysis_function_num_clusters_to_percent, 90)\\n self.all_possible_analysis[\\\"NoiseLevel\\\"] = Analysis(\\\"Noise level\\\", self.analysis_function_noise_level, distance_matrix.row_length)\\n\\n # Evaluators\\n self.all_possible_analysis[\\\"MirrorCohesion\\\"] = Analysis(\\\"MirrorCohesion\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":MirrorCohesionCalculator,\\\"matrix\\\":distance_matrix})\\n\\n self.all_possible_analysis[\\\"Cohesion\\\"] = Analysis(\\\"Cohesion\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":CohesionCalculator,\\\"matrix\\\":distance_matrix})\\n\\n self.all_possible_analysis[\\\"Separation\\\"] = Analysis(\\\"Separation\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":SeparationCalculator,\\\"matrix\\\":distance_matrix})\\n self.all_possible_analysis[\\\"MinimumMeanSeparation\\\"] = Analysis(\\\"MinimumMeanSeparation\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":MeanMinimumDistanceCalculator,\\\"matrix\\\":distance_matrix})\\n self.all_possible_analysis[\\\"Silhouette\\\"] = Analysis(\\\"Silhouette\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":SilhouetteCoefficientCalculator,\\\"matrix\\\":distance_matrix})\\n self.all_possible_analysis[\\\"Calinski-Harabasz\\\"] = Analysis(\\\"Calinski-Harabasz\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":CalinskiHarabaszCalculator,\\\"matrix\\\":distance_matrix})\\n self.all_possible_analysis[\\\"Dunn\\\"] = Analysis(\\\"Dunn\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":DunnCalculator,\\\"matrix\\\":distance_matrix})\\n self.all_possible_analysis[\\\"Davies-Bouldin\\\"] = Analysis(\\\"Davies-Bouldin\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":DaviesBouldinCalculator,\\\"matrix\\\":distance_matrix})\\n self.all_possible_analysis[\\\"GaussianSeparation\\\"] = Analysis(\\\"GaussianSeparation\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":GaussianSeparationCalculator,\\\"matrix\\\":distance_matrix})\\n self.all_possible_analysis[\\\"Compactness\\\"] = Analysis(\\\"Compactness\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":CompactnessCalculator,\\\"matrix\\\":distance_matrix})\\n\\n # Cython\\n self.all_possible_analysis[\\\"CythonMirrorCohesion\\\"] = Analysis(\\\"CythonMirrorCohesion\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":CythonMirrorCohesionCalculator,\\\"matrix\\\":distance_matrix})\\n self.all_possible_analysis[\\\"CythonMinimumMeanSeparation\\\"] = Analysis(\\\"CythonMinimumMeanSeparation\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":CythonMeanMinimumDistanceCalculator,\\\"matrix\\\":distance_matrix})\\n self.all_possible_analysis[\\\"CythonSilhouette\\\"] = Analysis(\\\"CythonSilhouette\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":CythonSilhouetteCoefficientCalculator,\\\"matrix\\\":distance_matrix})\\n\\n # Graph\\n self.all_possible_analysis[\\\"RatioCut\\\"] = Analysis(\\\"RatioCut\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":RatioCut,\\\"matrix\\\":distance_matrix})\\n self.all_possible_analysis[\\\"NCut\\\"] = Analysis(\\\"NCut\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":NCut,\\\"matrix\\\":distance_matrix})\\n self.all_possible_analysis[\\\"NormNCut\\\"] = Analysis(\\\"NormNCut\\\", self.analysis_function_norm_n_cut,distance_matrix)\\n self.all_possible_analysis[\\\"MinMaxCut\\\"] = Analysis(\\\"MinMaxCut\\\", self.evaluate_with_calculator,\\n {\\\"class\\\":MinMaxCut,\\\"matrix\\\":distance_matrix})\\n\\n # Cython & Graph\\n self.all_possible_analysis[\\\"CythonNormNCut\\\"] = Analysis(\\\"CythonNormNCut\\\", self.analysis_function_cython_norm_n_cut,distance_matrix)\\n\\n # PCA\\n self.all_possible_analysis[\\\"PCAanalysis\\\"] = Analysis(\\\"PCAanalysis\\\", self.analysis_function_pca, trajectory_handler)\",\n \"def test_scrape(self):\\n simfiles = scrape_category.get_category_from_ziv(\\\"category_test\\\", self.CATEGORY_URL)\\n compare_simfile_records(simfiles, EXPECTED_SIMFILES)\",\n \"def get_filters():\\n print(\\\"Welcome to bikeshare data! \\\\n\\\")\\n\\n # Taksk0.1: Users choose a city, create a list with length=CITY_DATA , \\n #in future, it other cities are added codes will updated automatically\\n all_cities=list(CITY_DATA)\\n for i in range(len(all_cities)):\\n message = (\\\"For the city of {} ,The code is {}\\\\n\\\".format(all_cities[i],i+1))\\n print(message)\\n ##output of the for loop will code each city with a number, according to it's (position+1) in the dictionary \\n ## position is from 0 to 2, city codes are from 1 to 3, no manual recoding for city names\\n ## user chooses a city \\\"user input\\\" by entering 1,2,3\\n \\n print(\\\"***choose a city to start\\\\n***\\\")\\n city_code=input()\\n \\n ## check if user choice is valid, if enter a number out of range code restarts until a correct city chosen\\n ## decode the user input number into city name\\n ## print a confirmation message to the user with his choice\\n while int(city_code) > (len(all_cities)):\\n print(\\\"Sorry, City choice invalid\\\")\\n city_code = input (\\\"Please choose a number from 1 to 3\\\\n\\\")\\n city_code=int(city_code)\\n else:\\n city= all_cities[int(city_code)-1] \\n print(\\\"Nice! you will get statistics for**\\\",city.title())\\n\\n # Task0.2: get user input for month (all, january, february, ... , june)\\n ##user enter month number from 1 to 6 representing january to June or all for all month\\n print(\\\"Choose a month from January to June\\\\n\\\") \\n month = input (\\\"Please type (all) to see all months \\\\nor select a number from 1 to 6 : January is 1 \\\\n---------------------------\\\\n\\\\n\\\")\\n ## if user chooses all month, no filtering, if month choice greater than 6 print warning and loop, until a correct choice\\n if month != \\\"all\\\":\\n month=int(month)\\n while month > 6:\\n print('**Warning** OUT OF RANGE!only months from 1 to 6 available')\\n month = input (\\\"Please choose a number from 1 to 6\\\\n\\\\n\\\")\\n month=int(month)\\n else:\\n month==month\\n print(\\\"\\\\n Month chosen is ***\\\" ,month, \\\"***\\\")\\n else:\\n print(\\\"No Month filter applied\\\")\\n \\n print(\\\"-\\\"*40)\\n\\n\\n #task0.3: TO DO: get user input for day of week (all, monday, tuesday, ... sunday)\\n ##create a list matching week days short names to their full name, write the list in title for \\\"first letter capital\\\"\\n days_dict = {\\\"Su\\\": \\\"Sunday\\\",\\n \\\"Mo\\\": \\\"Monday\\\",\\n \\\"Tu\\\": \\\"Tuesday\\\",\\n \\\"We\\\": \\\"Wednesday\\\", \\n \\\"Th\\\": \\\"Thursday\\\",\\n \\\"Fr\\\": \\\"Friday\\\",\\n \\\"Sa\\\": \\\"Saturday\\\"}\\n ## ask user to choose a day name by giving at least the first 2 letters of the day\\n ## conver user input to title format NOTE!! dont trim now as user may choose \\\"all\\\" days\\n ## if user choose all days, no warnings\\n ## if user enters a day name, trim only the first 2 letters to avoid Typos, look up if the letters correspond to day name\\n ## by consulting the dictionay, then return the day full name\\n print(\\\"Choose a day? \\\") \\n day= input (\\\"Please type (all) for no filtering \\\\nor choose a weeek day \\\\n \\\")\\n day=day.title()\\n \\n if day != \\\"All\\\":\\n day=(day[0:2]).title() \\n while day not in days_dict:\\n print('**Warning** not a valid day')\\n day = input (\\\"please enter at least first 2 characters of the day \\\\n\\\\n\\\")\\n day=(day[0:2]).title()\\n else:\\n day=days_dict[day]\\n print(\\\"\\\\n Day chosen is ***\\\" ,day, \\\"***\\\")\\n \\n else:\\n print(\\\"No day filter applied\\\") \\n \\n print('-'*40)\\n ## end of first function to gather user choices\\n ## return values for city name, month and day selction or all\\n ## saved as 3 inputs city,month,day\\n ##print a confirmation method to the user with his choices! city,month and day\\n print(\\\"you will see data for ** {}** city, for month *{}* and day * {}*\\\".format(city,month,day))\\n print(\\\"-\\\"*40)\\n return city, month, day\",\n \"def analyze(self):\\n self.__data = Ranking.ranks()\\n self.__motion, self.__blur, self.__text, self.__audio = self.__data\\n self.__rank_length = len(self.__motion)\\n\\n self.__ranks = [self.__motion[i] + self.__blur[i] +\\n self.__text[i] + self.__audio[i] for i in range(self.__rank_length)]\\n\\n try:\\n self.__timestamps = Ranking.get_timestamps()\\n except RankingOfFeatureMissing:\\n Log.e(RankingOfFeatureMissing.cause)\\n return\\n\\n self.__output_length = Ranking.get_video_length()\\n self.__actual_length = abs(self.__cache.read_data(CACHE_FRAME_COUNT) /\\n self.__cache.read_data(CACHE_FPS))\\n\\n self.__plot_rank_line()\\n self.__analytics()\",\n \"def read_data(self):\\n print 'Getting team stats...'\\n self.team_stats = get_team_stats(self.recent_years)\\n\\n print 'Getting matches...'\\n self.matches = get_matches(\\n with_team_stats=True,\\n duplicate_with_reversed=self.duplicate_with_reversed,\\n exclude_ties=self.exclude_ties,\\n recent_years=self.recent_years,\\n use_these_team_stats=self.team_stats,\\n )\",\n \"def analysis():\\n global prediction\\n\\n json_path = os.path.join(basedir, 'static', 'data', 'tmp_json')\\n # csv_path = os.path.join(basedir, 'static', 'data', 'csv')\\n # if not os.path.exists(csv_path):\\n # os.mkdir(csv_path)\\n\\n if os.name == 'nt':\\n audio_file = Path(os.path.join(json_path, 'audio_data.shlf.dir'))\\n video_file = Path(os.path.join(json_path, 'facial_data.shlf.dir'))\\n else:\\n audio_file = Path(os.path.join(json_path, 'audio_data.shlf'))\\n video_file = Path(os.path.join(json_path, 'facial_data.shlf'))\\n\\n # Files exists\\n if audio_file.is_file() and video_file.is_file():\\n with shelve.open(os.path.join(json_path, 'facial_data.shlf')) as shelf:\\n emotion_data = shelf['emotion_data']\\n microexpression_data = shelf['micro_expression_data']\\n blink_data = shelf['blink_data']\\n\\n with shelve.open(os.path.join(json_path, 'audio_data.shlf')) as shelf:\\n mean_energy = shelf['mean_energy']\\n max_pitch_amp = shelf['max_pitch_amp']\\n vowel_duration = shelf['vowel_duration']\\n pitch_contour = shelf['pitch_contour']\\n\\n else:\\n emotion_data = None\\n microexpression_data = None\\n blink_data = None\\n mean_energy = None\\n max_pitch_amp = None\\n vowel_duration = None\\n pitch_contour = None\\n\\n # Training Files (choose one)\\n # soc_file = os.path.join(basedir, 'static', 'data', 'train_files', 'first_soc.txt')\\n # niko_file = os.path.join(basedir, 'static', 'data', 'train_files', 'first_niko.txt')\\n # vero_file = os.path.join(basedir, 'static', 'data', 'train_files', 'first_vero.txt')\\n\\n # txt_file = soc_file\\n\\n # train_data = []\\n\\n # for cases where one parameter has more elements\\n # for i in range(min(len(blink_data), len(microexpression_data), len(mean_energy))):\\n # train_data.append(0)\\n\\n # train_file = open(txt_file)\\n\\n # for line in train_file:\\n # index1 = int((int(line[4]) * 600) + ((int(line[5]) * 60) + (int(line[7]) * 10) + int(line[8])) / 2)\\n # index2 = int((int(line[10]) * 600) + ((int(line[11]) * 60) + (int(line[13]) * 10) + int(line[14])) / 2)\\n # if line[0] == 'F':\\n # train_data[index1] = 1\\n # train_data[index2] = 1\\n\\n # with open(os.path.join(csv_path, 'train.csv'), 'w', newline='') as csv_file:\\n # writer = csv.writer(csv_file)\\n # writer.writerow(['Time Interval', 'Micro-expressions', 'Blinks',\\n # 'Mean Energy', 'Max Pitch Amplitude', 'Vowel Duration', 'Fundamental Frequency',\\n # 'False/True'])\\n\\n # # for cases where one parameter has more elements than another\\n # for index in range(min(len(mean_energy), len(blink_data), len(microexpression_data))):\\n # writer.writerow([index, microexpression_data[index], blink_data[index],\\n # mean_energy[index], max_pitch_amp[index], vowel_duration[index], pitch_contour[index],\\n # train_data[index]])\\n\\n # finalresults = [['Time Interval', 'Micro-expressions', 'Blinks',\\n # 'Mean Energy', 'Max Pitch Amplitude', 'Vowel Duration', 'Fundamental Frequency' ]]\\n final_results = []\\n\\n for index in range((min(len(mean_energy), len(blink_data), len(microexpression_data)))):\\n final_results.append([microexpression_data[index], blink_data[index],\\n mean_energy[index], max_pitch_amp[index], vowel_duration[index],\\n pitch_contour[index]])\\n\\n prediction[0] = predict(final_results)\\n\\n return render_template('analysis.html', mean_energy=mean_energy, max_pitch_amp=max_pitch_amp,\\n vowel_duration=vowel_duration, pitch_contour=pitch_contour, blink_data=blink_data,\\n microexpression_data=microexpression_data, emotion_data=emotion_data)\",\n \"def compute_statistics(self):\",\n \"def main():\\n spark = create_spark_session()\\n input_data = \\\"s3a://udacity-dend/\\\"\\n output_data = \\\"data/analytics\\\"\\n \\n process_song_data(spark, input_data, output_data) \\n process_log_data(spark, input_data, output_data)\",\n \"def analyse():\\n identity_list = create_identity_list()\\n frequency = create_identity_list()\\n\\n for sim in range(SIMULATIONS):\\n # Generate the hands and board\\n cards_used = []\\n hands_array = main.generate_hands(cards_used, CARDS, HANDS)\\n ftr = main.generate_ftr(cards_used, CARDS)\\n\\n # Find strengths of each hand and determine winner list, and amount of winning hands\\n strengths = main.get_strengths(hands_array, ftr, HANDS)\\n winner = main.determine_winner(hands_array, ftr, strengths)\\n winning_hands = len(main.get_winning_hands(winner))\\n\\n # Get the 'identities' of every hand\\n hand_identities = get_identities(hands_array)\\n\\n # Add 1 to corresponding identity value if the hand won\\n for hand in range(HANDS):\\n row_col = get_row_col_index(hand_identities[hand])\\n if winner[hand] == 1: # The corresponding hand won\\n identity_list[row_col[0]][row_col[1]] += 1.0/winning_hands\\n frequency[row_col[0]][row_col[1]] += 1\\n\\n # Turn the identity list into percentages using frequency list\\n percentage_list = convert_to_percentages(identity_list, frequency)\\n\\n # Nicely print the results\\n print_results(percentage_list)\",\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 main():\\n # Constants\\n groundstation_name = 'Wallops Antenna'\\n groundstation_address = 'Radar Road, Temperanceville, VA 23442'\\n satnum = 25544 # ISS = 25544\\n saturl=\\\"http://www.celestrak.com/NORAD/elements/stations.txt\\\"\\n gs_minimum_elevation_angle = 10.0\\n\\n # Alternate constants\\n gs_alt_lat = 37.854886 # Only needed if address not found\\n gs_alt_lon = -75.512936 # Ditto\\n gs_alt_el_meters = 3.8 # Ditto\\n gs_alt_tz_offset_seconds = -18000.0 # Ditto\\n gs_tzname = 'US/Eastern'\\n\\n # Construct the ground station info\\n try:\\n # Try to use the address...\\n gs = GroundStation.from_address(groundstation_address, \\\\\\n groundstation_name, \\\\\\n gs_minimum_elevation_angle)\\n except:\\n # Otherwise, use explicit location data...\\n gs = GroundStation.from_location(gs_alt_lat, gs_alt_lon, \\\\\\n gs_alt_el_meters, \\\\\\n gs_tzname, \\\\\\n groundstation_name, \\\\\\n gs_minimum_elevation_angle)\\n\\n # Times we need\\n now = datetime.now()\\n gs_today = gs.get_tz().localize(datetime(now.year, now.month, now.day))\\n gs_today_start = gs.get_tz().localize(datetime(now.year, now.month, now.day, \\\\\\n 0, 0, 0)) \\n gs_today_end = gs.get_tz().localize(datetime(now.year, now.month, now.day, \\\\\\n 23, 59, 59))\\n\\n # Get the InviewCalculator and compute the inviews\\n st = SatelliteTle(satnum, tle_url=saturl)\\n ic = InviewCalculator(gs, st)\\n inviews = ic.compute_inviews(gs_today_start, gs_today_end)\\n\\n # Print the results\\n print_satellite_header(st)\\n print_inview_header(gs.get_minimum_elevation_angle(), gs_today, gs)\\n print_inviews(gs, inviews)\\n print_azeltables(inviews, ic)\",\n \"def analyze_run():\\n file_datas_dict = load_datas(Args.data_files)\\n plotables_dict = dict()\\n for file_name, datas in file_datas_dict.viewitems():\\n analized_datas = analyze_datas(datas,Args.analysis_attributes)\\n plotables = ana_results_to_plotables(\\n analized_datas,\\n Args.analysis_attributes\\n )\\n if Args.dm_file_out:\\n analysis_save_dm(\\n analized_datas,\\n plotables,\\n Args.analysis_attributes,\\n Args.dm_file_out\\n )\\n if Args.mat_file_out:\\n analysis_save(\\n plotables,\\n Args.analysis_attributes,\\n Args.mat_file_out\\n )\\n if Args.verbose:\\n plotables_dict[file_name] = plotables\\n if Args.verbose:\\n ana_plot_figures(plotables_dict,Args.analysis_attributes)\",\n \"def compute(self, download_data=None):\\n if self.extractor is None:\\n # If download_data is None, decide based on whether eid or session path was provided\\n ensure_data = self.download_data if download_data is None else download_data\\n self.load_data(download_data=ensure_data)\\n self.log.info(f\\\"Session {self.session_path}: Running QC on habituation data...\\\")\\n\\n # Initialize checks\\n prefix = '_task_'\\n data = self.extractor.data\\n metrics = {}\\n passed = {}\\n\\n # Check all reward volumes == 3.0ul\\n check = prefix + 'reward_volumes'\\n metrics[check] = data['rewardVolume']\\n passed[check] = metrics[check] == 3.0\\n\\n # Check session durations are increasing in steps >= 12 minutes\\n check = prefix + 'habituation_time'\\n if not self.one or not self.session_path:\\n self.log.warning('unable to determine session trials without ONE')\\n metrics[check] = passed[check] = None\\n else:\\n subject, session_date = self.session_path.parts[-3:-1]\\n # compute from the date specified\\n date_minus_week = (\\n datetime.strptime(session_date, '%Y-%m-%d') - timedelta(days=7)\\n ).strftime('%Y-%m-%d')\\n sessions = self.one.alyx.rest('sessions', 'list', subject=subject,\\n date_range=[date_minus_week, session_date],\\n task_protocol='habituation')\\n # Remove the current session if already registered\\n if sessions and sessions[0]['start_time'].startswith(session_date):\\n sessions = sessions[1:]\\n metric = ([0, data['intervals'][-1, 1] - data['intervals'][0, 0]] +\\n [(datetime.fromisoformat(x['end_time']) -\\n datetime.fromisoformat(x['start_time'])).total_seconds() / 60\\n for x in [self.one.alyx.get(s['url']) for s in sessions]])\\n\\n # The duration from raw trial data\\n # duration = map(float, self.extractor.raw_data[-1]['elapsed_time'].split(':'))\\n # duration = timedelta(**dict(zip(('hours', 'minutes', 'seconds'),\\n # duration))).total_seconds() / 60\\n metrics[check] = np.array(metric)\\n passed[check] = np.diff(metric) >= 12\\n\\n # Check event orders: trial_start < stim on < stim center < feedback < stim off\\n check = prefix + 'trial_event_sequence'\\n nans = (\\n np.isnan(data[\\\"intervals\\\"][:, 0]) | # noqa\\n np.isnan(data[\\\"stimOn_times\\\"]) | # noqa\\n np.isnan(data[\\\"stimCenter_times\\\"]) |\\n np.isnan(data[\\\"valveOpen_times\\\"]) | # noqa\\n np.isnan(data[\\\"stimOff_times\\\"])\\n )\\n a = np.less(data[\\\"intervals\\\"][:, 0], data[\\\"stimOn_times\\\"], where=~nans)\\n b = np.less(data[\\\"stimOn_times\\\"], data[\\\"stimCenter_times\\\"], where=~nans)\\n c = np.less(data[\\\"stimCenter_times\\\"], data[\\\"valveOpen_times\\\"], where=~nans)\\n d = np.less(data[\\\"valveOpen_times\\\"], data[\\\"stimOff_times\\\"], where=~nans)\\n\\n metrics[check] = a & b & c & d & ~nans\\n passed[check] = metrics[check].astype(float)\\n\\n # Check that the time difference between the visual stimulus center-command being\\n # triggered and the stimulus effectively appearing in the center is smaller than 150 ms.\\n check = prefix + 'stimCenter_delays'\\n metric = np.nan_to_num(data[\\\"stimCenter_times\\\"] - data[\\\"stimCenterTrigger_times\\\"],\\n nan=np.inf)\\n passed[check] = (metric <= 0.15) & (metric > 0)\\n metrics[check] = metric\\n\\n # Phase check\\n check = prefix + 'phase'\\n metric = data['phase']\\n passed[check] = (metric <= 2 * np.pi) & (metric >= 0)\\n metrics[check] = metric\\n\\n check = prefix + 'phase_distribution'\\n metric, _ = np.histogram(data['phase'])\\n _, p = chisquare(metric)\\n passed[check] = p < 0.05\\n metrics[check] = metric\\n\\n # Checks common to training QC\\n checks = [check_goCue_delays, check_stimOn_goCue_delays,\\n check_stimOn_delays, check_stimOff_delays]\\n for fcn in checks:\\n check = prefix + fcn.__name__[6:]\\n metrics[check], passed[check] = fcn(data)\\n\\n self.metrics, self.passed = (metrics, passed)\",\n \"def __init__(self, langName):\\n self.langName = langName\\n self.readDataSets(langName)\\n # self.getVMWEReport()\\n self.analyzeSents()\\n self.orderParentVMWEs()\\n self.getTrainAndTest()\\n self.cleanSents()\\n self.extractDictionaries()\\n self.deleteNonRecognizableMWE()\\n printStats(self.trainingSents, 'Train', mweDic=self.mweDictionary, langName=langName, test=False)\\n printStats(self.testingSents, 'Test', mweDic=self.mweDictionary, test=True)\",\n \"def jaccard_sim(news_data_dict: dict, song_data_dict: dict):\\n jaccard_dict = defaultdict(list)\\n\\n for news_yr, news_txt in news_data_dict.items():\\n news_txt_flat = []\\n for nt in news_txt:\\n news_txt_flat += nt\\n news_txt_flat = set(news_txt_flat)\\n if news_yr <= 2011:\\n song_txt_flat = set()\\n for i in range(5):\\n song_yr = news_yr+i\\n for st in song_data_dict[song_yr]:\\n for stw in st:\\n song_txt_flat.add(stw)\\n shared_words = news_txt_flat.intersection(song_txt_flat)\\n jaccard = len(shared_words) / (len(song_txt_flat) + len(news_txt_flat) - len(shared_words))\\n jaccard = round(jaccard, 3)\\n jaccard_dict[news_yr].append(jaccard)\\n\\n return jaccard_dict\",\n \"def test_parse_hit_details(self):\\n for query in self.result:\\n first_hsp = self.result[query][0][0]\\n self.assertEqual(first_hsp[\\\"SUBJECT_ID\\\"], \\\"gi|148670104|gb|EDL02051.1|\\\")\\n self.assertEqual(\\n first_hsp[\\\"HIT_DEF\\\"],\\n \\\"insulin-like growth factor 2 receptor, isoform CRA_c [Mus musculus]\\\",\\n )\\n self.assertEqual(first_hsp[\\\"HIT_ACCESSION\\\"], \\\"2001\\\")\\n self.assertEqual(first_hsp[\\\"HIT_LENGTH\\\"], 707)\",\n \"def main():\\n\\n # confusion matrix model ensemble\\n df = pd.read_csv('pred_test_ensemble.csv')\\n print('Real test accuracy:', accuracy_score(df.labels.values, df.class_preds.values))\\n conf_matrix = confusion_matrix(df.labels.values, df.class_preds.values, labels=[0, 1, 2, 3])\\n\\n dct = {'': [0, 90, 180, 270]}\\n for i in range(4):\\n dct[str(i*90)] = conf_matrix[:, i]\\n \\n conf_matrix = pd.DataFrame(dct)\\n print(conf_matrix)\\n conf_matrix.to_csv('confusion_matrix_ensemble.csv', index=False)\\n\\n\\n\\n # # Statistical gama\\n # df = pd.read_csv('pred_test.csv')\\n # print('Statistical... ')\\n # statistical = gama_statistic(df)\\n # statistical.to_csv('gama_statistic.csv', index=False)\\n # print(statistical)\",\n \"def run_main():\\n # Matching lines against a matcher function.\\n matched_lines = match_file(file_names, matcher)\\n\\n # Will contain data sorted by file.\\n binned_data = {}\\n\\n # Looking through the lines that were inserted into the metrics file via the metrics component.\\n for key in matched_lines:\\n\\n # Grabbing matched lines by the file or orgination.\\n buffer = matched_lines[key]\\n\\n # This will contain dictionaries converted from JSON.\\n data = []\\n\\n # Loop through the collection, appending data converted from JSON entries.\\n for line in buffer:\\n data.append(extract_data(line))\\n\\n # Sort the data by file.\\n binned_data[key] = sort_data(data)\\n\\n # Output the final results.\\n generate_statistics(binned_data)\\n return 0\",\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 harmony(self):\\n\\n self.config.logger.info(\\\"Harmonizing grid area...\\\")\\n\\n # reset start time\\n t0 = time.time()\\n\\n # reconcile GCAM land use area with base layer land use data\\n recon_data = rec.reconcile(self.allreg, self.allaez, self.allregnumber, self.allregaez, self.spat_aez,\\n self.spat_region, self.spat_ludata, self.user_years, self.gcam_ludata, self.gcam_aez,\\n self.gcam_regionnumber)\\n\\n # unpack variables\\n self.spat_regaezarea, self.gcam_regaezarea, self.areacoef, self.gcam_regaezareaharm, self.ixr_idm, \\\\\\n self.ixy_ixr_ixm, self.gcam_ludata = recon_data\\n\\n # write harmonization coefficient array as a diagnostics file\\n if self.config.diagnostic == 1:\\n wdr.save_array(self.areacoef, self.config.harm_coeff_file)\\n\\n self.config.logger.info('PERFORMANCE: Harmonization completed in {0} seconds'.format(time.time() - t0))\",\n \"def spectra_analysis(file_name, sky_file_name): \\n\\n # read file name and select out the id that we are dealing with\\n curr_file_name = file_name.split('.')\\n curr_file_name = curr_file_name[0].split('/')\\n stk_f_n = curr_file_name[-1]\\n cube_id = int(re.search(r'\\\\d+', stk_f_n).group())\\n\\n # read catalogue and obtain the HST redshift estimate\\n #catalogue = np.load(\\\"data/matched_catalogue.npy\\\")\\n catalogue = np.load(\\\"data/low_redshift_catalogue.npy\\\")\\n cat_loc = np.where(catalogue[:,0] == cube_id)[0]\\n cube_info = catalogue[cat_loc][0]\\n \\n hst_redshift = cube_info[7]\\n\\n # spectra and sky noise data\\n spectra_data = spectrum_creator(file_name)\\n wl_soln = wavelength_solution(file_name)\\n sn_data = sky_noise(sky_file_name)\\n\\n galaxy_data = spectra_data['galaxy']\\n\\n # removing baseline from data\\n base = peakutils.baseline(galaxy_data, 3)\\n gd_mc = galaxy_data - base\\n\\n # scaling sky-noise to be similar to spectra data\\n gd_max = np.amax(galaxy_data)\\n sn_data_max = np.amax(sn_data)\\n sn_scale = gd_max / sn_data_max\\n\\n sn_data = sn_data * sn_scale\\n\\n # spectra lines\\n sl = {\\n 'emis': {\\n '[OII]': '3727',\\n 'CaK': '3933',\\n 'CaH': '3968',\\n 'Hdelta': '4101', \\n }, \\n 'abs': {'K': '3934.777',\\n }\\n } \\n\\n # we can use the redshift from the HST catalogue to define the region to search for\\n # the doublet in\\n\\n # lower and upper bound on wavelength range\\n lower_lambda = (1+hst_redshift)*3600\\n upper_lambda = (1+hst_redshift)*3850\\n\\n # x-axis data\\n data_h_range = np.linspace(wl_soln['begin'], wl_soln['end'], wl_soln['steps'])\\n mask = (lower_lambda < data_h_range) & (data_h_range < upper_lambda) \\n\\n lambda_data = data_h_range[mask]\\n flux_data = gd_mc[mask] \\n \\n # Finding peaks with PeakUtils\\n pu_peaks = peakutils.indexes(flux_data, thres=600, thres_abs=True)\\n pu_peaks_x = peakutils.interpolate(lambda_data, flux_data, pu_peaks)\\n\\n pu_peaks_x = np.sort(pu_peaks_x)\\n pu_peaks_x = pu_peaks_x[lower_lambda < pu_peaks_x]\\n pu_peaks_x = pu_peaks_x[pu_peaks_x < upper_lambda]\\n \\n data_dir = 'cube_results/' + stk_f_n\\n if not os.path.exists(data_dir):\\n os.mkdir(data_dir)\\n\\n peaks_file = open(data_dir + '/' + stk_f_n + '_peaks.txt', 'w')\\n peaks_file.write(\\\"Peaks found on \\\" + str(datetime.datetime.now()) + \\\"\\\\n\\\\n\\\")\\n\\n peaks_file.write(\\\"Number Wavelength \\\\n\\\")\\n for i_peak in range(len(pu_peaks_x)):\\n curr_peak = pu_peaks_x[i_peak]\\n peaks_file.write(str(i_peak) + \\\" \\\" + str(curr_peak) + \\\"\\\\n\\\")\\n\\n # manually selecting which peak is the [OII] peak - given in wavelength\\n if (pu_peaks_x.size != 0):\\n otwo_wav = float(pu_peaks_x[0]) \\n otwo_acc = float(sl['emis']['[OII]'])\\n\\n redshift = (otwo_wav / otwo_acc) - 1\\n else:\\n # accepting HST redshift if cannot find peak\\n redshift = hst_redshift\\n\\n return {'gd_shifted': gd_mc, 'sky_noise': sn_data, 'spectra': sl, 'redshift': \\n redshift, 'pu_peaks': pu_peaks_x}\",\n \"def main():\\n region = 'Kanto'\\n year = 2000\\n # callParallelGA(region)\\n callParallelReducedGA(region)\\n \\n\\n region = 'EastJapan'\\n year = 2000\\n callParallelReducedGA(region)\\n # callParallelGA(region)\\n\\n\\n region = 'Tohoku'\\n year = 2000\\n callParallelReducedGA(region)\\n # callParallelGA(region)\\n\\n \\n region = 'Kansai'\\n year = 2000\\n callParallelReducedGA(region)\\n # callParallelGA(region)\",\n \"def run():\\n\\n data = parse_data()\\n\\n wide = 25\\n tall = 6\\n\\n layers = []\\n for index in range(0, len(data), wide * tall):\\n item = data[index : index + wide * tall]\\n item = [item[x : x + wide] for x in range(0, wide * tall, wide)]\\n layers.append(item)\\n\\n lowest, layer = get_layer_containing_fewest_zeroes(layers)\\n\\n ones = sum([Counter(l).get(\\\"1\\\", 0) for l in layer])\\n twos = sum([Counter(l).get(\\\"2\\\", 0) for l in layer])\\n assert (ones * twos) == 1820\\n\\n display_layers(layers, wide, tall) # ckuj\",\n \"def main():\\n run_test_summary1a()\\n run_test_summary1c()\\n run_test_summary1c()\",\n \"def func(self):\\n account = self.account\\n city_name = 'Phoenix' if not self.args else self.args\\n a = Astral()\\n a.solar_depression = 'civil'\\n city = a[city_name]\\n if not city:\\n return\\n timezone = city.timezone\\n sun = city.sun(date=datetime.date.today(), local=True)\\n\\n account.msg('Information for %s/%s\\\\n' % (city_name, city.region))\\n account.msg('Timezone: %s' % timezone)\\n account.msg('Latitude: %.02f; Longitude: %.02f' % (city.latitude, city.longitude))\\n account.msg('Dawn: %s' % str(sun['dawn']))\\n account.msg('Sunrise: %s' % str(sun['sunrise']))\\n account.msg('Noon: %s' % str(sun['noon']))\\n account.msg('Sunset: %s' % str(sun['sunset']))\\n account.msg('Dusk: %s' % str(sun['dusk']))\",\n \"def test_2():\\n table = pandas.read_csv('data/matches.csv')\\n query_result = show.show(table,\\n dimensions=['player_of_match'],\\n metric='win_by_runs' ,\\n slices=[('season', Filters.EQUAL_TO, 2017)],\\n \\t date_range=('2017-05-09', '2017-05-12'),\\n \\t date_column_name='date', day_first=False,\\n \\t summary_operator=SummaryOperators.MEAN)\\n print(query_result)\\n expected_result = \\\"\\\"\\\" player_of_match MEAN of win_by_runs\\n0 KK Nair 7\\n1 MM Sharma 14\\n2 SS Iyer 0\\n3 WP Saha 7\\\"\\\"\\\"\\n\\n expected_suggestions = \\\"[]\\\"\\n\\n assert(expected_result == query_result[0].to_string())\\n assert(expected_suggestions == str(query_result[1]))\",\n \"def get_filters():\\r\\n print('Welcome to Bikeshare data Analysis...')\\r\\n try:\\r\\n # TO DO: get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs\\r\\n while True:\\r\\n try:\\r\\n cit_num = int(input('Enter city you would like to analyze \\\\n1 : Chicago\\\\n2 : Newyork\\\\n3 : Washington :\\\\n'))\\r\\n except ValueError:\\r\\n print(\\\"Please enter a number value\\\\n\\\")\\r\\n continue\\r\\n if cit_num not in (1,2,3):\\r\\n print(\\\"Please enter a valid number that refers to cities\\\\n\\\")\\r\\n continue\\r\\n else:\\r\\n break\\r\\n\\r\\n city = LST_CITY[cit_num - 1].lower()\\r\\n # TO DO: get user input for month (all, january, february, ... , june)\\r\\n while True:\\r\\n try:\\r\\n month_num = int(input('Enter month of the year you would like to analyze \\\\n1 : JAN\\\\n2 : FEB\\\\n3 : MAR\\\\n4 : APR\\\\n5 : MAY\\\\n6 : JUN\\\\n7 : WHOLE WEEK\\\\n'))\\r\\n except ValueError:\\r\\n print(\\\"Please enter a num value\\\\n\\\")\\r\\n continue\\r\\n if month_num not in range(1,8):\\r\\n print(\\\"Please enter a valid month...\\\\n\\\")\\r\\n continue\\r\\n else:\\r\\n break\\r\\n month = VALID_MONTHS[month_num-1]\\r\\n # TO DO: get user input for day of week (all, monday, tuesday, ... sunday)\\r\\n while True:\\r\\n try:\\r\\n day_num = int(input('Enter day of the week you would like to analyze \\\\n1 : MON\\\\n2 : TUE\\\\n3 : WED\\\\n4 : THU\\\\n5 : FRI\\\\n6 : SAT\\\\n7 : SUN\\\\n8 : ALL MONTHS\\\\n'))\\r\\n except ValueError:\\r\\n print(\\\"Please enter a num value\\\\n\\\")\\r\\n continue\\r\\n if day_num not in range(1, 9):\\r\\n print(\\\"Please enter a valid month number...\\\\n\\\")\\r\\n continue\\r\\n else:\\r\\n break\\r\\n day = VALID_DAYS[day_num-1]\\r\\n\\r\\n print('\\\\n'+'*'*20)\\r\\n print('Your selections are stated below\\\\nCity : {} , Month : {} , Day : {} '.format(city.title(),month.title(),day.title()))\\r\\n print('*'*20)\\r\\n \\r\\n return city, month, day ,cit_num , month_num , day_num\\r\\n \\r\\n except Exception as e:\\r\\n print('An exception has been occurred : {}'.format(e))\",\n \"def test_search(self):\\n response = Tmdb.search('ozark')\\n self.assertTrue(int(response.status_code) == 200)\\n data = response.json()\\n self.assertTrue(isinstance(data['results'], list))\\n # TODO check if all the shows are in the good format (can be from_dict/to_dict)\",\n \"def test_jaccard(self):\\n self.region_sets([['chr1',50,58],['chr1',70,80],['chr1',90,94]],\\n [['chr1',45,55],['chr1',76,86]])\\n result = self.setA.jaccard(self.setB)\\n self.assertEqual(result, 9/33)\",\n \"def main():\\n while True:\\n city, month, day, filters = get_filters()\\n dataframe = load_data(city, month, day, filters)\\n\\n print('\\\\n\\\\n************DISPLAYING STATISTICS*************')\\n time_stats(dataframe, filters)\\n station_stats(dataframe, filters)\\n trip_duration_stats(dataframe, filters)\\n user_stats(dataframe, filters)\\n visualize_data(dataframe, filters, city)\\n show_data(dataframe, filters, city)\\n\\n # To restart or quit program\\n restart_program()\",\n \"def sky_orbits(test=True):\\n \\n t = Table.read('/home/ana/data/baumgardt_positions.fits')\\n \\n ind_disterr = ~np.isfinite(t['e_Rsun'])\\n t['e_Rsun'][ind_disterr] = 0.1 * t['Rsun'][ind_disterr]\\n e_max = np.nanmax(t['e_Rsun'][~ind_disterr])\\n ind_cap = t['e_Rsun']>e_max\\n t['e_Rsun'][ind_cap] = e_max\\n \\n clusters = ['NGC 3201', 'NGC 4590', 'NGC 5824', 'NGC 5272', 'NGC 5139', 'NGC 5024']\\n #clusters = ['NGC 5824', 'NGC 5024']\\n N = len(clusters)\\n \\n match = dict()\\n match['NGC 3201'] = dict(streams=['gjoll'], direction=[-1], nstep=[35], gc_label='NGC\\\\n3201', gcra_off=0*u.deg, gcdec_off=-13*u.deg, gcl_off=0*u.deg, gcb_off=-13*u.deg, stream_label=['$Gj\\\\\\\\\\\\\\\" oll$'], stream_ra=[-156*u.deg], stream_dec=[-4.5*u.deg], eq_angle=[-45*u.deg], stream_l=[-148*u.deg], stream_b=[-33*u.deg], gal_angle=[22*u.deg])\\n \\n match['NGC 4590'] = dict(streams=['fjorm'], direction=[1], nstep=[100], gc_label='NGC\\\\n4590', gcra_off=-15*u.deg, gcdec_off=0*u.deg, gcl_off=-13*u.deg, gcb_off=-10*u.deg, stream_label=['$Fj\\\\\\\\\\\\\\\" orm$'], stream_ra=[-22*u.deg], stream_dec=[66*u.deg], eq_angle=[35*u.deg], stream_l=[110*u.deg], stream_b=[50*u.deg], gal_angle=[-50*u.deg])\\n \\n match['NGC 5024'] = dict(streams=['sylgr', 'ravi'], direction=[-1, 1], nstep=[300,500], gc_label='NGC\\\\n5024', gcra_off=-15*u.deg, gcdec_off=0*u.deg, gcl_off=10*u.deg, gcb_off=-20*u.deg, stream_label=['Sylgr', 'Ravi'], stream_ra=[-70*u.deg, 83*u.deg], stream_dec=[2*u.deg, -47*u.deg], eq_angle=[25*u.deg, 65*u.deg], stream_l=[-110*u.deg, -18.5*u.deg], stream_b=[62*u.deg, -47*u.deg], gal_angle=[30*u.deg, -10*u.deg])\\n \\n match['NGC 5139'] = dict(streams=['fimbulthul'], direction=[-1], nstep=[70], gc_label='NGC\\\\n5139', gcra_off=-5*u.deg, gcdec_off=-15*u.deg, gcl_off=0*u.deg, gcb_off=-12*u.deg, stream_label=['Fimbulthul'], stream_ra=[-20*u.deg], stream_dec=[-15*u.deg], eq_angle=[0*u.deg], stream_l=[-20*u.deg], stream_b=[45*u.deg], gal_angle=[0*u.deg])\\n \\n match['NGC 5272'] = dict(streams=['svol'], direction=[1], nstep=[70], gc_label='NGC\\\\n5272', gcra_off=-15*u.deg, gcdec_off=10*u.deg, gcl_off=-23*u.deg, gcb_off=-17*u.deg, stream_label=['$Sv\\\\\\\\\\\\\\\" ol$'], stream_ra=[-2*u.deg], stream_dec=[34*u.deg], eq_angle=[-10*u.deg], stream_l=[55*u.deg], stream_b=[55*u.deg], gal_angle=[-65*u.deg])\\n \\n match['NGC 5824'] = dict(streams=['triangulum', 'turbio'], direction=[1,1], nstep=[700,1], gc_label='NGC\\\\n5824', gcra_off=15*u.deg, gcdec_off=-5*u.deg, gcl_off=15*u.deg, gcb_off=-5*u.deg, stream_label=['Triangulum', 'Turbio'], stream_ra=[152*u.deg, 130*u.deg], stream_dec=[32*u.deg, -51*u.deg], eq_angle=[-48*u.deg, 30*u.deg], stream_l=[120*u.deg, -82*u.deg], stream_b=[-31*u.deg, -57*u.deg], gal_angle=[70*u.deg, 105*u.deg])\\n \\n dt = 0.5*u.Myr\\n wangle = 180*u.deg\\n ra_off = 120*u.deg\\n l_off = 0*u.deg\\n \\n colors = [mpl.cm.plasma(0.95*x/N) for x in range(N)]\\n \\n np.random.seed(27529)\\n if test:\\n Nsample = 1\\n else:\\n Nsample = 100\\n \\n plt.close()\\n fig = plt.figure(figsize=(12,12))\\n \\n ax0 = fig.add_subplot(211, projection='mollweide')\\n ax1 = fig.add_subplot(212, projection='mollweide')\\n ax = [ax0, ax1]\\n \\n for i in range(N):\\n #ind = t['Name']== clusters[i]\\n ind = t['Name']==clusters[i]\\n t_ = t[ind]\\n \\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'], pm_ra_cosdec=t_['pmRA_'], pm_dec=t_['pmDE'], radial_velocity=t_['RV'], frame='icrs')\\n cgal = c.transform_to(coord.Galactic)\\n #w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\\n \\n color = colors[i]\\n alpha_text = 0.8\\n \\n plt.sca(ax[0])\\n plt.plot((c.ra + ra_off).wrap_at(wangle).rad, c.dec.rad, '+', color=color, mew=3, ms=15, label=t_['Name'][0])\\n plt.text((c.ra + ra_off + match[clusters[i]]['gcra_off']).wrap_at(wangle).rad, (c.dec + match[clusters[i]]['gcdec_off']).rad, match[clusters[i]]['gc_label'], fontsize='small', ha='center', va='center', alpha=alpha_text)\\n \\n plt.sca(ax[1])\\n plt.plot((cgal.l + l_off).wrap_at(wangle).rad, cgal.b.rad, '+', color=color, mew=3, ms=15, label=t_['Name'][0])\\n plt.text((cgal.l + l_off + match[clusters[i]]['gcl_off']).wrap_at(wangle).rad, (cgal.b + match[clusters[i]]['gcb_off']).rad, match[clusters[i]]['gc_label'], fontsize='small', ha='center', va='center', alpha=alpha_text)\\n \\n\\n for j in range(len(match[clusters[i]]['direction'])):\\n # sample gc positional uncertainties\\n for k in range(-1, Nsample):\\n if k==-1:\\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'], pm_ra_cosdec=t_['pmRA_'], pm_dec=t_['pmDE'], radial_velocity=t_['RV'], frame='icrs')\\n w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\\n \\n lw = 1.5\\n alpha = 1\\n else:\\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'] + np.random.randn()*t_['e_Rsun'], pm_ra_cosdec=t_['pmRA_'] + np.random.randn()*t_['e_pmRA_'], pm_dec=t_['pmDE'] + np.random.randn()*t_['e_pmDE'], radial_velocity=t_['RV'] + np.random.randn()*t_['e_RV'], frame='icrs')\\n w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\\n \\n lw = 1\\n alpha = 0.1\\n \\n orbit = ham.integrate_orbit(w0, dt=dt*match[clusters[i]]['direction'][j], n_steps=match[clusters[i]]['nstep'][j])\\n orbit_eq = orbit.to_coord_frame(coord.ICRS, galactocentric_frame=gc_frame)\\n orbit_gal = orbit.to_coord_frame(coord.Galactic, galactocentric_frame=gc_frame)\\n \\n \\n plt.sca(ax[0])\\n dra = (orbit_eq.ra+ra_off).wrap_at(wangle)[1:] - (orbit_eq.ra+ra_off).wrap_at(wangle)[:-1]\\n if np.any(np.abs(dra)>180*u.deg):\\n pos_break = dra>180*u.deg\\n ind_break = np.argmax(pos_break)\\n ipad = 1\\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad[:ind_break-ipad], orbit_eq.dec.rad[:ind_break-ipad], '-', color=color, lw=lw, label='', alpha=alpha)\\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad[ind_break+ipad:], orbit_eq.dec.rad[ind_break+ipad:], '-', color=color, lw=lw, label='', alpha=alpha)\\n else:\\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad, orbit_eq.dec.rad, '-', color=color, lw=lw, label='', alpha=alpha)\\n \\n plt.sca(ax[1])\\n dl = orbit_gal.l.wrap_at(wangle)[1:] - orbit_gal.l.wrap_at(wangle)[:-1]\\n if np.any(np.abs(dl)>180*u.deg):\\n pos_break = dl>180*u.deg\\n ind_break = np.argmax(pos_break)\\n ipad = 1\\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad[:ind_break-ipad], orbit_gal.b.rad[:ind_break-ipad], '-', color=color, lw=lw, label='', alpha=alpha)\\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad[ind_break+ipad:], orbit_gal.b.rad[ind_break+ipad:], '-', color=color, lw=lw, label='', alpha=alpha)\\n else:\\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad, orbit_gal.b.rad, '-', color=color, lw=lw, label='', alpha=alpha)\\n \\n # add streams\\n pkl = pickle.load(open('../data/streams/data_{:s}.pkl'.format(match[clusters[i]]['streams'][j]), 'rb'))\\n cs = coord.SkyCoord(ra=pkl['dec'][0], dec=pkl['dec'][1], frame='icrs')\\n cs_gal = cs.transform_to(coord.Galactic)\\n \\n plt.sca(ax[0])\\n plt.plot((cs.ra+ra_off).wrap_at(wangle).rad, cs.dec.rad, 'o', color=color, ms=8, label=match[clusters[i]]['streams'][j])\\n plt.text(coord.Longitude(match[clusters[i]]['stream_ra'][j]).wrap_at(wangle).rad, coord.Latitude(match[clusters[i]]['stream_dec'][j]).rad, match[clusters[i]]['stream_label'][j], fontsize='small', alpha=alpha_text, rotation=match[clusters[i]]['eq_angle'][j].value, ha='center', va='center')\\n \\n plt.sca(ax[1])\\n plt.plot((cs_gal.l+l_off).wrap_at(wangle).rad, cs_gal.b.rad, 'o', color=color, ms=8, label=match[clusters[i]]['streams'][j])\\n plt.text(coord.Longitude(match[clusters[i]]['stream_l'][j]).wrap_at(wangle).rad, coord.Latitude(match[clusters[i]]['stream_b'][j]).rad, match[clusters[i]]['stream_label'][j], fontsize='small', alpha=alpha_text, rotation=match[clusters[i]]['gal_angle'][j].value, ha='center', va='center')\\n \\n \\n plt.sca(ax[0])\\n plt.grid(ls=':')\\n plt.xlabel('R.A. [deg]')\\n plt.ylabel('Dec [deg]')\\n\\n plt.gca().xaxis.set_ticklabels([])\\n \\n xloc = coord.Longitude(np.arange(-150,180,30)*u.deg)\\n xloc = np.delete(xloc, [3])\\n yloc = coord.Latitude(5*u.deg)\\n Nx = len(xloc)\\n \\n for i in range(Nx):\\n plt.text(xloc[i].wrap_at(wangle).rad, yloc.rad, '{:.0f}$\\\\degree$'.format((xloc[i]-ra_off).wrap_at(wangle).degree), alpha=0.6, ha='center', va='center')\\n \\n \\n plt.sca(ax[1])\\n plt.grid(ls=':')\\n plt.xlabel('Galactic longitude [deg]')\\n plt.ylabel('Galactic latitude [deg]')\\n \\n plt.gca().xaxis.set_ticklabels([])\\n \\n xloc = coord.Longitude(np.arange(-150,180,30)*u.deg)\\n xloc = np.delete(xloc, [2,3])\\n yloc = coord.Latitude(5*u.deg)\\n Nx = len(xloc)\\n \\n for i in range(Nx):\\n plt.text(xloc[i].wrap_at(wangle).rad, yloc.rad, '{:.0f}$\\\\degree$'.format((xloc[i]+l_off).wrap_at(wangle).degree), alpha=0.6, ha='center', va='center')\\n \\n \\n \\n plt.tight_layout(h_pad=2)\\n plt.savefig('../paper/sky_orbits.pdf')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66694874","0.57432646","0.5723401","0.5522852","0.55180657","0.5504678","0.5437675","0.54102576","0.53872174","0.53547543","0.53277946","0.53205276","0.53092575","0.5265327","0.5183534","0.5149629","0.5142744","0.51422846","0.51374143","0.51307535","0.51246846","0.5111326","0.5106823","0.50977486","0.5078957","0.5071514","0.5066866","0.5049063","0.502671","0.5012002","0.49999216","0.49736392","0.49687007","0.4966849","0.49654552","0.4960341","0.49488854","0.49487597","0.49459764","0.49377188","0.4931297","0.49193537","0.49175823","0.49143606","0.49073637","0.49037388","0.49020556","0.48998183","0.48910233","0.48891777","0.48838216","0.4879003","0.48724163","0.48652583","0.4865132","0.48533365","0.48488814","0.48408285","0.48324284","0.48274356","0.4823161","0.4822759","0.48198643","0.48191303","0.48177466","0.4817187","0.48090997","0.48070917","0.48062077","0.48010913","0.48003522","0.479872","0.47873342","0.47846764","0.47828007","0.47808087","0.4779133","0.47774383","0.4774203","0.4767178","0.47660217","0.4764641","0.4762371","0.475913","0.47568718","0.47547925","0.47526044","0.47461602","0.47422677","0.4735532","0.4732296","0.472427","0.4717124","0.47163177","0.4716019","0.4715762","0.47137326","0.4711089","0.47096556","0.4702856","0.4702148"],"string":"[\n \"0.66694874\",\n \"0.57432646\",\n \"0.5723401\",\n \"0.5522852\",\n \"0.55180657\",\n \"0.5504678\",\n \"0.5437675\",\n \"0.54102576\",\n \"0.53872174\",\n \"0.53547543\",\n \"0.53277946\",\n \"0.53205276\",\n \"0.53092575\",\n \"0.5265327\",\n \"0.5183534\",\n \"0.5149629\",\n \"0.5142744\",\n \"0.51422846\",\n \"0.51374143\",\n \"0.51307535\",\n \"0.51246846\",\n \"0.5111326\",\n \"0.5106823\",\n \"0.50977486\",\n \"0.5078957\",\n \"0.5071514\",\n \"0.5066866\",\n \"0.5049063\",\n \"0.502671\",\n \"0.5012002\",\n \"0.49999216\",\n \"0.49736392\",\n \"0.49687007\",\n \"0.4966849\",\n \"0.49654552\",\n \"0.4960341\",\n \"0.49488854\",\n \"0.49487597\",\n \"0.49459764\",\n \"0.49377188\",\n \"0.4931297\",\n \"0.49193537\",\n \"0.49175823\",\n \"0.49143606\",\n \"0.49073637\",\n \"0.49037388\",\n \"0.49020556\",\n \"0.48998183\",\n \"0.48910233\",\n \"0.48891777\",\n \"0.48838216\",\n \"0.4879003\",\n \"0.48724163\",\n \"0.48652583\",\n \"0.4865132\",\n \"0.48533365\",\n \"0.48488814\",\n \"0.48408285\",\n \"0.48324284\",\n \"0.48274356\",\n \"0.4823161\",\n \"0.4822759\",\n \"0.48198643\",\n \"0.48191303\",\n \"0.48177466\",\n \"0.4817187\",\n \"0.48090997\",\n \"0.48070917\",\n \"0.48062077\",\n \"0.48010913\",\n \"0.48003522\",\n \"0.479872\",\n \"0.47873342\",\n \"0.47846764\",\n \"0.47828007\",\n \"0.47808087\",\n \"0.4779133\",\n \"0.47774383\",\n \"0.4774203\",\n \"0.4767178\",\n \"0.47660217\",\n \"0.4764641\",\n \"0.4762371\",\n \"0.475913\",\n \"0.47568718\",\n \"0.47547925\",\n \"0.47526044\",\n \"0.47461602\",\n \"0.47422677\",\n \"0.4735532\",\n \"0.4732296\",\n \"0.472427\",\n \"0.4717124\",\n \"0.47163177\",\n \"0.4716019\",\n \"0.4715762\",\n \"0.47137326\",\n \"0.4711089\",\n \"0.47096556\",\n \"0.4702856\",\n \"0.4702148\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94282,"cells":{"query":{"kind":"string","value":"Send an email message."},"document":{"kind":"string","value":"def send_message(user_id, message):\r\n try:\r\n service = get_service('token.pickle')\r\n message = (service.users().messages().send(userId=user_id, body=message).execute())\r\n print('Message Id: %s' % message['id'])\r\n return message\r\n\r\n except errors.HttpError as error:\r\n print('An error occurred: %s' % error)"},"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 send_email(self, message):\n pass","def send_mail(email):\n return email.send()","def send_email(msg):\n\tprint(\"sendEmail: \" + msg)","def send_email(message):\n mail_server = smtplib.SMTP('localhost')\n mail_server.send_message(message)\n mail_server.quit()","def send_email(msg):\n common_send_email(subject=msg.subject, recipients=msg.recipients, html=msg.html)","def send_message(self, message):\n try:\n msg = sg.client.mail.send.post(request_body=message)\n app.logger.info(\"{error} with {response}\".format(error=msg.status_code, response=msg.body))\n app.logger.info(\"Successfully sent message: {msg}\".format(msg=msg))\n except Exception as e:\n app.logger.exception(\"Error While sending emails: {msg}\".format(msg=message))\n app.logger.exception(e)","def send_email(self, email_from, email_to, message):\n logging.info(\"Attempting to send email from \" + email_from + \" to \" + email_to)\n self.conn.sendmail(email_from, email_to, message)\n logging.info(\"Email sent\")","def send_message():\n # @todo validation & error handling.\n sg = SendGridAPIClient(apikey=os.environ.get('SENDGRID_API_KEY'))\n log(\"Message generated and sent at {}\".format(strftime('%x %H:%M:%S')))\n sg.client.mail.send.post(request_body=build_message())","def send(message):\n mail_server = smtplib.SMTP('localhost')\n mail_server.send_message(message)\n mail_server.quit()","def send_email(my_email, password, message):\n server = smtplib.SMTP(\"smtp.gmail.com\", 587)\n server.starttls()\n server.login(my_email, password)\n # send from my_email to my_email (from, to, message)\n server.sendmail(my_email, my_email, message)\n server.quit()","def send_mail(self, address, title, message):\n pass","def send_email(self):\n message = MIMEText(self.email_body, 'plain', 'utf-8')\n\n message['Subject'] = self.email_subject\n message['From'] = gmail_user\n message['To'] = ', '.join(self.recipients)\n\n try:\n server = smtplib.SMTP_SSL('smtp.gmail.com', 465)\n server.ehlo()\n\n server.login(gmail_user, gmail_password)\n\n server.sendmail(message['From'], self.recipients, message.as_string())\n\n server.close()\n\n print('Email sent!')\n except Exception as err:\n # TODO Write error to log file\n raise err","def send(self, email):\r\n smtp = smtplib.SMTP(self.server, self.port)\r\n smtp.ehlo()\r\n \r\n if self.tls:\r\n smtp.starttls()\r\n smtp.ehlo()\r\n\r\n if self.user and self.passwd:\r\n smtp.login(self.user, self.passwd)\r\n\r\n smtp.sendmail(email.from_address, email.to + email.ccs, str(email))\r\n if email.bccs:\r\n email.root['X-antroy-sent'] = \"True\"\r\n smtp.sendmail(email.from_address, email.bccs, str(email))\r\n del email.root['X-antroy-sent']\r\n smtp.quit()","def email(self, email_address, message):\n self.server.sendmail(self.username, email_address, message)","def send_email(subject, sender, recipients, text_body, html_body):\n\t\tmsg = Message(subject, sender=sender, recipients=recipients)\n\t\tmsg.body = text_body\n\t\tmsg.html = html_body\n\t\tmail.send(msg)","def send_email():\n send_mail(\"You've got some problem.\", 'REPAIR IT', 'dimazarj2009@rambler.ru',\n ['dimazarj2009@rambler.ru'], fail_silently=False,)","def send_mail(subject):\r\n obj = EmailNotification().emailobj()\r\n obj.send_mail(subject)","def send_email(subject, sender, recipients, text_body, html_body):\n msg = Message(subject=subject, sender=sender, recipients=recipients)\n msg.body = text_body\n msg.html = html_body\n mail.send(msg)","def send_email(self, to, subject, message):\n\n email_to = \"james@vixal.net\"\n try:\n mx_alarm = AlertEmail(email_to, self.subject, self.message)\n mx_alarm.send()\n print(\"\\t{} |{}| Successfully sent email.\".format(Timer.OK, self.tinfo['name']))\n return True\n except Exception as e:\n print(\"\\t{} Exception in send_email! {}\".format(Timer.FAIL, e))","def send_message(self, subject, body):\n headers = [\n \"From: \" + self.email,\n \"Subject: \" + subject,\n \"To: \" + self.email,\n \"MIME-Version: 1.0\",\n \"Content-Type: text/html\"]\n headers = \"\\r\\n\".join(headers)\n self.session.sendmail(\n self.email,\n self.email,\n headers + \"\\r\\n\\r\\n\" + body)","def send_message(user_id, name, user_info, subject, body):\n send_mail(subject, body, settings.SERVER_EMAIL, [\"%s <%s>\" % (name, user_id)],\n fail_silently=False, html_message=body)","def send_email(self, email):\n\n if not isinstance(email, str):\n raise TypeError('type of email must be str not %s' % type(email))\n\n message = self.get_message(email)\n self.server.send_message(message)","def send():\n try:\n data = request.get_json()\n if data['authkey'] != os.environ.get('MAIL_AUTHKEY'): \n return \"Ooops. Wrong `authkey`.\"\n msg = Message(data['subject'],\n sender=os.environ.get('MAIL_USERNAME'),\n recipients=[data['recipient']])\n msg.body = data['body'] \n mail.send(msg)\n return 'Mail sent!'\n except Exception as e:\n print('We got an error at ' + httpdate(datetime.datetime.now()))\n print(str(e)) \n return 'There was an error with that request.'","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def send_email(recipient, subject, message):\n from_email = os.getenv(\"EMAIL_SENDER\")\n status = send_mail(subject, message, from_email, [recipient])\n return status","def send_email(to_address, from_address, subject, body):\n mail = \"\"\"echo \"From: %(from)s\\r\\nDate: $(date)\\r\\nSubject: %(subject)s\\r\\nMIME-Version: 1.0\\r\\nContent-Type: text/html; charset=utf-8\\r\\n\\r\\n%(body)s\" | ssmtp %(to)s\"\"\" % {\n \"to\": to_address,\n \"from\": from_address,\n \"subject\": subject,\n \"body\": body,\n }\n cmd(mail)","def sendEmail(message):\n message_string = '\\n'.join(message)\n recipients = ['nadavo@campus.technion.ac.il', 'olegzendel@campus.technion.ac.il']\n msg = EmailMessage()\n msg['Subject'] = 'Finished training and predicting MEMM'\n msg['From'] = 'someserver@technion.ac.il'\n msg['To'] = ', '.join(recipients)\n msg.set_content(message_string)\n sender = SMTP('localhost')\n sender.send_message(msg)\n sender.quit()","def send_mail(to, sender, subject, message):\n\n msg = MIMEText(message)\n msg['From'] = sender\n msg['To'] = to\n msg['Subject'] = subject\n body = {'raw': base64.urlsafe_b64encode(msg.as_bytes()).decode()}\n MESSAGES.send(userId='me', body=body).execute()","def sending(self, message):\n sending_mail.send(sender=self.__class__, message=message)","def send_mail(self, subject):\r\n pass","def send_email(self, to, content):\r\n server = smtplib.SMTP(\"smtp.gmail.com\", 587)\r\n server.ehlo()\r\n server.starttls()\r\n server.login(self.from_, self.password)\r\n server.sendmail(self.from_, to, content)\r\n speak(\"Email has been sent Succesfully!\")\r\n return \"None\"","def send_mail(subject, message):\n \n import smtplib\n \n msg = \"\\r\\n\".join([\n \"From: \" + gmail_sender,\n \"To: \" + email_to,\n \"Subject: \" + subject,\n \"\",\n message\n ])\n\n server = smtplib.SMTP('smtp.gmail.com:587')\n server.ehlo()\n server.starttls()\n server.login(gmail_sender,gmail_password)\n server.sendmail(gmail_sender, email_to, msg)\n server.quit()","def sendEmail(_name, _email, _body):\n\n _mailer = app.config['MAIL_USERNAME']\n msg = Message(\"Contact Form\", sender=('iSOLveIT Contact', f'{_mailer}'), recipients=[f'{_mailer}'])\n msg.body = f'''{_body}\n\n\nSender's Name: {_name}\nSender's Email: {_email}\nDate Sent: {dt.now(tz=GMT_tz).strftime('%B %d, %Y, %H:%M ') + 'GMT'}\n'''\n mail.send(msg)\n return 'OK'","def _send_smtp(message, subject, to, to_name, sender, sender_name):\n host = app.config.get('MAIL_HOST')\n\n if not host:\n raise MailFailure('SMTP Server Not Configured')\n\n try:\n server = smtplib.SMTP(host)\n except (smtplib.SMTPConnectError, socket.error) as ex:\n app.logger.error('Unable to send mail: %s', str(ex))\n raise MailFailure('Error connecting to SMTP server.')\n\n msg = text.MIMEText(message)\n msg['Subject'] = subject\n msg['To'] = email.utils.formataddr((to_name, to))\n msg['From'] = email.utils.formataddr((sender_name, sender))\n\n try:\n if app.debug:\n server.set_debuglevel(True)\n server.sendmail(sender, [to], msg.as_string())\n except (smtplib.SMTPException, socket.error) as ex:\n app.logger.error('Unable to send mail: %s', str(ex))\n raise MailFailure('Error sending mail to SMTP server.')\n finally:\n try:\n server.quit()\n except smtplib.SMTPException:\n pass","def send_mail(self, msg):\n mail_queue.put(msg)","def send_email_via_api(self, to, subject, message):\n\n return self.mail.send(to, subject, message)","def send_email(self, to_address, subject, body, cc_recipients=[]):\n\n # Build and send message\n msg = Message(\n account=self.account,\n folder=self.account.sent,\n subject=subject,\n body= HTMLBody(body),\n to_recipients=[Mailbox(email_address=to_address)],\n cc_recipients=[(Mailbox(email_address=x)) for x in cc_recipients]\n )\n\n msg.send_and_save()\n print(\"Message to {} sent.\".format(to_address))","def quick_email(self, send_to, subject, body, style=None):\n message = Message(body, style=style)\n\n self.send_message(message, send_to, subject)","def send_email(recipient,subject,message):\n msg = MIMEText(message)\n me = 'cryolt2@gmail.com'\n \n msg['Subject'] = subject\n msg['From'] = me\n msg['To'] = recipient\n\n # Send the message via our own SMTP server, but don't include the\n # envelope header.\n username='cryolt2'\n password='Diamond=Geil!'\n\n server = smtplib.SMTP('smtp.gmail.com:587') \n server.starttls() \n server.login(username,password) \n server.sendmail(me, recipient, msg.as_string()) \n server.quit()","def send_message(self, message, send_to, subject):\n message = message.mime()\n\n message['From'] = self.email_address\n message['To'] = send_to\n\n message['Subject'] = subject\n\n self._login()\n self.server.sendmail(self.email_address, send_to, message.as_string())\n self._logout()","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def send(self, address_to, message, emailSubject = \"Automated Email\", attachmentFilePath = None):\r\n\t\tmail = self._createEmail(address_to, message, emailSubject)\r\n\t\tif attachmentFilePath != None:\r\n\t\t\tmail.attachment = self._createAttachment(attachmentFilePath)\r\n\t\tsg = sendgrid.SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))\r\n\t\tresponse = sg.send(mail)\r\n\t\tif response.status_code == 202:\r\n\t\t\tprint(\"Email sent\")\r\n\t\telse:\r\n\t\t\tprint(\"Email not sent. Please check error codes below - \")\r\n\t\t\tprint(response.status_code)\r\n\t\t\tprint(response.headers)","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None, **kwargs):\r\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\r\n send_mail(subject, message, from_email, [self.email], **kwargs)","def send_mail(self, html):\n message = Message(\n From=self._config['mail']['address'], To=self._config['mail']['to'],\n Subject=self._config['mail']['subject']\n )\n message.Html = html\n return self.sender.send(message)","def send_mail(from_email, to_emails, subject, plain_body, html_body):\n\n # Implementation goes here\n # ...","def test_send_email(self):\n\t\trecipient = \"\"\n\t\tself.email.send_email(self.subject, recipient, self.content)","def email_user(self, subject: str, message: str, from_email: str = None) -> None:\n send_mail(subject, message, from_email, [self.email])","def sent(self, message):\n sent_mail.send(sender=self.__class__, message=message)","def send_email(subject, text):\n url = ('https://api.mailgun.net/v3/%s/messages' %\n cfg('mail:mailgun_domain'))\n auth = ('api', cfg('mail:mailgun_key'))\n data = {'from': 'Akari Bot <%s>' % cfg('mail:from'),\n 'to': [cfg('mail:to')],\n 'subject': subject, 'text': text}\n return requests.post(url, auth=auth, data=data)","def _send(message: Message, application: Flask) -> None:\n\n with application.app_context():\n mail.send(message)","def email_user(self, subject, message, from_email=None):\n\t\tsend_mail(subject, message, from_email, [self.email])","def send_email(request):\n # send emails and return some manner of success response\n send(**request.params)\n return {'success': 'mail sent!'}","def send_email(self):\n server = smtplib.SMTP(\"smtp.gmail.com\", 587)\n server.ehlo()\n server.starttls()\n server.ehlo()\n server.login(\"sunnysunita.com@gmail.com\", \"tdcvgycwrzthjqgj\")\n\n subject = \"Price Fell Down\"\n body = \"Check the amazon link \" + self.__product_URL\n message = f\"Subject: {subject}\\n\\n{body}\"\n server.sendmail(\n \"sunnysunita.com@gmail.com\",\n self.__email,\n message\n )\n #print(\"Our mail is sent!!!!\")","def email_user(self, subject, message, from_email=None, **kwargs):\n\t\tsend_mail(subject, message, from_email, [self.email], **kwargs)","def email_to_user(self, subject, message, sender=None, **kwargs):\n send_mail(subject, message, sender, [self.email], **kwargs)","def send(self):\n return send_mail(self.subject, self.message, self.sender, self.recipients, fail_silently=False)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def send_async_email(self, msg):\n with app.app_context():\n result = mail.send(msg)\n print result","def send_email(sender: str, password: str) -> None:\r\n\r\n # Check for a email and password\r\n if not sender or not password:\r\n print('A recipent or password was not supplied')\r\n exit(1)\r\n \r\n initialize_server()\r\n\r\n webserver.login(sender, password)\r\n webserver.send_message(message)\r\n webserver.quit()","def sendEmail(recipient, content):\n server = smtplib.SMTP(\"smtp@gmail.com\", 587)\n server.ehlo()\n server.starttls()\n server.login(\"youremail@gmail.com\", \"password\")\n server.sendmail(\"youremail@gmail.com\", recipient, content)\n server.close()","def send(self):\n logger.debug('Sending Email')\n self.mimepgp.send()","def send_email(subject, message):\n email_from = config.get('email', 'email_from')\n email_to = config.get('email', 'email_to')\n email_password = config.get('email', 'email_password')\n msg = MIMEMultipart()\n msg['From'] = email_from\n msg['To'] = email_to\n msg['Subject'] = subject\n body = message\n msg.attach(MIMEText(body, 'plain'))\n\n server = smtplib.SMTP(config.get('email', 'smtp_server'))\n server.ehlo()\n server.starttls()\n server.login(email_from, email_password)\n text = msg.as_string()\n server.sendmail(email_from, email_to, text)\n server.quit()","def simple_send_email(sender, recipient, subject, message, server=EMAIL_HOST, port=EMAIL_PORT):\n headers = [\"From: \" + sender,\n \"Subject: \" + subject,\n \"To: \" + recipient,\n \"MIME-Version: 1.0\",\n \"Content-Type: text/plain\"]\n headers = \"\\r\\n\".join(headers)\n\n session = smtplib.SMTP(server, port)\n\n session.ehlo()\n session.starttls()\n session.ehlo()\n session.login(EMAIL_HOST_USER, EMAIL_HOST_PASSWORD)\n\n session.sendmail(sender, recipient, headers + \"\\r\\n\\r\\n\" + message)\n session.close()","def send_test_email():\n from flask_mail import Message\n from website.core import mail\n\n to = ['no-reply@mikefromit.com']\n subject = 'Test Email'\n template = '<h1>You Ok?</h1>'\n\n msg = Message(\n subject,\n recipients=to,\n html=template,\n sender=current_app.config['SECURITY_EMAIL_SENDER']\n )\n mail.send(msg)","def __send_message(self, message):\n logging.debug(\"Sending message\")\n try:\n message = self.__email_api.messages.send(message=message)\n return message\n except Error as error:\n logging.error('An error occurred emailing a user: {0}'.format(error))\n raise error","def send(self, email):\n client = self.clients[email.addressee]\n client.receive(email)","def send_email(recipient, subject, body) -> None:\n port = 465\n smtp_server = \"smtp.gmail.com\"\n sender_email = user['username']\n password = user['password']\n\n message = MIMEMultipart()\n message['From'] = sender_email\n message['To'] = recipient\n message['Subject'] = subject\n body = MIMEText(body) \n message.attach(body)\n\n server = smtplib.SMTP_SSL(smtp_server, port)\n server.login(sender_email, password)\n server.sendmail(sender_email, recipient, message.as_string())\n server.quit()","def send_mail(self):\n try:\n mail = smtplib.SMTP('smtp.gmail.com', 587)\n mail.ehlo()\n mail.starttls()\n mail.login(self.mail_user, self.mail_pass)\n content = \"Subject: Test %s %s on host %s\\n\\n%s\\n logs are save at localhost path:\\n%s\" % (\n self.test_name, self.event, self.host_name, self.event_details, self.log_path\n )\n mail.sendmail(self.mail_user, self.target_mail, content)\n mail.close()\n except Exception as e:\n self.logger.error(\"Sending mail failed with Error %s\", e)\n\n else:\n self.logger.info(\"Mail sent to %s\", self.target_mail)","def email_user(self, subject, message,\n from_email=settings.DEFAULT_FROM_EMAIL, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def send_email(subject, body, mail_to, reply_to=None):\n email_message = EmailMessage(\n subject=settings.EMAIL_SUBJECT.format(subject),\n body=body,\n from_email=settings.DEFAULT_FROM_EMAIL,\n to=mail_to,\n reply_to=reply_to,\n )\n email_message.content_subtype = 'html'\n email_message.send()","def _send(self, email_message):\n if not email_message.to:\n return False\n try:\n if (isinstance(email_message,gmail.EmailMessage)):\n e = message\n elif (isinstance(email_message,mail.EmailMessage)):\n e = gmail.EmailMessage(sender=email_message.from_email,\n to=email_message.to,\n subject=email_message.subject,\n body=email_message.body)\n if email_message.extra_headers.get('Reply-To', None):\n e.reply_to = email_message.extra_headers['Reply-To']\n if email_message.bcc:\n e.bcc = list(email_message.bcc)\n #TODO - add support for html messages and attachments...\n e.send()\n except:\n if not self.fail_silently:\n raise\n return False\n return True","def send_email(email_subject, recipient, message, config = None):\n try:\n config = current_app.config\n except:\n config = config\n\n sender = sendgrid.SendGridClient(config['SENDGRID_API_KEY'])\n\n email = sendgrid.Mail()\n\n email.set_subject(email_subject)\n email.add_to(recipient)\n email.set_from(config['FROM_EMAIL'])\n email.set_from_name(config['FROM_NAME'])\n email.set_replyto(config['FROM_NAME'])\n email.set_html(message)\n\n status, msg = sender.send(email)\n\n return status, msg","def mail_send():\n report_file_path = (\n f'{os.path.abspath(\".\")}/{Common.get_config_value(\"report_location\")}'\n )\n with open(f\"{report_file_path}/subject\", \"rb\") as subject_handler:\n subject = pickle.load(subject_handler)\n with open(f\"{report_file_path}/{'recipient'}\", \"rb\") as recipient_handler:\n recipient = pickle.load(recipient_handler)\n report_file_path = (\n f\"{os.path.abspath('.')}/{Common.get_config_value('report_location')}\"\n )\n try:\n if os.path.isfile(f\"{report_file_path}/mail_report.html\"):\n os.popen(\n f\"ssh -i {Common.get_config_value('build_server_pemfile')} \"\n f\"-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no\"\n f\" root@{Common.get_config_value('build_server_hostname')}\"\n f\" {Common.get_config_value('mail_script_location')}/\"\n f\"{Common.get_config_value('mail_script_name')} \"\n f\"{subject} {recipient}\"\n )\n Common.logger.info(\"Mail send successfully\")\n except Exception as ex:\n Common.logger.warning(f\"Mail sent failed due to exception: {ex}\")","def send_email(self, text):\n msg_text = MIMEText(text)\n msg_text['Subject'] = '[WebSite Watchdog] Failure'\n msg_text['From'] = self.from_email\n msg_text['To'] = self.to_email\n \n s = smtplib.SMTP(self.smtp_server)\n s.sendmail(self.from_email, [self.to_email], msg_text.as_string())\n s.quit()","def _send_mail(self, subject, content, email):\n msg = MIMEText(content, 'plain', 'utf-8')\n\n msg['Subject'] = '%s' % (subject)\n msg['From'] = email\n msg['To'] = self._get_config_value('email', 'toemail')\n\n try:\n smtp_conn = SMTP('localhost')\n smtp_conn.sendmail(msg['From'], [msg['To']], msg.as_string())\n smtp_conn.quit()\n except (socket.error, SMTPException), e:\n self._logger.error('Mail could not be sent (%s)' % e)\n return False\n return True","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.username])","def send_email(email: str, subject: str, message_body: str) -> bool:\n message = Mail(\n from_email=\"notifications@grocery.com\",\n to_emails=email,\n subject=subject,\n plain_text_content=message_body,\n )\n sg = SendGridAPIClient(os.environ.get(\"SENDGRID_API_KEY\"))\n sg.send(message)\n return True"],"string":"[\n \"def send_email(self, message):\\n pass\",\n \"def send_mail(email):\\n return email.send()\",\n \"def send_email(msg):\\n\\tprint(\\\"sendEmail: \\\" + msg)\",\n \"def send_email(message):\\n mail_server = smtplib.SMTP('localhost')\\n mail_server.send_message(message)\\n mail_server.quit()\",\n \"def send_email(msg):\\n common_send_email(subject=msg.subject, recipients=msg.recipients, html=msg.html)\",\n \"def send_message(self, message):\\n try:\\n msg = sg.client.mail.send.post(request_body=message)\\n app.logger.info(\\\"{error} with {response}\\\".format(error=msg.status_code, response=msg.body))\\n app.logger.info(\\\"Successfully sent message: {msg}\\\".format(msg=msg))\\n except Exception as e:\\n app.logger.exception(\\\"Error While sending emails: {msg}\\\".format(msg=message))\\n app.logger.exception(e)\",\n \"def send_email(self, email_from, email_to, message):\\n logging.info(\\\"Attempting to send email from \\\" + email_from + \\\" to \\\" + email_to)\\n self.conn.sendmail(email_from, email_to, message)\\n logging.info(\\\"Email sent\\\")\",\n \"def send_message():\\n # @todo validation & error handling.\\n sg = SendGridAPIClient(apikey=os.environ.get('SENDGRID_API_KEY'))\\n log(\\\"Message generated and sent at {}\\\".format(strftime('%x %H:%M:%S')))\\n sg.client.mail.send.post(request_body=build_message())\",\n \"def send(message):\\n mail_server = smtplib.SMTP('localhost')\\n mail_server.send_message(message)\\n mail_server.quit()\",\n \"def send_email(my_email, password, message):\\n server = smtplib.SMTP(\\\"smtp.gmail.com\\\", 587)\\n server.starttls()\\n server.login(my_email, password)\\n # send from my_email to my_email (from, to, message)\\n server.sendmail(my_email, my_email, message)\\n server.quit()\",\n \"def send_mail(self, address, title, message):\\n pass\",\n \"def send_email(self):\\n message = MIMEText(self.email_body, 'plain', 'utf-8')\\n\\n message['Subject'] = self.email_subject\\n message['From'] = gmail_user\\n message['To'] = ', '.join(self.recipients)\\n\\n try:\\n server = smtplib.SMTP_SSL('smtp.gmail.com', 465)\\n server.ehlo()\\n\\n server.login(gmail_user, gmail_password)\\n\\n server.sendmail(message['From'], self.recipients, message.as_string())\\n\\n server.close()\\n\\n print('Email sent!')\\n except Exception as err:\\n # TODO Write error to log file\\n raise err\",\n \"def send(self, email):\\r\\n smtp = smtplib.SMTP(self.server, self.port)\\r\\n smtp.ehlo()\\r\\n \\r\\n if self.tls:\\r\\n smtp.starttls()\\r\\n smtp.ehlo()\\r\\n\\r\\n if self.user and self.passwd:\\r\\n smtp.login(self.user, self.passwd)\\r\\n\\r\\n smtp.sendmail(email.from_address, email.to + email.ccs, str(email))\\r\\n if email.bccs:\\r\\n email.root['X-antroy-sent'] = \\\"True\\\"\\r\\n smtp.sendmail(email.from_address, email.bccs, str(email))\\r\\n del email.root['X-antroy-sent']\\r\\n smtp.quit()\",\n \"def email(self, email_address, message):\\n self.server.sendmail(self.username, email_address, message)\",\n \"def send_email(subject, sender, recipients, text_body, html_body):\\n\\t\\tmsg = Message(subject, sender=sender, recipients=recipients)\\n\\t\\tmsg.body = text_body\\n\\t\\tmsg.html = html_body\\n\\t\\tmail.send(msg)\",\n \"def send_email():\\n send_mail(\\\"You've got some problem.\\\", 'REPAIR IT', 'dimazarj2009@rambler.ru',\\n ['dimazarj2009@rambler.ru'], fail_silently=False,)\",\n \"def send_mail(subject):\\r\\n obj = EmailNotification().emailobj()\\r\\n obj.send_mail(subject)\",\n \"def send_email(subject, sender, recipients, text_body, html_body):\\n msg = Message(subject=subject, sender=sender, recipients=recipients)\\n msg.body = text_body\\n msg.html = html_body\\n mail.send(msg)\",\n \"def send_email(self, to, subject, message):\\n\\n email_to = \\\"james@vixal.net\\\"\\n try:\\n mx_alarm = AlertEmail(email_to, self.subject, self.message)\\n mx_alarm.send()\\n print(\\\"\\\\t{} |{}| Successfully sent email.\\\".format(Timer.OK, self.tinfo['name']))\\n return True\\n except Exception as e:\\n print(\\\"\\\\t{} Exception in send_email! {}\\\".format(Timer.FAIL, e))\",\n \"def send_message(self, subject, body):\\n headers = [\\n \\\"From: \\\" + self.email,\\n \\\"Subject: \\\" + subject,\\n \\\"To: \\\" + self.email,\\n \\\"MIME-Version: 1.0\\\",\\n \\\"Content-Type: text/html\\\"]\\n headers = \\\"\\\\r\\\\n\\\".join(headers)\\n self.session.sendmail(\\n self.email,\\n self.email,\\n headers + \\\"\\\\r\\\\n\\\\r\\\\n\\\" + body)\",\n \"def send_message(user_id, name, user_info, subject, body):\\n send_mail(subject, body, settings.SERVER_EMAIL, [\\\"%s <%s>\\\" % (name, user_id)],\\n fail_silently=False, html_message=body)\",\n \"def send_email(self, email):\\n\\n if not isinstance(email, str):\\n raise TypeError('type of email must be str not %s' % type(email))\\n\\n message = self.get_message(email)\\n self.server.send_message(message)\",\n \"def send():\\n try:\\n data = request.get_json()\\n if data['authkey'] != os.environ.get('MAIL_AUTHKEY'): \\n return \\\"Ooops. Wrong `authkey`.\\\"\\n msg = Message(data['subject'],\\n sender=os.environ.get('MAIL_USERNAME'),\\n recipients=[data['recipient']])\\n msg.body = data['body'] \\n mail.send(msg)\\n return 'Mail sent!'\\n except Exception as e:\\n print('We got an error at ' + httpdate(datetime.datetime.now()))\\n print(str(e)) \\n return 'There was an error with that request.'\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def send_email(recipient, subject, message):\\n from_email = os.getenv(\\\"EMAIL_SENDER\\\")\\n status = send_mail(subject, message, from_email, [recipient])\\n return status\",\n \"def send_email(to_address, from_address, subject, body):\\n mail = \\\"\\\"\\\"echo \\\"From: %(from)s\\\\r\\\\nDate: $(date)\\\\r\\\\nSubject: %(subject)s\\\\r\\\\nMIME-Version: 1.0\\\\r\\\\nContent-Type: text/html; charset=utf-8\\\\r\\\\n\\\\r\\\\n%(body)s\\\" | ssmtp %(to)s\\\"\\\"\\\" % {\\n \\\"to\\\": to_address,\\n \\\"from\\\": from_address,\\n \\\"subject\\\": subject,\\n \\\"body\\\": body,\\n }\\n cmd(mail)\",\n \"def sendEmail(message):\\n message_string = '\\\\n'.join(message)\\n recipients = ['nadavo@campus.technion.ac.il', 'olegzendel@campus.technion.ac.il']\\n msg = EmailMessage()\\n msg['Subject'] = 'Finished training and predicting MEMM'\\n msg['From'] = 'someserver@technion.ac.il'\\n msg['To'] = ', '.join(recipients)\\n msg.set_content(message_string)\\n sender = SMTP('localhost')\\n sender.send_message(msg)\\n sender.quit()\",\n \"def send_mail(to, sender, subject, message):\\n\\n msg = MIMEText(message)\\n msg['From'] = sender\\n msg['To'] = to\\n msg['Subject'] = subject\\n body = {'raw': base64.urlsafe_b64encode(msg.as_bytes()).decode()}\\n MESSAGES.send(userId='me', body=body).execute()\",\n \"def sending(self, message):\\n sending_mail.send(sender=self.__class__, message=message)\",\n \"def send_mail(self, subject):\\r\\n pass\",\n \"def send_email(self, to, content):\\r\\n server = smtplib.SMTP(\\\"smtp.gmail.com\\\", 587)\\r\\n server.ehlo()\\r\\n server.starttls()\\r\\n server.login(self.from_, self.password)\\r\\n server.sendmail(self.from_, to, content)\\r\\n speak(\\\"Email has been sent Succesfully!\\\")\\r\\n return \\\"None\\\"\",\n \"def send_mail(subject, message):\\n \\n import smtplib\\n \\n msg = \\\"\\\\r\\\\n\\\".join([\\n \\\"From: \\\" + gmail_sender,\\n \\\"To: \\\" + email_to,\\n \\\"Subject: \\\" + subject,\\n \\\"\\\",\\n message\\n ])\\n\\n server = smtplib.SMTP('smtp.gmail.com:587')\\n server.ehlo()\\n server.starttls()\\n server.login(gmail_sender,gmail_password)\\n server.sendmail(gmail_sender, email_to, msg)\\n server.quit()\",\n \"def sendEmail(_name, _email, _body):\\n\\n _mailer = app.config['MAIL_USERNAME']\\n msg = Message(\\\"Contact Form\\\", sender=('iSOLveIT Contact', f'{_mailer}'), recipients=[f'{_mailer}'])\\n msg.body = f'''{_body}\\n\\n\\nSender's Name: {_name}\\nSender's Email: {_email}\\nDate Sent: {dt.now(tz=GMT_tz).strftime('%B %d, %Y, %H:%M ') + 'GMT'}\\n'''\\n mail.send(msg)\\n return 'OK'\",\n \"def _send_smtp(message, subject, to, to_name, sender, sender_name):\\n host = app.config.get('MAIL_HOST')\\n\\n if not host:\\n raise MailFailure('SMTP Server Not Configured')\\n\\n try:\\n server = smtplib.SMTP(host)\\n except (smtplib.SMTPConnectError, socket.error) as ex:\\n app.logger.error('Unable to send mail: %s', str(ex))\\n raise MailFailure('Error connecting to SMTP server.')\\n\\n msg = text.MIMEText(message)\\n msg['Subject'] = subject\\n msg['To'] = email.utils.formataddr((to_name, to))\\n msg['From'] = email.utils.formataddr((sender_name, sender))\\n\\n try:\\n if app.debug:\\n server.set_debuglevel(True)\\n server.sendmail(sender, [to], msg.as_string())\\n except (smtplib.SMTPException, socket.error) as ex:\\n app.logger.error('Unable to send mail: %s', str(ex))\\n raise MailFailure('Error sending mail to SMTP server.')\\n finally:\\n try:\\n server.quit()\\n except smtplib.SMTPException:\\n pass\",\n \"def send_mail(self, msg):\\n mail_queue.put(msg)\",\n \"def send_email_via_api(self, to, subject, message):\\n\\n return self.mail.send(to, subject, message)\",\n \"def send_email(self, to_address, subject, body, cc_recipients=[]):\\n\\n # Build and send message\\n msg = Message(\\n account=self.account,\\n folder=self.account.sent,\\n subject=subject,\\n body= HTMLBody(body),\\n to_recipients=[Mailbox(email_address=to_address)],\\n cc_recipients=[(Mailbox(email_address=x)) for x in cc_recipients]\\n )\\n\\n msg.send_and_save()\\n print(\\\"Message to {} sent.\\\".format(to_address))\",\n \"def quick_email(self, send_to, subject, body, style=None):\\n message = Message(body, style=style)\\n\\n self.send_message(message, send_to, subject)\",\n \"def send_email(recipient,subject,message):\\n msg = MIMEText(message)\\n me = 'cryolt2@gmail.com'\\n \\n msg['Subject'] = subject\\n msg['From'] = me\\n msg['To'] = recipient\\n\\n # Send the message via our own SMTP server, but don't include the\\n # envelope header.\\n username='cryolt2'\\n password='Diamond=Geil!'\\n\\n server = smtplib.SMTP('smtp.gmail.com:587') \\n server.starttls() \\n server.login(username,password) \\n server.sendmail(me, recipient, msg.as_string()) \\n server.quit()\",\n \"def send_message(self, message, send_to, subject):\\n message = message.mime()\\n\\n message['From'] = self.email_address\\n message['To'] = send_to\\n\\n message['Subject'] = subject\\n\\n self._login()\\n self.server.sendmail(self.email_address, send_to, message.as_string())\\n self._logout()\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def send(self, address_to, message, emailSubject = \\\"Automated Email\\\", attachmentFilePath = None):\\r\\n\\t\\tmail = self._createEmail(address_to, message, emailSubject)\\r\\n\\t\\tif attachmentFilePath != None:\\r\\n\\t\\t\\tmail.attachment = self._createAttachment(attachmentFilePath)\\r\\n\\t\\tsg = sendgrid.SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))\\r\\n\\t\\tresponse = sg.send(mail)\\r\\n\\t\\tif response.status_code == 202:\\r\\n\\t\\t\\tprint(\\\"Email sent\\\")\\r\\n\\t\\telse:\\r\\n\\t\\t\\tprint(\\\"Email not sent. Please check error codes below - \\\")\\r\\n\\t\\t\\tprint(response.status_code)\\r\\n\\t\\t\\tprint(response.headers)\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\r\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\r\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def send_mail(self, html):\\n message = Message(\\n From=self._config['mail']['address'], To=self._config['mail']['to'],\\n Subject=self._config['mail']['subject']\\n )\\n message.Html = html\\n return self.sender.send(message)\",\n \"def send_mail(from_email, to_emails, subject, plain_body, html_body):\\n\\n # Implementation goes here\\n # ...\",\n \"def test_send_email(self):\\n\\t\\trecipient = \\\"\\\"\\n\\t\\tself.email.send_email(self.subject, recipient, self.content)\",\n \"def email_user(self, subject: str, message: str, from_email: str = None) -> None:\\n send_mail(subject, message, from_email, [self.email])\",\n \"def sent(self, message):\\n sent_mail.send(sender=self.__class__, message=message)\",\n \"def send_email(subject, text):\\n url = ('https://api.mailgun.net/v3/%s/messages' %\\n cfg('mail:mailgun_domain'))\\n auth = ('api', cfg('mail:mailgun_key'))\\n data = {'from': 'Akari Bot <%s>' % cfg('mail:from'),\\n 'to': [cfg('mail:to')],\\n 'subject': subject, 'text': text}\\n return requests.post(url, auth=auth, data=data)\",\n \"def _send(message: Message, application: Flask) -> None:\\n\\n with application.app_context():\\n mail.send(message)\",\n \"def email_user(self, subject, message, from_email=None):\\n\\t\\tsend_mail(subject, message, from_email, [self.email])\",\n \"def send_email(request):\\n # send emails and return some manner of success response\\n send(**request.params)\\n return {'success': 'mail sent!'}\",\n \"def send_email(self):\\n server = smtplib.SMTP(\\\"smtp.gmail.com\\\", 587)\\n server.ehlo()\\n server.starttls()\\n server.ehlo()\\n server.login(\\\"sunnysunita.com@gmail.com\\\", \\\"tdcvgycwrzthjqgj\\\")\\n\\n subject = \\\"Price Fell Down\\\"\\n body = \\\"Check the amazon link \\\" + self.__product_URL\\n message = f\\\"Subject: {subject}\\\\n\\\\n{body}\\\"\\n server.sendmail(\\n \\\"sunnysunita.com@gmail.com\\\",\\n self.__email,\\n message\\n )\\n #print(\\\"Our mail is sent!!!!\\\")\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n\\t\\tsend_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_to_user(self, subject, message, sender=None, **kwargs):\\n send_mail(subject, message, sender, [self.email], **kwargs)\",\n \"def send(self):\\n return send_mail(self.subject, self.message, self.sender, self.recipients, fail_silently=False)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def send_async_email(self, msg):\\n with app.app_context():\\n result = mail.send(msg)\\n print result\",\n \"def send_email(sender: str, password: str) -> None:\\r\\n\\r\\n # Check for a email and password\\r\\n if not sender or not password:\\r\\n print('A recipent or password was not supplied')\\r\\n exit(1)\\r\\n \\r\\n initialize_server()\\r\\n\\r\\n webserver.login(sender, password)\\r\\n webserver.send_message(message)\\r\\n webserver.quit()\",\n \"def sendEmail(recipient, content):\\n server = smtplib.SMTP(\\\"smtp@gmail.com\\\", 587)\\n server.ehlo()\\n server.starttls()\\n server.login(\\\"youremail@gmail.com\\\", \\\"password\\\")\\n server.sendmail(\\\"youremail@gmail.com\\\", recipient, content)\\n server.close()\",\n \"def send(self):\\n logger.debug('Sending Email')\\n self.mimepgp.send()\",\n \"def send_email(subject, message):\\n email_from = config.get('email', 'email_from')\\n email_to = config.get('email', 'email_to')\\n email_password = config.get('email', 'email_password')\\n msg = MIMEMultipart()\\n msg['From'] = email_from\\n msg['To'] = email_to\\n msg['Subject'] = subject\\n body = message\\n msg.attach(MIMEText(body, 'plain'))\\n\\n server = smtplib.SMTP(config.get('email', 'smtp_server'))\\n server.ehlo()\\n server.starttls()\\n server.login(email_from, email_password)\\n text = msg.as_string()\\n server.sendmail(email_from, email_to, text)\\n server.quit()\",\n \"def simple_send_email(sender, recipient, subject, message, server=EMAIL_HOST, port=EMAIL_PORT):\\n headers = [\\\"From: \\\" + sender,\\n \\\"Subject: \\\" + subject,\\n \\\"To: \\\" + recipient,\\n \\\"MIME-Version: 1.0\\\",\\n \\\"Content-Type: text/plain\\\"]\\n headers = \\\"\\\\r\\\\n\\\".join(headers)\\n\\n session = smtplib.SMTP(server, port)\\n\\n session.ehlo()\\n session.starttls()\\n session.ehlo()\\n session.login(EMAIL_HOST_USER, EMAIL_HOST_PASSWORD)\\n\\n session.sendmail(sender, recipient, headers + \\\"\\\\r\\\\n\\\\r\\\\n\\\" + message)\\n session.close()\",\n \"def send_test_email():\\n from flask_mail import Message\\n from website.core import mail\\n\\n to = ['no-reply@mikefromit.com']\\n subject = 'Test Email'\\n template = '<h1>You Ok?</h1>'\\n\\n msg = Message(\\n subject,\\n recipients=to,\\n html=template,\\n sender=current_app.config['SECURITY_EMAIL_SENDER']\\n )\\n mail.send(msg)\",\n \"def __send_message(self, message):\\n logging.debug(\\\"Sending message\\\")\\n try:\\n message = self.__email_api.messages.send(message=message)\\n return message\\n except Error as error:\\n logging.error('An error occurred emailing a user: {0}'.format(error))\\n raise error\",\n \"def send(self, email):\\n client = self.clients[email.addressee]\\n client.receive(email)\",\n \"def send_email(recipient, subject, body) -> None:\\n port = 465\\n smtp_server = \\\"smtp.gmail.com\\\"\\n sender_email = user['username']\\n password = user['password']\\n\\n message = MIMEMultipart()\\n message['From'] = sender_email\\n message['To'] = recipient\\n message['Subject'] = subject\\n body = MIMEText(body) \\n message.attach(body)\\n\\n server = smtplib.SMTP_SSL(smtp_server, port)\\n server.login(sender_email, password)\\n server.sendmail(sender_email, recipient, message.as_string())\\n server.quit()\",\n \"def send_mail(self):\\n try:\\n mail = smtplib.SMTP('smtp.gmail.com', 587)\\n mail.ehlo()\\n mail.starttls()\\n mail.login(self.mail_user, self.mail_pass)\\n content = \\\"Subject: Test %s %s on host %s\\\\n\\\\n%s\\\\n logs are save at localhost path:\\\\n%s\\\" % (\\n self.test_name, self.event, self.host_name, self.event_details, self.log_path\\n )\\n mail.sendmail(self.mail_user, self.target_mail, content)\\n mail.close()\\n except Exception as e:\\n self.logger.error(\\\"Sending mail failed with Error %s\\\", e)\\n\\n else:\\n self.logger.info(\\\"Mail sent to %s\\\", self.target_mail)\",\n \"def email_user(self, subject, message,\\n from_email=settings.DEFAULT_FROM_EMAIL, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def send_email(subject, body, mail_to, reply_to=None):\\n email_message = EmailMessage(\\n subject=settings.EMAIL_SUBJECT.format(subject),\\n body=body,\\n from_email=settings.DEFAULT_FROM_EMAIL,\\n to=mail_to,\\n reply_to=reply_to,\\n )\\n email_message.content_subtype = 'html'\\n email_message.send()\",\n \"def _send(self, email_message):\\n if not email_message.to:\\n return False\\n try:\\n if (isinstance(email_message,gmail.EmailMessage)):\\n e = message\\n elif (isinstance(email_message,mail.EmailMessage)):\\n e = gmail.EmailMessage(sender=email_message.from_email,\\n to=email_message.to,\\n subject=email_message.subject,\\n body=email_message.body)\\n if email_message.extra_headers.get('Reply-To', None):\\n e.reply_to = email_message.extra_headers['Reply-To']\\n if email_message.bcc:\\n e.bcc = list(email_message.bcc)\\n #TODO - add support for html messages and attachments...\\n e.send()\\n except:\\n if not self.fail_silently:\\n raise\\n return False\\n return True\",\n \"def send_email(email_subject, recipient, message, config = None):\\n try:\\n config = current_app.config\\n except:\\n config = config\\n\\n sender = sendgrid.SendGridClient(config['SENDGRID_API_KEY'])\\n\\n email = sendgrid.Mail()\\n\\n email.set_subject(email_subject)\\n email.add_to(recipient)\\n email.set_from(config['FROM_EMAIL'])\\n email.set_from_name(config['FROM_NAME'])\\n email.set_replyto(config['FROM_NAME'])\\n email.set_html(message)\\n\\n status, msg = sender.send(email)\\n\\n return status, msg\",\n \"def mail_send():\\n report_file_path = (\\n f'{os.path.abspath(\\\".\\\")}/{Common.get_config_value(\\\"report_location\\\")}'\\n )\\n with open(f\\\"{report_file_path}/subject\\\", \\\"rb\\\") as subject_handler:\\n subject = pickle.load(subject_handler)\\n with open(f\\\"{report_file_path}/{'recipient'}\\\", \\\"rb\\\") as recipient_handler:\\n recipient = pickle.load(recipient_handler)\\n report_file_path = (\\n f\\\"{os.path.abspath('.')}/{Common.get_config_value('report_location')}\\\"\\n )\\n try:\\n if os.path.isfile(f\\\"{report_file_path}/mail_report.html\\\"):\\n os.popen(\\n f\\\"ssh -i {Common.get_config_value('build_server_pemfile')} \\\"\\n f\\\"-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no\\\"\\n f\\\" root@{Common.get_config_value('build_server_hostname')}\\\"\\n f\\\" {Common.get_config_value('mail_script_location')}/\\\"\\n f\\\"{Common.get_config_value('mail_script_name')} \\\"\\n f\\\"{subject} {recipient}\\\"\\n )\\n Common.logger.info(\\\"Mail send successfully\\\")\\n except Exception as ex:\\n Common.logger.warning(f\\\"Mail sent failed due to exception: {ex}\\\")\",\n \"def send_email(self, text):\\n msg_text = MIMEText(text)\\n msg_text['Subject'] = '[WebSite Watchdog] Failure'\\n msg_text['From'] = self.from_email\\n msg_text['To'] = self.to_email\\n \\n s = smtplib.SMTP(self.smtp_server)\\n s.sendmail(self.from_email, [self.to_email], msg_text.as_string())\\n s.quit()\",\n \"def _send_mail(self, subject, content, email):\\n msg = MIMEText(content, 'plain', 'utf-8')\\n\\n msg['Subject'] = '%s' % (subject)\\n msg['From'] = email\\n msg['To'] = self._get_config_value('email', 'toemail')\\n\\n try:\\n smtp_conn = SMTP('localhost')\\n smtp_conn.sendmail(msg['From'], [msg['To']], msg.as_string())\\n smtp_conn.quit()\\n except (socket.error, SMTPException), e:\\n self._logger.error('Mail could not be sent (%s)' % e)\\n return False\\n return True\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.username])\",\n \"def send_email(email: str, subject: str, message_body: str) -> bool:\\n message = Mail(\\n from_email=\\\"notifications@grocery.com\\\",\\n to_emails=email,\\n subject=subject,\\n plain_text_content=message_body,\\n )\\n sg = SendGridAPIClient(os.environ.get(\\\"SENDGRID_API_KEY\\\"))\\n sg.send(message)\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8239757","0.80890095","0.79037267","0.78920776","0.7768939","0.7730623","0.7727504","0.76961035","0.76466435","0.7635667","0.7613354","0.7608988","0.7607686","0.7554999","0.7533295","0.7488125","0.74320126","0.74103194","0.7409468","0.7407818","0.7407659","0.7379054","0.73781234","0.7377925","0.7371525","0.73646206","0.7337151","0.733522","0.73204684","0.7319344","0.7315561","0.7312886","0.72968775","0.7276211","0.7274837","0.72666043","0.72538304","0.72514015","0.72259086","0.72171575","0.7209841","0.72038347","0.7203337","0.7203337","0.7203337","0.7203337","0.7203337","0.7203337","0.7203337","0.7203337","0.7203047","0.7203047","0.7188015","0.71835506","0.7174273","0.7171283","0.71695065","0.7169298","0.7150135","0.7144315","0.71131754","0.7108381","0.70906496","0.7089287","0.7087746","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.70606685","0.70528996","0.7043591","0.7036554","0.70276695","0.701519","0.7012193","0.70107424","0.7001337","0.70003504","0.69914514","0.6991162","0.69862646","0.6980836","0.69771427","0.6975864","0.69592273","0.6957208","0.6956571","0.69260556"],"string":"[\n \"0.8239757\",\n \"0.80890095\",\n \"0.79037267\",\n \"0.78920776\",\n \"0.7768939\",\n \"0.7730623\",\n \"0.7727504\",\n \"0.76961035\",\n \"0.76466435\",\n \"0.7635667\",\n \"0.7613354\",\n \"0.7608988\",\n \"0.7607686\",\n \"0.7554999\",\n \"0.7533295\",\n \"0.7488125\",\n \"0.74320126\",\n \"0.74103194\",\n \"0.7409468\",\n \"0.7407818\",\n \"0.7407659\",\n \"0.7379054\",\n \"0.73781234\",\n \"0.7377925\",\n \"0.7371525\",\n \"0.73646206\",\n \"0.7337151\",\n \"0.733522\",\n \"0.73204684\",\n \"0.7319344\",\n \"0.7315561\",\n \"0.7312886\",\n \"0.72968775\",\n \"0.7276211\",\n \"0.7274837\",\n \"0.72666043\",\n \"0.72538304\",\n \"0.72514015\",\n \"0.72259086\",\n \"0.72171575\",\n \"0.7209841\",\n \"0.72038347\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203047\",\n \"0.7203047\",\n \"0.7188015\",\n \"0.71835506\",\n \"0.7174273\",\n \"0.7171283\",\n \"0.71695065\",\n \"0.7169298\",\n \"0.7150135\",\n \"0.7144315\",\n \"0.71131754\",\n \"0.7108381\",\n \"0.70906496\",\n \"0.7089287\",\n \"0.7087746\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.70606685\",\n \"0.70528996\",\n \"0.7043591\",\n \"0.7036554\",\n \"0.70276695\",\n \"0.701519\",\n \"0.7012193\",\n \"0.70107424\",\n \"0.7001337\",\n \"0.70003504\",\n \"0.69914514\",\n \"0.6991162\",\n \"0.69862646\",\n \"0.6980836\",\n \"0.69771427\",\n \"0.6975864\",\n \"0.69592273\",\n \"0.6957208\",\n \"0.6956571\",\n \"0.69260556\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94283,"cells":{"query":{"kind":"string","value":"Shows basic usage of the Gmail API. Lists the user's Gmail labels."},"document":{"kind":"string","value":"def build_service():\r\n creds = None\r\n # The file token.pickle stores the user's access and refresh tokens, and is\r\n # created automatically when the authorization flow completes for the first\r\n # time.\r\n if os.path.exists('token.pickle'):\r\n with open('token.pickle', 'rb') as token:\r\n creds = pickle.load(token)\r\n # If there are no (valid) credentials available, let the user log in.\r\n if not creds or not creds.valid:\r\n if creds and creds.expired and creds.refresh_token:\r\n creds.refresh(Request())\r\n else:\r\n flow = InstalledAppFlow.from_client_secrets_file(\r\n f\"{EMAIL_ACCOUNT_FILE}\", SCOPES)\r\n creds = flow.run_local_server(port=0)\r\n # Save the credentials for the next run\r\n with open('token.pickle', 'wb') as token:\r\n pickle.dump(creds, token)\r\n\r\n service = build('gmail', 'v1', credentials=creds)\r\n return service"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_labels():\n\n logging.info(\"Getting metadata about labels\")\n\n labels = []\n\n if len(args.labels) == 0:\n logging.warning(\"No labels specified, assuming all labels. If you have a lot of labels in your inbox you could hit API limits quickly.\")\n results = GMAIL_CLIENT.users().labels().list(userId='me').execute()\n\n labels = results.get('labels', [])\n else:\n logging.info('Using labels: %s ', args.labels)\n\n for label in args.labels:\n labels.append({'id': label})\n\n if not labels:\n logging.info('No labels found.')\n sys.exit()\n\n return labels","def gmail(screen):\n\n\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = discovery.build('gmail', 'v1', http=http)\n\n results = service.users().labels().list(userId='me').execute()\n labels = results.get('labels', [])\n\n\n\n if not labels:\n print('No labels found.')\n else:\n if PRINT_CATEGORY: print('Labels:')\n for label in labels:\n if PRINT_CATEGORY: print(label['name'])\n if label['name']=='UNREAD':\n listMessages = ListMessagesWithLabels(service, 'me', label['name'])\n nbMessages = len(listMessages)\n nbMess = 0\n\n printTerminal('ENZO! Tu as ['+str(nbMessages)+'] messages non lus.',True)\n say('ENZO! Tu as: '+str(nbMessages)+' messages non lus.')\n\n for message in listMessages:\n #print(GetMessage(service, 'me', message['id'], False))\n nbMess+=1\n ggMessage = GetMessage(service, 'me', message['id'], False)\n #print(ggMessage)\n\n #msg_str = base64.urlsafe_b64decode(ggMessage['raw'].encode('ASCII'))\n #print(msg_str)\n\n for header in ggMessage['payload']['headers']:\n #print(header)\n if header['name']=='Subject':\n #unicode(text,'utf-8')\n #screen.addstr(0,1,\"\")\n if screen:\n screen.addstr(str(nbMess)+'] '+header['value'])\n say(header['value'])\n screen.refresh()\n else:\n print(str(nbMess)+'] '+header['value'])\n say(header['value'])\n #TTS(header['value'],'french', 50 ,2 )\n #status=subprocess.call([\"espeak\",\"-s 100 -v fr \",header['value']], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)\n\n #for part in ggMessage['payload']['parts']:\n # msg = base64.urlsafe_b64decode(part['body']['data'].encode('ASCII'))\n # print(removehtml(msg))\n #print(part['body']['data'])\n #say(part['body']['data'])\n if len(sys.argv) > 1:\n if sys.argv[1]=='-t':\n TTS(ggMessage,'french', 50 ,2 )\n #for toto in label:\n # print(toto)","def main():\n creds = None\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n creds = pickle.load(token)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'credentials.json', SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n\n service = build('gmail', 'v1', credentials=creds)\n\n # Call the Gmail API\n results = service.users().labels().list(userId='me').execute()\n labels = results.get('labels', [])\n\n if not labels:\n print('No labels found.')\n else:\n print('Labels:')\n for label in labels:\n print(label['name'])\n path = \"./ham\"\n try:\n os.mkdir(path)\n except OSError:\n print (\"Creation of the directory %s failed\" % path)\n else:\n print (\"Successfully created the directory %s \" % path)\n\n messages = []\n messages = ListMessagesMatchingQuery(service, 'me', 'in:inbox')\n idx = 0\n for message in messages:\n GetMimeMessage(service, 'me', message['id'], idx)\n idx+=1","def main():\n creds = None\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n creds = pickle.load(token)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'credentials.json', SCOPES)\n creds = flow.run_local_server()\n # Save the credentials for the next run\n with open('token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n\n\n service = build('gmail', 'v1', credentials=creds)\n\n labels = ListLabels(service, 'me')\n\n messages = ListMessagesWithLabels(service, 'me', label_ids=[\"CATEGORY_FORUMS\"])","def getLabels(self) -> List[str]:\n\n results = self.service.users().labels().list(userId='me').execute()\n labels = results.get('labels', [])\n\n return labels","def ListLabels(service, user_id):\n try:\n response = service.users().labels().list(userId=user_id).execute()\n labels = response['labels']\n for label in labels:\n print ('Label id: %s - Label name: %s' % (label['id'], label['name']))\n return labels\n except errors.HttpError as error:\n print ('An error occurred: %s' % error)","def main():\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = discovery.build('gmail', 'v1', http=http)\n user_id = 'me'\n\n ## get_labels ##\n #print_all_labels(service,user_id)\n #fetch_and_store(service,user_id)\n #apply_rules()","def main():\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = discovery.build('gmail', 'v1', http=http)\n\n results = service.users().labels().list(userId='me').execute()\n labels = results.get('labels', [])\n\n FPS = 30\n WINDOWWIDTH = 480\n WINDOWHEIGHT = 320\n\n WHITE = (255, 255, 255)\n RED = (255, 0, 0)\n BLUE = (0, 0, 255)\n GREEN = (0, 255, 0)\n BLACK = (0, 0, 0)\n LIGHTGREEN = (53, 230, 97)\n LIGHTBLUE = (53, 156, 230)\n LIGHTORANGE = (242, 109, 19)\n\n windowBgColor = WHITE\n\n pygame.init()\n FPSCLOCK = pygame.time.Clock()\n DISPLAYSURFACE = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))\n pygame.display.set_caption('PLUTO')\n\n myfont = pygame.font.Font(None, 30)\n label = myfont.render(\"<-- Enter address\", 1, BLACK)\n\n buttonEnterEmail = pygbutton.PygButton((10, 10, 100, 80), 'Enter Email', bgcolor=LIGHTORANGE)\n buttonScan = pygbutton.PygButton((10, 100, 225, 210), 'Scan and Send', bgcolor=LIGHTGREEN, font=myfont)\n buttonReceive = pygbutton.PygButton((245, 100, 225, 210), 'Receive and Print', bgcolor=LIGHTBLUE, font=myfont)\n buttonPrintICR = pygbutton.PygButton((370, 10, 100, 80), 'Letterhead', bgcolor=RED)\n winBgButtons = (buttonEnterEmail, buttonScan, buttonReceive, buttonPrintICR)\n\n allButtons = winBgButtons\n\n userinput = \"\"\n\n while True:\n for event in pygame.event.get(): # event handling loop\n \n if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):\n pygame.quit()\n sys.exit()\n\n if 'click' in buttonReceive.handleEvent(event): #User called for printing of file\n \n idenListCurr = ListMessagesMatchingQuery(service, 'me', 'in:inbox')\n idenListLast = None\n \n #if idenListLast != idenListCurr: #to be used in future with inbox functionality\n\n #msgList = [] #should be a way to do this where only add the new messages\n \n #for each in idenListCurr:\n #iden = each[u'id']\n #mimeMsg = GetMimeMessage(service, 'me', iden)\n \n #msgList.append(mimeMsg)\n\n #idenListLast = idenListCurr\n \n\n #displayInterface(msgList)\n htmlMsg = GetRawMessageHtml(service, 'me', idenListCurr[0][u'id'])\n writeFile(htmlMsg, \"temp\", \"html\")\n \n try:\n pdfkit.from_file(\"/home/pi/git/PlutoTest/temp.html\", \"temp.pdf\") #change to your directory\n except IOError:\n pass\n \n popup = Popup(DISPLAYSURFACE)\n tempInput = popup.run(\"Your message will print\")\n printCups.executePrint(\"/home/pi/git/PlutoTest/temp.pdf\") #change to your directory\n os.remove(\"/home/pi/git/PlutoTest/temp.pdf\") #change to your directory\n os.remove(\"/home/pi/git/PlutoTest/temp.html\") #change to your directory\n time.sleep(5)\n \n if 'click' in buttonScan.handleEvent(event):#user called for scanning and sending of file\n scan.executeScan(\"temp\")\n \n message = CreateMessageWithAttachment(\"example.pluto.email@gmail.com\", userinput, \"Hello from Pluto!\", \"Enjoy!\",\n \"/home/pi/git/PlutoTest/\", \"temp.png\") #change to your email, directory\n SendMessage(service, 'me', message)\n \n \n os.remove(\"/home/pi/git/PlutoTest/temp.png\") #change to your directory\n popup = Popup(DISPLAYSURFACE)\n tempInput = popup.run(\"Your message has been sent\")\n print(\"sent\")\n time.sleep(5)\n \n if 'click' in buttonEnterEmail.handleEvent(event): #user called to enter e-mail address\n vkeybd = VirtualKeyboard(DISPLAYSURFACE)\n tempInput = vkeybd.run(\"...\")\n if tempInput != \"...\":\n userinput = tempInput\n label = myfont.render(\"To: \" + userinput, 1, BLACK)\n \n if 'click' in buttonPrintICR.handleEvent(event): #user called to print letterhead\n popup = Popup(DISPLAYSURFACE)\n tempInput = popup.run(\"The letterhead will print\")\n printCups.executePrint(\"/home/pi/git/PlutoTest/DemoPaper.png\") #change to your directory\n time.sleep(5)\n\n\n DISPLAYSURFACE.fill(windowBgColor)\n\n for b in allButtons:\n b.draw(DISPLAYSURFACE)\n\n # draw the text onto the surface\n DISPLAYSURFACE.blit(label, (120, 35, 350, 80))\n\n pygame.display.update()\n FPSCLOCK.tick(FPS)","def main():\n creds = None\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n creds = pickle.load(token)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'credentials.json', SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n\n service = build('gmail', 'v1', credentials=creds)\n\n user_id = 'me'\n label_id_one = 'INBOX'\n label_id_two = 'UNREAD'\n\n # Call the Gmail API\n results = service.users().labels().list(userId='me').execute()\n labels = results.get('labels', [])\n unread_msgs = service.users().messages().list(userId='me',labelIds=[label_id_one, label_id_two]).execute()\n mssg_list = unread_msgs['messages']\n print (\"Total unread messages in inbox: \", str(len(mssg_list)))\n final_list = [ ]\n\n for mssg in mssg_list:\n temp_dict = { }\n m_id = mssg['id'] # get id of individual message\n message = service.users().messages().get(userId=user_id, id=m_id).execute() # fetch the message using API\n payld = message['payload'] # get payload of the message \n headr = payld['headers'] # get header of the payload\n\n\n for one in headr: # getting the Subject\n if one['name'] == 'Subject':\n msg_subject = one['value']\n temp_dict['Subject'] = msg_subject\n else:\n pass\n\n\n for two in headr: # getting the date\n if two['name'] == 'Date':\n msg_date = two['value']\n date_parse = (parser.parse(msg_date))\n m_date = (date_parse.date())\n temp_dict['Date'] = str(m_date)\n else:\n pass\n\n for three in headr: # getting the Sender\n if three['name'] == 'From':\n msg_from = three['value']\n temp_dict['Sender'] = msg_from\n else:\n pass\n\n temp_dict['Snippet'] = message['snippet'] # fetching message snippet\n\n\n try:\n \n # Fetching message body\n mssg_parts = payld['parts'] # fetching the message parts\n part_one = mssg_parts[0] # fetching first element of the part \n part_body = part_one['body'] # fetching body of the message\n part_data = part_body['data'] # fetching data from the body\n clean_one = part_data.replace(\"-\",\"+\") # decoding from Base64 to UTF-8\n clean_one = clean_one.replace(\"_\",\"/\") # decoding from Base64 to UTF-8\n clean_two = base64.b64decode (bytes(clean_one, 'UTF-8')) # decoding from Base64 to UTF-8\n soup = BeautifulSoup(clean_two , \"lxml\" )\n mssg_body = soup.body()\n # mssg_body is a readible form of message body\n # depending on the end user's requirements, it can be further cleaned \n # using regex, beautiful soup, or any other method\n temp_dict['Message_body'] = mssg_body\n\n except :\n pass\n\n print (temp_dict)\n final_list.append(temp_dict) # This will create a dictonary item in the final list\n return final_list[:3]\n # This will mark the messagea as read\n #service.users().messages().list(userId=user_id, id=m_id,body={ 'removeLabelIds': ['UNREAD']}).execute() \n\n\n if not labels:\n print('No labels found.')\n else:\n print('Labels:')\n for label in labels:\n print(label['name'])","def ListMessagesWithLabels(service, user_id, label_ids=[]):\n try:\n response = service.users().messages().list(userId=user_id,\n labelIds=label_ids).execute()\n messages = []\n if 'messages' in response:\n messages.extend(response['messages'])\n\n while 'nextPageToken' in response:\n page_token = response['nextPageToken']\n response = service.users().messages().list(userId=user_id,\n labelIds=label_ids,\n pageToken=page_token).execute()\n messages.extend(response['messages'])\n\n return messages\n except errors.HttpError:\n print(\"An error occurred\")","def ListMessagesWithLabels(service, user_id, label_ids=[]):\n try:\n response = service.users().messages().list(userId=user_id,\n labelIds=label_ids).execute()\n messages = []\n if 'messages' in response:\n messages.extend(response['messages'])\n\n while 'nextPageToken' in response:\n page_token = response['nextPageToken']\n response = service.users().messages().list(userId=user_id,\n labelIds=label_ids,\n pageToken=page_token).execute()\n #print (response)\n messages.extend(response['messages'])\n for m in messages:\n print(m)\n DeleteMessage(service, 'me', m['id'])\n\n except errors.HttpError as error:\n print ('An error occurred: %s' % error)","def get(self, request, format=None):\n user_social_auth = UserSocialAuth.objects.get(user=self.request.user)\n credentials = AccessTokenCredentials(user_social_auth.extra_data['access_token'],\n 'my-user-agent/1.0')\n http = httplib2.Http()\n http = credentials.authorize(http)\n service = discovery.build('gmail', 'v1', credentials=credentials)\n results = service.users().messages().list(userId='me').execute()\n messages = []\n for result in results['messages'][:100]:\n \n msg = service.users().messages().get(userId='me', id=result['id']).execute()\n subject = ''\n _from = ''\n for header in msg['payload']['headers']:\n if header['name'] == 'Subject':\n subject = header['value']\n elif header['name'] == 'From':\n _from = header['value']\n messages.append({'subject': subject, 'from': _from})\n \n return Response(messages)","def ListMessagesWithLabels(service, user_id, label_ids=[]):\r\n try:\r\n response = service.users().messages().list(userId=user_id,\r\n labelIds=label_ids).execute()\r\n messages = []\r\n if \"messages\" in response:\r\n messages.extend(response[\"messages\"])\r\n\r\n while 'nextPageToken' in response:\r\n page_token = response[\"nextPageToken\"]\r\n response = service.users().messages().list(userId=user_id,\r\n labelIds=label_ids,\r\n pageToken=page_token).execute()\r\n messages.extend(response[\"messages\"])\r\n return messages\r\n except errors.HttpError as error:\r\n print(\"An error occurred: %s\" % error)","def main():\r\n credentials = get_credentials()\r\n http = credentials.authorize(httplib2.Http())\r\n service = discovery.build('gmail', 'v1', http=http)\r\n\r\n response = service.users().messages().list(userId=USER_ID, labelIds=[\"SPAM\"]).execute()\r\n messages = []\r\n if 'messages' in response:\r\n messages.extend(response['messages'])\r\n\r\n while 'nextPageToken' in response:\r\n page_token = response['nextPageToken']\r\n response = service.users().messages().list(userId=USER_ID, labelIds=[\"SPAM\"], pageToken=page_token).execute()\r\n messages.extend(response['messages'])\r\n\r\n i = 0\r\n for message in messages:\r\n msg_id = message[\"id\"]\r\n message = service.users().messages().get(userId=USER_ID, id=msg_id).execute()\r\n for prop in message[\"payload\"][\"headers\"]:\r\n if prop[\"name\"] == \"From\":\r\n print(\"ID:\", i, \"\\tFrom:\", prop[\"value\"].encode('ascii','replace'), end=\"\\t\")\r\n elif prop[\"name\"] == \"Subject\":\r\n print(\"Subject:\", prop[\"value\"].encode('ascii','replace'))\r\n i += 1\r\n\r\n to_keep = raw_input(\"Do you want to keep any emails? [N / 0,1,...] \")\r\n if \",\" in to_keep:\r\n to_keep = to_keep.split(\",\")\r\n for i in range(len(to_keep)):\r\n to_keep[i] = int(to_keep[i])\r\n elif to_keep != \"N\":\r\n to_keep = [int(to_keep)]\r\n\r\n if isinstance(to_keep, list):\r\n for i in range(len(to_keep)-1,-1,-1):\r\n msg_labels = {'removeLabelIds': [\"SPAM\"], 'addLabelIds': [\"INBOX\"]}\r\n msg_id = messages[to_keep[i]][\"id\"]\r\n message = service.users().messages().modify(userId=USER_ID, id=msg_id, body=msg_labels).execute()\r\n del messages[to_keep[i]]\r\n\r\n # ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\r\n # filter0 = service.users().settings().filters().get(userId=USER_ID, id=\"ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\").execute()\r\n # print(filter0)\r\n\r\n for message in messages:\r\n msg_id = message[\"id\"]\r\n # for prop in message[\"payload\"][\"headers\"]:\r\n # if prop[\"name\"] == \"From\":\r\n # start_email = prop[\"value\"].find(\"<\")\r\n # end_email = prop[\"value\"].find(\">\", start_email + 1)\r\n # email_address = prop[\"value\"][start_email + 1:end_email]\r\n # filter0[\"criteria\"][\"from\"] = filter0[\"criteria\"][\"from\"] + \" OR \" + email_address\r\n service.users().messages().delete(userId=USER_ID, id=msg_id).execute()\r\n\r\n # service.users().settings().filters().delete(userId=USER_ID, id=\"ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\").execute()\r\n # service.users().settings().filters().create(userId=USER_ID, body=filter0).execute()\r\n print(\"All Spam Deleted!\")","def ListMessagesWithLabels(service, user_id, label_ids=[]):\n try:\n response = service.users().messages().list(userId=user_id, labelIds=label_ids).execute()\n messages = []\n if 'messages' in response:\n messages.extend(response['messages'])\n\n while 'nextPageToken' in response:\n page_token = response['nextPageToken']\n response = service.users().messages().list(userId=user_id, labelIds=label_ids, pageToken=page_token).execute()\n messages.extend(response['messages'])\n return messages\n except errors.HttpError, error:\n print('An error occurred: %s' % error)","def ListMessagesWithLabels(service, user_id, label_ids=[]):\n try:\n response = service.users().messages().list(userId=user_id,\n labelIds=label_ids).execute()\n messages = []\n if 'messages' in response:\n messages.extend(response['messages'])\n\n while 'nextPageToken' in response:\n page_token = response['nextPageToken']\n response = service.users().messages().list(userId=user_id,\n labelIds=label_ids,\n pageToken=page_token).execute()\n messages.extend(response['messages'])\n\n return messages\n except errors.HttpError as error:\n print('An error occurred: %s' % error)","def main():\n token = 'C:/Users/asif.rouf/PycharmProjects/pythonProject/AX_Admin_portal/Test/utils/google-api-token.json'\n credential = 'C:/Users/asif.rouf/PycharmProjects/pythonProject/AX_Admin_portal/Test/utils/google-api-credentials.json'\n creds = None\n # The file token.json stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists(token):\n creds = Credentials.from_authorized_user_file(token, SCOPES)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n credential, SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n # with open('token.json', 'w') as token:\n # token.write(creds.to_json())\n\n service = build('gmail', 'v1', credentials=creds)\n\n # # Call the Gmail API\n # results = service.users().labels().list(userId='me').execute()\n # labels = results.get('labels', [])\n #\n # if not labels:\n # print('No labels found.')\n # else:\n # print('Labels:')\n # for label in labels:\n # print(label['name'])\n\n # Call the Gmail API to fetch INBOX\n results = service.users().messages().list(userId='me', labelIds=['INBOX']).execute()\n messages = results.get('messages', [])\n # message1 = messages[0]\n # print(message1)\n message1 = {'id': '17a5ca5f5f4bd0aa', 'threadId': '17a5b1bb861b3bc2'}\n message1 = {'id': '17a5cbc54c546465', 'threadId': '17a5b1bb861b3bc2'}\n\n # message1 = {'id': '17a5b852afe04a52', 'threadId': '17a50c997c059e68'}\n print(messages)\n print(message1)\n\n if not messages:\n print(\"No messages found.\")\n else:\n print(\"Message snippets:\")\n # for message in messages:\n # msg = service.users().messages().get(userId='me', id=message['id']).execute()\n # print(messages)\n # print(msg['snippet'])\n\n # msg = service.users().messages().get(userId='me', id=message1['id']).execute()\n # print(msg['snippet'])\n ###############################\n msg = service.users().messages().get(userId='me', id=message1['id'], format='raw').execute()\n msg_str = base64.urlsafe_b64decode(msg['raw'].encode('ASCII'))\n mime_msg = email.message_from_bytes(msg_str)\n print(msg['snippet'])\n print(mime_msg)\n print(mime_msg['Date'])\n print(mime_msg['From'])\n print(mime_msg['To'])\n print(mime_msg['Subject'])\n #\n # print(datetime.utcnow())\n\n ######################################################\n # msg = service.users().messages().get(userId='me', id=message1['id'], format='full').execute()\n # # parts can be the message body, or attachments\n # payload = msg['payload']\n # headers = payload.get(\"headers\")\n # parts = payload.get(\"parts\")\n # # print(payload)\n # # print(parts)\n # # print(headers)\n # for header in headers:\n # print(header['name'])\n # print(header['value'])\n #\n ######################################################\n msg = service.users().messages().get(userId='me', id=message1['id']).execute()\n\n # Use try-except to avoid any Errors\n try:\n # Get value of 'payload' from dictionary 'txt'\n payload = msg['payload']\n headers = payload['headers']\n subject = ''\n sender = ''\n\n # Look for Subject and Sender Email in the headers\n for d in headers:\n if d['name'] == 'Subject':\n subject = d['value']\n if d['name'] == 'From':\n sender = d['value']\n # The Body of the message is in Encrypted format. So, we have to decode it.\n # Get the data and decode it with base 64 decoder.\n parts = payload.get('parts')[0]\n data = parts['body']['data']\n data = data.replace(\"-\", \"+\").replace(\"_\", \"/\")\n decoded_data = base64.b64decode(data)\n\n # Now, the data obtained is in lxml. So, we will parse\n # it with BeautifulSoup library\n soup = BeautifulSoup(decoded_data, \"lxml\")\n body = soup.body()\n\n # Printing the subject, sender's email and message\n print(\"Subject: \", subject)\n print(\"From: \", sender)\n print(\"Message: \", body)\n # for link in soup.find_all('a', href=True):\n # print(link['href'])\n link = soup.find('a', href=True)\n print(link['href'])\n except:\n pass","def new_label(self, context, payload):\n\n labels = GmailActions.labels(context)['labels']\n label_id = \"\"\n\n for label in labels:\n if label['name'] == payload['name']:\n label_id = label['id']\n break\n\n access_token = util.get_access_token(context['headers'])\n url = util.get_url(context) + f\"labels/{label_id}\"\n response = util.rest(\"GET\", url, access_token)\n\n if response.status_code > 400:\n raise Exception(\"Error \", response.text)\n\n return json.loads(response.text)","def list_labels(service, repo):\n app = App()\n if repo:\n serv = app.get_service(service, repo=repo)\n else:\n serv = app.guess_service()\n repo_labels = serv.list_labels()\n if not repo_labels:\n print(\"No labels.\")\n return\n print(tabulate([\n (\n label.name,\n label.color,\n label.description\n )\n for label in repo_labels\n ], tablefmt=\"fancy_grid\"))","def search(self, query, labels=[]):\n qstring = query + ' ' + self.opts.query\n if labels:\n query += ' (' + ' OR '.join(['label:' + l for l in labels]) + ')'\n print(query)\n cmd = self.service.users().messages()\n try:\n results = cmd.list(userId='me', q=query,\n includeSpamTrash=True).execute()\n if 'messages' not in results:\n return []\n gids = [m['id'] for m in results['messages']]\n \n while 'nextPageToken' in results:\n page_token = results['nextPageToken']\n results = cmd.list(userId='me', q=query,\n pageToken=page_token,\n includeSpamTrash=True).execute()\n gids.extend([m['id'] for m in results['messages']])\n return gids\n except errors.HttpError as ex:\n print('An error occurred: %s' % ex)\n return []","def label_list(request):\n\n labels = Label.objects.all().order_by('group__id', 'name')\n\n return render_to_response('annotations/label_list.html', {\n 'labels': labels,\n },\n context_instance=RequestContext(request)\n )","def ListMessagesWithLabels(service, user_id, label_ids=[]):\n try:\n response = service.users().messages().list(userId=user_id,\n labelIds=label_ids).execute()\n messages = []\n if 'messages' in response:\n messages.extend(response['messages'])\n\n while 'nextPageToken' in response:\n page_token = response['nextPageToken']\n response = service.users().messages().list(userId=user_id,\n labelIds=label_ids,\n pageToken=page_token).execute()\n messages.extend(response['messages'])\n\n return messages\n\n except errors.HttpError, error:\n print('An error occurred: %s' % error)","def main():\n creds = None\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n creds = pickle.load(token)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'credentials.json', SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n\n service = build('gmail', 'v1', credentials=creds)\n\n # Calls the Gmail API to get Emails\n threads = listMessages(service, 'me', 'Jay Patel,')\n\n if not threads:\n print('No TUalerts found.')\n else:\n getCrimeLocation(service, 'me', threads)\n\n # Prints the TUlalerts (Mostly for testing purposes)\n printAlerts()","def get_labels(self):\n return get_labels(self.api_key)","def labels(self) -> list[\"Label\"]:\n _args: list[Arg] = []\n _ctx = self._select(\"labels\", _args)\n _ctx = Label(_ctx)._select_multiple(\n _name=\"name\",\n _value=\"value\",\n )\n return _ctx.execute_sync(list[Label])","def get_label_list(\n self,\n project_id: int\n ) -> requests.models.Response:\n return self.get(\n 'v1/projects/{project_id}/labels'.format(\n project_id=project_id\n )\n )","def labels_by_name(self, username, repository_name, access_token=None):\n return self._complete_request_by_name(\n username, repository_name, \"labels\", access_token)","def GetAdGroupLabel(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def get_labels():\n json_request = request.json # get the json from the server\n keys = sort_keys(json_request.keys()) # sort the keys (i.e. the token ids)\n labels = []\n for k in keys:\n # get the labels that the user input to the UI\n val = (json_request[k]['text'], json_request[k]['value'])\n labels.append(val)\n return labels","def user_labels(self) -> Mapping[str, str]:\n return pulumi.get(self, \"user_labels\")","def list_gpo(self, _):\n results = self.engine.query(self.engine.GPO_INFO_FILTER(), [\"cn\", \"displayName\"])\n for gpo in results:\n print(\"{cn}: {name}\".format(cn=gpo[\"cn\"], name=gpo[\"displayName\"]))","def get_labels(self):\n resp = self._client.scan(TableName=self.LABELS_TABLE)\n return [self._item_to_label(item) for item in resp['Items']]","def main():\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = discovery.build('gmail', 'v1', http=http)\n\n messageIds = []\n i = 0\n nextPageToken = None\n while (i <= 15):\n try:\n response = service.users().messages().list(userId='me', q='after:2016/09/01', maxResults=10000, pageToken=nextPageToken).execute()\n messages = response.get('messages')\n nextPageToken = response['nextPageToken']\n\n for m in messages:\n messageIds.append(m['id'])\n\n i+=1 \n except KeyError:\n break\n\n senders = []\n counter = 0\n for i in messageIds:\n data = service.users().messages().get(userId='me', id=i).execute()\n for d in data['payload']['headers']:\n if d['name'] == 'Received':\n print(d['value'][d['value'].find('; ')+1:d['value'].find('(PST)')])\n if d['name'] == 'From' and 'bounce' not in d['value']:\n senders.append(d['value'])\n print(counter, ' ', d['value'])\n counter += 1\n break\n\n emails = []\n with open('out.csv', 'wb') as f:\n writer = csv.writer(f, delimiter=',')\n for person in set(senders):\n cleaned = clean_data(person)\n name = cleaned[0]\n email = cleaned[1]\n if email not in emails:\n emails.append(email)\n if name != None and email != None:\n writer.writerow([name, email])","def addmessageslabels(self, uidlist, labels):\n\n labels = labels - self.ignorelabels\n result = self._messagelabels_aux('+X-GM-LABELS', uidlist, labels)\n if result:\n for uid in uidlist:\n self.messagelist[uid]['labels'] = self.messagelist[uid]['labels'] | labels","def build_user_labels_request(self):\n request = {\n \"systemLabels\": {\n \"name\": \"appName\",\n \"list_name\": [ \"a\",\"b\",\"c\"],\n \"boolean_value\": False\n },\n \"userLabels\": {\n \"key1\": \"value1\",\n \"key2\": \"value2\"\n }\n }\n return request","def get_emails():\n\n # generate the gmail api service\n service = build_gmail_api_v1()\n\n # compute date for one year ago\n today = date.today()\n one_year_ago = today - timedelta(days=365.25)\n start = one_year_ago - timedelta(days=1)\n end = one_year_ago + timedelta(days=1)\n start_string = start.strftime(\"%Y/%m/%d\")\n end_string = end.strftime(\"%Y/%m/%d\")\n query_string = f'after:{start_string} before:{end_string}'\n\n # generate the gmail api request (get list of messages from one year ago)\n request = service.users().messages().list(userId='me', q=query_string)\n\n # try to get the api response\n try:\n response = request.execute()\n except HTTPError as e:\n print('Error response status code : {0}, reason : {1}'.format(\n e.resp.status, e.error_details))\n return []\n\n # get list of message ids from the api response\n messages = list(response[\"messages\"])\n ids = [message[\"id\"] for message in messages]\n\n # store all emails in a list\n data_to_display = []\n\n # loop through each message id\n for id in ids:\n\n try:\n # store email data in a dict\n email = {}\n\n # get message data by querying gmail api using message id\n request = service.users().messages().get(userId='me', id=id)\n response = request.execute()\n\n # get date, subject, from, to, etc from message header\n headers = list(response[\"payload\"][\"headers\"])\n looking_for = [\"Date\", \"Subject\", \"From\", \"To\"]\n for header in headers:\n if header[\"name\"] in looking_for:\n email[header[\"name\"]] = header[\"value\"]\n\n # try to get message body (base64) from response\n # the json structure varies a lot so that is why there are no many try/except\n try:\n base64_message = response[\"payload\"][\"parts\"][0][\"parts\"][0][\"body\"][\"data\"]\n except (KeyError, TypeError) as e:\n try:\n base64_message = response[\"payload\"][\"parts\"][1][\"body\"][\"data\"]\n except (KeyError, TypeError, IndexError) as e:\n try:\n base64_message = response[\"payload\"][\"parts\"][0][\"body\"][\"data\"]\n except (KeyError, TypeError, IndexError) as e:\n try:\n base64_message = response[\"payload\"][\"body\"][\"data\"]\n except (KeyError, TypeError, IndexError) as e:\n base64_message = \"Ti9B\"\n\n # decode the email body\n email[\"body\"] = base64.urlsafe_b64decode(\n base64_message).decode('utf-8')\n\n # populate list with email\n data_to_display.append(email)\n\n except HTTPError as e:\n print('Error response status code : {0}, reason : {1}'.format(\n e.resp.status, e.error_details))\n\n return data_to_display","def get_all(self):\n data = {\n 'readByQuery': {\n 'object': 'EEACCOUNTLABEL',\n 'fields': '*',\n 'query': None,\n 'pagesize': '1000'\n }\n }\n\n return self.format_and_send_request(data)['data']['eeaccountlabel']","def main():\n #Gmail2TelegramClient(\"1234\") -- a person\n #Gmail2TelegramClient(\"-1234\") -- group chat","def retrieve_labels(user_id: int) -> dict:\n user_label_table = dict()\n cur.execute('''SELECT USER_ID, NAME, CONTENT FROM \"labels\"''')\n rows = cur.fetchall()\n for row in rows:\n if user_id == row[0]:\n user_label_table[row[1]] = row[2]\n return user_label_table","def lookup_label_id(service, labels):\n if not labels:\n return\n\n labelids = {} # label name => label id\n results = service.users().labels().list(userId='me').execute()\n mylabs = results.get('labels', [])\n for lab in mylabs:\n if len(labelids) == len(labels):\n break\n if lab['name'] in labels:\n labelids[lab['name']] = lab['id']\n return labelids","def labels(self, number=-1, etag=None):\n url = self._build_url(\"labels\", base_url=self._api)\n return self._iter(int(number), url, label.ShortLabel, etag=etag)","def build_gmail_api_v1():\n\n credentials = build_credentials()\n return googleapiclient.discovery.build('gmail', 'v1', credentials=credentials)","def main():\n creds = None\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first time.\n scores = {} # scores is an empty dict already\n\n if os.path.getsize('token.pickle') > 0: \n with open('token.pickle', \"rb\") as f:\n unpickler = pickle.Unpickler(f)\n # if file is not empty scores will be equal\n # to the value unpickled\n scores = unpickler.load()\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n creds = pickle.load(token)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'credentials.json', SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n\n # Starts Gmail V1 with logged in user\n service = build('gmail', 'v1', credentials=creds)\n \n# ================================================================================== \n\n\n # MAIL CHECKHER ================================================================\n\n # get mails via gmail api\n results = service.users().messages().list(userId='me', labelIds=['INBOX']).execute()\n messages = results.get('messages', [])\n\n # mail number\n mail_nr = 0\n\n # variabel for how many mails we want to search through\n message_count = int(input(\"Hur många mails vill du söka igenom? \"))\n # if 0 mails are chosen\n if not messages:\n print('Inga mail i inkorgen')\n else:\n # looks through the email inbox for mails \"message_count\" amount of times\n for message in messages[:message_count]:\n # gets the email id's in full format so we can extraqct information via the gmail api\n msg = service.users().messages().get(userId='me', id=message['id'], format='full', metadataHeaders=None).execute()\n # gets the headers of the email in a variable\n headers = msg[\"payload\"][\"headers\"]\n # from headers gets the sender email, who it was from \n from_ = [i['value'] for i in headers if i[\"name\"]==\"From\"]\n # from headers gets the subject of the email\n subject = [i['value'] for i in headers if i[\"name\"]==\"Subject\"]\n # keeps count of the current email\n mail_nr += 1\n # if the email is from the security system email print it's information\n if from_ == ['Python Ormarna <python.ormar@gmail.com>'] or from_ == ['python.ormar@gmail.com']:\n # gets the email in raw format via gmail api\n rawmsg = service.users().messages().get(userId=\"me\", id=message[\"id\"], format=\"raw\", metadataHeaders=None).execute()\n print(\"=\"*100)\n print(\"\\nMail:\", mail_nr)\n print(\"Detta mail är från erat säkerhetssystem\")\n # variable the UNIX time of when the email was sent\n datum = int(msg['internalDate'])\n datum /= 1000\n # prints the date and time when the email was revived in local y/m/d/h/m/s\n print(\"Mottaget:\", datetime.fromtimestamp(datum).strftime('%Y-%m-%d %H:%M:%S'))\n print(\"Från:\", from_)\n print(\"Ämne:\", subject)\n # prints a snippet from the email\n print(msg['snippet'])\n print(\"\\n\")\n else:\n print(\"=\"*100)\n print(\"\\nMail:\", mail_nr)\n print(\"Detta mail är INTE från erat säkerhetssystem\\n\")\n time.sleep(1)\n print(\"Inga fler mail hittades\")","def new_labeled_email(self, context, payload):\n\n access_token = util.get_access_token(context['headers'])\n url = util.get_url(context) + f\"messages/{payload['id']}\"\n response = util.rest(\"GET\", url, access_token)\n\n return GmailApi.get_email_data(json.loads(response.text))","def test_get_form_label_email(self):\n self.assertEqual(\n self.user.get_form_label(email=True),\n 'testuser <testuser@example.com>',\n )","def get_labels(self) -> List[str]:\n return self.labels","def print_labels(self,labels):\n\t\tfor key in labels:\n\t\t\tprint key, ':\\t', labels[key]","def get_project_labels(session=konfuzio_session()) -> List[dict]:\n url = get_project_url()\n r = retry_get(session, url)\n sorted_labels = sorted(r.json()['labels'], key=itemgetter('id'))\n return sorted_labels","def GetLabels(args, client, instance_properties=False):\n labels_value = client.messages.Instance.LabelsValue\n if instance_properties:\n labels_value = client.messages.InstanceProperties.LabelsValue\n if args.labels:\n return labels_value(additionalProperties=[\n labels_value.AdditionalProperty(key=key, value=value)\n for key, value in sorted(six.iteritems(args.labels))\n ])\n return None","def list_metering_labels(self, retrieve_all=True, **_params):\r\n return self.list('metering_labels', self.metering_labels_path,\r\n retrieve_all, **_params)","def label_messages(self, org, messages, label):\n pass","def list_labels(self, repository):\n data = self._get_all_data('/repos/{}/labels'.format(repository))\n return {l['name']: str(l['color']) for l in data}","def get_label():\n inp = option_text('Input label name (leave blank for no label):')\n add_to_collected('label', inp)\n OPTIONS['label'] = inp\n return","def labels_by_id(self, repository_id, access_token=None):\n return self._complete_request_by_id(\n repository_id, \"labels\", access_token)","def get_messages_from_navbar():\n\tlabels = frappe.get_all(\"Navbar Item\", filters={\"item_label\": (\"is\", \"set\")}, pluck=\"item_label\")\n\treturn [(\"Navbar:\", label, \"Label of a Navbar Item\") for label in labels]","def labels(self, label_type = 'basic'):\n\t\tif label_type == None:\n\t\t\treturn {}\n\t\telif label_type == 'basic':\n\t\t\treturn self.dependency_labels()\n\t\telif label_type == 'SAMT':\n\t\t\treturn self.SAMT_labels()\n\t\telif label_type == 'all':\n\t\t\treturn self.label_all()\n\t\telse:\n\t\t\traise ValueError(\"%s is no valid labeltype\" %label_type)","def get_labels():\n return if_found(dao.get_labels())","def get_labels(self, uuid=None):\n return self._get_query('labels', self._build_params(uuid=uuid), Label)","def label_list(entry):\n printing_resident_sheets(entry, rf'{constants.OUTPUTS_DIR}\\label_sheet.xlsx')\n printing_documents.create_label_list()","def user_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:\n return pulumi.get(self, \"user_labels\")","def get_labels(self, uuids=None, name=None, pager=None):\n params = self._build_params(uuid=uuids, name=name)\n return Label.deserialize_list(self._get_multiple('labels', params, pager))","def display_name_labels(self):\n for name in self.names:\n # create a label for each name\n self.root.add_widget(Label(text=name))","def get_labels(pr_id):\n label_json = get_status_json(pr_id, 'labels')\n current_labels = [l['name'] for l in label_json]\n return current_labels","def add_labels(self, labels: dict):\n self.status = \"Creating labels\"\n for lname, value in labels.items():\n self.labels.add_label(lname, value)","def get(self):\n app_id = app_identity.get_application_id()\n users = User.query(User.email != None)\n for user in users:\n games = Game.query(Game.user == user.key, Game.game_over == False)\n if games:\n subject = \"This is a reminder!\"\n body = \"Hello {}, you have some unfinished games.\".format(\n user.name)\n\n mail.send_mail('noreply@{}.appspot.com'.format(app_id),\n user.email, subject, body)","def labels(self):\r\n return labels.RepoLabels(self)","def _add_user_label(self):\n user_label = tk.Label(parent, text='Пользователь: ' +\n self.user_info.ShortUserName + ' Версия ' + __version__,\n font=('Arial', 8))\n user_label.pack(side=tk.RIGHT, anchor=tk.NE)","def pull_labels(self, org):\n pass","def _get_labels_for_user(self, project, assignment, user):\n return Session.query(model.Label).filter(and_(model.Label.user_id==user.id,\n model.Label.project_id==project.id,\n model.Label.assignment_id==assignment.id)).all()","def labels(self):\n return self._labels","def user_labels_new(*args):\n return _ida_hexrays.user_labels_new(*args)","def __get_emails(self):\n # This returns a list of Gmail message objects. Documentation can be found at\n # https://developers.google.com/gmail/api/v1/reference/users/messages/list\n return self.__service.users().messages().list(userId='me').execute()['messages']","def labels(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"labels\")","def labels(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"labels\")","def get_labels():\n session = get_session()\n try:\n query = session.query(Album.label).distinct()\n final_query = query\n labels = query.all()\n label_list = []\n for label in labels:\n label_list.append(label[0])\n count = final_query.count()\n return jsonify({\n 'items': label_list,\n 'count': count\n })\n finally:\n session.close()","def get(self, id):\n context = request.environ.get('context')\n obj = dbapi.netdevices_get_by_id(context, id)\n response = {\"labels\": list(obj.labels)}\n return response, 200, None","def _messagelabels_aux(self, arg, uidlist, labels):\n labels = labels - self.ignorelabels\n uidlist = [uid for uid in uidlist if uid > 0]\n if len(uidlist) > 0:\n imapobj = self.imapserver.acquireconnection()\n try:\n labels_str = '(' + ' '.join([imaputil.quote(lb) for lb in labels]) + ')'\n # Coalesce uid's into ranges\n uid_str = imaputil.uid_sequence(uidlist)\n result = self._store_to_imap(imapobj, uid_str, arg, labels_str)\n\n except imapobj.readonly:\n self.ui.labelstoreadonly(self, uidlist, labels)\n return None\n\n finally:\n self.imapserver.releaseconnection(imapobj)\n\n if result:\n retlabels = imaputil.flags2hash(imaputil.imapsplit(result)[1])['X-GM-LABELS']\n retlabels = set([imaputil.dequote(lb) for lb in imaputil.imapsplit(retlabels)])\n return retlabels\n return None","async def test__get_labels():\n # Uppercase 'C'\n assert ImageConfig._get_labels(json.loads('{\"Config\":{\"Labels\":{\"x\":\"5\"}}}')) == {\n \"x\": \"5\"\n }\n\n # Lowercase 'C'\n assert ImageConfig._get_labels(json.loads('{\"config\":{\"Labels\":{\"x\":\"5\"}}}')) == {\n \"x\": \"5\"\n }\n\n # Missing 'Labels'\n assert ImageConfig._get_labels(json.loads('{\"Config\":{}}')) == {}","def list_groups(self):\n\n for counter, label in enumerate(self.exp_labels_list):\n print('Key {}: {} \\n'.format(str(counter), label))","def get_labels() -> list[Label]:\n\n labels_file = deepcopy(get_data(\"labels.yml\"))\n standard_labels = []\n for group_info in labels_file[\"groups\"]:\n labels = group_info.pop(\"labels\", [])\n group = LabelGroup(**group_info)\n for label_info in labels:\n label = Label(**label_info, group=group)\n standard_labels.append(label)\n for label_info in labels_file[\"standalone\"]:\n label = Label(**label_info)\n standard_labels.append(label)\n return standard_labels","def get_all_labels(self):\n labels = self.wls_board.get_labels\n return labels","def get_labels(self) -> List[str]:\n raise NotImplementedError()","def build_expected_user_labels_response(self):\n labels = [\n {\n \"key\": \"key1\",\n \"value\": \"value1\"\n },\n {\n \"key\": \"key2\",\n \"value\": \"value2\"\n }\n ]\n return labels","def user_labels_next(*args):\n return _ida_hexrays.user_labels_next(*args)","def labels(self) -> Optional[Sequence[str]]:\n return pulumi.get(self, \"labels\")","def get_labels(self):\n\t\traise NotImplementedError()","def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]:\n return pulumi.get(self, \"labels\")","def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]:\n return pulumi.get(self, \"labels\")","def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]:\n return pulumi.get(self, \"labels\")","def getGroup():\n\tprint\n\tprint \"Requesting the list of groups for this account\"\n\n\tgroups_result = getResult('/papi/v0/groups')\n\n\treturn (groups_result)","def greet_users(names):\n for name in names:\n msg = \"Hello, \" + name.title() + \"!\"\n print(msg)","def greet_users(names):\n for name in names:\n msg = \"Hello, \" + name.title() + \"!\"\n print(msg)","def get_users(msg: telebot.types.Message):\n users = User.select()\n m = ''\n for user in users:\n menu_caption = \"In PVP game\" if user.state == states.USER_IN_PVP_GAME else \"In AI game\" if user.state == states.USER_IN_AI_GAME else \"In menu\"\n m += f'[{user.first_name}](tg://user?id={user.user_id}) - {menu_caption}\\n'\n\n bot.send_message(\n msg.from_user.id,\n m,\n parse_mode='Markdown'\n )","def do_list(client, args):\n\trepos = client.repos.list(args.user)\n\tprint '%s has the following repositories:' % args.user\n\tprint 'Name - Description'\n\tfor repo in repos:\n\t\tprint '%s - %s' % (repo.name, repo.description)","def get_labels(self):\n return self.labels","def get_label_list():\n f_name = os.path.join(FLAGS.labels_dir, FLAGS.labels_name)\n if os.path.exists(f_name):\n with open(f_name, 'rb') as f:\n try:\n label_list = [line.rstrip('\\n') for line in f]\n except:\n print(\"Could not read file:\" + f_name)\n sys.exit()\n return label_list","def _get_label ( self ):\n if self._label is not None:\n return self._label\n return user_name_for( self.name )","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def get_labels(self):\n raise NotImplementedError()","def ListAnnotations(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')"],"string":"[\n \"def get_labels():\\n\\n logging.info(\\\"Getting metadata about labels\\\")\\n\\n labels = []\\n\\n if len(args.labels) == 0:\\n logging.warning(\\\"No labels specified, assuming all labels. If you have a lot of labels in your inbox you could hit API limits quickly.\\\")\\n results = GMAIL_CLIENT.users().labels().list(userId='me').execute()\\n\\n labels = results.get('labels', [])\\n else:\\n logging.info('Using labels: %s ', args.labels)\\n\\n for label in args.labels:\\n labels.append({'id': label})\\n\\n if not labels:\\n logging.info('No labels found.')\\n sys.exit()\\n\\n return labels\",\n \"def gmail(screen):\\n\\n\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('gmail', 'v1', http=http)\\n\\n results = service.users().labels().list(userId='me').execute()\\n labels = results.get('labels', [])\\n\\n\\n\\n if not labels:\\n print('No labels found.')\\n else:\\n if PRINT_CATEGORY: print('Labels:')\\n for label in labels:\\n if PRINT_CATEGORY: print(label['name'])\\n if label['name']=='UNREAD':\\n listMessages = ListMessagesWithLabels(service, 'me', label['name'])\\n nbMessages = len(listMessages)\\n nbMess = 0\\n\\n printTerminal('ENZO! Tu as ['+str(nbMessages)+'] messages non lus.',True)\\n say('ENZO! Tu as: '+str(nbMessages)+' messages non lus.')\\n\\n for message in listMessages:\\n #print(GetMessage(service, 'me', message['id'], False))\\n nbMess+=1\\n ggMessage = GetMessage(service, 'me', message['id'], False)\\n #print(ggMessage)\\n\\n #msg_str = base64.urlsafe_b64decode(ggMessage['raw'].encode('ASCII'))\\n #print(msg_str)\\n\\n for header in ggMessage['payload']['headers']:\\n #print(header)\\n if header['name']=='Subject':\\n #unicode(text,'utf-8')\\n #screen.addstr(0,1,\\\"\\\")\\n if screen:\\n screen.addstr(str(nbMess)+'] '+header['value'])\\n say(header['value'])\\n screen.refresh()\\n else:\\n print(str(nbMess)+'] '+header['value'])\\n say(header['value'])\\n #TTS(header['value'],'french', 50 ,2 )\\n #status=subprocess.call([\\\"espeak\\\",\\\"-s 100 -v fr \\\",header['value']], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)\\n\\n #for part in ggMessage['payload']['parts']:\\n # msg = base64.urlsafe_b64decode(part['body']['data'].encode('ASCII'))\\n # print(removehtml(msg))\\n #print(part['body']['data'])\\n #say(part['body']['data'])\\n if len(sys.argv) > 1:\\n if sys.argv[1]=='-t':\\n TTS(ggMessage,'french', 50 ,2 )\\n #for toto in label:\\n # print(toto)\",\n \"def main():\\n creds = None\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'credentials.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n\\n service = build('gmail', 'v1', credentials=creds)\\n\\n # Call the Gmail API\\n results = service.users().labels().list(userId='me').execute()\\n labels = results.get('labels', [])\\n\\n if not labels:\\n print('No labels found.')\\n else:\\n print('Labels:')\\n for label in labels:\\n print(label['name'])\\n path = \\\"./ham\\\"\\n try:\\n os.mkdir(path)\\n except OSError:\\n print (\\\"Creation of the directory %s failed\\\" % path)\\n else:\\n print (\\\"Successfully created the directory %s \\\" % path)\\n\\n messages = []\\n messages = ListMessagesMatchingQuery(service, 'me', 'in:inbox')\\n idx = 0\\n for message in messages:\\n GetMimeMessage(service, 'me', message['id'], idx)\\n idx+=1\",\n \"def main():\\n creds = None\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'credentials.json', SCOPES)\\n creds = flow.run_local_server()\\n # Save the credentials for the next run\\n with open('token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n\\n\\n service = build('gmail', 'v1', credentials=creds)\\n\\n labels = ListLabels(service, 'me')\\n\\n messages = ListMessagesWithLabels(service, 'me', label_ids=[\\\"CATEGORY_FORUMS\\\"])\",\n \"def getLabels(self) -> List[str]:\\n\\n results = self.service.users().labels().list(userId='me').execute()\\n labels = results.get('labels', [])\\n\\n return labels\",\n \"def ListLabels(service, user_id):\\n try:\\n response = service.users().labels().list(userId=user_id).execute()\\n labels = response['labels']\\n for label in labels:\\n print ('Label id: %s - Label name: %s' % (label['id'], label['name']))\\n return labels\\n except errors.HttpError as error:\\n print ('An error occurred: %s' % error)\",\n \"def main():\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('gmail', 'v1', http=http)\\n user_id = 'me'\\n\\n ## get_labels ##\\n #print_all_labels(service,user_id)\\n #fetch_and_store(service,user_id)\\n #apply_rules()\",\n \"def main():\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('gmail', 'v1', http=http)\\n\\n results = service.users().labels().list(userId='me').execute()\\n labels = results.get('labels', [])\\n\\n FPS = 30\\n WINDOWWIDTH = 480\\n WINDOWHEIGHT = 320\\n\\n WHITE = (255, 255, 255)\\n RED = (255, 0, 0)\\n BLUE = (0, 0, 255)\\n GREEN = (0, 255, 0)\\n BLACK = (0, 0, 0)\\n LIGHTGREEN = (53, 230, 97)\\n LIGHTBLUE = (53, 156, 230)\\n LIGHTORANGE = (242, 109, 19)\\n\\n windowBgColor = WHITE\\n\\n pygame.init()\\n FPSCLOCK = pygame.time.Clock()\\n DISPLAYSURFACE = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))\\n pygame.display.set_caption('PLUTO')\\n\\n myfont = pygame.font.Font(None, 30)\\n label = myfont.render(\\\"<-- Enter address\\\", 1, BLACK)\\n\\n buttonEnterEmail = pygbutton.PygButton((10, 10, 100, 80), 'Enter Email', bgcolor=LIGHTORANGE)\\n buttonScan = pygbutton.PygButton((10, 100, 225, 210), 'Scan and Send', bgcolor=LIGHTGREEN, font=myfont)\\n buttonReceive = pygbutton.PygButton((245, 100, 225, 210), 'Receive and Print', bgcolor=LIGHTBLUE, font=myfont)\\n buttonPrintICR = pygbutton.PygButton((370, 10, 100, 80), 'Letterhead', bgcolor=RED)\\n winBgButtons = (buttonEnterEmail, buttonScan, buttonReceive, buttonPrintICR)\\n\\n allButtons = winBgButtons\\n\\n userinput = \\\"\\\"\\n\\n while True:\\n for event in pygame.event.get(): # event handling loop\\n \\n if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):\\n pygame.quit()\\n sys.exit()\\n\\n if 'click' in buttonReceive.handleEvent(event): #User called for printing of file\\n \\n idenListCurr = ListMessagesMatchingQuery(service, 'me', 'in:inbox')\\n idenListLast = None\\n \\n #if idenListLast != idenListCurr: #to be used in future with inbox functionality\\n\\n #msgList = [] #should be a way to do this where only add the new messages\\n \\n #for each in idenListCurr:\\n #iden = each[u'id']\\n #mimeMsg = GetMimeMessage(service, 'me', iden)\\n \\n #msgList.append(mimeMsg)\\n\\n #idenListLast = idenListCurr\\n \\n\\n #displayInterface(msgList)\\n htmlMsg = GetRawMessageHtml(service, 'me', idenListCurr[0][u'id'])\\n writeFile(htmlMsg, \\\"temp\\\", \\\"html\\\")\\n \\n try:\\n pdfkit.from_file(\\\"/home/pi/git/PlutoTest/temp.html\\\", \\\"temp.pdf\\\") #change to your directory\\n except IOError:\\n pass\\n \\n popup = Popup(DISPLAYSURFACE)\\n tempInput = popup.run(\\\"Your message will print\\\")\\n printCups.executePrint(\\\"/home/pi/git/PlutoTest/temp.pdf\\\") #change to your directory\\n os.remove(\\\"/home/pi/git/PlutoTest/temp.pdf\\\") #change to your directory\\n os.remove(\\\"/home/pi/git/PlutoTest/temp.html\\\") #change to your directory\\n time.sleep(5)\\n \\n if 'click' in buttonScan.handleEvent(event):#user called for scanning and sending of file\\n scan.executeScan(\\\"temp\\\")\\n \\n message = CreateMessageWithAttachment(\\\"example.pluto.email@gmail.com\\\", userinput, \\\"Hello from Pluto!\\\", \\\"Enjoy!\\\",\\n \\\"/home/pi/git/PlutoTest/\\\", \\\"temp.png\\\") #change to your email, directory\\n SendMessage(service, 'me', message)\\n \\n \\n os.remove(\\\"/home/pi/git/PlutoTest/temp.png\\\") #change to your directory\\n popup = Popup(DISPLAYSURFACE)\\n tempInput = popup.run(\\\"Your message has been sent\\\")\\n print(\\\"sent\\\")\\n time.sleep(5)\\n \\n if 'click' in buttonEnterEmail.handleEvent(event): #user called to enter e-mail address\\n vkeybd = VirtualKeyboard(DISPLAYSURFACE)\\n tempInput = vkeybd.run(\\\"...\\\")\\n if tempInput != \\\"...\\\":\\n userinput = tempInput\\n label = myfont.render(\\\"To: \\\" + userinput, 1, BLACK)\\n \\n if 'click' in buttonPrintICR.handleEvent(event): #user called to print letterhead\\n popup = Popup(DISPLAYSURFACE)\\n tempInput = popup.run(\\\"The letterhead will print\\\")\\n printCups.executePrint(\\\"/home/pi/git/PlutoTest/DemoPaper.png\\\") #change to your directory\\n time.sleep(5)\\n\\n\\n DISPLAYSURFACE.fill(windowBgColor)\\n\\n for b in allButtons:\\n b.draw(DISPLAYSURFACE)\\n\\n # draw the text onto the surface\\n DISPLAYSURFACE.blit(label, (120, 35, 350, 80))\\n\\n pygame.display.update()\\n FPSCLOCK.tick(FPS)\",\n \"def main():\\n creds = None\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'credentials.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n\\n service = build('gmail', 'v1', credentials=creds)\\n\\n user_id = 'me'\\n label_id_one = 'INBOX'\\n label_id_two = 'UNREAD'\\n\\n # Call the Gmail API\\n results = service.users().labels().list(userId='me').execute()\\n labels = results.get('labels', [])\\n unread_msgs = service.users().messages().list(userId='me',labelIds=[label_id_one, label_id_two]).execute()\\n mssg_list = unread_msgs['messages']\\n print (\\\"Total unread messages in inbox: \\\", str(len(mssg_list)))\\n final_list = [ ]\\n\\n for mssg in mssg_list:\\n temp_dict = { }\\n m_id = mssg['id'] # get id of individual message\\n message = service.users().messages().get(userId=user_id, id=m_id).execute() # fetch the message using API\\n payld = message['payload'] # get payload of the message \\n headr = payld['headers'] # get header of the payload\\n\\n\\n for one in headr: # getting the Subject\\n if one['name'] == 'Subject':\\n msg_subject = one['value']\\n temp_dict['Subject'] = msg_subject\\n else:\\n pass\\n\\n\\n for two in headr: # getting the date\\n if two['name'] == 'Date':\\n msg_date = two['value']\\n date_parse = (parser.parse(msg_date))\\n m_date = (date_parse.date())\\n temp_dict['Date'] = str(m_date)\\n else:\\n pass\\n\\n for three in headr: # getting the Sender\\n if three['name'] == 'From':\\n msg_from = three['value']\\n temp_dict['Sender'] = msg_from\\n else:\\n pass\\n\\n temp_dict['Snippet'] = message['snippet'] # fetching message snippet\\n\\n\\n try:\\n \\n # Fetching message body\\n mssg_parts = payld['parts'] # fetching the message parts\\n part_one = mssg_parts[0] # fetching first element of the part \\n part_body = part_one['body'] # fetching body of the message\\n part_data = part_body['data'] # fetching data from the body\\n clean_one = part_data.replace(\\\"-\\\",\\\"+\\\") # decoding from Base64 to UTF-8\\n clean_one = clean_one.replace(\\\"_\\\",\\\"/\\\") # decoding from Base64 to UTF-8\\n clean_two = base64.b64decode (bytes(clean_one, 'UTF-8')) # decoding from Base64 to UTF-8\\n soup = BeautifulSoup(clean_two , \\\"lxml\\\" )\\n mssg_body = soup.body()\\n # mssg_body is a readible form of message body\\n # depending on the end user's requirements, it can be further cleaned \\n # using regex, beautiful soup, or any other method\\n temp_dict['Message_body'] = mssg_body\\n\\n except :\\n pass\\n\\n print (temp_dict)\\n final_list.append(temp_dict) # This will create a dictonary item in the final list\\n return final_list[:3]\\n # This will mark the messagea as read\\n #service.users().messages().list(userId=user_id, id=m_id,body={ 'removeLabelIds': ['UNREAD']}).execute() \\n\\n\\n if not labels:\\n print('No labels found.')\\n else:\\n print('Labels:')\\n for label in labels:\\n print(label['name'])\",\n \"def ListMessagesWithLabels(service, user_id, label_ids=[]):\\n try:\\n response = service.users().messages().list(userId=user_id,\\n labelIds=label_ids).execute()\\n messages = []\\n if 'messages' in response:\\n messages.extend(response['messages'])\\n\\n while 'nextPageToken' in response:\\n page_token = response['nextPageToken']\\n response = service.users().messages().list(userId=user_id,\\n labelIds=label_ids,\\n pageToken=page_token).execute()\\n messages.extend(response['messages'])\\n\\n return messages\\n except errors.HttpError:\\n print(\\\"An error occurred\\\")\",\n \"def ListMessagesWithLabels(service, user_id, label_ids=[]):\\n try:\\n response = service.users().messages().list(userId=user_id,\\n labelIds=label_ids).execute()\\n messages = []\\n if 'messages' in response:\\n messages.extend(response['messages'])\\n\\n while 'nextPageToken' in response:\\n page_token = response['nextPageToken']\\n response = service.users().messages().list(userId=user_id,\\n labelIds=label_ids,\\n pageToken=page_token).execute()\\n #print (response)\\n messages.extend(response['messages'])\\n for m in messages:\\n print(m)\\n DeleteMessage(service, 'me', m['id'])\\n\\n except errors.HttpError as error:\\n print ('An error occurred: %s' % error)\",\n \"def get(self, request, format=None):\\n user_social_auth = UserSocialAuth.objects.get(user=self.request.user)\\n credentials = AccessTokenCredentials(user_social_auth.extra_data['access_token'],\\n 'my-user-agent/1.0')\\n http = httplib2.Http()\\n http = credentials.authorize(http)\\n service = discovery.build('gmail', 'v1', credentials=credentials)\\n results = service.users().messages().list(userId='me').execute()\\n messages = []\\n for result in results['messages'][:100]:\\n \\n msg = service.users().messages().get(userId='me', id=result['id']).execute()\\n subject = ''\\n _from = ''\\n for header in msg['payload']['headers']:\\n if header['name'] == 'Subject':\\n subject = header['value']\\n elif header['name'] == 'From':\\n _from = header['value']\\n messages.append({'subject': subject, 'from': _from})\\n \\n return Response(messages)\",\n \"def ListMessagesWithLabels(service, user_id, label_ids=[]):\\r\\n try:\\r\\n response = service.users().messages().list(userId=user_id,\\r\\n labelIds=label_ids).execute()\\r\\n messages = []\\r\\n if \\\"messages\\\" in response:\\r\\n messages.extend(response[\\\"messages\\\"])\\r\\n\\r\\n while 'nextPageToken' in response:\\r\\n page_token = response[\\\"nextPageToken\\\"]\\r\\n response = service.users().messages().list(userId=user_id,\\r\\n labelIds=label_ids,\\r\\n pageToken=page_token).execute()\\r\\n messages.extend(response[\\\"messages\\\"])\\r\\n return messages\\r\\n except errors.HttpError as error:\\r\\n print(\\\"An error occurred: %s\\\" % error)\",\n \"def main():\\r\\n credentials = get_credentials()\\r\\n http = credentials.authorize(httplib2.Http())\\r\\n service = discovery.build('gmail', 'v1', http=http)\\r\\n\\r\\n response = service.users().messages().list(userId=USER_ID, labelIds=[\\\"SPAM\\\"]).execute()\\r\\n messages = []\\r\\n if 'messages' in response:\\r\\n messages.extend(response['messages'])\\r\\n\\r\\n while 'nextPageToken' in response:\\r\\n page_token = response['nextPageToken']\\r\\n response = service.users().messages().list(userId=USER_ID, labelIds=[\\\"SPAM\\\"], pageToken=page_token).execute()\\r\\n messages.extend(response['messages'])\\r\\n\\r\\n i = 0\\r\\n for message in messages:\\r\\n msg_id = message[\\\"id\\\"]\\r\\n message = service.users().messages().get(userId=USER_ID, id=msg_id).execute()\\r\\n for prop in message[\\\"payload\\\"][\\\"headers\\\"]:\\r\\n if prop[\\\"name\\\"] == \\\"From\\\":\\r\\n print(\\\"ID:\\\", i, \\\"\\\\tFrom:\\\", prop[\\\"value\\\"].encode('ascii','replace'), end=\\\"\\\\t\\\")\\r\\n elif prop[\\\"name\\\"] == \\\"Subject\\\":\\r\\n print(\\\"Subject:\\\", prop[\\\"value\\\"].encode('ascii','replace'))\\r\\n i += 1\\r\\n\\r\\n to_keep = raw_input(\\\"Do you want to keep any emails? [N / 0,1,...] \\\")\\r\\n if \\\",\\\" in to_keep:\\r\\n to_keep = to_keep.split(\\\",\\\")\\r\\n for i in range(len(to_keep)):\\r\\n to_keep[i] = int(to_keep[i])\\r\\n elif to_keep != \\\"N\\\":\\r\\n to_keep = [int(to_keep)]\\r\\n\\r\\n if isinstance(to_keep, list):\\r\\n for i in range(len(to_keep)-1,-1,-1):\\r\\n msg_labels = {'removeLabelIds': [\\\"SPAM\\\"], 'addLabelIds': [\\\"INBOX\\\"]}\\r\\n msg_id = messages[to_keep[i]][\\\"id\\\"]\\r\\n message = service.users().messages().modify(userId=USER_ID, id=msg_id, body=msg_labels).execute()\\r\\n del messages[to_keep[i]]\\r\\n\\r\\n # ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\\r\\n # filter0 = service.users().settings().filters().get(userId=USER_ID, id=\\\"ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\\\").execute()\\r\\n # print(filter0)\\r\\n\\r\\n for message in messages:\\r\\n msg_id = message[\\\"id\\\"]\\r\\n # for prop in message[\\\"payload\\\"][\\\"headers\\\"]:\\r\\n # if prop[\\\"name\\\"] == \\\"From\\\":\\r\\n # start_email = prop[\\\"value\\\"].find(\\\"<\\\")\\r\\n # end_email = prop[\\\"value\\\"].find(\\\">\\\", start_email + 1)\\r\\n # email_address = prop[\\\"value\\\"][start_email + 1:end_email]\\r\\n # filter0[\\\"criteria\\\"][\\\"from\\\"] = filter0[\\\"criteria\\\"][\\\"from\\\"] + \\\" OR \\\" + email_address\\r\\n service.users().messages().delete(userId=USER_ID, id=msg_id).execute()\\r\\n\\r\\n # service.users().settings().filters().delete(userId=USER_ID, id=\\\"ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\\\").execute()\\r\\n # service.users().settings().filters().create(userId=USER_ID, body=filter0).execute()\\r\\n print(\\\"All Spam Deleted!\\\")\",\n \"def ListMessagesWithLabels(service, user_id, label_ids=[]):\\n try:\\n response = service.users().messages().list(userId=user_id, labelIds=label_ids).execute()\\n messages = []\\n if 'messages' in response:\\n messages.extend(response['messages'])\\n\\n while 'nextPageToken' in response:\\n page_token = response['nextPageToken']\\n response = service.users().messages().list(userId=user_id, labelIds=label_ids, pageToken=page_token).execute()\\n messages.extend(response['messages'])\\n return messages\\n except errors.HttpError, error:\\n print('An error occurred: %s' % error)\",\n \"def ListMessagesWithLabels(service, user_id, label_ids=[]):\\n try:\\n response = service.users().messages().list(userId=user_id,\\n labelIds=label_ids).execute()\\n messages = []\\n if 'messages' in response:\\n messages.extend(response['messages'])\\n\\n while 'nextPageToken' in response:\\n page_token = response['nextPageToken']\\n response = service.users().messages().list(userId=user_id,\\n labelIds=label_ids,\\n pageToken=page_token).execute()\\n messages.extend(response['messages'])\\n\\n return messages\\n except errors.HttpError as error:\\n print('An error occurred: %s' % error)\",\n \"def main():\\n token = 'C:/Users/asif.rouf/PycharmProjects/pythonProject/AX_Admin_portal/Test/utils/google-api-token.json'\\n credential = 'C:/Users/asif.rouf/PycharmProjects/pythonProject/AX_Admin_portal/Test/utils/google-api-credentials.json'\\n creds = None\\n # The file token.json stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists(token):\\n creds = Credentials.from_authorized_user_file(token, SCOPES)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n credential, SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n # with open('token.json', 'w') as token:\\n # token.write(creds.to_json())\\n\\n service = build('gmail', 'v1', credentials=creds)\\n\\n # # Call the Gmail API\\n # results = service.users().labels().list(userId='me').execute()\\n # labels = results.get('labels', [])\\n #\\n # if not labels:\\n # print('No labels found.')\\n # else:\\n # print('Labels:')\\n # for label in labels:\\n # print(label['name'])\\n\\n # Call the Gmail API to fetch INBOX\\n results = service.users().messages().list(userId='me', labelIds=['INBOX']).execute()\\n messages = results.get('messages', [])\\n # message1 = messages[0]\\n # print(message1)\\n message1 = {'id': '17a5ca5f5f4bd0aa', 'threadId': '17a5b1bb861b3bc2'}\\n message1 = {'id': '17a5cbc54c546465', 'threadId': '17a5b1bb861b3bc2'}\\n\\n # message1 = {'id': '17a5b852afe04a52', 'threadId': '17a50c997c059e68'}\\n print(messages)\\n print(message1)\\n\\n if not messages:\\n print(\\\"No messages found.\\\")\\n else:\\n print(\\\"Message snippets:\\\")\\n # for message in messages:\\n # msg = service.users().messages().get(userId='me', id=message['id']).execute()\\n # print(messages)\\n # print(msg['snippet'])\\n\\n # msg = service.users().messages().get(userId='me', id=message1['id']).execute()\\n # print(msg['snippet'])\\n ###############################\\n msg = service.users().messages().get(userId='me', id=message1['id'], format='raw').execute()\\n msg_str = base64.urlsafe_b64decode(msg['raw'].encode('ASCII'))\\n mime_msg = email.message_from_bytes(msg_str)\\n print(msg['snippet'])\\n print(mime_msg)\\n print(mime_msg['Date'])\\n print(mime_msg['From'])\\n print(mime_msg['To'])\\n print(mime_msg['Subject'])\\n #\\n # print(datetime.utcnow())\\n\\n ######################################################\\n # msg = service.users().messages().get(userId='me', id=message1['id'], format='full').execute()\\n # # parts can be the message body, or attachments\\n # payload = msg['payload']\\n # headers = payload.get(\\\"headers\\\")\\n # parts = payload.get(\\\"parts\\\")\\n # # print(payload)\\n # # print(parts)\\n # # print(headers)\\n # for header in headers:\\n # print(header['name'])\\n # print(header['value'])\\n #\\n ######################################################\\n msg = service.users().messages().get(userId='me', id=message1['id']).execute()\\n\\n # Use try-except to avoid any Errors\\n try:\\n # Get value of 'payload' from dictionary 'txt'\\n payload = msg['payload']\\n headers = payload['headers']\\n subject = ''\\n sender = ''\\n\\n # Look for Subject and Sender Email in the headers\\n for d in headers:\\n if d['name'] == 'Subject':\\n subject = d['value']\\n if d['name'] == 'From':\\n sender = d['value']\\n # The Body of the message is in Encrypted format. So, we have to decode it.\\n # Get the data and decode it with base 64 decoder.\\n parts = payload.get('parts')[0]\\n data = parts['body']['data']\\n data = data.replace(\\\"-\\\", \\\"+\\\").replace(\\\"_\\\", \\\"/\\\")\\n decoded_data = base64.b64decode(data)\\n\\n # Now, the data obtained is in lxml. So, we will parse\\n # it with BeautifulSoup library\\n soup = BeautifulSoup(decoded_data, \\\"lxml\\\")\\n body = soup.body()\\n\\n # Printing the subject, sender's email and message\\n print(\\\"Subject: \\\", subject)\\n print(\\\"From: \\\", sender)\\n print(\\\"Message: \\\", body)\\n # for link in soup.find_all('a', href=True):\\n # print(link['href'])\\n link = soup.find('a', href=True)\\n print(link['href'])\\n except:\\n pass\",\n \"def new_label(self, context, payload):\\n\\n labels = GmailActions.labels(context)['labels']\\n label_id = \\\"\\\"\\n\\n for label in labels:\\n if label['name'] == payload['name']:\\n label_id = label['id']\\n break\\n\\n access_token = util.get_access_token(context['headers'])\\n url = util.get_url(context) + f\\\"labels/{label_id}\\\"\\n response = util.rest(\\\"GET\\\", url, access_token)\\n\\n if response.status_code > 400:\\n raise Exception(\\\"Error \\\", response.text)\\n\\n return json.loads(response.text)\",\n \"def list_labels(service, repo):\\n app = App()\\n if repo:\\n serv = app.get_service(service, repo=repo)\\n else:\\n serv = app.guess_service()\\n repo_labels = serv.list_labels()\\n if not repo_labels:\\n print(\\\"No labels.\\\")\\n return\\n print(tabulate([\\n (\\n label.name,\\n label.color,\\n label.description\\n )\\n for label in repo_labels\\n ], tablefmt=\\\"fancy_grid\\\"))\",\n \"def search(self, query, labels=[]):\\n qstring = query + ' ' + self.opts.query\\n if labels:\\n query += ' (' + ' OR '.join(['label:' + l for l in labels]) + ')'\\n print(query)\\n cmd = self.service.users().messages()\\n try:\\n results = cmd.list(userId='me', q=query,\\n includeSpamTrash=True).execute()\\n if 'messages' not in results:\\n return []\\n gids = [m['id'] for m in results['messages']]\\n \\n while 'nextPageToken' in results:\\n page_token = results['nextPageToken']\\n results = cmd.list(userId='me', q=query,\\n pageToken=page_token,\\n includeSpamTrash=True).execute()\\n gids.extend([m['id'] for m in results['messages']])\\n return gids\\n except errors.HttpError as ex:\\n print('An error occurred: %s' % ex)\\n return []\",\n \"def label_list(request):\\n\\n labels = Label.objects.all().order_by('group__id', 'name')\\n\\n return render_to_response('annotations/label_list.html', {\\n 'labels': labels,\\n },\\n context_instance=RequestContext(request)\\n )\",\n \"def ListMessagesWithLabels(service, user_id, label_ids=[]):\\n try:\\n response = service.users().messages().list(userId=user_id,\\n labelIds=label_ids).execute()\\n messages = []\\n if 'messages' in response:\\n messages.extend(response['messages'])\\n\\n while 'nextPageToken' in response:\\n page_token = response['nextPageToken']\\n response = service.users().messages().list(userId=user_id,\\n labelIds=label_ids,\\n pageToken=page_token).execute()\\n messages.extend(response['messages'])\\n\\n return messages\\n\\n except errors.HttpError, error:\\n print('An error occurred: %s' % error)\",\n \"def main():\\n creds = None\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'credentials.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n\\n service = build('gmail', 'v1', credentials=creds)\\n\\n # Calls the Gmail API to get Emails\\n threads = listMessages(service, 'me', 'Jay Patel,')\\n\\n if not threads:\\n print('No TUalerts found.')\\n else:\\n getCrimeLocation(service, 'me', threads)\\n\\n # Prints the TUlalerts (Mostly for testing purposes)\\n printAlerts()\",\n \"def get_labels(self):\\n return get_labels(self.api_key)\",\n \"def labels(self) -> list[\\\"Label\\\"]:\\n _args: list[Arg] = []\\n _ctx = self._select(\\\"labels\\\", _args)\\n _ctx = Label(_ctx)._select_multiple(\\n _name=\\\"name\\\",\\n _value=\\\"value\\\",\\n )\\n return _ctx.execute_sync(list[Label])\",\n \"def get_label_list(\\n self,\\n project_id: int\\n ) -> requests.models.Response:\\n return self.get(\\n 'v1/projects/{project_id}/labels'.format(\\n project_id=project_id\\n )\\n )\",\n \"def labels_by_name(self, username, repository_name, access_token=None):\\n return self._complete_request_by_name(\\n username, repository_name, \\\"labels\\\", access_token)\",\n \"def GetAdGroupLabel(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def get_labels():\\n json_request = request.json # get the json from the server\\n keys = sort_keys(json_request.keys()) # sort the keys (i.e. the token ids)\\n labels = []\\n for k in keys:\\n # get the labels that the user input to the UI\\n val = (json_request[k]['text'], json_request[k]['value'])\\n labels.append(val)\\n return labels\",\n \"def user_labels(self) -> Mapping[str, str]:\\n return pulumi.get(self, \\\"user_labels\\\")\",\n \"def list_gpo(self, _):\\n results = self.engine.query(self.engine.GPO_INFO_FILTER(), [\\\"cn\\\", \\\"displayName\\\"])\\n for gpo in results:\\n print(\\\"{cn}: {name}\\\".format(cn=gpo[\\\"cn\\\"], name=gpo[\\\"displayName\\\"]))\",\n \"def get_labels(self):\\n resp = self._client.scan(TableName=self.LABELS_TABLE)\\n return [self._item_to_label(item) for item in resp['Items']]\",\n \"def main():\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('gmail', 'v1', http=http)\\n\\n messageIds = []\\n i = 0\\n nextPageToken = None\\n while (i <= 15):\\n try:\\n response = service.users().messages().list(userId='me', q='after:2016/09/01', maxResults=10000, pageToken=nextPageToken).execute()\\n messages = response.get('messages')\\n nextPageToken = response['nextPageToken']\\n\\n for m in messages:\\n messageIds.append(m['id'])\\n\\n i+=1 \\n except KeyError:\\n break\\n\\n senders = []\\n counter = 0\\n for i in messageIds:\\n data = service.users().messages().get(userId='me', id=i).execute()\\n for d in data['payload']['headers']:\\n if d['name'] == 'Received':\\n print(d['value'][d['value'].find('; ')+1:d['value'].find('(PST)')])\\n if d['name'] == 'From' and 'bounce' not in d['value']:\\n senders.append(d['value'])\\n print(counter, ' ', d['value'])\\n counter += 1\\n break\\n\\n emails = []\\n with open('out.csv', 'wb') as f:\\n writer = csv.writer(f, delimiter=',')\\n for person in set(senders):\\n cleaned = clean_data(person)\\n name = cleaned[0]\\n email = cleaned[1]\\n if email not in emails:\\n emails.append(email)\\n if name != None and email != None:\\n writer.writerow([name, email])\",\n \"def addmessageslabels(self, uidlist, labels):\\n\\n labels = labels - self.ignorelabels\\n result = self._messagelabels_aux('+X-GM-LABELS', uidlist, labels)\\n if result:\\n for uid in uidlist:\\n self.messagelist[uid]['labels'] = self.messagelist[uid]['labels'] | labels\",\n \"def build_user_labels_request(self):\\n request = {\\n \\\"systemLabels\\\": {\\n \\\"name\\\": \\\"appName\\\",\\n \\\"list_name\\\": [ \\\"a\\\",\\\"b\\\",\\\"c\\\"],\\n \\\"boolean_value\\\": False\\n },\\n \\\"userLabels\\\": {\\n \\\"key1\\\": \\\"value1\\\",\\n \\\"key2\\\": \\\"value2\\\"\\n }\\n }\\n return request\",\n \"def get_emails():\\n\\n # generate the gmail api service\\n service = build_gmail_api_v1()\\n\\n # compute date for one year ago\\n today = date.today()\\n one_year_ago = today - timedelta(days=365.25)\\n start = one_year_ago - timedelta(days=1)\\n end = one_year_ago + timedelta(days=1)\\n start_string = start.strftime(\\\"%Y/%m/%d\\\")\\n end_string = end.strftime(\\\"%Y/%m/%d\\\")\\n query_string = f'after:{start_string} before:{end_string}'\\n\\n # generate the gmail api request (get list of messages from one year ago)\\n request = service.users().messages().list(userId='me', q=query_string)\\n\\n # try to get the api response\\n try:\\n response = request.execute()\\n except HTTPError as e:\\n print('Error response status code : {0}, reason : {1}'.format(\\n e.resp.status, e.error_details))\\n return []\\n\\n # get list of message ids from the api response\\n messages = list(response[\\\"messages\\\"])\\n ids = [message[\\\"id\\\"] for message in messages]\\n\\n # store all emails in a list\\n data_to_display = []\\n\\n # loop through each message id\\n for id in ids:\\n\\n try:\\n # store email data in a dict\\n email = {}\\n\\n # get message data by querying gmail api using message id\\n request = service.users().messages().get(userId='me', id=id)\\n response = request.execute()\\n\\n # get date, subject, from, to, etc from message header\\n headers = list(response[\\\"payload\\\"][\\\"headers\\\"])\\n looking_for = [\\\"Date\\\", \\\"Subject\\\", \\\"From\\\", \\\"To\\\"]\\n for header in headers:\\n if header[\\\"name\\\"] in looking_for:\\n email[header[\\\"name\\\"]] = header[\\\"value\\\"]\\n\\n # try to get message body (base64) from response\\n # the json structure varies a lot so that is why there are no many try/except\\n try:\\n base64_message = response[\\\"payload\\\"][\\\"parts\\\"][0][\\\"parts\\\"][0][\\\"body\\\"][\\\"data\\\"]\\n except (KeyError, TypeError) as e:\\n try:\\n base64_message = response[\\\"payload\\\"][\\\"parts\\\"][1][\\\"body\\\"][\\\"data\\\"]\\n except (KeyError, TypeError, IndexError) as e:\\n try:\\n base64_message = response[\\\"payload\\\"][\\\"parts\\\"][0][\\\"body\\\"][\\\"data\\\"]\\n except (KeyError, TypeError, IndexError) as e:\\n try:\\n base64_message = response[\\\"payload\\\"][\\\"body\\\"][\\\"data\\\"]\\n except (KeyError, TypeError, IndexError) as e:\\n base64_message = \\\"Ti9B\\\"\\n\\n # decode the email body\\n email[\\\"body\\\"] = base64.urlsafe_b64decode(\\n base64_message).decode('utf-8')\\n\\n # populate list with email\\n data_to_display.append(email)\\n\\n except HTTPError as e:\\n print('Error response status code : {0}, reason : {1}'.format(\\n e.resp.status, e.error_details))\\n\\n return data_to_display\",\n \"def get_all(self):\\n data = {\\n 'readByQuery': {\\n 'object': 'EEACCOUNTLABEL',\\n 'fields': '*',\\n 'query': None,\\n 'pagesize': '1000'\\n }\\n }\\n\\n return self.format_and_send_request(data)['data']['eeaccountlabel']\",\n \"def main():\\n #Gmail2TelegramClient(\\\"1234\\\") -- a person\\n #Gmail2TelegramClient(\\\"-1234\\\") -- group chat\",\n \"def retrieve_labels(user_id: int) -> dict:\\n user_label_table = dict()\\n cur.execute('''SELECT USER_ID, NAME, CONTENT FROM \\\"labels\\\"''')\\n rows = cur.fetchall()\\n for row in rows:\\n if user_id == row[0]:\\n user_label_table[row[1]] = row[2]\\n return user_label_table\",\n \"def lookup_label_id(service, labels):\\n if not labels:\\n return\\n\\n labelids = {} # label name => label id\\n results = service.users().labels().list(userId='me').execute()\\n mylabs = results.get('labels', [])\\n for lab in mylabs:\\n if len(labelids) == len(labels):\\n break\\n if lab['name'] in labels:\\n labelids[lab['name']] = lab['id']\\n return labelids\",\n \"def labels(self, number=-1, etag=None):\\n url = self._build_url(\\\"labels\\\", base_url=self._api)\\n return self._iter(int(number), url, label.ShortLabel, etag=etag)\",\n \"def build_gmail_api_v1():\\n\\n credentials = build_credentials()\\n return googleapiclient.discovery.build('gmail', 'v1', credentials=credentials)\",\n \"def main():\\n creds = None\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first time.\\n scores = {} # scores is an empty dict already\\n\\n if os.path.getsize('token.pickle') > 0: \\n with open('token.pickle', \\\"rb\\\") as f:\\n unpickler = pickle.Unpickler(f)\\n # if file is not empty scores will be equal\\n # to the value unpickled\\n scores = unpickler.load()\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'credentials.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n\\n # Starts Gmail V1 with logged in user\\n service = build('gmail', 'v1', credentials=creds)\\n \\n# ================================================================================== \\n\\n\\n # MAIL CHECKHER ================================================================\\n\\n # get mails via gmail api\\n results = service.users().messages().list(userId='me', labelIds=['INBOX']).execute()\\n messages = results.get('messages', [])\\n\\n # mail number\\n mail_nr = 0\\n\\n # variabel for how many mails we want to search through\\n message_count = int(input(\\\"Hur många mails vill du söka igenom? \\\"))\\n # if 0 mails are chosen\\n if not messages:\\n print('Inga mail i inkorgen')\\n else:\\n # looks through the email inbox for mails \\\"message_count\\\" amount of times\\n for message in messages[:message_count]:\\n # gets the email id's in full format so we can extraqct information via the gmail api\\n msg = service.users().messages().get(userId='me', id=message['id'], format='full', metadataHeaders=None).execute()\\n # gets the headers of the email in a variable\\n headers = msg[\\\"payload\\\"][\\\"headers\\\"]\\n # from headers gets the sender email, who it was from \\n from_ = [i['value'] for i in headers if i[\\\"name\\\"]==\\\"From\\\"]\\n # from headers gets the subject of the email\\n subject = [i['value'] for i in headers if i[\\\"name\\\"]==\\\"Subject\\\"]\\n # keeps count of the current email\\n mail_nr += 1\\n # if the email is from the security system email print it's information\\n if from_ == ['Python Ormarna <python.ormar@gmail.com>'] or from_ == ['python.ormar@gmail.com']:\\n # gets the email in raw format via gmail api\\n rawmsg = service.users().messages().get(userId=\\\"me\\\", id=message[\\\"id\\\"], format=\\\"raw\\\", metadataHeaders=None).execute()\\n print(\\\"=\\\"*100)\\n print(\\\"\\\\nMail:\\\", mail_nr)\\n print(\\\"Detta mail är från erat säkerhetssystem\\\")\\n # variable the UNIX time of when the email was sent\\n datum = int(msg['internalDate'])\\n datum /= 1000\\n # prints the date and time when the email was revived in local y/m/d/h/m/s\\n print(\\\"Mottaget:\\\", datetime.fromtimestamp(datum).strftime('%Y-%m-%d %H:%M:%S'))\\n print(\\\"Från:\\\", from_)\\n print(\\\"Ämne:\\\", subject)\\n # prints a snippet from the email\\n print(msg['snippet'])\\n print(\\\"\\\\n\\\")\\n else:\\n print(\\\"=\\\"*100)\\n print(\\\"\\\\nMail:\\\", mail_nr)\\n print(\\\"Detta mail är INTE från erat säkerhetssystem\\\\n\\\")\\n time.sleep(1)\\n print(\\\"Inga fler mail hittades\\\")\",\n \"def new_labeled_email(self, context, payload):\\n\\n access_token = util.get_access_token(context['headers'])\\n url = util.get_url(context) + f\\\"messages/{payload['id']}\\\"\\n response = util.rest(\\\"GET\\\", url, access_token)\\n\\n return GmailApi.get_email_data(json.loads(response.text))\",\n \"def test_get_form_label_email(self):\\n self.assertEqual(\\n self.user.get_form_label(email=True),\\n 'testuser <testuser@example.com>',\\n )\",\n \"def get_labels(self) -> List[str]:\\n return self.labels\",\n \"def print_labels(self,labels):\\n\\t\\tfor key in labels:\\n\\t\\t\\tprint key, ':\\\\t', labels[key]\",\n \"def get_project_labels(session=konfuzio_session()) -> List[dict]:\\n url = get_project_url()\\n r = retry_get(session, url)\\n sorted_labels = sorted(r.json()['labels'], key=itemgetter('id'))\\n return sorted_labels\",\n \"def GetLabels(args, client, instance_properties=False):\\n labels_value = client.messages.Instance.LabelsValue\\n if instance_properties:\\n labels_value = client.messages.InstanceProperties.LabelsValue\\n if args.labels:\\n return labels_value(additionalProperties=[\\n labels_value.AdditionalProperty(key=key, value=value)\\n for key, value in sorted(six.iteritems(args.labels))\\n ])\\n return None\",\n \"def list_metering_labels(self, retrieve_all=True, **_params):\\r\\n return self.list('metering_labels', self.metering_labels_path,\\r\\n retrieve_all, **_params)\",\n \"def label_messages(self, org, messages, label):\\n pass\",\n \"def list_labels(self, repository):\\n data = self._get_all_data('/repos/{}/labels'.format(repository))\\n return {l['name']: str(l['color']) for l in data}\",\n \"def get_label():\\n inp = option_text('Input label name (leave blank for no label):')\\n add_to_collected('label', inp)\\n OPTIONS['label'] = inp\\n return\",\n \"def labels_by_id(self, repository_id, access_token=None):\\n return self._complete_request_by_id(\\n repository_id, \\\"labels\\\", access_token)\",\n \"def get_messages_from_navbar():\\n\\tlabels = frappe.get_all(\\\"Navbar Item\\\", filters={\\\"item_label\\\": (\\\"is\\\", \\\"set\\\")}, pluck=\\\"item_label\\\")\\n\\treturn [(\\\"Navbar:\\\", label, \\\"Label of a Navbar Item\\\") for label in labels]\",\n \"def labels(self, label_type = 'basic'):\\n\\t\\tif label_type == None:\\n\\t\\t\\treturn {}\\n\\t\\telif label_type == 'basic':\\n\\t\\t\\treturn self.dependency_labels()\\n\\t\\telif label_type == 'SAMT':\\n\\t\\t\\treturn self.SAMT_labels()\\n\\t\\telif label_type == 'all':\\n\\t\\t\\treturn self.label_all()\\n\\t\\telse:\\n\\t\\t\\traise ValueError(\\\"%s is no valid labeltype\\\" %label_type)\",\n \"def get_labels():\\n return if_found(dao.get_labels())\",\n \"def get_labels(self, uuid=None):\\n return self._get_query('labels', self._build_params(uuid=uuid), Label)\",\n \"def label_list(entry):\\n printing_resident_sheets(entry, rf'{constants.OUTPUTS_DIR}\\\\label_sheet.xlsx')\\n printing_documents.create_label_list()\",\n \"def user_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"user_labels\\\")\",\n \"def get_labels(self, uuids=None, name=None, pager=None):\\n params = self._build_params(uuid=uuids, name=name)\\n return Label.deserialize_list(self._get_multiple('labels', params, pager))\",\n \"def display_name_labels(self):\\n for name in self.names:\\n # create a label for each name\\n self.root.add_widget(Label(text=name))\",\n \"def get_labels(pr_id):\\n label_json = get_status_json(pr_id, 'labels')\\n current_labels = [l['name'] for l in label_json]\\n return current_labels\",\n \"def add_labels(self, labels: dict):\\n self.status = \\\"Creating labels\\\"\\n for lname, value in labels.items():\\n self.labels.add_label(lname, value)\",\n \"def get(self):\\n app_id = app_identity.get_application_id()\\n users = User.query(User.email != None)\\n for user in users:\\n games = Game.query(Game.user == user.key, Game.game_over == False)\\n if games:\\n subject = \\\"This is a reminder!\\\"\\n body = \\\"Hello {}, you have some unfinished games.\\\".format(\\n user.name)\\n\\n mail.send_mail('noreply@{}.appspot.com'.format(app_id),\\n user.email, subject, body)\",\n \"def labels(self):\\r\\n return labels.RepoLabels(self)\",\n \"def _add_user_label(self):\\n user_label = tk.Label(parent, text='Пользователь: ' +\\n self.user_info.ShortUserName + ' Версия ' + __version__,\\n font=('Arial', 8))\\n user_label.pack(side=tk.RIGHT, anchor=tk.NE)\",\n \"def pull_labels(self, org):\\n pass\",\n \"def _get_labels_for_user(self, project, assignment, user):\\n return Session.query(model.Label).filter(and_(model.Label.user_id==user.id,\\n model.Label.project_id==project.id,\\n model.Label.assignment_id==assignment.id)).all()\",\n \"def labels(self):\\n return self._labels\",\n \"def user_labels_new(*args):\\n return _ida_hexrays.user_labels_new(*args)\",\n \"def __get_emails(self):\\n # This returns a list of Gmail message objects. Documentation can be found at\\n # https://developers.google.com/gmail/api/v1/reference/users/messages/list\\n return self.__service.users().messages().list(userId='me').execute()['messages']\",\n \"def labels(self) -> pulumi.Output[Optional[Sequence[str]]]:\\n return pulumi.get(self, \\\"labels\\\")\",\n \"def labels(self) -> pulumi.Output[Optional[Sequence[str]]]:\\n return pulumi.get(self, \\\"labels\\\")\",\n \"def get_labels():\\n session = get_session()\\n try:\\n query = session.query(Album.label).distinct()\\n final_query = query\\n labels = query.all()\\n label_list = []\\n for label in labels:\\n label_list.append(label[0])\\n count = final_query.count()\\n return jsonify({\\n 'items': label_list,\\n 'count': count\\n })\\n finally:\\n session.close()\",\n \"def get(self, id):\\n context = request.environ.get('context')\\n obj = dbapi.netdevices_get_by_id(context, id)\\n response = {\\\"labels\\\": list(obj.labels)}\\n return response, 200, None\",\n \"def _messagelabels_aux(self, arg, uidlist, labels):\\n labels = labels - self.ignorelabels\\n uidlist = [uid for uid in uidlist if uid > 0]\\n if len(uidlist) > 0:\\n imapobj = self.imapserver.acquireconnection()\\n try:\\n labels_str = '(' + ' '.join([imaputil.quote(lb) for lb in labels]) + ')'\\n # Coalesce uid's into ranges\\n uid_str = imaputil.uid_sequence(uidlist)\\n result = self._store_to_imap(imapobj, uid_str, arg, labels_str)\\n\\n except imapobj.readonly:\\n self.ui.labelstoreadonly(self, uidlist, labels)\\n return None\\n\\n finally:\\n self.imapserver.releaseconnection(imapobj)\\n\\n if result:\\n retlabels = imaputil.flags2hash(imaputil.imapsplit(result)[1])['X-GM-LABELS']\\n retlabels = set([imaputil.dequote(lb) for lb in imaputil.imapsplit(retlabels)])\\n return retlabels\\n return None\",\n \"async def test__get_labels():\\n # Uppercase 'C'\\n assert ImageConfig._get_labels(json.loads('{\\\"Config\\\":{\\\"Labels\\\":{\\\"x\\\":\\\"5\\\"}}}')) == {\\n \\\"x\\\": \\\"5\\\"\\n }\\n\\n # Lowercase 'C'\\n assert ImageConfig._get_labels(json.loads('{\\\"config\\\":{\\\"Labels\\\":{\\\"x\\\":\\\"5\\\"}}}')) == {\\n \\\"x\\\": \\\"5\\\"\\n }\\n\\n # Missing 'Labels'\\n assert ImageConfig._get_labels(json.loads('{\\\"Config\\\":{}}')) == {}\",\n \"def list_groups(self):\\n\\n for counter, label in enumerate(self.exp_labels_list):\\n print('Key {}: {} \\\\n'.format(str(counter), label))\",\n \"def get_labels() -> list[Label]:\\n\\n labels_file = deepcopy(get_data(\\\"labels.yml\\\"))\\n standard_labels = []\\n for group_info in labels_file[\\\"groups\\\"]:\\n labels = group_info.pop(\\\"labels\\\", [])\\n group = LabelGroup(**group_info)\\n for label_info in labels:\\n label = Label(**label_info, group=group)\\n standard_labels.append(label)\\n for label_info in labels_file[\\\"standalone\\\"]:\\n label = Label(**label_info)\\n standard_labels.append(label)\\n return standard_labels\",\n \"def get_all_labels(self):\\n labels = self.wls_board.get_labels\\n return labels\",\n \"def get_labels(self) -> List[str]:\\n raise NotImplementedError()\",\n \"def build_expected_user_labels_response(self):\\n labels = [\\n {\\n \\\"key\\\": \\\"key1\\\",\\n \\\"value\\\": \\\"value1\\\"\\n },\\n {\\n \\\"key\\\": \\\"key2\\\",\\n \\\"value\\\": \\\"value2\\\"\\n }\\n ]\\n return labels\",\n \"def user_labels_next(*args):\\n return _ida_hexrays.user_labels_next(*args)\",\n \"def labels(self) -> Optional[Sequence[str]]:\\n return pulumi.get(self, \\\"labels\\\")\",\n \"def get_labels(self):\\n\\t\\traise NotImplementedError()\",\n \"def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]:\\n return pulumi.get(self, \\\"labels\\\")\",\n \"def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]:\\n return pulumi.get(self, \\\"labels\\\")\",\n \"def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]:\\n return pulumi.get(self, \\\"labels\\\")\",\n \"def getGroup():\\n\\tprint\\n\\tprint \\\"Requesting the list of groups for this account\\\"\\n\\n\\tgroups_result = getResult('/papi/v0/groups')\\n\\n\\treturn (groups_result)\",\n \"def greet_users(names):\\n for name in names:\\n msg = \\\"Hello, \\\" + name.title() + \\\"!\\\"\\n print(msg)\",\n \"def greet_users(names):\\n for name in names:\\n msg = \\\"Hello, \\\" + name.title() + \\\"!\\\"\\n print(msg)\",\n \"def get_users(msg: telebot.types.Message):\\n users = User.select()\\n m = ''\\n for user in users:\\n menu_caption = \\\"In PVP game\\\" if user.state == states.USER_IN_PVP_GAME else \\\"In AI game\\\" if user.state == states.USER_IN_AI_GAME else \\\"In menu\\\"\\n m += f'[{user.first_name}](tg://user?id={user.user_id}) - {menu_caption}\\\\n'\\n\\n bot.send_message(\\n msg.from_user.id,\\n m,\\n parse_mode='Markdown'\\n )\",\n \"def do_list(client, args):\\n\\trepos = client.repos.list(args.user)\\n\\tprint '%s has the following repositories:' % args.user\\n\\tprint 'Name - Description'\\n\\tfor repo in repos:\\n\\t\\tprint '%s - %s' % (repo.name, repo.description)\",\n \"def get_labels(self):\\n return self.labels\",\n \"def get_label_list():\\n f_name = os.path.join(FLAGS.labels_dir, FLAGS.labels_name)\\n if os.path.exists(f_name):\\n with open(f_name, 'rb') as f:\\n try:\\n label_list = [line.rstrip('\\\\n') for line in f]\\n except:\\n print(\\\"Could not read file:\\\" + f_name)\\n sys.exit()\\n return label_list\",\n \"def _get_label ( self ):\\n if self._label is not None:\\n return self._label\\n return user_name_for( self.name )\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def get_labels(self):\\n raise NotImplementedError()\",\n \"def ListAnnotations(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69438267","0.67967373","0.67262995","0.64360845","0.63330704","0.62724566","0.6237401","0.5750789","0.5673543","0.5591335","0.55725247","0.5570501","0.55700606","0.5568798","0.5558453","0.55524904","0.550932","0.549548","0.5492455","0.5464197","0.5463122","0.5420545","0.5341041","0.52676064","0.5200485","0.51316243","0.5107093","0.50787425","0.50407284","0.50254977","0.50041085","0.49922433","0.4991385","0.49253178","0.49183184","0.490567","0.48841432","0.48712835","0.48693612","0.48648402","0.48414052","0.48378563","0.48214775","0.47722575","0.47654605","0.47642642","0.47605622","0.4754152","0.4749384","0.4711193","0.47110534","0.47039685","0.46741915","0.46413237","0.4639425","0.46300715","0.4627345","0.46050972","0.45976943","0.45974928","0.4572201","0.4571045","0.45691425","0.45686793","0.45579994","0.4556998","0.45491806","0.45491183","0.45362765","0.45296088","0.4525228","0.45229295","0.45086512","0.45086512","0.44879213","0.44854105","0.4483515","0.4482555","0.4472183","0.4472051","0.44700742","0.44667396","0.44641134","0.44639027","0.44597068","0.44554645","0.44546765","0.44546765","0.44546765","0.44518867","0.44507888","0.44507888","0.44472745","0.44424102","0.44413784","0.44405758","0.44337413","0.44319054","0.44319054","0.44319054","0.44279084"],"string":"[\n \"0.69438267\",\n \"0.67967373\",\n \"0.67262995\",\n \"0.64360845\",\n \"0.63330704\",\n \"0.62724566\",\n \"0.6237401\",\n \"0.5750789\",\n \"0.5673543\",\n \"0.5591335\",\n \"0.55725247\",\n \"0.5570501\",\n \"0.55700606\",\n \"0.5568798\",\n \"0.5558453\",\n \"0.55524904\",\n \"0.550932\",\n \"0.549548\",\n \"0.5492455\",\n \"0.5464197\",\n \"0.5463122\",\n \"0.5420545\",\n \"0.5341041\",\n \"0.52676064\",\n \"0.5200485\",\n \"0.51316243\",\n \"0.5107093\",\n \"0.50787425\",\n \"0.50407284\",\n \"0.50254977\",\n \"0.50041085\",\n \"0.49922433\",\n \"0.4991385\",\n \"0.49253178\",\n \"0.49183184\",\n \"0.490567\",\n \"0.48841432\",\n \"0.48712835\",\n \"0.48693612\",\n \"0.48648402\",\n \"0.48414052\",\n \"0.48378563\",\n \"0.48214775\",\n \"0.47722575\",\n \"0.47654605\",\n \"0.47642642\",\n \"0.47605622\",\n \"0.4754152\",\n \"0.4749384\",\n \"0.4711193\",\n \"0.47110534\",\n \"0.47039685\",\n \"0.46741915\",\n \"0.46413237\",\n \"0.4639425\",\n \"0.46300715\",\n \"0.4627345\",\n \"0.46050972\",\n \"0.45976943\",\n \"0.45974928\",\n \"0.4572201\",\n \"0.4571045\",\n \"0.45691425\",\n \"0.45686793\",\n \"0.45579994\",\n \"0.4556998\",\n \"0.45491806\",\n \"0.45491183\",\n \"0.45362765\",\n \"0.45296088\",\n \"0.4525228\",\n \"0.45229295\",\n \"0.45086512\",\n \"0.45086512\",\n \"0.44879213\",\n \"0.44854105\",\n \"0.4483515\",\n \"0.4482555\",\n \"0.4472183\",\n \"0.4472051\",\n \"0.44700742\",\n \"0.44667396\",\n \"0.44641134\",\n \"0.44639027\",\n \"0.44597068\",\n \"0.44554645\",\n \"0.44546765\",\n \"0.44546765\",\n \"0.44546765\",\n \"0.44518867\",\n \"0.44507888\",\n \"0.44507888\",\n \"0.44472745\",\n \"0.44424102\",\n \"0.44413784\",\n \"0.44405758\",\n \"0.44337413\",\n \"0.44319054\",\n \"0.44319054\",\n \"0.44319054\",\n \"0.44279084\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94284,"cells":{"query":{"kind":"string","value":"Input of the Network"},"document":{"kind":"string","value":"def __init__(self, shape, input_var=None):\n\n self.output = layers.InputLayer(shape, input_var=input_var)"},"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 input(self):","def input(self):\r\n pass","def d_input(self):\n pass","def inputs(self):\n pass","def input(self):\n return self[\"input\"]","def input(self):\n return self[\"input\"]","def input_nodes(self):\n pass","def processInputs(self):","def input(self):\n connected_node = self.get_connected_node()\n if connected_node:\n #it is not possible to connect to an input\n return connected_node.output()\n return None","def get_input(self):\n pass","def read_input():\n input()\n size = int(input().split()[-1])\n nb_edges = int(input().split()[-1])\n\n g = UndirectedGraph()\n\n if parameters.DEBUG:\n print('Build nodes')\n\n nodes = [g.add_node() for _ in range(size)]\n\n if parameters.DEBUG:\n print('Build edges')\n edges = []\n weights = {}\n i = 0\n for i in range(nb_edges):\n if parameters.DEBUG:\n i += 1\n if i % 1000 == 0:\n print('Edge %d / %d' % (i, nb_edges))\n line = input()\n _, u, v, w = line.split()\n\n e = g.add_edge(nodes[int(u) - 1], nodes[int(v) - 1])\n weights[e] = int(w)\n\n edges.append((int(u), int(v), int(w)))\n\n line = input()\n while 'Terminals' not in line:\n line = input()\n if 'SECTION' in line:\n line = input()\n while 'Terminals' not in line:\n line = input()\n nb_terms = int(line.split()[-1])\n terms = []\n for i in range(nb_terms):\n line = input()\n _, t = line.split()\n terms.append(nodes[int(t) - 1])\n\n return instances.SteinerInstance(g, terms, weights)","def _get_input(self):\n return self.__input","def _get_input(self):\n return self.__input","def _get_input(self):\n return self.__input","def _get_input(self):\n return self.__input","def _get_input(self):\n return self.__input","def _get_input(self):\n return self.__input","def _get_input(self):\n return self.__input","def n_inputs(self):","def input(self):\n return self._input","def input(self):\n return self._input","def input(self):\n return self._input","def process_inputs(self, inputs):","def input(self, name: str) -> bpy.types.NodeSocket:\n\t\treturn self.inputs[name]","def input(self):\r\n\r\n if len(self.inputs) == 1:\r\n return self.inputs[0]\r\n else:\r\n raise Exception(\"Single input requested. Node has none or more than one input (%d).\"\r\n % len(self.inputs))","def _input(self):\n\n return self.input_processor.readline().strip()","def network(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"network\")","def get_inputs(self):\r\n raise NotImplementedError","def get_inputs(self):\r\n raise NotImplementedError","def read_input(E):\n # ---------- INSERT CODE BELOW ----------\n edge_list = []\n\n for _ in range(E):\n src, dst, cost = input('').rstrip('\\r\\n').split()\n edge_list.append((int(src),int(dst),int(cost)))\n \n return edge_list\n # ---------- INSERT CODE ABOVE ----------","def input_handling():\r\n # get program parameters from user\r\n k_in, n_in, Random = io.get_values()\r\n\r\n # Generation of n data points (2d or 3d)\r\n n, K, d, data, labels = io.sk_generator(n_in, k_in, Random)\r\n # Print description of Inputs and Random choices\r\n io.print_description(k_in, n_in, K, n, Random, d)\r\n\r\n return n, K, d, data, labels, Random","def read_input(self) -> None:\n raw_input = sys.stdin.read()\n\n self.input = raw_input.split('\\n')\n self.input = self.input[0:-1]\n\n self.packets = []\n for item in self.input:\n if item:\n self.packets.append(literal_eval(item))","def QNetwork(input_var):\n n_actions = 2\n\n from lasagne.layers import batch_norm\n from lasagne.layers import DenseLayer\n from lasagne.layers import InputLayer\n from lasagne.nonlinearities import rectify, linear, sigmoid, softmax, tanh\n from lasagne.init import GlorotNormal\n network = InputLayer(shape=(None,4), input_var=input_var, name='Input')\n network = (DenseLayer(incoming=network,\n num_units=24,\n nonlinearity=rectify,\n W=GlorotNormal())\n )\n network = (DenseLayer(incoming=network,\n num_units=24,\n nonlinearity=rectify,\n W=GlorotNormal())\n\n# W=lasagne.init.HeUniform())\n )\n network = DenseLayer(incoming=network,\n num_units=n_actions,\n W=GlorotNormal(),\n b=lasagne.init.Constant(0),\n nonlinearity=linear)\n network = lasagne.layers.ReshapeLayer(network, (-1, n_actions))\n return network","def get_input(inputs):\n return input(inputs)","def forward(self, input):\n\n return self.network(input)","def forward(self, input):\n\n return self.network(input)","def forward(self, input):\n\n return self.network(input)","def inputs(self):\n return NotImplementedError","def net_input(self,X):\n return np.dot(X,self.w_[1:])+self.w_[0]","def inputs(self) -> 'Input':\n return self.Input","def parse(self, input):\n pass","def get_input(self):\n if self.console_label is None:\n self.text_area.delete('1.0', END)\n print(\"The training has finished and the training file was created and sent to the server! Go Back.\")\n return\n\n valid_responses = {'y', 'n', 'u', 'f'}\n\n user_input = self.user_input.get()\n\n self.user_input.delete(0, END)\n\n if user_input not in valid_responses:\n return\n\n self.console_label.label_record_pair(user_input, self.current_record_pair)\n\n if user_input == 'f':\n self.upload_training_file()\n self.current_record_pair = None\n self.console_label = None\n self.text_area.delete('1.0', END)\n return\n\n self.text_area.yview(END)\n\n self.current_record_pair = self.console_label.get_uncertain_pair()","def stdin(self):\n pass","def __init__(self):\n self.inputs = {}","def out(self, inputs):","def trainNet():","def input(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"input\")","def process_input(self,r,g,b):\n pass","def get_input_id(self):\n return self.net.inputs[0]","def get_input(cls, message):\n data = input(message)\n return data","def input(self, input):\n\n self._input = input","def set_input(self, input):\n pass","def set_input(self, input):\n pass","def _get_inputs(self):\n return self.__inputs","def _get_inputs(self):\n return self.__inputs","def _get_inputs(self):\n return self.__inputs","def inp(text):\r\n input(text)","def get_input_data(self, name='0'):\n return data","def requestInput(st):\n return input(st+\": \")","def getInput():\t\n\tglobal active_\n\n\t#to disable the service \n\tactive_ = False \n\t\n\t# reading the previous input\n\tprev_input_ = rospy.get_param('/input')\n\tinput_ = prev_input_\n\t\n\t#in order to make the user to choose one of the 5 possible inputs\n\twhile (prev_input_ == input_) or (input_ > 5 or input_ < 1):\n\t\tif input_ > 5 or input_ < 1: \n\t\t\t#in the case in which the user make another selection\n\t\t\tprint \"Unknown input, please try again\" \n\t\t\n\t\t#propose to the user which are the real possibilities\n\t\tprint(\"Please select one of the following senteces\\n\")\n\t\tprint(\"1 - Move the robot randomly in the environment, by choosing one of six possible target positions\\n\")\n\t\tprint(\"2 - The user can chose the next target position\\n\")\n\t\tprint(\"3 - Start following the external walls\\n\")\n\t\tprint(\"4 - Stop the robot in the last position\\n\")\n\t\tprint(\"5 - Change the planning algorithm from move_base to bug0 and vice versa\\n\")\n\n\t\t#read the input typed by the user\t\n\t\tinput_ = (int(raw_input(\"Please select a number between 1 and 5: \")))\n\n\t#set the choice made by the user\n\tif input_ >= 1 and input_ <= 5:\n\t\trospy.set_param('/input', input_)","def run(self, input):\n print self.print_meep(input)","def get_input():\r\n operation = input()\r\n\r\n return operation","def _nn_read_data(self):\n\t\treaData = True\n\t\tnnIncomingData = False\n\t\tnnData = \"\"\n\t\twhile reaData and self._neuralNetwork.poll()==None:\n\t\t\tnnIncomingMsg = self._neuralNetwork.stdout.readline().rstrip(\"\\n\").split()\n\t\t\tif \"COMM_OUT\" in nnIncomingMsg: nnIncomingData = True\n\t\t\telif \"END\" in nnIncomingMsg: reaData = False\n\t\t\telif nnIncomingData: nnData += \" \".join(nnIncomingMsg)+\"\\n\"\n\t\t\tprint \"\\t\\tNeuron: \"+\" \".join(nnIncomingMsg)\n\t\treturn nnData","def _send_data_to_nn(self,wbtData):\n\t\tself._neuralNetwork.stdin.write(\"COMM IN\\n\") # this shitty COMM IN is not really needed..to modify in closedloop.py\n\t\tself._neuralNetwork.stdin.write(wbtData)","def __init__(self, incoming, name='RNNInputLayer'):\n super(RNNInputLayer, self).__init__()\n self.incoming, self.incoming_shape = get_input(incoming)\n with tf.variable_scope(name) as self.layer_scope:\n self.out = self.incoming()\n self.name = name","def writeInput(self) -> str:\n\n self.init()\n\n self.prepareConnectors()\n\n self.writeHeaders()\n self.writeMesh()\n self.writeNodeSets()\n self.writeElementSets()\n self.writeKinematicConnectors()\n self.writeMPCs()\n self.writeMaterials()\n self.writeMaterialAssignments()\n self.writeInitialConditions()\n self.writeAnalysisConditions()\n self.writeLoadSteps()\n\n return self._input","def inputs(self):\n return self._inputs","def input(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"input\")","def hyper(self, input):\n return","def getInput(self):\n return self.__string","def input():\n return list_of_inputs.pop(0)","def call(self, inputs, **kwargs):\n nodes, edges, edge_index = inputs\n n_in = self.lay_gather_in([nodes, edge_index])\n n_out = self.lay_gather_out([nodes, edge_index])\n msg = self.message_function([n_in, n_out, edges])\n pool_n = self.aggregate_message([nodes, msg, edge_index])\n n_new = self.update_nodes([nodes, pool_n])\n return n_new","def __call__(self, inputs, training):\n\n\t\treturn self._build_network(inputs, training)","def _buildInput (self):\n\n\t\tindata = self.config['input']\n\t\tif not isinstance (indata, dict):\n\t\t\tindata = ','.join(utils.alwaysList (indata))\t\t\t\n\t\t\tdepdchan = channel.fromChannels (*[d.channel for d in self.depends])\n\t\t\tindata = {indata: depdchan if self.depends else channel.fromArgv()}\n\t\t\t\n\t\t# expand to one key-channel pairs\n\t\tfor inkeys, invals in indata.iteritems():\n\t\t\tkeys = utils.split(inkeys, ',')\n\t\t\tif callable (invals):\n\t\t\t\tvals = invals (*[d.channel.copy() for d in self.depends] if self.depends else channel.fromArgv())\n\t\t\t\tvals = vals.split()\n\t\t\telif isinstance (invals, basestring): # only for files: \"/a/b/*.txt, /a/c/*.txt\"\n\t\t\t\tvals = utils.split(invals, ',')\n\t\t\telif isinstance (invals, channel):\n\t\t\t\tvals = invals.split()\n\t\t\telif isinstance (invals, list):\n\t\t\t\tvals = channel.create(invals).split()\n\t\t\telse:\n\t\t\t\traise ValueError (\"%s: Unexpected values for input. Expect dict, list, str, channel, callable.\" % self._name())\n\t\t\t\n\t\t\twidth = len (vals)\n\t\t\tif len (keys) > width:\n\t\t\t\traise ValueError ('%s: Not enough data for input variables.\\nVarialbes: %s\\nData: %s' % (self._name(), keys, vals))\n\t\t\t\n\t\t\tfor i, key in enumerate(keys):\n\t\t\t\tintype = key.split(':')[-1]\n\t\t\t\tthekey = key.split(':')[0]\n\t\t\t\tval = vals[i].toList() #if isinstance(vals[i], channel) else vals[i]\n\n\t\t\t\tif intype not in proc.IN_VARTYPE + proc.IN_FILESTYPE + proc.IN_FILETYPE:\n\t\t\t\t\tintype = proc.IN_VARTYPE[0]\n\t\t\t\t\n\t\t\t\tif intype in proc.IN_FILESTYPE:\n\t\t\t\t\tfor x, v in enumerate(val):\n\t\t\t\t\t\tif isinstance (v, basestring):\n\t\t\t\t\t\t\tval[x] = channel.fromPath (v).toList()\n\t\t\t\t\n\t\t\t\tif self.length == 0: \n\t\t\t\t\tself.props['length'] = len (val)\n\t\t\t\tif self.length != len (val):\n\t\t\t\t\traise ValueError ('%s: Expect same lengths for input channels, but got %s and %s (keys: %s).' % (self._name(), self.length, len (val), key))\n\t\t\t\tself.props['indata'][thekey] = {\n\t\t\t\t\t'type': intype,\n\t\t\t\t\t'data': val\n\t\t\t\t}\n\t\t\tself.props['jobs'] = [None] * self.length","def build_graph_from_input(self, input_node):\n raise NotImplementedError","def revisar_input(self):\n pass","def inputs(self):\n return super().inputs","def inputs(self):\n return super().inputs","def inputs(self):\n return super().inputs","def inputs(self):\n return super().inputs","def inputs(self):\n return self.inputs","def read_inputs(self):\n self.in_power.read()\n self.in_alert.read()","def input(self, description):\n if isinstance(description, (int, long)):\n self._input = description\n self._sendCommand('%02dFN' % description)\n elif description in self.inputs:\n self._input = self.inputs[description]\n self._sendCommand('%02dFN' % self.inputs[description])\n else:\n raise Exception('No such input: %s' % description)","def buildPackets(self):\n return self.input","def net_input(self, X):\n return np.dot(X, self.w[1:]) + self.w[0]","def build_user_input(self):\n pass","def get_input():\n parser = argparse.ArgumentParser(description='Parameters')\n parser.add_argument('--host', help='adress of the host')\n parser.add_argument('--port', help='port of IPMI host')\n parser.add_argument('--user', help='user allowed to acces IPMI')\n parser.add_argument('--passwd', help='password for the specific user')\n parser.add_argument('--interval', help='seconds between each data reading')\n parser.add_argument('--nread', help='number of time to collect data')\n parser.add_argument('--store', action='store_true',\n help='save the data collected in a nosql db')\n args = parser.parse_args()\n return args, parser","def load(self, input):","def net_input(self, X):\n return np.dot(X, self.weight_[1:]) + self.weight_[0]","def net_input(self, X):\n return np.dot(X, self.weight_[1:]) + self.weight_[0]","def writeInput(self):\n\n #self.collect.writeInput()","def input(self):\n\t\treturn self.image","def generate_input_data(self):\n for socket_name, c in self.__taskobject.inputs.items():\n if c['optional']:\n self.__inputs[socket_name] = {'data': None, 'enable': False}\n else:\n self.__inputs[socket_name] = {'data': None, 'enable': True}","def run(self, input):\n return {}","def getInput(self):\n self.userInput = self.entry.get()","def single_input_node(self, port: int):\n input_nodes = self.input_nodes(port)\n if len(input_nodes) != 1:\n raise Error('The amount of input nodes for port \"{}\" is not equal to 1. '.format(port) +\n refer_to_faq_msg(33))\n return input_nodes[0]","def build_input(self):\n n_input = tf.placeholder(tf.int32, [None, None], name='n_input')\n t_input = tf.placeholder(tf.int32, [None, None], name='t_input')\n n_target = tf.placeholder(tf.int32, [None, None], name='n_target')\n t_target = tf.placeholder(tf.int32, [None, None], name='t_target')\n keep_prob = tf.placeholder(tf.float32, name='keep_prob')\n return n_input, t_input, n_target, t_target, keep_prob","def input_type():\n pass","def read_input(self) -> None:\n raw_input = sys.stdin.read()\n\n self._input = raw_input.split('\\n')\n self._input = self._input[0:-1]\n\n for line in self._input:\n direction, steps = line.split()\n self._instructions.append((direction, int(steps)))","def _handleInput(self, paramInput):\n super()._handleInput(paramInput)\n settings, notFound = paramInput.findNodesAndExtractValues(['nu','C', 'kernel', 'degree', 'gamma', 'coef0',\n 'tol', 'cache_size', 'shrinking', 'max_iter'])\n # notFound must be empty\n assert(not notFound)\n self.initializeModel(settings)","def input(self, inputters, field, number=None):\n raise NotImplementedError"],"string":"[\n \"def input(self):\",\n \"def input(self):\\r\\n pass\",\n \"def d_input(self):\\n pass\",\n \"def inputs(self):\\n pass\",\n \"def input(self):\\n return self[\\\"input\\\"]\",\n \"def input(self):\\n return self[\\\"input\\\"]\",\n \"def input_nodes(self):\\n pass\",\n \"def processInputs(self):\",\n \"def input(self):\\n connected_node = self.get_connected_node()\\n if connected_node:\\n #it is not possible to connect to an input\\n return connected_node.output()\\n return None\",\n \"def get_input(self):\\n pass\",\n \"def read_input():\\n input()\\n size = int(input().split()[-1])\\n nb_edges = int(input().split()[-1])\\n\\n g = UndirectedGraph()\\n\\n if parameters.DEBUG:\\n print('Build nodes')\\n\\n nodes = [g.add_node() for _ in range(size)]\\n\\n if parameters.DEBUG:\\n print('Build edges')\\n edges = []\\n weights = {}\\n i = 0\\n for i in range(nb_edges):\\n if parameters.DEBUG:\\n i += 1\\n if i % 1000 == 0:\\n print('Edge %d / %d' % (i, nb_edges))\\n line = input()\\n _, u, v, w = line.split()\\n\\n e = g.add_edge(nodes[int(u) - 1], nodes[int(v) - 1])\\n weights[e] = int(w)\\n\\n edges.append((int(u), int(v), int(w)))\\n\\n line = input()\\n while 'Terminals' not in line:\\n line = input()\\n if 'SECTION' in line:\\n line = input()\\n while 'Terminals' not in line:\\n line = input()\\n nb_terms = int(line.split()[-1])\\n terms = []\\n for i in range(nb_terms):\\n line = input()\\n _, t = line.split()\\n terms.append(nodes[int(t) - 1])\\n\\n return instances.SteinerInstance(g, terms, weights)\",\n \"def _get_input(self):\\n return self.__input\",\n \"def _get_input(self):\\n return self.__input\",\n \"def _get_input(self):\\n return self.__input\",\n \"def _get_input(self):\\n return self.__input\",\n \"def _get_input(self):\\n return self.__input\",\n \"def _get_input(self):\\n return self.__input\",\n \"def _get_input(self):\\n return self.__input\",\n \"def n_inputs(self):\",\n \"def input(self):\\n return self._input\",\n \"def input(self):\\n return self._input\",\n \"def input(self):\\n return self._input\",\n \"def process_inputs(self, inputs):\",\n \"def input(self, name: str) -> bpy.types.NodeSocket:\\n\\t\\treturn self.inputs[name]\",\n \"def input(self):\\r\\n\\r\\n if len(self.inputs) == 1:\\r\\n return self.inputs[0]\\r\\n else:\\r\\n raise Exception(\\\"Single input requested. Node has none or more than one input (%d).\\\"\\r\\n % len(self.inputs))\",\n \"def _input(self):\\n\\n return self.input_processor.readline().strip()\",\n \"def network(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"network\\\")\",\n \"def get_inputs(self):\\r\\n raise NotImplementedError\",\n \"def get_inputs(self):\\r\\n raise NotImplementedError\",\n \"def read_input(E):\\n # ---------- INSERT CODE BELOW ----------\\n edge_list = []\\n\\n for _ in range(E):\\n src, dst, cost = input('').rstrip('\\\\r\\\\n').split()\\n edge_list.append((int(src),int(dst),int(cost)))\\n \\n return edge_list\\n # ---------- INSERT CODE ABOVE ----------\",\n \"def input_handling():\\r\\n # get program parameters from user\\r\\n k_in, n_in, Random = io.get_values()\\r\\n\\r\\n # Generation of n data points (2d or 3d)\\r\\n n, K, d, data, labels = io.sk_generator(n_in, k_in, Random)\\r\\n # Print description of Inputs and Random choices\\r\\n io.print_description(k_in, n_in, K, n, Random, d)\\r\\n\\r\\n return n, K, d, data, labels, Random\",\n \"def read_input(self) -> None:\\n raw_input = sys.stdin.read()\\n\\n self.input = raw_input.split('\\\\n')\\n self.input = self.input[0:-1]\\n\\n self.packets = []\\n for item in self.input:\\n if item:\\n self.packets.append(literal_eval(item))\",\n \"def QNetwork(input_var):\\n n_actions = 2\\n\\n from lasagne.layers import batch_norm\\n from lasagne.layers import DenseLayer\\n from lasagne.layers import InputLayer\\n from lasagne.nonlinearities import rectify, linear, sigmoid, softmax, tanh\\n from lasagne.init import GlorotNormal\\n network = InputLayer(shape=(None,4), input_var=input_var, name='Input')\\n network = (DenseLayer(incoming=network,\\n num_units=24,\\n nonlinearity=rectify,\\n W=GlorotNormal())\\n )\\n network = (DenseLayer(incoming=network,\\n num_units=24,\\n nonlinearity=rectify,\\n W=GlorotNormal())\\n\\n# W=lasagne.init.HeUniform())\\n )\\n network = DenseLayer(incoming=network,\\n num_units=n_actions,\\n W=GlorotNormal(),\\n b=lasagne.init.Constant(0),\\n nonlinearity=linear)\\n network = lasagne.layers.ReshapeLayer(network, (-1, n_actions))\\n return network\",\n \"def get_input(inputs):\\n return input(inputs)\",\n \"def forward(self, input):\\n\\n return self.network(input)\",\n \"def forward(self, input):\\n\\n return self.network(input)\",\n \"def forward(self, input):\\n\\n return self.network(input)\",\n \"def inputs(self):\\n return NotImplementedError\",\n \"def net_input(self,X):\\n return np.dot(X,self.w_[1:])+self.w_[0]\",\n \"def inputs(self) -> 'Input':\\n return self.Input\",\n \"def parse(self, input):\\n pass\",\n \"def get_input(self):\\n if self.console_label is None:\\n self.text_area.delete('1.0', END)\\n print(\\\"The training has finished and the training file was created and sent to the server! Go Back.\\\")\\n return\\n\\n valid_responses = {'y', 'n', 'u', 'f'}\\n\\n user_input = self.user_input.get()\\n\\n self.user_input.delete(0, END)\\n\\n if user_input not in valid_responses:\\n return\\n\\n self.console_label.label_record_pair(user_input, self.current_record_pair)\\n\\n if user_input == 'f':\\n self.upload_training_file()\\n self.current_record_pair = None\\n self.console_label = None\\n self.text_area.delete('1.0', END)\\n return\\n\\n self.text_area.yview(END)\\n\\n self.current_record_pair = self.console_label.get_uncertain_pair()\",\n \"def stdin(self):\\n pass\",\n \"def __init__(self):\\n self.inputs = {}\",\n \"def out(self, inputs):\",\n \"def trainNet():\",\n \"def input(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"input\\\")\",\n \"def process_input(self,r,g,b):\\n pass\",\n \"def get_input_id(self):\\n return self.net.inputs[0]\",\n \"def get_input(cls, message):\\n data = input(message)\\n return data\",\n \"def input(self, input):\\n\\n self._input = input\",\n \"def set_input(self, input):\\n pass\",\n \"def set_input(self, input):\\n pass\",\n \"def _get_inputs(self):\\n return self.__inputs\",\n \"def _get_inputs(self):\\n return self.__inputs\",\n \"def _get_inputs(self):\\n return self.__inputs\",\n \"def inp(text):\\r\\n input(text)\",\n \"def get_input_data(self, name='0'):\\n return data\",\n \"def requestInput(st):\\n return input(st+\\\": \\\")\",\n \"def getInput():\\t\\n\\tglobal active_\\n\\n\\t#to disable the service \\n\\tactive_ = False \\n\\t\\n\\t# reading the previous input\\n\\tprev_input_ = rospy.get_param('/input')\\n\\tinput_ = prev_input_\\n\\t\\n\\t#in order to make the user to choose one of the 5 possible inputs\\n\\twhile (prev_input_ == input_) or (input_ > 5 or input_ < 1):\\n\\t\\tif input_ > 5 or input_ < 1: \\n\\t\\t\\t#in the case in which the user make another selection\\n\\t\\t\\tprint \\\"Unknown input, please try again\\\" \\n\\t\\t\\n\\t\\t#propose to the user which are the real possibilities\\n\\t\\tprint(\\\"Please select one of the following senteces\\\\n\\\")\\n\\t\\tprint(\\\"1 - Move the robot randomly in the environment, by choosing one of six possible target positions\\\\n\\\")\\n\\t\\tprint(\\\"2 - The user can chose the next target position\\\\n\\\")\\n\\t\\tprint(\\\"3 - Start following the external walls\\\\n\\\")\\n\\t\\tprint(\\\"4 - Stop the robot in the last position\\\\n\\\")\\n\\t\\tprint(\\\"5 - Change the planning algorithm from move_base to bug0 and vice versa\\\\n\\\")\\n\\n\\t\\t#read the input typed by the user\\t\\n\\t\\tinput_ = (int(raw_input(\\\"Please select a number between 1 and 5: \\\")))\\n\\n\\t#set the choice made by the user\\n\\tif input_ >= 1 and input_ <= 5:\\n\\t\\trospy.set_param('/input', input_)\",\n \"def run(self, input):\\n print self.print_meep(input)\",\n \"def get_input():\\r\\n operation = input()\\r\\n\\r\\n return operation\",\n \"def _nn_read_data(self):\\n\\t\\treaData = True\\n\\t\\tnnIncomingData = False\\n\\t\\tnnData = \\\"\\\"\\n\\t\\twhile reaData and self._neuralNetwork.poll()==None:\\n\\t\\t\\tnnIncomingMsg = self._neuralNetwork.stdout.readline().rstrip(\\\"\\\\n\\\").split()\\n\\t\\t\\tif \\\"COMM_OUT\\\" in nnIncomingMsg: nnIncomingData = True\\n\\t\\t\\telif \\\"END\\\" in nnIncomingMsg: reaData = False\\n\\t\\t\\telif nnIncomingData: nnData += \\\" \\\".join(nnIncomingMsg)+\\\"\\\\n\\\"\\n\\t\\t\\tprint \\\"\\\\t\\\\tNeuron: \\\"+\\\" \\\".join(nnIncomingMsg)\\n\\t\\treturn nnData\",\n \"def _send_data_to_nn(self,wbtData):\\n\\t\\tself._neuralNetwork.stdin.write(\\\"COMM IN\\\\n\\\") # this shitty COMM IN is not really needed..to modify in closedloop.py\\n\\t\\tself._neuralNetwork.stdin.write(wbtData)\",\n \"def __init__(self, incoming, name='RNNInputLayer'):\\n super(RNNInputLayer, self).__init__()\\n self.incoming, self.incoming_shape = get_input(incoming)\\n with tf.variable_scope(name) as self.layer_scope:\\n self.out = self.incoming()\\n self.name = name\",\n \"def writeInput(self) -> str:\\n\\n self.init()\\n\\n self.prepareConnectors()\\n\\n self.writeHeaders()\\n self.writeMesh()\\n self.writeNodeSets()\\n self.writeElementSets()\\n self.writeKinematicConnectors()\\n self.writeMPCs()\\n self.writeMaterials()\\n self.writeMaterialAssignments()\\n self.writeInitialConditions()\\n self.writeAnalysisConditions()\\n self.writeLoadSteps()\\n\\n return self._input\",\n \"def inputs(self):\\n return self._inputs\",\n \"def input(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"input\\\")\",\n \"def hyper(self, input):\\n return\",\n \"def getInput(self):\\n return self.__string\",\n \"def input():\\n return list_of_inputs.pop(0)\",\n \"def call(self, inputs, **kwargs):\\n nodes, edges, edge_index = inputs\\n n_in = self.lay_gather_in([nodes, edge_index])\\n n_out = self.lay_gather_out([nodes, edge_index])\\n msg = self.message_function([n_in, n_out, edges])\\n pool_n = self.aggregate_message([nodes, msg, edge_index])\\n n_new = self.update_nodes([nodes, pool_n])\\n return n_new\",\n \"def __call__(self, inputs, training):\\n\\n\\t\\treturn self._build_network(inputs, training)\",\n \"def _buildInput (self):\\n\\n\\t\\tindata = self.config['input']\\n\\t\\tif not isinstance (indata, dict):\\n\\t\\t\\tindata = ','.join(utils.alwaysList (indata))\\t\\t\\t\\n\\t\\t\\tdepdchan = channel.fromChannels (*[d.channel for d in self.depends])\\n\\t\\t\\tindata = {indata: depdchan if self.depends else channel.fromArgv()}\\n\\t\\t\\t\\n\\t\\t# expand to one key-channel pairs\\n\\t\\tfor inkeys, invals in indata.iteritems():\\n\\t\\t\\tkeys = utils.split(inkeys, ',')\\n\\t\\t\\tif callable (invals):\\n\\t\\t\\t\\tvals = invals (*[d.channel.copy() for d in self.depends] if self.depends else channel.fromArgv())\\n\\t\\t\\t\\tvals = vals.split()\\n\\t\\t\\telif isinstance (invals, basestring): # only for files: \\\"/a/b/*.txt, /a/c/*.txt\\\"\\n\\t\\t\\t\\tvals = utils.split(invals, ',')\\n\\t\\t\\telif isinstance (invals, channel):\\n\\t\\t\\t\\tvals = invals.split()\\n\\t\\t\\telif isinstance (invals, list):\\n\\t\\t\\t\\tvals = channel.create(invals).split()\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise ValueError (\\\"%s: Unexpected values for input. Expect dict, list, str, channel, callable.\\\" % self._name())\\n\\t\\t\\t\\n\\t\\t\\twidth = len (vals)\\n\\t\\t\\tif len (keys) > width:\\n\\t\\t\\t\\traise ValueError ('%s: Not enough data for input variables.\\\\nVarialbes: %s\\\\nData: %s' % (self._name(), keys, vals))\\n\\t\\t\\t\\n\\t\\t\\tfor i, key in enumerate(keys):\\n\\t\\t\\t\\tintype = key.split(':')[-1]\\n\\t\\t\\t\\tthekey = key.split(':')[0]\\n\\t\\t\\t\\tval = vals[i].toList() #if isinstance(vals[i], channel) else vals[i]\\n\\n\\t\\t\\t\\tif intype not in proc.IN_VARTYPE + proc.IN_FILESTYPE + proc.IN_FILETYPE:\\n\\t\\t\\t\\t\\tintype = proc.IN_VARTYPE[0]\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif intype in proc.IN_FILESTYPE:\\n\\t\\t\\t\\t\\tfor x, v in enumerate(val):\\n\\t\\t\\t\\t\\t\\tif isinstance (v, basestring):\\n\\t\\t\\t\\t\\t\\t\\tval[x] = channel.fromPath (v).toList()\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif self.length == 0: \\n\\t\\t\\t\\t\\tself.props['length'] = len (val)\\n\\t\\t\\t\\tif self.length != len (val):\\n\\t\\t\\t\\t\\traise ValueError ('%s: Expect same lengths for input channels, but got %s and %s (keys: %s).' % (self._name(), self.length, len (val), key))\\n\\t\\t\\t\\tself.props['indata'][thekey] = {\\n\\t\\t\\t\\t\\t'type': intype,\\n\\t\\t\\t\\t\\t'data': val\\n\\t\\t\\t\\t}\\n\\t\\t\\tself.props['jobs'] = [None] * self.length\",\n \"def build_graph_from_input(self, input_node):\\n raise NotImplementedError\",\n \"def revisar_input(self):\\n pass\",\n \"def inputs(self):\\n return super().inputs\",\n \"def inputs(self):\\n return super().inputs\",\n \"def inputs(self):\\n return super().inputs\",\n \"def inputs(self):\\n return super().inputs\",\n \"def inputs(self):\\n return self.inputs\",\n \"def read_inputs(self):\\n self.in_power.read()\\n self.in_alert.read()\",\n \"def input(self, description):\\n if isinstance(description, (int, long)):\\n self._input = description\\n self._sendCommand('%02dFN' % description)\\n elif description in self.inputs:\\n self._input = self.inputs[description]\\n self._sendCommand('%02dFN' % self.inputs[description])\\n else:\\n raise Exception('No such input: %s' % description)\",\n \"def buildPackets(self):\\n return self.input\",\n \"def net_input(self, X):\\n return np.dot(X, self.w[1:]) + self.w[0]\",\n \"def build_user_input(self):\\n pass\",\n \"def get_input():\\n parser = argparse.ArgumentParser(description='Parameters')\\n parser.add_argument('--host', help='adress of the host')\\n parser.add_argument('--port', help='port of IPMI host')\\n parser.add_argument('--user', help='user allowed to acces IPMI')\\n parser.add_argument('--passwd', help='password for the specific user')\\n parser.add_argument('--interval', help='seconds between each data reading')\\n parser.add_argument('--nread', help='number of time to collect data')\\n parser.add_argument('--store', action='store_true',\\n help='save the data collected in a nosql db')\\n args = parser.parse_args()\\n return args, parser\",\n \"def load(self, input):\",\n \"def net_input(self, X):\\n return np.dot(X, self.weight_[1:]) + self.weight_[0]\",\n \"def net_input(self, X):\\n return np.dot(X, self.weight_[1:]) + self.weight_[0]\",\n \"def writeInput(self):\\n\\n #self.collect.writeInput()\",\n \"def input(self):\\n\\t\\treturn self.image\",\n \"def generate_input_data(self):\\n for socket_name, c in self.__taskobject.inputs.items():\\n if c['optional']:\\n self.__inputs[socket_name] = {'data': None, 'enable': False}\\n else:\\n self.__inputs[socket_name] = {'data': None, 'enable': True}\",\n \"def run(self, input):\\n return {}\",\n \"def getInput(self):\\n self.userInput = self.entry.get()\",\n \"def single_input_node(self, port: int):\\n input_nodes = self.input_nodes(port)\\n if len(input_nodes) != 1:\\n raise Error('The amount of input nodes for port \\\"{}\\\" is not equal to 1. '.format(port) +\\n refer_to_faq_msg(33))\\n return input_nodes[0]\",\n \"def build_input(self):\\n n_input = tf.placeholder(tf.int32, [None, None], name='n_input')\\n t_input = tf.placeholder(tf.int32, [None, None], name='t_input')\\n n_target = tf.placeholder(tf.int32, [None, None], name='n_target')\\n t_target = tf.placeholder(tf.int32, [None, None], name='t_target')\\n keep_prob = tf.placeholder(tf.float32, name='keep_prob')\\n return n_input, t_input, n_target, t_target, keep_prob\",\n \"def input_type():\\n pass\",\n \"def read_input(self) -> None:\\n raw_input = sys.stdin.read()\\n\\n self._input = raw_input.split('\\\\n')\\n self._input = self._input[0:-1]\\n\\n for line in self._input:\\n direction, steps = line.split()\\n self._instructions.append((direction, int(steps)))\",\n \"def _handleInput(self, paramInput):\\n super()._handleInput(paramInput)\\n settings, notFound = paramInput.findNodesAndExtractValues(['nu','C', 'kernel', 'degree', 'gamma', 'coef0',\\n 'tol', 'cache_size', 'shrinking', 'max_iter'])\\n # notFound must be empty\\n assert(not notFound)\\n self.initializeModel(settings)\",\n \"def input(self, inputters, field, number=None):\\n raise NotImplementedError\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7633749","0.7437","0.68596274","0.684022","0.6768303","0.6768303","0.6635569","0.6624624","0.6530338","0.644091","0.6440604","0.6437605","0.6437605","0.6437605","0.6437605","0.6437605","0.6437605","0.6437605","0.64358646","0.6357148","0.6357148","0.6357148","0.63256097","0.63188505","0.62520593","0.62299395","0.6215211","0.6170456","0.6170456","0.61694866","0.61469495","0.6097177","0.6080556","0.60722476","0.60571694","0.60571694","0.60571694","0.6019627","0.5994837","0.5971399","0.5957929","0.5955149","0.5938013","0.591181","0.58880574","0.5884213","0.583897","0.58353806","0.58327454","0.583251","0.58272004","0.58250463","0.58250463","0.58243096","0.58243096","0.58243096","0.58237857","0.5821127","0.5807407","0.580276","0.57961625","0.5792817","0.57895315","0.5771906","0.57534945","0.57451105","0.57423997","0.57403266","0.5728213","0.5725835","0.57142794","0.5710048","0.5703046","0.5703034","0.5680818","0.5679648","0.56794214","0.56794214","0.56794214","0.56794214","0.5668195","0.5667299","0.5665239","0.5654016","0.5652643","0.5642237","0.56366974","0.56300527","0.56252944","0.56252944","0.56243384","0.5597075","0.5597029","0.5584721","0.557096","0.55664986","0.55631864","0.55621743","0.55562806","0.55456275","0.5539064"],"string":"[\n \"0.7633749\",\n \"0.7437\",\n \"0.68596274\",\n \"0.684022\",\n \"0.6768303\",\n \"0.6768303\",\n \"0.6635569\",\n \"0.6624624\",\n \"0.6530338\",\n \"0.644091\",\n \"0.6440604\",\n \"0.6437605\",\n \"0.6437605\",\n \"0.6437605\",\n \"0.6437605\",\n \"0.6437605\",\n \"0.6437605\",\n \"0.6437605\",\n \"0.64358646\",\n \"0.6357148\",\n \"0.6357148\",\n \"0.6357148\",\n \"0.63256097\",\n \"0.63188505\",\n \"0.62520593\",\n \"0.62299395\",\n \"0.6215211\",\n \"0.6170456\",\n \"0.6170456\",\n \"0.61694866\",\n \"0.61469495\",\n \"0.6097177\",\n \"0.6080556\",\n \"0.60722476\",\n \"0.60571694\",\n \"0.60571694\",\n \"0.60571694\",\n \"0.6019627\",\n \"0.5994837\",\n \"0.5971399\",\n \"0.5957929\",\n \"0.5955149\",\n \"0.5938013\",\n \"0.591181\",\n \"0.58880574\",\n \"0.5884213\",\n \"0.583897\",\n \"0.58353806\",\n \"0.58327454\",\n \"0.583251\",\n \"0.58272004\",\n \"0.58250463\",\n \"0.58250463\",\n \"0.58243096\",\n \"0.58243096\",\n \"0.58243096\",\n \"0.58237857\",\n \"0.5821127\",\n \"0.5807407\",\n \"0.580276\",\n \"0.57961625\",\n \"0.5792817\",\n \"0.57895315\",\n \"0.5771906\",\n \"0.57534945\",\n \"0.57451105\",\n \"0.57423997\",\n \"0.57403266\",\n \"0.5728213\",\n \"0.5725835\",\n \"0.57142794\",\n \"0.5710048\",\n \"0.5703046\",\n \"0.5703034\",\n \"0.5680818\",\n \"0.5679648\",\n \"0.56794214\",\n \"0.56794214\",\n \"0.56794214\",\n \"0.56794214\",\n \"0.5668195\",\n \"0.5667299\",\n \"0.5665239\",\n \"0.5654016\",\n \"0.5652643\",\n \"0.5642237\",\n \"0.56366974\",\n \"0.56300527\",\n \"0.56252944\",\n \"0.56252944\",\n \"0.56243384\",\n \"0.5597075\",\n \"0.5597029\",\n \"0.5584721\",\n \"0.557096\",\n \"0.55664986\",\n \"0.55631864\",\n \"0.55621743\",\n \"0.55562806\",\n \"0.55456275\",\n \"0.5539064\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94285,"cells":{"query":{"kind":"string","value":"Allocate a TransposedConvLayer with shared variable internal parameters."},"document":{"kind":"string","value":"def __init__(self, input, num_filters, filter_size, stride=(2, 2), padding=(0, 0), activation=rectify):\n\n self.input = input\n self.output = layers.TransposedConv2DLayer(self.input, num_filters, filter_size, stride=stride, crop=padding,\n W=initialize_parameters()[0], b=initialize_parameters()[1],\n nonlinearity=activation)"},"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 transpose(incoming, conv, nonlinearity, *args, **kwargs):\n return TransposedConv2DLayer(incoming, conv.input_shape[1],\n conv.filter_size, stride=conv.stride,\n crop=conv.pad, W=conv.W,\n flip_filters=not conv.flip_filters,\n nonlinearity=nonlinearity, *args,\n **kwargs)","def create(self) -> None:\n if self.torch is not None: # type: ignore\n return\n self.torch = torch.nn.ConvTranspose2d(**self.args.arg_values)","def TCN(input_dim): \r\n # Number of dilations in order to use for the temporal blocks.\r\n dilations = np.array([1, 2, 4, 8, 16, 32])\r\n\r\n input_dim.insert(0,1)\r\n print(f\"input_dim: {input_dim}\")\r\n input_layer = Input(shape=input_dim)\r\n cropping = 0\r\n assert (sum(dilations) * block_size + 1) == 127, \"Paper specifies receptive field size should be 127\"\r\n \r\n prev_layer, skip_layer, _ = add_temporal_block(input_layer, None, 1, 1, cropping)\r\n \r\n for dilation in dilations:\r\n prev_layer, skip_layer, cropping = add_temporal_block(prev_layer, skip_layer, 2, dilation, cropping)\r\n\r\n output_layer = PReLU(shared_axes=[2, 3])(skip_layer)\r\n output_layer = SpectralNormalization(Conv1D(fixed_filters, kernel_size=1))(output_layer)\r\n output_layer = PReLU(shared_axes=[2, 3])(output_layer)\r\n output_layer = SpectralNormalization(Conv1D(1, kernel_size=1))(output_layer)\r\n\r\n return Model(input_layer, output_layer)","def convt_block(layer, concat, fsize, name):\n with tf.variable_scope(name):\n\n layer = tf.layers.conv2d_transpose(layer, filters=fsize, kernel_size=2, strides=2, \n kernel_regularizer=l2_reg(1e-1), name='convt')\n layer = tf.concat([layer, concat], axis=-1, name='concat')\n\n return layer","def CustomConv3DTranspose(x_in, nf, strides=2, kernel_size = 3):\r\n\tx_out = Conv3DTranspose(nf, kernel_size=3, padding='same',kernel_initializer='he_normal', strides=strides)(x_in)\r\n\t#print(\"AAAAA\", x_out.shape)\r\n\tx_out = BatchNormalization()(x_out)\r\n\tx_out = LeakyReLU(0.2)(x_out)\r\n\treturn x_out","def __init__(\n self,\n *,\n input_dims: Union[List[int], Tuple[int]],\n cnn_transpose_filter_specifiers: List[List[Union[int, List]]],\n cnn_transpose_use_bias: bool = True,\n cnn_transpose_activation: Optional[str] = \"relu\",\n cnn_transpose_use_layernorm: bool = False,\n ):\n super().__init__()\n\n assert len(input_dims) == 3\n\n cnn_transpose_activation = get_activation_fn(\n cnn_transpose_activation, framework=\"tf2\"\n )\n\n layers = []\n\n # Input layer.\n layers.append(tf.keras.layers.Input(shape=input_dims))\n\n for i, (num_filters, kernel_size, strides) in enumerate(\n cnn_transpose_filter_specifiers\n ):\n is_final_layer = i == len(cnn_transpose_filter_specifiers) - 1\n layers.append(\n tf.keras.layers.Conv2DTranspose(\n filters=num_filters,\n kernel_size=kernel_size,\n strides=strides,\n padding=\"same\",\n # Last layer is never activated (regardless of config).\n activation=(\n None\n if cnn_transpose_use_layernorm or is_final_layer\n else cnn_transpose_activation\n ),\n # Last layer always uses bias (b/c has no LayerNorm, regardless of\n # config).\n use_bias=cnn_transpose_use_bias or is_final_layer,\n )\n )\n if cnn_transpose_use_layernorm and not is_final_layer:\n # Use epsilon=1e-5 here (instead of default 1e-3) to be unified with\n # torch. Need to normalize over all axes.\n layers.append(\n tf.keras.layers.LayerNormalization(axis=[-3, -2, -1], epsilon=1e-5)\n )\n layers.append(tf.keras.layers.Activation(cnn_transpose_activation))\n\n # Create the final CNNTranspose network.\n self.cnn_transpose = tf.keras.Sequential(layers)\n\n self.expected_input_dtype = tf.float32","def conv2d_transpose(self, output_shape, filter_):\n return self.add_layer(conv2d_transpose, output_shape, filter_)","def copy_conv(sess, tftensor, layer):\n\n W = sess.graph.get_tensor_by_name('{}/conv2d_params:0'.format(tftensor)).eval()\n W = W.transpose((3, 2, 0, 1))\n\n assert W.shape == layer.W.data.shape\n\n layer.W.data = W","def test_transposed_conv2d_model(self):\n tf.compat.v1.reset_default_graph()\n\n _ = transposed_conv2d_model()\n\n conn_graph = ConnectedGraph(tf.compat.v1.get_default_graph(), ['input_1'], ['conv2d_transpose/BiasAdd'])\n self.assertEqual(conn_graph.get_all_ops()['conv2d_transpose/conv2d_transpose'].type, 'Conv2DTranspose')","def __init__(self, img_size, latent_dim=10):\n super(DecoderBurgess, self).__init__()\n\n # Layer parameters\n hid_channels = 32\n kernel_size = 4\n hidden_dim = 256\n self.img_size = img_size\n # Shape required to start transpose convs\n self.reshape = (hid_channels, kernel_size, kernel_size)\n n_chan = self.img_size[0]\n self.img_size = img_size\n\n # Fully connected layers\n self.lin1 = nn.Linear(latent_dim, hidden_dim)\n self.lin2 = nn.Linear(hidden_dim, hidden_dim)\n self.lin3 = nn.Linear(hidden_dim, np.product(self.reshape))\n\n # Convolutional layers\n cnn_kwargs = dict(stride=2, padding=1)\n # If input image is 64x64 do fourth convolution\n if self.img_size[1] == self.img_size[2] == 64:\n self.convT_64 = nn.ConvTranspose2d(\n hid_channels, hid_channels, kernel_size, **cnn_kwargs\n )\n\n self.convT1 = nn.ConvTranspose2d(\n hid_channels, hid_channels, kernel_size, **cnn_kwargs\n )\n self.convT2 = nn.ConvTranspose2d(\n hid_channels, hid_channels, kernel_size, **cnn_kwargs\n )\n self.convT3 = nn.ConvTranspose2d(\n hid_channels, n_chan, kernel_size, **cnn_kwargs\n )","def __init__(self, img_size,\n latent_dim=10):\n super(DecoderBurgess, self).__init__()\n\n # Layer parameters\n hid_channels = 32\n kernel_size = 4\n hidden_dim = 256\n self.img_size = img_size\n # Shape required to start transpose convs\n self.reshape = (hid_channels, kernel_size, kernel_size)\n n_chan = self.img_size[0]\n self.img_size = img_size\n\n # Fully connected layers\n self.lin1 = nn.Linear(latent_dim, hidden_dim)\n self.lin2 = nn.Linear(hidden_dim, hidden_dim)\n self.lin3 = nn.Linear(hidden_dim, np.product(self.reshape))\n\n # Convolutional layers\n cnn_kwargs = dict(stride=2, padding=1)\n # If input image is 64x64 do fourth convolution\n if self.img_size[1] == self.img_size[2] == 64:\n self.convT_64 = nn.ConvTranspose2d(\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\n\n self.convT1 = nn.ConvTranspose2d(\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\n self.convT2 = nn.ConvTranspose2d(\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\n self.convT3 = nn.ConvTranspose2d(\n hid_channels, n_chan, kernel_size, **cnn_kwargs)","def convert_conv2d_transpose(g, op, block):\n\n dilations = op.attr(\"dilations\")\n groups = op.attr(\"groups\")\n paddings = op.attr(\"paddings\")\n padding_algorithm = op.attr(\"padding_algorithm\")\n strides = op.attr(\"strides\")\n output_padding = op.attr(\"output_padding\") if op.attr(\"output_padding\") else [0, 0]\n\n kernel = g.get_node(op.input(\"Filter\")[0])\n input_x = g.get_node(op.input(\"Input\")[0])\n _, out_channels, k_h, k_w = infer_shape(kernel)\n k_size = [k_h, k_w]\n if padding_algorithm == \"VALID\":\n paddings = [0, 0]\n elif padding_algorithm == \"SAME\":\n # SAME padding of conv2d_transpose is not same with conv2d\n # We cannot use auto_pad here, only static shape is supported now\n dilations = [1, 1]\n input_shape = shape_of(input_x)\n h_w = _op.strided_slice(input_shape, [2], [4])\n try:\n h_w = infer_value(h_w, g.get_params()).numpy().tolist()\n except Exception as e:\n msg = \"The SAME padding algorithm of conv2d_transpose not support dynamic shape\"\n raise tvm.error.OpAttributeInvalid(msg) from e\n paddings = []\n for i in range(2):\n if strides[i] == 1 or h_w[i] % strides[i] == 0:\n pad = max(k_size[i] - strides[i], 0)\n else:\n pad = max(k_size[i] - (h_w[i] % strides[i]), 0)\n pad_before = pad // 2\n pad_after = pad - pad_before\n paddings.insert(-1, pad_before)\n paddings.append(pad_after)\n elif padding_algorithm == \"EXPLICIT\":\n if len(paddings) == 2:\n paddings = [paddings[0], paddings[1], paddings[0], paddings[1]]\n elif len(paddings) == 4:\n paddings = [paddings[0], paddings[2], paddings[1], paddings[3]]\n else:\n msg = f'Value {padding_algorithm} in attribute \"padding\" of operator Conv is not \"valid.\"'\n raise tvm.error.OpAttributeInvalid(msg)\n\n out = _op.nn.conv2d_transpose(\n input_x,\n kernel,\n strides=strides,\n padding=paddings,\n dilation=dilations,\n groups=groups,\n channels=out_channels * groups,\n kernel_size=k_size,\n output_padding=output_padding,\n )\n g.add_node(op.output(\"Output\")[0], out)","def __init__(self, img_size,\n latent_dim=10):\n \n super(DecoderRezendeViola, self).__init__()\n\n # Layer parameters\n hid_channels = 32\n kernel_size = 4\n hidden_dim = 256\n self.img_size = img_size\n # Shape required to start transpose convs\n self.reshape = (hid_channels, kernel_size, kernel_size)\n n_chan = self.img_size[0]\n self.img_size = img_size\n\n # Fully connected layers\n self.lin1 = nn.Linear(latent_dim, hidden_dim)\n self.lin2 = nn.Linear(hidden_dim, hidden_dim)\n self.lin3 = nn.Linear(hidden_dim, np.product(self.reshape))\n\n # Convolutional layers\n cnn_kwargs = dict(stride=2, padding=1)\n # If input image is 64x64 do fourth convolution\n if self.img_size[1] == self.img_size[2] == 64:\n self.convT_64 = nn.ConvTranspose2d(\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\n\n self.convT1 = nn.ConvTranspose2d(\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\n self.convT2 = nn.ConvTranspose2d(\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\n self.convT3 = nn.ConvTranspose2d(\n hid_channels, 2 * n_chan, kernel_size, **cnn_kwargs)","def conv_transpose1d(self, kernel, **kwargs):\n raise NotImplementedError(\"conv_transpose1d is not implemented\")","def _create_conv_pool(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n k = [op.handle.kernel_h, op.handle.kernel_w]\n s = [op.handle.stride_h, op.handle.stride_w]\n oddp = op.odd_padding\n p = [\n op.handle.pad_h + oddp[0],\n op.handle.pad_w + oddp[1],\n op.handle.pad_w + oddp[2],\n op.handle.pad_h + oddp[3],\n ]\n\n node.attribute.extend([\n helper.make_attribute('kernel_shape', k),\n helper.make_attribute('pads', p),\n helper.make_attribute('strides', s),\n ])\n if cls._get_singa_op_type(op) == '_Conv2d':\n node.op_type = cls._rename_operators.get('_Conv2d')\n node.attribute.extend([\n helper.make_attribute('group', op.handle.group),\n helper.make_attribute('auto_pad', 'NOTSET'),\n ])\n\n elif op.handle.is_max_pooling:\n node.op_type = cls._rename_operators.get('MaxPool2d')\n else:\n node.op_type = cls._rename_operators.get('AvgPool2d')\n return node","def __init__(self, in_channels, out_channels, kernel_size, num_layers=3,\n use_conv_transpose=True):\n super().__init__()\n\n _validate_args(in_channels, out_channels, kernel_size, num_layers)\n\n self.kernel_size = kernel_size\n self.use_conv_transpose = use_conv_transpose\n\n self.padding = (kernel_size-1)//2\n\n # All deconv blocks must contain at least one block mapping the\n # number of input channels to the number of output channels\n conv_list = [\n self._create_single_block(in_channels, out_channels)\n ]\n\n # Create the rest of the blocks\n for _ in range(num_layers - 1):\n conv_list.append(\n self._create_single_block(out_channels, out_channels)\n )\n\n self.convs = nn.Sequential(*conv_list)\n self.pool = nn.MaxUnpool2d((2, 2))","def conv_transpose2d(self, kernel, **kwargs):\n raise NotImplementedError(\"conv_transpose2d is not implemented\")","def __call__(self, inputs):\n with tf.variable_scope('conv_t_{}'.format(self.idx)):\n activation_fn = get_act_fn(self.act_fn)\n\n if self.cfg.VAR_ON_CPU:\n kernels = variable_on_cpu(\n name='kernels',\n shape=[self.kernel_size, self.kernel_size,\n self.n_kernel, inputs.get_shape().as_list()[3]],\n initializer=self.w_init_fn,\n dtype=tf.float32)\n conv_t = tf.nn.conv2d_transpose(\n value=inputs,\n filter=kernels,\n output_shape=self.output_shape,\n strides=[1, self.stride, self.stride, 1],\n padding=self.padding)\n\n if self.use_bias:\n biases = variable_on_cpu(\n name='biases',\n shape=[self.n_kernel],\n initializer=tf.zeros_initializer(),\n dtype=tf.float32)\n conv_t = tf.nn.bias_add(conv_t, biases)\n\n if activation_fn is not None:\n conv_t = activation_fn(conv_t)\n\n else:\n biases_initializer = tf.zeros_initializer() if self.use_bias else None\n conv_t = tf.contrib.layers.conv2d_transpose(\n inputs=inputs,\n num_outputs=self.n_kernel,\n kernel_size=self.kernel_size,\n stride=self.stride,\n padding=self.padding,\n activation_fn=activation_fn,\n weights_initializer=self.w_init_fn,\n biases_initializer=biases_initializer)\n\n return conv_t","def __init__(self,\n intermediate_channels,\n output_channels,\n pred_key,\n name,\n conv_type='depthwise_separable_conv',\n bn_layer=tf.keras.layers.BatchNormalization):\n super(PanopticDeepLabSingleHead, self).__init__(name=name)\n self._pred_key = pred_key\n\n self.conv_block = convolutions.StackedConv2DSame(\n conv_type=conv_type,\n num_layers=1,\n output_channels=intermediate_channels,\n kernel_size=5,\n name='conv_block',\n use_bias=False,\n use_bn=True,\n bn_layer=bn_layer,\n activation='relu')\n self.final_conv = layers.Conv2D(\n output_channels,\n kernel_size=1,\n name='final_conv',\n kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.01))","def __init__(self, in_channels, out_channels, kernel_size, padding=0, **kwargs):\n ConstrainedLayer.__init__(self, nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding, bias=False), **kwargs)","def _conv2d_transpose_block(in_f, out_f, *args, **kwargs):\n return nn.Sequential(\n nn.ConvTranspose2d(in_f, out_f, *args, **kwargs),\n nn.BatchNorm2d(out_f),\n nn.ReLU(),\n nn.Dropout2d(p=0.2)\n )","def __init__(\n self,\n in_shape: Tuple,\n kernel_size: int,\n out_channels: int = None,\n stride: int = 1,\n aux_shape: Optional[Tuple] = None,\n downsampling_mode: str = \"convolutional\",\n upsampling_mode: str = \"convolutional\",\n transposed: bool = False,\n residual: bool = True,\n weightnorm: bool = True,\n gated: bool = True,\n activation: nn.Module = nn.ReLU,\n dropout: Optional[float] = None,\n ):\n super().__init__(in_shape=in_shape, transposed=transposed, residual=residual, aux_shape=aux_shape)\n\n # some parameters\n self.channels_in = in_shape[0]\n self.channels_out = out_channels\n self.kernel_size = kernel_size\n self.stride = stride\n self.resample_mode = upsampling_mode if transposed else downsampling_mode\n self.transposed = transposed\n self.residual = residual\n self.gated = gated\n self.activation_pre = activation() if self.residual else None\n\n # first convolution is always non-transposed and stride 1\n self.conv1 = TransposeableNormedSameConv2d(\n in_shape=in_shape,\n out_channels=out_channels,\n kernel_size=kernel_size,\n stride=1,\n transposed=False,\n resample_mode=\"convolutional\",\n weightnorm=weightnorm,\n )\n\n # aux op\n if aux_shape is not None:\n self.activation_aux = activation()\n\n if list(aux_shape[1:]) > list(self.conv1.out_shape[1:]):\n # Downsample height and width (and match channels)\n aux_stride = tuple(np.asarray(aux_shape[1:]) // np.asarray(self.conv1.out_shape[1:]))\n self.aux_op = TransposeableNormedSameConv2d(\n in_shape=aux_shape,\n out_channels=self.conv1.out_shape[0],\n kernel_size=kernel_size,\n stride=aux_stride,\n transposed=False,\n resample_mode=self.resample_mode,\n weightnorm=weightnorm,\n )\n elif list(aux_shape[1:]) < list(self.conv1.out_shape[1:]):\n # Upsample height and width (and match channels)\n aux_stride = tuple(np.asarray(self.conv1.out_shape[1:]) // np.asarray(aux_shape[1:]))\n self.aux_op = TransposeableNormedSameConv2d(\n in_shape=aux_shape,\n out_channels=self.conv1.out_shape[0],\n kernel_size=kernel_size,\n stride=aux_stride,\n transposed=True,\n resample_mode=self.resample_mode,\n weightnorm=weightnorm,\n )\n elif aux_shape[0] != self.conv1.out_shape[0]:\n # Change only channels using 1x1 convolution\n self.aux_op = TransposeableNormedSameConv2d(\n in_shape=aux_shape,\n out_channels=self.conv1.out_shape[0],\n kernel_size=1,\n stride=1,\n transposed=False,\n resample_mode=self.resample_mode,\n weightnorm=weightnorm,\n )\n else:\n # aux_shape and out_shape are the same\n assert aux_shape == self.conv1.out_shape\n self.aux_op = None\n else:\n self.aux_op = None\n\n self.activation_mid = activation()\n\n # dropout\n self.dropout = nn.Dropout(dropout) if dropout else dropout\n\n # second convolution is potentially transposed and potentially resampling\n gated_channels = 2 * out_channels if self.gated else out_channels\n self.conv2 = TransposeableNormedSameConv2d(\n in_shape=self.conv1.out_shape,\n out_channels=gated_channels,\n kernel_size=kernel_size,\n stride=self.stride,\n weightnorm=weightnorm,\n transposed=transposed,\n resample_mode=self.resample_mode,\n ) # doubled out channels for gating\n\n # output shape\n self._out_shape = (out_channels, *self.conv2.out_shape[1:]) # always out_channels regardless of gating\n\n # residual connections\n self.residual_op = ResidualConnectionConv2d(self._in_shape, self._out_shape, residual)","def BasicConv3d(in_planes, out_planes, kernel_size, stride=(1, 1, 1), padding=(0, 0, 0),\n bias=False, dw_t_conv=False):\n return nn.Conv3d(in_planes, out_planes, kernel_size=kernel_size,\n stride=stride, padding=padding, bias=bias,\n groups=in_planes if dw_t_conv else 1)","def intermediate_layer(layer, filters, kernel_size):\n layer = Conv2D(filters=filters, kernel_size=kernel_size,\n strides=(2, 2), padding=\"same\")(layer)\n layer = LeakyReLU(alpha=LEAKY_RELU_ALPHA)(layer)\n return layer","def conv_2d_transpose(incoming, nb_filter, filter_size, output_shape,\n strides=1, padding='same', activation='linear',\n bias=True, weights_init='uniform_scaling',\n bias_init='zeros', regularizer=None, weight_decay=0.001,\n trainable=True, restore=True, name=\"Conv2DTranspose\"):\n assert padding in ['same', 'valid', 'SAME', 'VALID'], \\\n \"Padding must be same' or 'valid'\"\n\n input_shape = utils.get_incoming_shape(incoming)\n assert len(input_shape) == 4, \"Incoming Tensor shape must be 4-D\"\n\n filter_size = utils.autoformat_filter_conv2d(filter_size,\n nb_filter,\n input_shape[-1])\n strides = utils.autoformat_kernel_2d(strides)\n padding = utils.autoformat_padding(padding)\n\n with tf.name_scope(name) as scope:\n\n W_init = initializations.get(weights_init)()\n W_regul = None\n if regularizer:\n W_regul = lambda x: losses.get(regularizer)(x, weight_decay)\n W = vs.variable(scope + 'W', shape=filter_size,\n regularizer=W_regul, initializer=W_init,\n trainable=trainable, restore=restore)\n # Track per layer variables\n tf.add_to_collection(tf.GraphKeys.LAYER_VARIABLES + '/' + scope, W)\n\n b = None\n if bias:\n b_init = initializations.get(bias_init)()\n b = vs.variable(scope + 'b', shape=nb_filter,\n initializer=b_init, trainable=trainable,\n restore=restore)\n # Track per layer variables\n tf.add_to_collection(tf.GraphKeys.LAYER_VARIABLES + '/' + scope, b)\n\n # Determine the complete shape of the output tensor.\n batch_size = tf.gather(tf.shape(incoming), tf.constant([0]))\n if len(output_shape) == 2:\n output_shape = output_shape + [nb_filter]\n elif len(output_shape) != 3:\n raise Exception(\"output_shape length error: \" \n + str(len(output_shape))\n + \", only a length of 2 or 3 is supported.\")\n complete_out_shape = tf.concat(0, [batch_size, tf.constant(output_shape)])\n \n inference = tf.nn.conv2d_transpose(incoming, W, complete_out_shape,\n strides, padding)\n \n # Reshape tensor so its shape is correct.\n inference.set_shape([None] + output_shape)\n\n if b: inference = tf.nn.bias_add(inference, b)\n\n if isinstance(activation, str):\n inference = activations.get(activation)(inference)\n elif hasattr(activation, '__call__'):\n inference = activation(inference)\n else:\n raise ValueError(\"Invalid Activation.\")\n\n # Track activations.\n tf.add_to_collection(tf.GraphKeys.ACTIVATIONS, inference)\n\n # Add attributes to Tensor to easy access weights.\n inference.scope = scope\n inference.W = W\n inference.b = b\n\n return inference","def __init__(self, last_channels, this_channels, repeat_time, max_pool = False):\n super().__init__()\n\n self.repeat_time = repeat_time\n self.activate = nn.SELU()\n self.bn = nn.BatchNorm2d\n self.max_pool = None\n\n if max_pool:\n self.max_pool = nn.MaxPool2d(3, 2, 1)\n else:\n self.conv1_1 = nn.Sequential(\n nn.Conv2d(last_channels, this_channels, 3, stride=2, padding=1),\n self.bn(this_channels),\n )\n self.conv1_2 = nn.Sequential(\n nn.Conv2d(this_channels, this_channels, 3, stride=1, padding=1),\n self.bn(this_channels),\n )\n\n self.conv2 = nn.Sequential(\n nn.Conv2d(this_channels, this_channels, 3, stride=1, padding=1),\n self.bn(this_channels),\n self.activate,\n nn.Conv2d(this_channels, this_channels, 3, stride=1, padding=1),\n self.bn(this_channels),\n )","def __init__(self, channel_in, channel_out, kernel_size, stride, padding, output_padding=0):\n super().__init__()\n self.block = nn.Sequential(\n nn.ConvTranspose2d(channel_in, channel_out, kernel_size, stride, padding, output_padding),\n nn.BatchNorm2d(channel_out)\n )\n self.act = nn.ReLU()","def _init_layers(self) -> None:\n self.relu = nn.ReLU(inplace=True)\n self.cls_convs = nn.ModuleList()\n self.reg_convs = nn.ModuleList()\n for i in range(self.stacked_convs):\n chn = self.in_channels if i == 0 else self.feat_channels\n self.cls_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.reg_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n pred_pad_size = self.pred_kernel_size // 2\n self.atss_cls = nn.Conv2d(\n self.feat_channels,\n self.num_anchors * self.cls_out_channels,\n self.pred_kernel_size,\n padding=pred_pad_size)\n self.atss_reg = nn.Conv2d(\n self.feat_channels,\n self.num_base_priors * 4,\n self.pred_kernel_size,\n padding=pred_pad_size)\n self.atss_centerness = nn.Conv2d(\n self.feat_channels,\n self.num_base_priors * 1,\n self.pred_kernel_size,\n padding=pred_pad_size)\n self.scales = nn.ModuleList(\n [Scale(1.0) for _ in self.prior_generator.strides])","def pretrained_conv_layer(name, input_tensor, params):\n with tf.name_scope(name):\n weights = tf.constant(params[name+'_W'])\n biases = tf.constant(params[name+'_b'])\n\n conv = tf.nn.conv2d(input=input_tensor,\n filter=weights,\n strides=[1, 1, 1, 1],\n padding='SAME',\n name='convolution')\n\n preactivations = tf.nn.bias_add(conv, biases, name='bias_addition')\n activations = tf.nn.relu(preactivations, name='activation')\n return activations","def _append_conv_layer(self, param):\n self._parameterized_conv_layers.append(\n tf.keras.layers.Conv3D(\n padding='same',\n use_bias=False,\n kernel_regularizer=self._kernel_regularizer,\n **param,\n ))\n norm_layer_params = self._build_norm_layer_params(param)\n self._parameterized_conv_layers.append(self._norm(**norm_layer_params))\n\n relu_layer_params = self._build_activation_layer_params(param)\n self._parameterized_conv_layers.append(\n tf.keras.layers.Activation('relu', **relu_layer_params))","def __init__(self, img_size, latent_dim=10):\n super(EncoderBurgess, self).__init__()\n\n # Layer parameters\n hid_channels = 32\n kernel_size = 4\n hidden_dim = 256\n self.latent_dim = latent_dim\n self.img_size = img_size\n # Shape required to start transpose convs\n self.reshape = (hid_channels, kernel_size, kernel_size)\n n_chan = self.img_size[0]\n\n # Convolutional layers\n cnn_kwargs = dict(stride=2, padding=1)\n self.conv1 = nn.Conv2d(n_chan, hid_channels, kernel_size, **cnn_kwargs)\n self.conv2 = nn.Conv2d(hid_channels, hid_channels, kernel_size, **cnn_kwargs)\n self.conv3 = nn.Conv2d(hid_channels, hid_channels, kernel_size, **cnn_kwargs)\n\n # If input image is 64x64 do fourth convolution\n if self.img_size[1] == self.img_size[2] == 64:\n self.conv_64 = nn.Conv2d(\n hid_channels, hid_channels, kernel_size, **cnn_kwargs\n )\n\n # Fully connected layers\n self.lin1 = nn.Linear(np.product(self.reshape), hidden_dim)\n self.lin2 = nn.Linear(hidden_dim, hidden_dim)\n\n # Fully connected layers for mean and variance\n self.mu_logvar_gen = nn.Linear(hidden_dim, self.latent_dim * 2)","def __init__(self, incoming, W=None, b=tf.zeros, ksize: int = None, num_outputs: int = None,\n weight_initializer=None, a=tf.nn.elu, strides=(1, 1, 1, 1), padding='ZEROPAD', dilation_rate=(1, 1),\n name='ConvLayer'):\n super(ConvLayer, self).__init__()\n with tf.variable_scope(name) as self.layer_scope:\n self.incoming, self.incoming_shape = get_input(incoming)\n \n # Set init for W and b\n if all(p is not None for p in [weight_initializer, ksize, num_outputs]):\n W = tofov(weight_initializer, shape=(ksize, ksize, self.incoming_shape[-1], num_outputs),\n var_params=dict(name='W_conv'))\n else:\n W = tofov(W, shape=None, var_params=dict(name='W_conv'))\n ksize = W.get_shape()[0].value\n if b is not None:\n b = tofov(b, shape=W.get_shape().as_list()[-1], var_params=dict(name='b_conv'))\n \n self.a = a\n self.b = b\n self.W = W\n self.padding = padding\n self.strides = strides\n self.dilation_rate = dilation_rate\n \n self.out = None\n self.name = name","def declaration_conv2d_transpose_impl(data, kernel, strides, padding, out_dtype):\n data_pad, kernel_transform = \\\n conv2d_transpose_nchw_preprocess(data, kernel, strides, padding, out_dtype)\n batch, in_c, in_h, in_w = data_pad.shape\n out_c, _, filter_h, filter_w = kernel_transform.shape\n stride_h, stride_w = strides\n\n # convolution stage\n out_c = simplify(out_c)\n out_h = simplify(in_h - filter_h + 1)\n out_w = simplify(in_w - filter_w + 1)\n dc = tvm.reduce_axis((0, in_c), name='dc')\n dh = tvm.reduce_axis((0, filter_h), name='dh')\n dw = tvm.reduce_axis((0, filter_w), name='dw')\n\n Output = tvm.compute(\n (batch, out_c, out_h, out_w),\n lambda b, c, h, w: tvm.sum(\n data_pad[b, dc, h+dh, w+dw].astype(out_dtype) *\n kernel_transform[c, dc, dh, dw].astype(out_dtype),\n axis=[dc, dh, dw]), tag=\"conv2d_transpose_nchw\")\n\n return Output","def _conv_transpose(\n conv_type,\n nd_util,\n input,\n weight,\n bias=None,\n stride=1,\n padding=0,\n output_padding=0,\n groups=1,\n dilation=1,\n):\n weight_shape = list(weight.shape)\n return FunctionLib.apply(\n conv_type,\n input.device,\n [input, weight] + ([bias] if bias else []),\n in_channels=weight_shape[0],\n out_channels=weight_shape[1],\n kernel_shape=weight_shape[2:],\n strides=nd_util(stride),\n pads=nd_util(padding),\n dilations=nd_util(dilation),\n group=groups,\n output_padding=nd_util(output_padding),\n bias=bias is not None,\n dtype=weight.dtype,\n input_shape=list(input.shape),\n )","def _conv2d(self, prev_layer, layer_idx, layer_name):\n W, b = self._weights(layer_idx, layer_name)\n W = tf.constant(W)\n b = tf.constant(np.reshape(b, (b.size)))\n return tf.nn.conv2d(prev_layer, filter=W, strides=[1, 1, 1, 1], padding='SAME') + b","def _init_layers(self) -> None:\n super()._init_layers()\n self.controller = nn.Conv2d(\n self.feat_channels, self.num_params, 3, padding=1)","def __init__(self,\n channels: int,\n kernel_size: int=15,\n activation: nn.Layer=nn.ReLU(),\n norm: str=\"batch_norm\",\n causal: bool=False,\n bias: bool=True,\n adaptive_scale: bool=False,\n init_weights: bool=False):\n assert check_argument_types()\n super().__init__()\n self.bias = bias\n self.channels = channels\n self.kernel_size = kernel_size\n self.adaptive_scale = adaptive_scale\n if self.adaptive_scale:\n ada_scale = self.create_parameter(\n [1, 1, channels], default_initializer=I.Constant(1.0))\n self.add_parameter('ada_scale', ada_scale)\n ada_bias = self.create_parameter(\n [1, 1, channels], default_initializer=I.Constant(0.0))\n self.add_parameter('ada_bias', ada_bias)\n\n self.pointwise_conv1 = Conv1D(\n channels,\n 2 * channels,\n kernel_size=1,\n stride=1,\n padding=0,\n bias_attr=None\n if bias else False, # None for True, using bias as default config\n )\n\n # self.lorder is used to distinguish if it's a causal convolution,\n # if self.lorder > 0:\n # it's a causal convolution, the input will be padded with\n # `self.lorder` frames on the left in forward (causal conv impl).\n # else: it's a symmetrical convolution\n if causal:\n padding = 0\n self.lorder = kernel_size - 1\n else:\n # kernel_size should be an odd number for none causal convolution\n assert (kernel_size - 1) % 2 == 0\n padding = (kernel_size - 1) // 2\n self.lorder = 0\n\n self.depthwise_conv = Conv1D(\n channels,\n channels,\n kernel_size,\n stride=1,\n padding=padding,\n groups=channels,\n bias_attr=None\n if bias else False, # None for True, using bias as default config\n )\n\n assert norm in ['batch_norm', 'layer_norm']\n if norm == \"batch_norm\":\n self.use_layer_norm = False\n self.norm = BatchNorm1D(channels)\n else:\n self.use_layer_norm = True\n self.norm = LayerNorm(channels)\n\n self.pointwise_conv2 = Conv1D(\n channels,\n channels,\n kernel_size=1,\n stride=1,\n padding=0,\n bias_attr=None\n if bias else False, # None for True, using bias as default config\n )\n self.activation = activation\n\n if init_weights:\n self.init_weights()","def _dense_connect_layer(self, input_data, name):\n with tf.variable_scope(name):\n conv_out = self._composite_conv(input_data=input_data, out_channel=self._growth_rate,\n name='composite_conv')\n concate_cout = tf.concat(values=[conv_out, input_data], axis=3, name='concatenate')\n\n return concate_cout","def __init__(self, nfeat, nhid, nclass, dropout, alpha):\n super(GCN, self).__init__()\n self.dropout = dropout\n\n self.conv1 = GraphConvolutionLayer(nfeat, nhid, dropout=dropout, alpha=alpha, not_final=True)\n \n self.add_module('conv1', self.conv1)\n\n self.conv2 = GraphConvolutionLayer(nhid, nclass, dropout=dropout, alpha=alpha, not_final=False)","def __init__(\n self,\n latentspace,\n first_reshape_shape,\n channels=None,\n kernel_widths=None,\n strides=None,\n up_sampling=None,\n hidden_activation=\"relu\",\n output_activation=\"tanh\",\n **kwargs):\n # assign the default values if they were not specified\n channels = default_value([256, 128, 128, 64, 64, 3], channels)\n kernel_widths = default_value([4, 4, 4, 4, 4, 4], kernel_widths)\n strides = default_value([1, 1, 1, 1, 1, 1], strides)\n up_sampling = default_value([2, 2, 2, 2, 1, 1], up_sampling)\n\n h_Activation = lambda activation: LeakyReLU(0.02) if activation == \"leaky_relu\" else Activation(activation)\n initializer = tf.keras.initializers.RandomNormal(0, 0.02)\n\n inp = Input((latentspace,))\n\n # A Block\n A = Dense(np.prod(first_reshape_shape), kernel_initializer=initializer)(inp)\n A = LayerNormalization()(A)\n A = h_Activation(hidden_activation)(A)\n A = Reshape(first_reshape_shape)(A)\n\n # B Block\n B = Dense(64)(inp)\n B = LayerNormalization()(B)\n B = h_Activation(hidden_activation)(B)\n B = Reshape((1, 1, 64))(B)\n B = UpSampling2D(first_reshape_shape[0])(B)\n\n for channel, kernel_width, stride, up in zip(channels[:-1], kernel_widths[:-1], strides[:-1], up_sampling[:-1]):\n A, B = up_sampling_block(\n A, B, # Concat A&B to A\n up, # Up sampling for A&B\n channel, kernel_width, stride, initializer, # Conv2D for A\n # Layer normalization\n h_Activation(hidden_activation) # Activation for A\n ) # returns A, B\n\n # Final block which finally produces the output image.\n A = Concatenate()([A, B])\n A = Conv2D(channels[-1], kernel_widths[-1], strides[-1],\n padding=\"same\", kernel_initializer=initializer)(A)\n out = h_Activation(output_activation)(A)\n\n # Construct the functional model by calling the constructor of the Model super class.\n super(Decoder, self).__init__(inp, out, **kwargs)","def Conv2DTranspose(\n inputs,\n filters,\n kernel_size,\n strides=(1, 1),\n padding='same',\n data_format='channels_last',\n activation=None,\n use_bias=True,\n kernel_initializer=None,\n bias_initializer=tf.zeros_initializer(),\n kernel_regularizer=None,\n bias_regularizer=None,\n activity_regularizer=None,\n dyn_hw=None):\n if kernel_initializer is None:\n if get_tf_version_tuple() <= (1, 12):\n kernel_initializer = tf.contrib.layers.variance_scaling_initializer(2.0)\n else:\n kernel_initializer = tf.keras.initializers.VarianceScaling(2.0, distribution='untruncated_normal')\n\n if get_tf_version_tuple() <= (1, 12):\n with rename_get_variable({'kernel': 'W', 'bias': 'b'}):\n layer = tf.layers.Conv2DTranspose(\n filters,\n kernel_size,\n strides=strides,\n padding=padding,\n data_format=data_format,\n activation=activation,\n use_bias=use_bias,\n kernel_initializer=kernel_initializer,\n bias_initializer=bias_initializer,\n kernel_regularizer=kernel_regularizer,\n bias_regularizer=bias_regularizer,\n activity_regularizer=activity_regularizer,\n _reuse=tf.get_variable_scope().reuse)\n ret = layer.apply(inputs, scope=tf.get_variable_scope())\n ret = tf.identity(ret, name='output')\n ret.variables = VariableHolder(W=layer.kernel)\n if use_bias:\n ret.variables.b = layer.bias\n else:\n # Our own implementation, to avoid Keras bugs. https://github.com/tensorflow/tensorflow/issues/25946\n assert kernel_regularizer is None and bias_regularizer is None and activity_regularizer is None, \\\n \"Unsupported arguments due to Keras bug in TensorFlow 1.13\"\n data_format = get_data_format(data_format, keras_mode=False)\n shape_dyn = tf.shape(inputs)\n strides2d = shape2d(strides)\n channels_in = inputs.shape[1 if data_format == 'NCHW' else 3]\n if data_format == 'NCHW':\n channels_in = inputs.shape[1]\n out_shape_dyn = tf.stack(\n [shape_dyn[0], filters,\n shape_dyn[2] * strides2d[0],\n shape_dyn[3] * strides2d[1]])\n out_shape3_sta = [filters,\n None if inputs.shape[2] is None else inputs.shape[2] * strides2d[0],\n None if inputs.shape[3] is None else inputs.shape[3] * strides2d[1]]\n else:\n channels_in = inputs.shape[-1]\n out_shape_dyn = tf.stack(\n [shape_dyn[0],\n shape_dyn[1] * strides2d[0],\n shape_dyn[2] * strides2d[1],\n filters])\n out_shape3_sta = [None if inputs.shape[1] is None else inputs.shape[1] * strides2d[0],\n None if inputs.shape[2] is None else inputs.shape[2] * strides2d[1],\n filters]\n\n kernel_shape = shape2d(kernel_size)\n W = tf.get_variable('W', kernel_shape + [filters, channels_in], initializer=kernel_initializer)\n if use_bias:\n b = tf.get_variable('b', [filters], initializer=bias_initializer)\n conv = tf.nn.conv2d_transpose(\n inputs, W, out_shape_dyn,\n shape4d(strides, data_format=data_format),\n padding=padding.upper(),\n data_format=data_format)\n conv.set_shape(tf.TensorShape([None] + out_shape3_sta))\n ret = activation(tf.nn.bias_add(conv, b, data_format=data_format) if use_bias else conv, name='output')\n\n ret.variables = VariableHolder(W=W)\n if use_bias:\n ret.variables.b = b\n return ret","def __init__(self, input_channel_dim: int, hidden_channel_dim: int = 64):\n\n super().__init__()\n layers = OrderedDict(\n [\n (\n \"conv_1\",\n nn.Sequential(\n nn.Conv2d(\n in_channels=input_channel_dim,\n out_channels=hidden_channel_dim,\n kernel_size=4,\n stride=2,\n ),\n nn.LeakyReLU(0.2, True),\n ),\n ),\n ]\n )\n current_dim = hidden_channel_dim\n for i in range(1, 4):\n prev_dim = current_dim\n current_dim *= 2\n layers[f\"conv_{i+1}\"] = nn.Sequential(\n nn.Conv2d(\n in_channels=prev_dim,\n out_channels=current_dim,\n kernel_size=4,\n stride=2,\n ),\n nn.LeakyReLU(0.2, True),\n )\n layers[\"conv_5\"] = nn.Sequential(\n nn.Conv2d(\n in_channels=current_dim,\n out_channels=1,\n kernel_size=4,\n stride=2,\n )\n )\n self.layers = nn.Sequential(layers)","def build(self, input_shape: tf.Tensor):\n self.conv = tf.keras.layers.Conv2D(\n self.channels, (1, 1), input_shape=input_shape)\n self.bn = tf.keras.layers.BatchNormalization(momentum=self.momentum)","def conv1d_transpose(inputs,\n filters,\n kernel_size,\n strides=2,\n padding='same',\n data_format='channels_last',\n activation=None,\n use_bias=True,\n kernel_initializer=None,\n bias_initializer=tf.zeros_initializer(),\n kernel_regularizer=None,\n bias_regularizer=None,\n activity_regularizer=None,\n kernel_constraint=None,\n bias_constraint=None,\n trainable=True,\n name=None,\n reuse=None):\n\n # expand inputs dimension\n inputs = tf.expand_dims(inputs,axis=1) # (batch_size, 1, N, d)\n\n params = {\"inputs\":inputs, \"filters\":filters, \"kernel_size\":(1,kernel_size),\n \"strides\":(1,strides),\"padding\":padding,\"data_format\":data_format,\n \"activation\":activation,\"use_bias\":use_bias,\n \"kernel_initializer\":kernel_initializer,\"bias_initializer\":bias_initializer,\n \"kernel_regularizer\":kernel_regularizer,\"bias_regularizer\":bias_regularizer,\n \"activity_regularizer\":activity_regularizer,\"kernel_constraint\":kernel_constraint,\n \"bias_constraint\":bias_constraint,\"trainable\":trainable,\"name\":name,\"reuse\":reuse} \n\n conv_out = tf.squeeze(tf.layers.conv2d_transpose(**params),axis=1) # (batch_size, 2N, kernel_size)\n\n return conv_out","def __init__(self, momentum: float = .5):\n super(VanillaEncoder, self).__init__()\n self.conv1 = PointNetConv2Layer(64, momentum)\n self.conv2 = PointNetConv2Layer(64, momentum)\n self.conv3 = PointNetConv2Layer(64, momentum)\n self.conv4 = PointNetConv2Layer(128, momentum)\n self.conv5 = PointNetConv2Layer(1024, momentum)","def declaration_conv2d_transpose_impl(data, kernel, strides, padding, out_dtype, output_padding):\n data_pad, kernel_transform = conv2d_transpose_nchw_preprocess(\n data, kernel, strides, padding, out_dtype, output_padding\n )\n batch, in_c, in_h, in_w = data_pad.shape\n out_c, _, filter_h, filter_w = kernel_transform.shape\n\n # convolution stage\n out_c = simplify(out_c)\n\n out_h = simplify(in_h - filter_h + 1)\n out_w = simplify(in_w - filter_w + 1)\n dc = te.reduce_axis((0, in_c), name=\"dc\")\n dh = te.reduce_axis((0, filter_h), name=\"dh\")\n dw = te.reduce_axis((0, filter_w), name=\"dw\")\n\n Output = te.compute(\n (batch, out_c, out_h, out_w),\n lambda b, c, h, w: te.sum(\n data_pad[b, dc, h + dh, w + dw].astype(out_dtype)\n * kernel_transform[c, dc, dh, dw].astype(out_dtype),\n axis=[dc, dh, dw],\n ),\n tag=\"conv2d_transpose_nchw\",\n )\n\n return Output","def _composite_conv(self, input_data, out_channel, name):\n with tf.variable_scope(name):\n bn_1 = self.layer_bn(input_data=input_data, is_training=self._is_training, name='bn_1')\n\n relu_1 = self.relu(input_data=bn_1, name='relu_1')\n\n if self._with_bc:\n conv_1 = self.conv2d(input_data=relu_1, out_channel=out_channel, kernel_size=1,\n padding='SAME', stride=1, use_bias=False, name='conv_1')\n\n bn_2 = self.layer_bn(input_data=conv_1, is_training=self._is_training, name='bn_2')\n relu_2 = self.relu(input_data=bn_2, name='relu_2')\n conv_2 = self.conv2d(input_data=relu_2, out_channel=out_channel, kernel_size=3,\n padding='SAME', stride=1, use_bias=False, name='conv_2')\n\n else:\n conv_2 = self.conv2d(input_data=relu_1, out_channel=out_channel, kernel_size=3,\n padding='SAME', stride=1, use_bias=False, name='conv_2')\n\n return conv_2","def resblock(input_tensor, num_channels):\n tensor = Conv2D(filters=num_channels, kernel_size=3, padding='same')(\n input_tensor)\n tensor = Activation('relu')(tensor)\n tensor = Conv2D(filters=num_channels, kernel_size=3, padding='same')(\n tensor)\n tensor = Add()([tensor, input_tensor])\n output_tensor = Activation('relu')(tensor)\n return output_tensor","def allocate_primal_variables_conv(layer):\n\n assert layer.isconv\n\n gpu_vars = ((layer.l, [1]),\n (layer.k, [1]))\n cpu_vars = ()\n\n heavy_vars = ((layer.W_i, [Cfg.n_batches] + layer.W_shape),\n (layer.b_i, [Cfg.n_batches] + layer.b_shape),\n (layer.l_i, [Cfg.n_batches]))\n\n if Cfg.store_on_gpu:\n gpu_vars += heavy_vars\n else:\n cpu_vars += heavy_vars\n\n gpu_fun = update_gpu_fun(gpu_vars)\n cpu_fun = update_cpu_fun(cpu_vars, layer)\n\n def update_all_fun():\n gpu_fun()\n cpu_fun()\n\n return update_all_fun","def _conv2d_layer(self, inputs, filters_num, kernel_size, name, use_bias=False, strides=1):\n if strides > 1: # modified 0327\n inputs = tf.pad(inputs, paddings=[[0, 0], [1, 0], [1, 0], [0, 0]], mode='CONSTANT')\n conv = tf.layers.conv2d(inputs=inputs, filters=filters_num,\n kernel_size=kernel_size, strides=[strides, strides],\n padding=('SAME' if strides == 1 else 'VALID'), # padding = 'SAME', #\n use_bias=use_bias,\n name=name) # , kernel_initializer = tf.contrib.layers.xavier_initializer()\n return conv","def build(self,\r\n conv_filters=196,\r\n conv_size=13,\r\n conv_strides=4,\r\n act='relu',\r\n rnn_layers=2,\r\n LSTM_units=128,\r\n drop_out=0.8):\r\n i = Input(shape=self.input_size, name='input')\r\n x = Conv1D(conv_filters,\r\n conv_size,\r\n strides=conv_strides,\r\n name='conv1d')(i)\r\n x = BatchNormalization()(x)\r\n x = Activation(act)(x)\r\n for _ in range(rnn_layers):\r\n x = Bidirectional(LSTM(LSTM_units,\r\n return_sequences=True))(x)\r\n x = Dropout(drop_out)(x)\r\n x = BatchNormalization()(x)\r\n y_pred = TimeDistributed(Dense(self.output_size,\r\n activation='softmax'))(x)\r\n # ctc inputs\r\n labels = Input(name='the_labels', shape=[None, ], dtype='int32')\r\n input_length = Input(name='input_length', shape=[1], dtype='int32')\r\n label_length = Input(name='label_length', shape=[1], dtype='int32')\r\n # Keras doesn't currently support loss funcs with extra parameters\r\n # so CTC loss is implemented in a lambda layer\r\n loss_out = Lambda(ctc_lambda_func,\r\n output_shape=(1,),\r\n name='ctc')([y_pred,\r\n labels,\r\n input_length,\r\n label_length])\r\n self.tm = Model(inputs=i,\r\n outputs=y_pred)\r\n self.m = Model(inputs=[i,\r\n labels,\r\n input_length,\r\n label_length],\r\n outputs=loss_out)\r\n return self.m, self.tm","def up_conv_2d(input_tensor, nb_filters, name):\n resize = UpSampling2D(size=(2, 2), interpolation='nearest')(input_tensor)\n paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])\n resize = tf.pad(resize, paddings, \"SYMMETRIC\")\n output_layer = Conv2D(\n filters=nb_filters,\n kernel_size=(3, 3),\n activation='relu',\n name=name)(\n resize)\n\n return output_layer","def __init__(self,\n in_channels: int,\n out_channels: int,\n kernel_size: Union[int, Sequence[int]],\n stride: Union[int, Sequence[int]] = 1,\n padding: PaddingArgType = PaddingMode.DEFAULT,\n output_padding: Union[int, Sequence[int]] = 0,\n dilation: Union[int, Sequence[int]] = 1,\n resize_at_exit: bool = False,\n use_shortcut: Optional[bool] = None,\n shortcut: Optional[LayerOrLayerFactory] = None,\n conv0: Optional[LayerOrLayerFactory] = None,\n conv1: Optional[LayerOrLayerFactory] = None,\n merge_context0: Optional[Module] = None,\n merge_context1: Optional[Module] = None,\n activation: Optional[LayerFactory] = None,\n normalizer: Optional[NormalizerFactory] = None,\n dropout: Optional[Union[float, LayerOrLayerFactory]] = None,\n weight_norm: WeightNormArgType = False,\n gated: bool = False,\n gate_bias: float = DEFAULT_GATE_BIAS,\n use_bias: Optional[bool] = None,\n weight_init: TensorInitArgType = DEFAULT_WEIGHT_INIT,\n bias_init: TensorInitArgType = DEFAULT_BIAS_INIT,\n data_init: Optional[DataInitArgType] = None,\n device: Optional[str] = None,\n ):\n def use_bias_or_else(default_val: bool):\n if use_bias is None:\n return default_val\n return use_bias\n\n def compile_layer_list(layers: List[Module]) -> Module:\n if len(layers) == 0:\n return Identity()\n elif len(layers) == 1:\n return layers[0]\n else:\n return Sequential(layers)\n\n spatial_ndims = self._get_spatial_ndims()\n is_deconv = self._is_deconv()\n\n # validate arguments\n in_channels = int(in_channels)\n out_channels = int(out_channels)\n\n kernel_size = validate_conv_size('kernel_size', kernel_size, spatial_ndims)\n stride = validate_conv_size('strides', stride, spatial_ndims)\n dilation = validate_conv_size('dilation', dilation, spatial_ndims)\n padding = validate_padding(padding, kernel_size, dilation, spatial_ndims)\n\n if output_padding != 0 and not is_deconv:\n raise ValueError(f'The `output_padding` argument is not allowed '\n f'by {self.__class__.__qualname__}.')\n output_padding = validate_output_padding(\n output_padding, stride, dilation, spatial_ndims)\n\n if conv0 is None:\n conv0 = self._default_conv_factory()\n\n if conv1 is None:\n conv1 = self._default_conv_factory()\n\n orig_merge_context0 = merge_context0\n if merge_context0 is None:\n merge_context0 = IgnoreContext()\n else:\n merge_context0 = validate_layer('merge_context0', merge_context0)\n\n if merge_context1 is None:\n merge_context1 = IgnoreContext()\n else:\n merge_context1 = validate_layer('merge_context1', merge_context1)\n\n if shortcut is not None:\n use_shortcut = True\n if use_shortcut is None:\n use_shortcut = (\n any(s != 1 for s in stride) or\n any(p[0] + p[1] != (k - 1) * d\n for p, k, d in zip(padding, kernel_size, dilation)) or\n in_channels != out_channels)\n\n if activation is not None:\n activation_factory = validate_layer_factory('activation', activation)\n else:\n activation_factory = None\n\n if normalizer is not None:\n normalizer_factory = validate_layer_factory('normalizer', normalizer)\n else:\n normalizer_factory = None\n\n if isinstance(dropout, float):\n dropout = Dropout(p=dropout)\n elif dropout is not None:\n dropout = get_layer_from_layer_or_factory('dropout', dropout)\n\n conv0_weight_norm = weight_norm\n if conv0_weight_norm is True:\n conv0_weight_norm = (\n WeightNormMode.FULL if normalizer is None or dropout is not None\n else WeightNormMode.NO_SCALE\n )\n\n kwargs = {'weight_init': weight_init, 'bias_init': bias_init,\n 'data_init': data_init, 'device': device}\n\n # build the shortcut path\n if use_shortcut:\n if shortcut is None:\n shortcut = self._default_conv_factory()\n if not isinstance(shortcut, Module):\n shortcut = get_layer_from_layer_or_factory(\n 'shortcut', shortcut, kwargs=dict(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=kernel_size,\n stride=stride,\n padding=padding,\n dilation=dilation,\n use_bias=use_bias_or_else(gated),\n weight_norm=weight_norm,\n **self._add_output_padding_to_kwargs(output_padding, kwargs)\n )\n )\n else:\n shortcut = Identity()\n\n # prepare the arguments for the residual path\n if resize_at_exit:\n conv0_out_channels = in_channels\n conv0_stride = 1\n conv0_padding = PaddingMode.HALF # such that it can keep the output shape\n conv0_kwargs = kwargs\n conv1_stride = stride\n conv1_padding = padding\n conv1_kwargs = self._add_output_padding_to_kwargs(output_padding, kwargs)\n else:\n conv0_out_channels = out_channels\n conv0_stride = stride\n conv0_padding = padding\n conv0_kwargs = self._add_output_padding_to_kwargs(output_padding, kwargs)\n conv1_stride = 1\n conv1_padding = PaddingMode.HALF # such that it can keep the output shape\n conv1_kwargs = kwargs\n\n conv1_out_channels = out_channels\n if gated:\n conv1_out_channels *= 2\n\n # pre_conv0\n pre_conv0 = []\n if normalizer_factory is not None:\n pre_conv0.append(normalizer_factory(in_channels))\n if activation_factory is not None:\n pre_conv0.append(activation_factory())\n pre_conv0 = compile_layer_list(pre_conv0)\n\n # conv0\n conv0 = get_layer_from_layer_or_factory( # conv0\n 'conv0', conv0, kwargs=dict(\n in_channels=in_channels,\n out_channels=conv0_out_channels,\n kernel_size=kernel_size,\n stride=conv0_stride,\n padding=conv0_padding,\n dilation=dilation,\n use_bias=use_bias_or_else(normalizer_factory is None or\n dropout is not None or\n orig_merge_context0 is not None),\n weight_norm=conv0_weight_norm,\n **conv0_kwargs,\n )\n )\n\n # pre_conv1\n pre_conv1 = []\n if dropout is not None:\n pre_conv1.append(dropout)\n if normalizer_factory is not None:\n pre_conv1.append(normalizer_factory(conv0_out_channels))\n if activation_factory is not None:\n pre_conv1.append(activation_factory())\n pre_conv1 = compile_layer_list(pre_conv1)\n\n # conv1\n conv1 = get_layer_from_layer_or_factory(\n 'conv1', conv1, kwargs=dict(\n in_channels=conv0_out_channels,\n out_channels=conv1_out_channels,\n kernel_size=kernel_size,\n stride=conv1_stride,\n padding=conv1_padding,\n dilation=dilation,\n use_bias=use_bias_or_else(True),\n weight_norm=weight_norm,\n **conv1_kwargs,\n )\n )\n\n # post_conv1\n if gated:\n post_conv1 = Gated(\n feature_axis=-(spatial_ndims + 1),\n num_features=out_channels,\n gate_bias=gate_bias,\n )\n else:\n post_conv1 = Identity()\n\n # construct the layer\n super().__init__()\n self.shortcut = shortcut\n self.pre_conv0 = pre_conv0\n self.merge_context0 = merge_context0\n self.conv0 = conv0\n self.pre_conv1 = pre_conv1\n self.merge_context1 = merge_context1\n self.conv1 = conv1\n self.post_conv1 = post_conv1","def _make_conv_layers(self):\n conv = nn.Sequential(\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=1), # padding=3 so, output is 224.\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(kernel_size=2, stride=2),\n\n nn.Conv2d(64, 192, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(192, 128, 1, padding=1), ## kernel size = 1 이므로 padding = 0(defalut)\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(128, 256, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(1024, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(1024, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True)\n )\n return conv","def initParams(self):\n sizes = [self.inputDim]+self.layerSizes+[self.outputDim]\n scales = [np.sqrt(6)/np.sqrt(n+m) for n,m in zip(sizes[:-1],sizes[1:])]\n self.stack = [[np.random.rand(m,n)*2*s-s,np.zeros((m,1))] \\\n for n,m,s in zip(sizes[:-1],sizes[1:],scales)]\n self.hActs_M = [cm.empty((s,self.maxBatch)) for s in sizes]\n\n if self.train:\n # Now assuming that all layers are the same size\n self.grad = [[cm.empty(w.shape),cm.empty(b.shape)] for w,b in self.stack]\n self.deltasC_M = cm.empty((self.outputDim,self.maxBatch))\n self.deltasOut_M = cm.empty((sizes[1],self.maxBatch)) \n self.deltasIn_M = cm.empty((sizes[1],self.maxBatch)) \n self.tmpGrad_M = cm.empty((self.layerSize,self.maxBatch))\n \n # Allocate memory once here and reuse\n # Store probs\n self.probs_M = cm.empty((self.outputDim,self.maxBatch))\n # Store col max\n self.rowVec_M = cm.empty((1,self.maxBatch))\n \n self.stack = [[cm.CUDAMatrix(w),cm.CUDAMatrix(b)]\n for w,b in self.stack]\n\n if self.temporalLayer > 0:\n # dummy bias used for temporal layer\n dummy = cm.empty((1,1))\n dummy.assign(0.0)\n\n scale = np.sqrt(6)/np.sqrt(self.layerSize*2)\n wtf = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\n self.layerSize)-scale)\n wtb = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\n self.layerSize)-scale)\n self.stack.append([wtf,dummy])\n self.stack.append([wtb,dummy])\n\n # forward and backward activations for temporal layer\n self.hActsFor_M = cm.empty((self.layerSize,self.maxBatch))\n self.hActsBack_M = cm.empty((self.layerSize,self.maxBatch))\n\n if self.train:\n dwtf = cm.empty(wtf.shape)\n self.grad.append([dwtf,dummy])\n dwtb = cm.empty(wtb.shape)\n self.grad.append([dwtb,dummy])\n\n self.tmpGradBack_M = cm.empty((self.layerSize,self.maxBatch))\n self.deltasFor_M = cm.empty((self.layerSize,self.maxBatch))\n self.deltasBack_M = cm.empty((self.layerSize,self.maxBatch))","def transition_layer(X, nb_filters, compression):\n\n init = K.initializers.he_normal(seed=None)\n\n bn1 = K.layers.BatchNormalization()(X)\n activation1 = K.layers.Activation('relu')(bn1)\n filters = int(nb_filters * compression)\n conv1 = K.layers.Conv2D(\n filters=filters,\n kernel_size=(1, 1),\n padding='same',\n kernel_initializer=init\n )(activation1)\n\n avgpool = K.layers.AveragePooling2D(\n pool_size=(2, 2),\n strides=(2, 2),\n padding='same',\n )(conv1)\n\n return avgpool, filters","def test_multiple_transpose_conv2d(self):\n\n tf.compat.v1.reset_default_graph()\n with tf.device('/cpu:0'):\n model = tf.keras.Sequential()\n model.add(tf.keras.layers.Conv2DTranspose(1, (4, 4), input_shape=(28, 28, 3)))\n model.add(tf.keras.layers.MaxPooling2D((2, 2)))\n model.add(tf.keras.layers.Conv2DTranspose(1, (4, 4), input_shape=(28, 28, 3)))\n model.add(tf.keras.layers.MaxPooling2D((2, 2)))\n model.summary()\n\n conn_graph = ConnectedGraph(tf.compat.v1.get_default_graph(), [model.input.op.name], [model.output.op.name])\n self.assertEqual(conn_graph.get_all_ops()['conv2d_transpose/conv2d_transpose'].type, 'Conv2DTranspose')\n self.assertEqual(conn_graph.get_all_ops()['conv2d_transpose_1/conv2d_transpose'].type, 'Conv2DTranspose')","def test_on_conv_transpose_2d_padding(self):\n x = jn.array([[[[2., 1., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.], [13., 14., 15., 16.]]]])\n y = jn.array([[[[2., 5., 5., 10.], [11., 27., 32., 46.], [24., 66., 76., 86.], [40., 106., 116., 126.]]]])\n w_init = lambda s: jn.array([[[[1., 2.], [3., 4.]]]]).transpose((2, 3, 0, 1))\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=objax.ConvPadding.SAME, w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='same', w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='Same', w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='SAME', w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=(1, 0), w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=[(1, 0), (1, 0)], w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n y = [[[[2., 5., 5., 10., 8.], [11., 27., 32., 46., 32.], [24., 66., 76., 86., 56.],\n [40., 106., 116., 126., 80.], [39., 94., 101., 108., 64.]]]]\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=1, w_init=w_init)\n self.assertEqual(conv(x).tolist(), y)\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=(1, 1), w_init=w_init)\n self.assertEqual(conv(x).tolist(), y)\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=[(1, 1), (1, 1)], w_init=w_init)\n self.assertEqual(conv(x).tolist(), y)","def create_cnn(num_half_rows, num_half_columns, num_channels):\n\n error_checking.assert_is_integer(num_half_rows)\n error_checking.assert_is_integer(num_half_columns)\n error_checking.assert_is_integer(num_channels)\n\n error_checking.assert_is_greater(num_half_rows, 0)\n error_checking.assert_is_greater(num_half_columns, 0)\n error_checking.assert_is_greater(num_channels, 0)\n\n regularizer_object = keras.regularizers.l1_l2(l1=L1_WEIGHT, l2=L2_WEIGHT)\n\n num_grid_rows = 2 * num_half_rows + 1\n num_grid_columns = 2 * num_half_columns + 1\n input_layer_object = keras.layers.Input(\n shape=(num_grid_rows, num_grid_columns, num_channels)\n )\n\n current_num_filters = None\n current_layer_object = None\n\n # Add convolutional layers.\n for _ in range(NUM_CONV_LAYER_SETS):\n for _ in range(NUM_CONV_LAYERS_PER_SET):\n\n if current_num_filters is None:\n current_num_filters = (\n num_channels * NUM_CHANNELS_TO_FIRST_NUM_FILTERS)\n this_input_layer_object = input_layer_object\n\n else:\n current_num_filters *= 2\n this_input_layer_object = current_layer_object\n\n current_layer_object = keras.layers.Conv2D(\n filters=current_num_filters,\n kernel_size=(NUM_CONV_FILTER_ROWS, NUM_CONV_FILTER_COLUMNS),\n strides=(1, 1), padding='valid', data_format='channels_last',\n dilation_rate=(1, 1), activation=None, use_bias=True,\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\n kernel_regularizer=regularizer_object\n )(this_input_layer_object)\n\n current_layer_object = keras.layers.LeakyReLU(\n alpha=SLOPE_FOR_RELU\n )(current_layer_object)\n\n if CONV_LAYER_DROPOUT_FRACTION is not None:\n current_layer_object = keras.layers.Dropout(\n rate=CONV_LAYER_DROPOUT_FRACTION\n )(current_layer_object)\n\n if USE_BATCH_NORMALIZATION:\n current_layer_object = keras.layers.BatchNormalization(\n axis=-1, center=True, scale=True\n )(current_layer_object)\n\n current_layer_object = keras.layers.MaxPooling2D(\n pool_size=(NUM_POOLING_ROWS, NUM_POOLING_COLUMNS),\n strides=(NUM_POOLING_ROWS, NUM_POOLING_COLUMNS),\n padding='valid', data_format='channels_last'\n )(current_layer_object)\n\n these_dimensions = numpy.array(\n current_layer_object.get_shape().as_list()[1:], dtype=int)\n num_features = numpy.prod(these_dimensions)\n\n current_layer_object = keras.layers.Flatten()(current_layer_object)\n\n # Add intermediate dense layers.\n _, num_outputs_by_dense_layer = (\n architecture_utils.get_dense_layer_dimensions(\n num_input_units=num_features, num_classes=NUM_CLASSES,\n num_dense_layers=NUM_DENSE_LAYERS)\n )\n\n for k in range(NUM_DENSE_LAYERS - 1):\n current_layer_object = keras.layers.Dense(\n num_outputs_by_dense_layer[k], activation=None, use_bias=True,\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\n kernel_regularizer=regularizer_object\n )(current_layer_object)\n\n current_layer_object = keras.layers.LeakyReLU(\n alpha=SLOPE_FOR_RELU\n )(current_layer_object)\n\n if DENSE_LAYER_DROPOUT_FRACTION is not None:\n current_layer_object = keras.layers.Dropout(\n rate=DENSE_LAYER_DROPOUT_FRACTION\n )(current_layer_object)\n\n if USE_BATCH_NORMALIZATION:\n current_layer_object = keras.layers.BatchNormalization(\n axis=-1, center=True, scale=True\n )(current_layer_object)\n\n # Add output layer (also dense).\n current_layer_object = keras.layers.Dense(\n NUM_CLASSES, activation=None, use_bias=True,\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\n kernel_regularizer=regularizer_object\n )(current_layer_object)\n\n current_layer_object = keras.layers.Activation(\n 'softmax'\n )(current_layer_object)\n\n if DENSE_LAYER_DROPOUT_FRACTION is not None and NUM_DENSE_LAYERS == 1:\n current_layer_object = keras.layers.Dropout(\n rate=DENSE_LAYER_DROPOUT_FRACTION\n )(current_layer_object)\n\n # Put the whole thing together and compile.\n cnn_model_object = keras.models.Model(\n inputs=input_layer_object, outputs=current_layer_object)\n cnn_model_object.compile(\n loss=keras.losses.categorical_crossentropy,\n optimizer=keras.optimizers.Adam(),\n metrics=LIST_OF_METRIC_FUNCTIONS)\n\n cnn_model_object.summary()\n return cnn_model_object","def TCN_V3(\n n_classes, \n feat_dim,\n max_len,\n gap=1,\n dropout=0.0,\n activation=\"relu\"):\n\n ROW_AXIS = 1\n CHANNEL_AXIS = 2\n \n initial_conv_len = 8\n initial_conv_num = 128\n\n config = [ \n [(1,8,128)],\n [(1,8,128)],\n [(1,8,128)],\n [(2,8,256)],\n [(1,8,256)],\n [(1,8,256)],\n ]\n\n input = Input(shape=(max_len,feat_dim))\n model = input\n\n model = Convolution1D(initial_conv_num, \n initial_conv_len,\n init=\"he_normal\",\n border_mode=\"same\",\n subsample_length=1)(model)\n\n for depth in range(0,len(config)):\n blocks = []\n for stride,filter_dim,num in config[depth]:\n ## residual block\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\n relu = Activation(activation)(bn)\n dr = Dropout(dropout)(relu)\n conv = Convolution1D(num, \n filter_dim,\n init=\"he_normal\",\n border_mode=\"same\",\n subsample_length=stride)(dr)\n #dr = Dropout(dropout)(conv)\n\n\n ## potential downsample\n conv_shape = K.int_shape(conv)\n model_shape = K.int_shape(model)\n if conv_shape[CHANNEL_AXIS] != model_shape[CHANNEL_AXIS]:\n model = Convolution1D(num, \n 1,\n init=\"he_normal\",\n border_mode=\"same\",\n subsample_length=2)(model)\n\n ## merge block\n model = merge([model,conv],mode='sum',concat_axis=CHANNEL_AXIS)\n\n ## final bn+relu\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\n model = Activation(activation)(bn)\n\n\n if gap:\n pool_window_shape = K.int_shape(model)\n gap = AveragePooling1D(pool_window_shape[ROW_AXIS],\n stride=1)(model)\n flatten = Flatten()(gap)\n else:\n flatten = Flatten()(model)\n\n dense = Dense(output_dim=n_classes,\n init=\"he_normal\",\n activation=\"softmax\")(flatten)\n\n model = Model(input=input, output=dense)\n # optimizer = SGD(lr=0.01, momentum=0.9, decay=0.0, nesterov=True) \n # model.compile(loss='categorical_crossentropy', optimizer=optimizer,metrics=['accuracy'])\n return model","def __init__(self, dim, dim_head = 64, heads = 8, window_size = 16, skip_type = 'ConcatCross'):\n super().__init__()\n self.scale = dim_head ** -0.5\n self.heads = heads\n self.window_size = window_size\n self.skip_type = skip_type\n inner_dim = dim_head * heads\n\n self.to_q = nn.Conv3d(dim, inner_dim, 1, bias = False)\n self.to_kv = nn.Conv3d(dim, inner_dim * 2, 1, bias = False)\n self.to_out = nn.Conv3d(inner_dim, dim, 1)","def convolutional(input_layer, filters_shape, downsample=False, activate=True, bn=True):\n if downsample:\n input_layer = ZeroPadding2D(((1, 0), (1, 0)))(input_layer)\n padding = 'valid'\n strides = 2\n else:\n strides = 1\n padding = 'same'\n\n conv = Conv2D(filters=filters_shape[-1], kernel_size=filters_shape[0], strides=strides,\n padding=padding, use_bias=not bn, kernel_regularizer=l2(0.0005),\n kernel_initializer=tf.random_normal_initializer(stddev=0.01),\n bias_initializer=tf.constant_initializer(0.))(input_layer)\n if bn:\n conv = BatchNormalization()(conv)\n if activate == True:\n conv = LeakyReLU(alpha=0.1)(conv)\n\n return conv","def create_conv2d(x, W):\n return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')","def resblock(input_tensor, num_channels):\r\n step_1_conv = Conv2D(num_channels, (3, 3), padding='same')(input_tensor)\r\n step_2_relu = Activation('relu')(step_1_conv)\r\n step_3_conv = Conv2D(num_channels, (3, 3), padding='same')(step_2_relu)\r\n output = Add()([input_tensor, step_3_conv])\r\n return Activation('relu')(output)","def _transition_layer(self, input_data, name):\n input_channels = input_data.get_shape().as_list()[3]\n\n with tf.variable_scope(name):\n # First batch norm\n bn = self.layer_bn(input_data=input_data, is_training=self._is_training, name='bn')\n\n # Second 1 X 1 conv\n if self._with_bc:\n out_channels = int(input_channels * self._bc_theta)\n conv = self.conv2d(input_data=bn, out_channel=out_channels, kernel_size=1,\n stride=1, use_bias=False, name='conv')\n # Third average pooling\n avgpool_out = self.avg_pooling(input_data=conv, kernel_size=2, stride=2, name='avgpool')\n else:\n conv = self.conv2d(input_data=bn, out_channel=input_channels, kernel_size=1,\n stride=1, use_bias=False, name='conv')\n # Third average pooling\n avgpool_out = self.avg_pooling(input_data=conv, kernel_size=2, stride=2, name='avgpool')\n\n return avgpool_out","def deconv2d_bn_act(inputs, filters, kernel_size, kernel_init, activation, strides, padding=\"SAME\"):\n _tmp = tf.layers.conv2d_transpose(inputs=inputs, filters=filters, kernel_size=kernel_size,\n kernel_initializer=kernel_init, activation=None, strides=strides, padding=padding)\n _tmp = tf.contrib.layers.batch_norm(_tmp, center=True, scale=True, is_training=phase)\n _tmp = activation(_tmp)\n\n return _tmp","def Conv2DTranspose_BN(x, filters, kernel_size, strides=(1,1), padding='same', activation='relu', kernel_initializer='he_normal', kernel_regularizer=None):\n\n x = Conv2DTranspose(filters, kernel_size=kernel_size, strides=strides, padding=padding, kernel_regularizer=kernel_regularizer)(x)\n x = BatchNormalization()(x)\n x = Activation(activation)(x)\n return x","def TCN_V2(\n n_classes, \n feat_dim,\n max_len,\n gap=1,\n dropout=0.0,\n activation=\"relu\"):\n\n ROW_AXIS = 1\n CHANNEL_AXIS = 2\n \n initial_conv_len = 8\n initial_conv_num = 64\n\n config = [ \n [(1,8,64)],\n [(1,8,64)],\n [(1,8,64)],\n [(1,8,64)],\n [(1,8,64)],\n [(2,8,128)],\n [(1,8,128)],\n [(1,8,128)],\n [(1,8,128)],\n [(1,8,128)],\n ]\n\n input = Input(shape=(max_len,feat_dim))\n model = input\n\n model = Convolution1D(initial_conv_num, \n initial_conv_len,\n init=\"he_normal\",\n border_mode=\"same\",\n subsample_length=1)(model)\n\n for depth in range(0,len(config)):\n blocks = []\n for stride,filter_dim,num in config[depth]:\n ## residual block\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\n relu = Activation(activation)(bn)\n dr = Dropout(dropout)(relu)\n conv = Convolution1D(num, \n filter_dim,\n init=\"he_normal\",\n border_mode=\"same\",\n subsample_length=stride)(dr)\n #dr = Dropout(dropout)(conv)\n\n\n ## potential downsample\n conv_shape = K.int_shape(conv)\n model_shape = K.int_shape(model)\n if conv_shape[CHANNEL_AXIS] != model_shape[CHANNEL_AXIS]:\n model = Convolution1D(num, \n 1,\n init=\"he_normal\",\n border_mode=\"same\",\n subsample_length=2)(model)\n\n ## merge block\n model = merge([model,conv],mode='sum',concat_axis=CHANNEL_AXIS)\n\n ## final bn+relu\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\n model = Activation(activation)(bn)\n\n\n if gap:\n pool_window_shape = K.int_shape(model)\n gap = AveragePooling1D(pool_window_shape[ROW_AXIS],\n stride=1)(model)\n flatten = Flatten()(gap)\n else:\n flatten = Flatten()(model)\n\n dense = Dense(output_dim=n_classes,\n init=\"he_normal\",\n activation=\"softmax\")(flatten)\n\n model = Model(input=input, output=dense)\n # optimizer = SGD(lr=0.01, momentum=0.9, decay=0.0, nesterov=True) \n # model.compile(loss='categorical_crossentropy', optimizer=optimizer,metrics=['accuracy'])\n return model","def contract(self, depth, kernel_cc_weight=0.0):\n\n def composite_layer(x):\n name = 'contr_%d' % depth\n num_filters = self.base_num_filters * 2 ** depth\n x = self.conv_depth(num_filters=num_filters, name=name, kernel_cc_weight=kernel_cc_weight)(x)\n self.contr_tensors[depth] = x\n x = MaxPoolingND(x)(x)\n return x\n\n return composite_layer","def __init__(self, in_dim, activation):\r\n super(Self_Attn, self).__init__()\r\n self.input_channel = in_dim\r\n self.activation = activation\r\n self.k = 8\r\n self.query = nn.Conv2d(self.input_channel, self.input_channel // self.k, kernel_size=1)\r\n self.key = nn.Conv2d(self.input_channel, self.input_channel // self.k, kernel_size=1)\r\n self.value = nn.Conv2d(self.input_channel, self.input_channel, kernel_size=1)\r\n self.h = nn.Conv2d(self.input_channel, self.input_channel, kernel_size=1)\r\n self.gamma = nn.Parameter(torch.zeros(1), requires_grad=True)\r\n self.softmax = nn.Softmax(dim=-1)","def _conv_block(x, filters, activation=True):\n h = tf.keras.layers.Conv2D(\n filters,\n kernel_size=[3, 3],\n kernel_initializer='he_normal',\n bias_initializer='zeros',\n strides=[1, 1],\n padding='same',\n use_bias=True)(\n x)\n if activation:\n h = tf.keras.layers.LeakyReLU(0.2)(h)\n return h","def __init__(self, in_size, out_size, kernel_size=3, stride=2, padding=1, output_padding=1):\n super().__init__()\n ConvTransBlockList = nn.ModuleList()\n ConvTransBlockList.append(nn.ConvTranspose2d(in_size, out_size,\n kernel_size=kernel_size, stride=stride,\n padding=padding, output_padding=output_padding,\n bias=False)\n )\n ConvTransBlockList.append(nn.InstanceNorm2d(out_size))\n ConvTransBlockList.append(nn.ReLU())\n self.model = nn.Sequential(*ConvTransBlockList)","def _init_layers(self):\n self.relu = nn.ReLU(inplace=True)\n self.cls_convs = nn.ModuleList()\n self.reg_convs = nn.ModuleList()\n for i in range(self.stacked_convs):\n chn = self.in_channels if i == 0 else self.feat_channels\n self.cls_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=dict(type='DCN', deform_groups=1)\n if i == 0 and self.use_dcn else self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.reg_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=dict(type='DCN', deform_groups=1)\n if i == 0 and self.use_dcn else self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.atss_cls = nn.Conv2d(\n self.feat_channels,\n self.num_base_priors * self.cls_out_channels,\n 3,\n padding=1)\n self.atss_reg = nn.Conv2d(\n self.feat_channels, self.num_base_priors * 4, 3, padding=1)\n self.atss_iou = nn.Conv2d(\n self.feat_channels, self.num_base_priors * 1, 3, padding=1)\n self.scales = nn.ModuleList(\n [Scale(1.0) for _ in self.prior_generator.strides])\n\n # we use the global list in loss\n self.cls_num_pos_samples_per_level = [\n 0. for _ in range(len(self.prior_generator.strides))\n ]\n self.reg_num_pos_samples_per_level = [\n 0. for _ in range(len(self.prior_generator.strides))\n ]","def conv3x3(in_channels, out_channels, stride=1, \n padding=1, bias=True, groups=1):\n return nn.Conv2d(\n in_channels, \n out_channels, \n kernel_size=3, \n stride=stride,\n padding=padding,\n bias=bias,\n groups=groups)","def __init__(self, indim, outdim, ksize=3, stride=1, activation=nn.ReLU):\n\n # Run initialization for super class\n super(ConvBlock, self).__init__()\n\n # Check ksize, stride requirements\n assert (ksize % 2) == 1\n assert stride == 1\n assert indim == outdim\n\n # Store proper activation function depending on configuration\n self.activ = activation\n\n # Compute padding according to `ksize`. Make sure\n # that this will not cause image width and height to change.\n padding = ksize // 2\n\n # We will follow the architecture in slide 76 of lecture 21, but with\n # our `_conv` function as our conv ``block''. We'll also use\n # nn.Sequential() and its `add_module' function. Note that the 64 and\n # 256 in that slide are just examples, and you should instead use indim\n # and outdim.\n #\n # Also note that we are creating these layers with support for\n # different `ksize`, `stride`, `padding`, unlike previous assignment.\n self.layers = nn.Sequential()\n self.layers.add_module(\"conv_1\", self._conv(indim, indim, 1, 1, 0))\n self.layers.add_module(\"conv_2\", self._conv(\n indim, indim, ksize, 1, padding))\n self.layers.add_module(\"conv_3\", self._conv(indim, outdim, 1, 1, 0))","def conv_3d(self):\n # Model.\n model = Sequential()\n model.add(Conv3D(32, (3,3,3), activation='relu', input_shape=self.input_shape))\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))\n model.add(Conv3D(64, (3,3,3), activation='relu'))\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))\n model.add(Conv3D(128, (3,3,3), activation='relu'))\n model.add(Conv3D(128, (3,3,3), activation='relu'))\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))\n model.add(Conv3D(256, (2,2,2), activation='relu'))\n model.add(Conv3D(256, (2,2,2), activation='relu'))\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))\n\n model.add(Flatten())\n model.add(Dense(1024))\n model.add(Dropout(0.5))\n model.add(Dense(1024))\n model.add(Dropout(0.5))\n model.add(Dense(self.nb_classes, activation='softmax'))\n\n return model","def create(self) -> None:\n if self.torch is not None: # type: ignore\n return\n self.torch = torch.nn.Conv2d(**self.args.arg_values)","def _init_predictor(self):\n self.conv_cls_prev = self._init_branch(\n conv_channels=self.cls_branch,\n conv_strides=(1, ) * len(self.cls_branch))\n self.conv_cls = nn.Conv2d(self.cls_branch[-1], self.cls_out_channels,\n 1)\n # init regression head\n self.conv_reg_prevs = nn.ModuleList()\n # init output head\n self.conv_regs = nn.ModuleList()\n # group_reg_dims:\n # ((4, ), (2, ), (20, ), (3, ), (3, ), (8, 8), (1, ), (1, ))\n for i in range(len(self.group_reg_dims)):\n reg_dims = self.group_reg_dims[i]\n reg_branch_channels = self.reg_branch[i]\n out_channel = self.out_channels[i]\n reg_list = nn.ModuleList()\n if len(reg_branch_channels) > 0:\n self.conv_reg_prevs.append(\n self._init_branch(\n conv_channels=reg_branch_channels,\n conv_strides=(1, ) * len(reg_branch_channels)))\n for reg_dim in reg_dims:\n reg_list.append(nn.Conv2d(out_channel, reg_dim, 1))\n self.conv_regs.append(reg_list)\n else:\n self.conv_reg_prevs.append(None)\n for reg_dim in reg_dims:\n reg_list.append(nn.Conv2d(self.feat_channels, reg_dim, 1))\n self.conv_regs.append(reg_list)","def conv_mpool_activation(scope, input_layer, n_channels=2, mpool=False, kernel_conv=(5, 5), \n stride_conv=(1, 1), kernel_pool=(2, 2), stride_pool=(2, 2), activation=tf.nn.relu):\n with tf.variable_scope(scope):\n # infer input_nchannels\n inp_channels = input_layer.shape.as_list()[-1]\n\n # define var for conv-filter\n filter_shape = tuple(kernel_conv) + (inp_channels, ) + (n_channels, )\n filter_weights = tf.Variable(tf.truncated_normal(shape=filter_shape, stddev=0.01), name='weights')\n\n # bias\n bias = tf.Variable(tf.zeros(shape=[n_channels]), name='bias')\n\n # apply the filter\n strides = (1, ) + tuple(stride_conv) + (1, )\n output = tf.nn.conv2d(input=input_layer, filter=filter_weights, strides=strides, padding='SAME')\n\n # bias\n output = output + bias\n\n # apply mpooling if needed\n if mpool:\n ksize = (1, ) + tuple(kernel_pool) + (1, )\n strides = (1, ) + tuple(stride_pool) + (1, )\n output = tf.nn.max_pool(output, ksize=ksize, strides=strides, padding='SAME')\n\n return tf.identity(activation(output), name='output')","def c3d(self):\n model = Sequential()\n # 1st layer group\n model.add(Conv3D(64, 3, 3, 3, activation='relu',\n border_mode='same', name='conv1',\n subsample=(1, 1, 1),\n input_shape=self.input_shape))\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2),\n border_mode='valid', name='pool1'))\n # 2nd layer group\n model.add(Conv3D(128, 3, 3, 3, activation='relu',\n border_mode='same', name='conv2',\n subsample=(1, 1, 1)))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='valid', name='pool2'))\n # 3rd layer group\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\n border_mode='same', name='conv3a',\n subsample=(1, 1, 1)))\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\n border_mode='same', name='conv3b',\n subsample=(1, 1, 1)))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='valid', name='pool3'))\n # 4th layer group\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv4a',\n subsample=(1, 1, 1)))\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv4b',\n subsample=(1, 1, 1)))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='valid', name='pool4'))\n\n # 5th layer group\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv5a',\n subsample=(1, 1, 1)))\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv5b',\n subsample=(1, 1, 1)))\n model.add(ZeroPadding3D(padding=(0, 1, 1)))\n # model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n # border_mode='valid', name='pool5', dim_ordering=\"tf\"))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='same', name='pool5', dim_ordering=\"tf\"))\n model.add(Flatten())\n\n # FC layers group\n model.add(Dense(4096, activation='relu', name='fc6'))\n model.add(Dropout(0.5))\n model.add(Dense(4096, activation='relu', name='fc7'))\n model.add(Dropout(0.5))\n model.add(Dense(self.nb_classes, activation='softmax'))\n for layer in model.layers:\n print(layer.output_shape)\n return model","def setUp(self):\n\n super(Conv2DTransposeTest, self).setUp()\n\n self.batch_size = 100\n self.in_height = 32\n self.in_width = 32\n self.in_channels = 3\n self.out_channels = 10\n self.kernel_shape_h = 5\n self.kernel_shape_w = 5\n self.strides = (1, 1, 1, 1)\n self.padding = snt.SAME\n\n self.in_shape = (self.batch_size, self.in_height, self.in_width,\n self.in_channels)\n\n self.out_shape = (self.in_height, self.in_width)\n\n self.kernel_shape = (self.kernel_shape_h, self.kernel_shape_w)\n\n self.kernel_shape2 = (self.kernel_shape_h, self.kernel_shape_w,\n self.out_channels, self.in_channels)","def TCN_V1(\n n_classes, \n feat_dim,\n max_len,\n gap=1,\n dropout=0.0,\n activation=\"relu\"):\n\n ROW_AXIS = 1\n CHANNEL_AXIS = 2\n \n initial_conv_len = 8\n initial_conv_num = 64\n\n config = [ \n [(1,8,64)],\n [(1,8,64)],\n [(1,8,64)],\n [(2,8,128)],\n [(1,8,128)],\n [(1,8,128)],\n [(2,8,256)],\n [(1,8,256)],\n [(1,8,256)],\n ]\n\n input = Input(shape=(max_len,feat_dim))\n model = input\n\n model = Convolution1D(initial_conv_num, \n initial_conv_len,\n init=\"he_normal\",\n border_mode=\"same\",\n subsample_length=1)(model)\n\n for depth in range(0,len(config)):\n blocks = []\n for stride,filter_dim,num in config[depth]:\n ## residual block\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\n relu = Activation(activation)(bn)\n dr = Dropout(dropout)(relu)\n conv = Convolution1D(num, \n filter_dim,\n init=\"he_normal\",\n border_mode=\"same\",\n subsample_length=stride)(dr)\n\n ## potential downsample\n conv_shape = K.int_shape(conv)\n model_shape = K.int_shape(model)\n if conv_shape[CHANNEL_AXIS] != model_shape[CHANNEL_AXIS]:\n model = Convolution1D(num, \n 1,\n init=\"he_normal\",\n border_mode=\"same\",\n subsample_length=2)(model)\n\n ## merge block\n model = merge([model,conv],mode='sum',concat_axis=CHANNEL_AXIS)\n\n ## final bn+relu\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\n model = Activation(activation)(bn)\n\n\n if gap:\n pool_window_shape = K.int_shape(model)\n gap = AveragePooling1D(pool_window_shape[ROW_AXIS],\n stride=1)(model)\n flatten = Flatten()(gap)\n else:\n flatten = Flatten()(model)\n\n dense = Dense(output_dim=n_classes,\n init=\"he_normal\",\n activation=\"softmax\")(flatten)\n\n model = Model(input=input, output=dense)\n # optimizer = SGD(lr=0.01, momentum=0.9, decay=0.0, nesterov=True) \n # model.compile(loss='categorical_crossentropy', optimizer=optimizer,metrics=['accuracy'])\n return model","def transition_up(self, x, filters, name):\n with tf.name_scope(name):\n x = tf.layers.conv2d_transpose(x,\n filters=filters,\n kernel_size=[3, 3],\n strides=[2, 2],\n padding='SAME',\n activation=None,\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\n name=name+'_trans_conv3x3')\n\n return x","def preprocess_module(mod):\n\n def alter_conv(attrs, inputs, tinfos, out_type):\n new_attrs = dict(attrs)\n data_info = tinfos[0]\n weight_info = tinfos[1]\n (desired_data_layout, desired_kernel_layout) = (\"NCHW\", \"OIHW\")\n new_attrs[\"data_layout\"] = desired_data_layout\n new_attrs[\"kernel_layout\"] = desired_kernel_layout\n\n if is_depthwise_conv2d(\n data_info.shape,\n attrs[\"data_layout\"],\n weight_info.shape,\n attrs[\"kernel_layout\"],\n attrs[\"groups\"],\n ):\n dkl = desired_kernel_layout\n new_attrs[\"kernel_layout\"] = dkl[1] + dkl[0] + dkl[2] + dkl[3]\n return relay.nn.conv2d(*inputs, **new_attrs)\n\n with OpAttrContext(\"nn.conv2d\", \"FTVMAlterOpLayout\", alter_conv):\n seq = tvm.transform.Sequential(\n [\n transform.ConvertLayout({\"nn.conv2d\": [\"NCHW\", \"OIHW\"]}),\n transform.ConvertLayout({\"nn.conv2d_transpose\": [\"NCHW\", \"OIHW\"]}),\n transform.AlterOpLayout(),\n transform.FoldConstant(),\n ]\n )\n with tvm.transform.PassContext(opt_level=3):\n preprocessed_mod = seq(mod)\n return preprocessed_mod","def _get_model(\n shape,\n kernel_h,\n kernel_w,\n input_zp,\n input_sc,\n kernel_zp,\n kernel_sc,\n output_zp,\n output_sc,\n stride,\n dilation,\n groups,\n kernel_layout,\n dtype,\n out_channels,\n bias,\n):\n a = relay.var(\"a\", shape=shape, dtype=dtype)\n p = tei.get_same_padding((shape[1], shape[2]), (kernel_h, kernel_w), dilation, stride)\n weight_shape = (shape[3], out_channels // groups, kernel_h, kernel_w)\n\n weight_data = tvm.nd.array(\n np.random.randint(\n np.iinfo(dtype).min,\n high=(np.iinfo(dtype).max + 1),\n size=weight_shape,\n dtype=dtype,\n )\n )\n weights = relay.const(weight_data, dtype)\n op = relay.qnn.op.conv2d_transpose(\n a,\n weights,\n input_zero_point=relay.const(input_zp, \"int32\"),\n input_scale=relay.const(input_sc, \"float32\"),\n kernel_zero_point=relay.const(kernel_zp, \"int32\"),\n kernel_scale=relay.const(kernel_sc, \"float32\"),\n kernel_size=(kernel_h, kernel_w),\n padding=p,\n strides=stride,\n dilation=dilation,\n data_layout=\"NHWC\",\n kernel_layout=kernel_layout,\n out_dtype=\"int32\",\n channels=out_channels,\n groups=groups,\n )\n if bias:\n bias_data = tvm.nd.array(\n np.random.randint(\n np.iinfo(dtype).min,\n high=np.iinfo(dtype).max + 1,\n size=(out_channels,),\n dtype=\"int32\",\n )\n )\n biasc = relay.const(bias_data, \"int32\")\n op = relay.nn.bias_add(op, biasc, axis=3)\n\n if isinstance(kernel_sc, tvm.runtime.ndarray.NDArray):\n req_input_sc = [sc * input_sc for sc in kernel_sc.numpy()]\n else:\n req_input_sc = input_sc * kernel_sc\n\n op = relay.qnn.op.requantize(\n op,\n input_zero_point=relay.const(input_zp, \"int32\"),\n input_scale=relay.const(req_input_sc, \"float32\"),\n output_zero_point=relay.const(output_zp, \"int32\"),\n output_scale=relay.const(output_sc, \"float32\"),\n axis=3,\n rounding=\"UPWARD\",\n out_dtype=dtype,\n )\n params = {\"w\": weight_data}\n if bias:\n params[\"b\"] = bias_data\n return op, params","def ConvBlock(tensor, nb_filters, kernel_size=3, padding='same', initializer='he_normal', activation=\"relu\", regularization=None):\n\n\n x = Conv2D(filters=nb_filters, kernel_size=kernel_size, padding=padding, kernel_initializer=initializer, kernel_regularizer=regularization)(tensor)\n x = BatchNormalization()(x)\n x = Activation(activation)(x)\n x = Conv2D(filters=nb_filters, kernel_size=kernel_size, padding=padding, kernel_initializer=initializer, kernel_regularizer=regularization)(x)\n x = BatchNormalization()(x)\n x = Activation(activation)(x)\n return x","def create_conv2d(self, x, w, b, stride = 1, name = None):\n x = tf.nn.conv2d(x, w, strides=[1, stride, stride, 1], padding='VALID', name = name)\n x = tf.nn.bias_add(x, b)\n return tf.nn.relu(x)","def __init__(self):\n # def __init__(self, embed_size, input_channels):\n super(OffsetCNN, self).__init__()\n self.conv0 = nn.Conv3d(1, 1, (1, 1, 1), padding=(0,0,0))\n self.bn0 = nn.BatchNorm3d(1)\n self.lrelu = nn.LeakyReLU()","def tfconv2d_transpose(in_channels,\n out_channels,\n kernel_size,\n stride=1,\n output_padding = 0,\n groups=1,\n bias=True,\n dilation=1,\n tf_padding_type = None):\n modules = []\n if tf_padding_type == 'same':\n padding = nn.ZeroPad2d(0)\n hook = hook_factory_tf_inverse_padding_same(kernel_size, stride)\n padding.register_forward_pre_hook(hook)\n modules.append(padding)\n\n # eliminate the effect of the in-build padding (is not capable of asymmeric padding)\n if isinstance(kernel_size, int):\n padding = kernel_size - 1\n else:\n padding = (kernel_size[0] - 1, kernel_size[1] - 1)\n\n modules.append(nn.ConvTranspose2d(in_channels,\n out_channels,\n kernel_size,\n stride,\n padding,\n output_padding,\n groups,\n bias,\n dilation))\n\n return nn.Sequential(*modules)","def _build_conv_layer_params(self, input_shape):\n conv_layer_params = []\n if self._conv_type == '3d':\n conv_layer_params.append(\n dict(\n filters=self._filters,\n kernel_size=[self._kernel_size] * 3,\n strides=self._strides,\n dilation_rate=self._rates,\n kernel_initializer=tf_utils.clone_initializer(\n self._kernel_initializer),\n ))\n elif self._conv_type == '2d':\n conv_layer_params.append(\n dict(\n filters=self._filters,\n kernel_size=[1, self._kernel_size, self._kernel_size],\n strides=[1, self._strides[1], self._strides[2]],\n dilation_rate=[1, self._rates[1], self._rates[2]],\n kernel_initializer=tf_utils.clone_initializer(\n self._kernel_initializer),\n ))\n elif self._conv_type == '1+2d':\n channels_in = input_shape[self._channel_axis]\n conv_layer_params.append(\n dict(\n filters=channels_in,\n kernel_size=[self._kernel_size, 1, 1],\n strides=[self._strides[0], 1, 1],\n dilation_rate=[self._rates[0], 1, 1],\n kernel_initializer=tf_utils.clone_initializer(\n self._temporal_conv_initializer),\n ))\n conv_layer_params.append(\n dict(\n filters=self._filters,\n kernel_size=[1, self._kernel_size, self._kernel_size],\n strides=[1, self._strides[1], self._strides[2]],\n dilation_rate=[1, self._rates[1], self._rates[2]],\n kernel_initializer=tf_utils.clone_initializer(\n self._kernel_initializer),\n ))\n elif self._conv_type == '2+1d':\n conv_layer_params.append(\n dict(\n filters=self._filters,\n kernel_size=[1, self._kernel_size, self._kernel_size],\n strides=[1, self._strides[1], self._strides[2]],\n dilation_rate=[1, self._rates[1], self._rates[2]],\n kernel_initializer=tf_utils.clone_initializer(\n self._kernel_initializer),\n ))\n conv_layer_params.append(\n dict(\n filters=self._filters,\n kernel_size=[self._kernel_size, 1, 1],\n strides=[self._strides[0], 1, 1],\n dilation_rate=[self._rates[0], 1, 1],\n kernel_initializer=tf_utils.clone_initializer(\n self._temporal_conv_initializer),\n ))\n elif self._conv_type == '1+1+1d':\n conv_layer_params.append(\n dict(\n filters=self._filters,\n kernel_size=[1, 1, self._kernel_size],\n strides=[1, 1, self._strides[2]],\n dilation_rate=[1, 1, self._rates[2]],\n kernel_initializer=tf_utils.clone_initializer(\n self._kernel_initializer),\n ))\n conv_layer_params.append(\n dict(\n filters=self._filters,\n kernel_size=[1, self._kernel_size, 1],\n strides=[1, self._strides[1], 1],\n dilation_rate=[1, self._rates[1], 1],\n kernel_initializer=tf_utils.clone_initializer(\n self._kernel_initializer),\n ))\n conv_layer_params.append(\n dict(\n filters=self._filters,\n kernel_size=[self._kernel_size, 1, 1],\n strides=[self._strides[0], 1, 1],\n dilation_rate=[self._rates[0], 1, 1],\n kernel_initializer=tf_utils.clone_initializer(\n self._kernel_initializer),\n ))\n else:\n raise ValueError('Unsupported conv_type: {}'.format(self._conv_type))\n return conv_layer_params","def TBLCCCNN_Model(pan_image_height_size, pan_image_width_size, ms_to_pan_ratio, n_bands, n1_pan, n2_pan, n3_pan, \r\n n1_ms, n2_ms, n3_ms, dropout_rate, n_classes, l_r):\r\n \r\n if (pan_image_height_size % ms_to_pan_ratio) != 0 or (pan_image_width_size % ms_to_pan_ratio) != 0:\r\n raise ValueError('Please make sure that both pan_image_height_size and pan_image_width_size can be divided by {}'.format(int(ms_to_pan_ratio)))\r\n \r\n pan_img_input = Input(shape = (pan_image_height_size, pan_image_width_size, 1))\r\n conv_1_pan = Conv2D(n1_pan, (7, 7), padding = 'same', activation = 'relu')(pan_img_input)\r\n max_pool_1_pan = MaxPooling2D(pool_size = (2, 2))(conv_1_pan)\r\n conv_2_pan = Conv2D(n2_pan, (3, 3), padding = 'same', activation = 'relu')(max_pool_1_pan)\r\n max_pool_2_pan = MaxPooling2D(pool_size = (2, 2))(conv_2_pan)\r\n conv_3_pan = Conv2D(n3_pan, (3, 3), padding = 'same', activation = 'relu')(max_pool_2_pan)\r\n glob_max_pool_pan = GlobalMaxPooling2D()(conv_3_pan)\r\n glob_max_pool_pan = Dropout(dropout_rate)(glob_max_pool_pan)\r\n \r\n ms_img_input = Input(shape = (int(pan_image_height_size / ms_to_pan_ratio), int(pan_image_width_size / ms_to_pan_ratio), \r\n n_bands))\r\n conv_1_ms = Conv2D(n1_ms, (3, 3), padding = 'same', activation = 'relu')(ms_img_input)\r\n conv_2_ms = Conv2D(n2_ms, (3, 3), padding = 'same', activation = 'relu')(conv_1_ms)\r\n conv_3_ms = Conv2D(n3_ms, (3, 3), padding = 'same', activation = 'relu')(conv_2_ms)\r\n glob_max_pool_ms = GlobalMaxPooling2D()(conv_3_ms)\r\n glob_max_pool_ms = Dropout(dropout_rate)(glob_max_pool_ms)\r\n \r\n all_features = concatenate([glob_max_pool_pan, glob_max_pool_ms])\r\n \r\n pred_layer = Dense(n_classes, activation = 'softmax')(all_features)\r\n \r\n tblcccnn_model = Model(inputs = [ms_img_input, pan_img_input], outputs = pred_layer)\r\n tblcccnn_model.compile(loss = 'categorical_crossentropy', optimizer = Adam(lr = l_r), \r\n metrics = ['categorical_crossentropy'])\r\n \r\n return tblcccnn_model","def __init__(self, channels, momentum):\n super(PointNetConv2Layer, self).__init__()\n self.channels = channels\n self.momentum = momentum","def _init_layers(self):\n self.relu = nn.ReLU(inplace=True)\n self.cls_convs = nn.ModuleList()\n self.reg_convs = nn.ModuleList()\n for i in range(self.stacked_convs):\n chn = self.in_channels if i == 0 else self.feat_channels\n self.cls_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.reg_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.retina_cls = nn.Conv2d(\n self.feat_channels,\n self.num_anchors * self.cls_out_channels,\n 3,\n padding=1)\n self.retina_reg = nn.Conv2d(\n self.feat_channels, self.num_anchors * 4, 3, padding=1)","def __init__(self, in_channels, num_classes):\n super(InceptionAux, self).__init__()\n self.relu = nn.LeakyReLU()\n self.dropout1 = nn.Dropout(p=0.5)\n self.pool = nn.AvgPool2d(kernel_size=5, stride=3)\n self.conv = conv_block(in_channels, 128, kernel_size=1)\n self.fc1 = nn.Linear(12800, 1024)\n self.fc2 = nn.Linear(1024, 420)\n self.dropout2 = nn.Dropout(p=0.4)\n self.fc3 = nn.Linear(420,128)\n self.dropout3 = nn.Dropout(p=0.4)\n self.fc4 = nn.Linear(128,num_classes)","def __init__(self, dropout=0, input_dim=(3, 32, 32), num_filters=32, filter_size=7,\r\n hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0, \r\n use_batch_norm=False, dtype=np.float32):\r\n self.use_dropout = dropout > 0\r\n self.use_batch_norm = use_batch_norm\r\n self.params = {}\r\n self.reg = reg\r\n self.num_layers = 3\r\n self.dtype = dtype\r\n self.pool_height = 2\r\n self.pool_width = 2\r\n self.pool_stride = 2\r\n\r\n ############################################################################\r\n # TODO: Initialize weights and biases for the three-layer convolutional #\r\n # network. Weights should be initialized from a Gaussian with standard #\r\n # deviation equal to weight_scale; biases should be initialized to zero. #\r\n # All weights and biases should be stored in the dictionary self.params. #\r\n # Store weights and biases for the convolutional layer using the keys 'W1' #\r\n # and 'b1'; use keys 'W2' and 'b2' for the weights and biases of the #\r\n # hidden affine layer, and keys 'W3' and 'b3' for the weights and biases #\r\n # of the output affine layer. #\r\n ############################################################################\r\n # NUmber of channels\r\n C, H, W = input_dim\r\n self.params['W1'] = np.random.randn(num_filters, C, filter_size, filter_size) * weight_scale\r\n self.params['b1'] = np.zeros(num_filters)\r\n H_pool = (H - self.pool_height) / 2 + 1\r\n W_pool = (W - self.pool_width) / 2 + 1\r\n self.params['W2'] = np.random.randn(np.prod((num_filters, H_pool, W_pool)), hidden_dim) * weight_scale\r\n self.params['b2'] = np.zeros(hidden_dim)\r\n self.params['W3'] = np.random.randn(hidden_dim, num_classes) * weight_scale\r\n self.params['b3'] = np.zeros(num_classes)\r\n\r\n # Initialize the parameters for batch normalization if necessary\r\n if self.use_batch_norm:\r\n self.params['gamma1'] = np.ones(num_filters) \r\n self.params['beta1'] = np.zeros(num_filters)\r\n self.params['gamma2'] = np.ones(hidden_dim)\r\n self.params['beta2'] = np.zeros(hidden_dim)\r\n\r\n # Set dropout parameters if necessary\r\n self.dropout_param={}\r\n if self.use_dropout:\r\n self.dropout_param ={'mode':'train', 'p':dropout}\r\n\r\n self.bn_params = []\r\n if self.use_batch_norm:\r\n self.bn_params = [{'mode': 'train'} for i in range(self.num_layers - 1)]\r\n\r\n ############################################################################\r\n # END OF YOUR CODE #\r\n ############################################################################\r\n\r\n for k, v in self.params.items():\r\n self.params[k] = v.astype(dtype)","def __init__(self):\n\n super(ConvModule, self).__init__()\n\n self.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=5, stride=[1, 2])\n self.conv1_bn = nn.BatchNorm2d(64)\n self.conv2 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=5, stride=[1, 2])\n self.conv2_bn = nn.BatchNorm2d(128)\n self.pool1 = nn.MaxPool2d(kernel_size=4, stride=2)\n self.dropout0 = nn.Dropout(p=0.4)\n\n self.conv3 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=[1, 2])\n self.conv3_bn = nn.BatchNorm2d(256)\n self.conv4 = nn.Conv2d(in_channels=256, out_channels=64, kernel_size=3, stride=[1, 2])\n self.conv4_bn = nn.BatchNorm2d(64)\n self.pool2 = nn.MaxPool2d(kernel_size=4, stride=2)\n #\n # self.conv5 = nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=[1, 2])\n # self.conv5_bn = nn.BatchNorm2d(64)\n # self.pool3 = nn.MaxPool2d(kernel_size=3, stride=[1, 2])","def conv_layer( x, params, training ):\n\n batch_norm = params[4] # Boolean\n\n if batch_norm:\n activation = None\n else:\n activation = tf.nn.relu\n\n kernel_initializer = tf.contrib.layers.variance_scaling_initializer()\n bias_initializer = tf.constant_initializer( value=0.0 )\n\n top = tf.layers.conv2d( x, \n filters=params[0],\n kernel_size=params[1],\n padding=params[2],\n activation=activation,\n kernel_initializer=kernel_initializer,\n bias_initializer=bias_initializer,\n name=params[3] )\n if batch_norm:\n top = norm_layer( top, training, params[3]+'/batch_norm' )\n top = tf.nn.relu( top, name=params[3]+'/relu' )\n\n return top","def init(self):\n self.reparam_layers = []\n if self.model_type == \"GCN\":\n for i in range(self.num_layers):\n if self.reparam_all_layers is True:\n is_reparam = True\n elif isinstance(self.reparam_all_layers, tuple):\n reparam_all_layers = tuple([kk + self.num_layers if kk < 0 else kk for kk in self.reparam_all_layers])\n is_reparam = i in reparam_all_layers\n else:\n raise\n if is_reparam:\n self.reparam_layers.append(i)\n setattr(self, \"conv{}\".format(i + 1),\n GCNConv(self.num_features if i == 0 else self.latent_size,\n self.latent_size if i != self.num_layers - 1 else self.num_classes,\n cached=True,\n reparam_mode=self.reparam_mode if is_reparam else None,\n prior_mode=self.prior_mode if is_reparam else None,\n sample_size=self.sample_size,\n bias=True if self.with_relu else False,\n val_use_mean=self.val_use_mean,\n normalize=self.normalize,\n ))\n # self.conv1 = ChebConv(self.num_features, 16, K=2)\n # self.conv2 = ChebConv(16, self.num_features, K=2)\n\n elif self.model_type == \"GAT\":\n latent_size = int(self.latent_size / 2) # Under the default setting, latent_size = 8\n for i in range(self.num_layers):\n if i == 0:\n input_size = self.num_features\n else:\n if self.struct_dropout_mode[0] == 'DNsampling' or (self.struct_dropout_mode[0] == 'standard' and len(self.struct_dropout_mode) == 3):\n input_size = latent_size * 8 * 2\n else:\n input_size = latent_size * 8\n if self.reparam_all_layers is True:\n is_reparam = True\n elif isinstance(self.reparam_all_layers, tuple):\n reparam_all_layers = tuple([kk + self.num_layers if kk < 0 else kk for kk in self.reparam_all_layers])\n is_reparam = i in reparam_all_layers\n else:\n raise\n if is_reparam:\n self.reparam_layers.append(i)\n setattr(self, \"conv{}\".format(i + 1), GATConv(\n input_size,\n latent_size if i != self.num_layers - 1 else self.num_classes,\n heads=8 if i != self.num_layers - 1 else 1, concat=True,\n reparam_mode=self.reparam_mode if is_reparam else None,\n prior_mode=self.prior_mode if is_reparam else None,\n val_use_mean=self.val_use_mean,\n struct_dropout_mode=self.struct_dropout_mode,\n sample_size=self.sample_size,\n ))\n if self.struct_dropout_mode[0] == 'DNsampling' or (self.struct_dropout_mode[0] == 'standard' and len(self.struct_dropout_mode) == 3):\n setattr(self, \"conv{}_1\".format(i + 1), GATConv(\n input_size,\n latent_size if i != self.num_layers - 1 else self.num_classes,\n heads=8 if i != self.num_layers - 1 else 1, concat=True,\n reparam_mode=self.reparam_mode if is_reparam else None,\n prior_mode=self.prior_mode if is_reparam else None,\n val_use_mean=self.val_use_mean,\n struct_dropout_mode=self.struct_dropout_mode,\n sample_size=self.sample_size,\n ))\n # On the Pubmed dataset, use heads=8 in conv2.\n \n else:\n raise Exception(\"Model_type {} is not valid!\".format(self.model_type))\n\n self.reparam_layers = sorted(self.reparam_layers)\n \n if self.model_type == \"GCN\":\n if self.with_relu:\n reg_params = [getattr(self, \"conv{}\".format(i+1)).parameters() for i in range(self.num_layers - 1)]\n self.reg_params = itertools.chain(*reg_params)\n self.non_reg_params = getattr(self, \"conv{}\".format(self.num_layers)).parameters()\n else:\n self.reg_params = OrderedDict()\n self.non_reg_params = self.parameters()\n else:\n self.reg_params = self.parameters()\n self.non_reg_params = OrderedDict()\n self.to(self.device)","def testTransposeNDHWC(self, use_bias):\n\n conv3_transpose = snt.Conv3DTranspose(\n output_channels=self.out_channels,\n output_shape=self.out_shape,\n kernel_shape=self.kernel_shape,\n padding=self.padding,\n stride=self.strides,\n name=\"conv3_transpose\",\n use_bias=use_bias,\n data_format=conv.DATA_FORMAT_NDHWC)\n conv3 = conv3_transpose.transpose()\n\n # Check kernel shapes, strides and padding match.\n self.assertEqual(conv3_transpose.kernel_shape, conv3.kernel_shape)\n self.assertEqual((1,) + self.strides + (1,), conv3.stride)\n self.assertEqual(conv3_transpose.padding, conv3.padding)\n\n # Before conv3_transpose is connected, we cannot know how many\n # `output_channels` conv1 should have.\n err = \"Variables in conv3_transpose not instantiated yet\"\n with self.assertRaisesRegexp(snt.NotConnectedError, err):\n _ = conv3.output_channels\n\n # After connection the number of `output_channels` is known.\n x = tf.constant(np.random.randn(self.batch_size,\n self.in_depth,\n self.in_height,\n self.in_width,\n self.in_channels),\n dtype=np.float32)\n conv3_transpose(x)\n self.assertEqual(self.in_channels, conv3.output_channels)\n\n # However, even after connection, the `input_shape` of the forward\n # convolution is not known until it is itself connected (i.e. it can be\n # connected to a different shape input from the `output_shape` of the\n # transpose convolution!)\n err = \"Variables in conv3_transpose_transpose not instantiated yet\"\n with self.assertRaisesRegexp(snt.NotConnectedError, err):\n self.assertEqual(conv3_transpose.output_shape, conv3.input_shape)","def _cnn(self, state):\n\n x = self.relu(self.bn1(self.conv1(state)))\n x = self.relu(self.bn2(self.conv2(x)))\n x = self.relu(self.bn3(self.conv3(x)))\n x = x.reshape(x.size(0), -1)\n\n return x"],"string":"[\n \"def transpose(incoming, conv, nonlinearity, *args, **kwargs):\\n return TransposedConv2DLayer(incoming, conv.input_shape[1],\\n conv.filter_size, stride=conv.stride,\\n crop=conv.pad, W=conv.W,\\n flip_filters=not conv.flip_filters,\\n nonlinearity=nonlinearity, *args,\\n **kwargs)\",\n \"def create(self) -> None:\\n if self.torch is not None: # type: ignore\\n return\\n self.torch = torch.nn.ConvTranspose2d(**self.args.arg_values)\",\n \"def TCN(input_dim): \\r\\n # Number of dilations in order to use for the temporal blocks.\\r\\n dilations = np.array([1, 2, 4, 8, 16, 32])\\r\\n\\r\\n input_dim.insert(0,1)\\r\\n print(f\\\"input_dim: {input_dim}\\\")\\r\\n input_layer = Input(shape=input_dim)\\r\\n cropping = 0\\r\\n assert (sum(dilations) * block_size + 1) == 127, \\\"Paper specifies receptive field size should be 127\\\"\\r\\n \\r\\n prev_layer, skip_layer, _ = add_temporal_block(input_layer, None, 1, 1, cropping)\\r\\n \\r\\n for dilation in dilations:\\r\\n prev_layer, skip_layer, cropping = add_temporal_block(prev_layer, skip_layer, 2, dilation, cropping)\\r\\n\\r\\n output_layer = PReLU(shared_axes=[2, 3])(skip_layer)\\r\\n output_layer = SpectralNormalization(Conv1D(fixed_filters, kernel_size=1))(output_layer)\\r\\n output_layer = PReLU(shared_axes=[2, 3])(output_layer)\\r\\n output_layer = SpectralNormalization(Conv1D(1, kernel_size=1))(output_layer)\\r\\n\\r\\n return Model(input_layer, output_layer)\",\n \"def convt_block(layer, concat, fsize, name):\\n with tf.variable_scope(name):\\n\\n layer = tf.layers.conv2d_transpose(layer, filters=fsize, kernel_size=2, strides=2, \\n kernel_regularizer=l2_reg(1e-1), name='convt')\\n layer = tf.concat([layer, concat], axis=-1, name='concat')\\n\\n return layer\",\n \"def CustomConv3DTranspose(x_in, nf, strides=2, kernel_size = 3):\\r\\n\\tx_out = Conv3DTranspose(nf, kernel_size=3, padding='same',kernel_initializer='he_normal', strides=strides)(x_in)\\r\\n\\t#print(\\\"AAAAA\\\", x_out.shape)\\r\\n\\tx_out = BatchNormalization()(x_out)\\r\\n\\tx_out = LeakyReLU(0.2)(x_out)\\r\\n\\treturn x_out\",\n \"def __init__(\\n self,\\n *,\\n input_dims: Union[List[int], Tuple[int]],\\n cnn_transpose_filter_specifiers: List[List[Union[int, List]]],\\n cnn_transpose_use_bias: bool = True,\\n cnn_transpose_activation: Optional[str] = \\\"relu\\\",\\n cnn_transpose_use_layernorm: bool = False,\\n ):\\n super().__init__()\\n\\n assert len(input_dims) == 3\\n\\n cnn_transpose_activation = get_activation_fn(\\n cnn_transpose_activation, framework=\\\"tf2\\\"\\n )\\n\\n layers = []\\n\\n # Input layer.\\n layers.append(tf.keras.layers.Input(shape=input_dims))\\n\\n for i, (num_filters, kernel_size, strides) in enumerate(\\n cnn_transpose_filter_specifiers\\n ):\\n is_final_layer = i == len(cnn_transpose_filter_specifiers) - 1\\n layers.append(\\n tf.keras.layers.Conv2DTranspose(\\n filters=num_filters,\\n kernel_size=kernel_size,\\n strides=strides,\\n padding=\\\"same\\\",\\n # Last layer is never activated (regardless of config).\\n activation=(\\n None\\n if cnn_transpose_use_layernorm or is_final_layer\\n else cnn_transpose_activation\\n ),\\n # Last layer always uses bias (b/c has no LayerNorm, regardless of\\n # config).\\n use_bias=cnn_transpose_use_bias or is_final_layer,\\n )\\n )\\n if cnn_transpose_use_layernorm and not is_final_layer:\\n # Use epsilon=1e-5 here (instead of default 1e-3) to be unified with\\n # torch. Need to normalize over all axes.\\n layers.append(\\n tf.keras.layers.LayerNormalization(axis=[-3, -2, -1], epsilon=1e-5)\\n )\\n layers.append(tf.keras.layers.Activation(cnn_transpose_activation))\\n\\n # Create the final CNNTranspose network.\\n self.cnn_transpose = tf.keras.Sequential(layers)\\n\\n self.expected_input_dtype = tf.float32\",\n \"def conv2d_transpose(self, output_shape, filter_):\\n return self.add_layer(conv2d_transpose, output_shape, filter_)\",\n \"def copy_conv(sess, tftensor, layer):\\n\\n W = sess.graph.get_tensor_by_name('{}/conv2d_params:0'.format(tftensor)).eval()\\n W = W.transpose((3, 2, 0, 1))\\n\\n assert W.shape == layer.W.data.shape\\n\\n layer.W.data = W\",\n \"def test_transposed_conv2d_model(self):\\n tf.compat.v1.reset_default_graph()\\n\\n _ = transposed_conv2d_model()\\n\\n conn_graph = ConnectedGraph(tf.compat.v1.get_default_graph(), ['input_1'], ['conv2d_transpose/BiasAdd'])\\n self.assertEqual(conn_graph.get_all_ops()['conv2d_transpose/conv2d_transpose'].type, 'Conv2DTranspose')\",\n \"def __init__(self, img_size, latent_dim=10):\\n super(DecoderBurgess, self).__init__()\\n\\n # Layer parameters\\n hid_channels = 32\\n kernel_size = 4\\n hidden_dim = 256\\n self.img_size = img_size\\n # Shape required to start transpose convs\\n self.reshape = (hid_channels, kernel_size, kernel_size)\\n n_chan = self.img_size[0]\\n self.img_size = img_size\\n\\n # Fully connected layers\\n self.lin1 = nn.Linear(latent_dim, hidden_dim)\\n self.lin2 = nn.Linear(hidden_dim, hidden_dim)\\n self.lin3 = nn.Linear(hidden_dim, np.product(self.reshape))\\n\\n # Convolutional layers\\n cnn_kwargs = dict(stride=2, padding=1)\\n # If input image is 64x64 do fourth convolution\\n if self.img_size[1] == self.img_size[2] == 64:\\n self.convT_64 = nn.ConvTranspose2d(\\n hid_channels, hid_channels, kernel_size, **cnn_kwargs\\n )\\n\\n self.convT1 = nn.ConvTranspose2d(\\n hid_channels, hid_channels, kernel_size, **cnn_kwargs\\n )\\n self.convT2 = nn.ConvTranspose2d(\\n hid_channels, hid_channels, kernel_size, **cnn_kwargs\\n )\\n self.convT3 = nn.ConvTranspose2d(\\n hid_channels, n_chan, kernel_size, **cnn_kwargs\\n )\",\n \"def __init__(self, img_size,\\n latent_dim=10):\\n super(DecoderBurgess, self).__init__()\\n\\n # Layer parameters\\n hid_channels = 32\\n kernel_size = 4\\n hidden_dim = 256\\n self.img_size = img_size\\n # Shape required to start transpose convs\\n self.reshape = (hid_channels, kernel_size, kernel_size)\\n n_chan = self.img_size[0]\\n self.img_size = img_size\\n\\n # Fully connected layers\\n self.lin1 = nn.Linear(latent_dim, hidden_dim)\\n self.lin2 = nn.Linear(hidden_dim, hidden_dim)\\n self.lin3 = nn.Linear(hidden_dim, np.product(self.reshape))\\n\\n # Convolutional layers\\n cnn_kwargs = dict(stride=2, padding=1)\\n # If input image is 64x64 do fourth convolution\\n if self.img_size[1] == self.img_size[2] == 64:\\n self.convT_64 = nn.ConvTranspose2d(\\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\\n\\n self.convT1 = nn.ConvTranspose2d(\\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\\n self.convT2 = nn.ConvTranspose2d(\\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\\n self.convT3 = nn.ConvTranspose2d(\\n hid_channels, n_chan, kernel_size, **cnn_kwargs)\",\n \"def convert_conv2d_transpose(g, op, block):\\n\\n dilations = op.attr(\\\"dilations\\\")\\n groups = op.attr(\\\"groups\\\")\\n paddings = op.attr(\\\"paddings\\\")\\n padding_algorithm = op.attr(\\\"padding_algorithm\\\")\\n strides = op.attr(\\\"strides\\\")\\n output_padding = op.attr(\\\"output_padding\\\") if op.attr(\\\"output_padding\\\") else [0, 0]\\n\\n kernel = g.get_node(op.input(\\\"Filter\\\")[0])\\n input_x = g.get_node(op.input(\\\"Input\\\")[0])\\n _, out_channels, k_h, k_w = infer_shape(kernel)\\n k_size = [k_h, k_w]\\n if padding_algorithm == \\\"VALID\\\":\\n paddings = [0, 0]\\n elif padding_algorithm == \\\"SAME\\\":\\n # SAME padding of conv2d_transpose is not same with conv2d\\n # We cannot use auto_pad here, only static shape is supported now\\n dilations = [1, 1]\\n input_shape = shape_of(input_x)\\n h_w = _op.strided_slice(input_shape, [2], [4])\\n try:\\n h_w = infer_value(h_w, g.get_params()).numpy().tolist()\\n except Exception as e:\\n msg = \\\"The SAME padding algorithm of conv2d_transpose not support dynamic shape\\\"\\n raise tvm.error.OpAttributeInvalid(msg) from e\\n paddings = []\\n for i in range(2):\\n if strides[i] == 1 or h_w[i] % strides[i] == 0:\\n pad = max(k_size[i] - strides[i], 0)\\n else:\\n pad = max(k_size[i] - (h_w[i] % strides[i]), 0)\\n pad_before = pad // 2\\n pad_after = pad - pad_before\\n paddings.insert(-1, pad_before)\\n paddings.append(pad_after)\\n elif padding_algorithm == \\\"EXPLICIT\\\":\\n if len(paddings) == 2:\\n paddings = [paddings[0], paddings[1], paddings[0], paddings[1]]\\n elif len(paddings) == 4:\\n paddings = [paddings[0], paddings[2], paddings[1], paddings[3]]\\n else:\\n msg = f'Value {padding_algorithm} in attribute \\\"padding\\\" of operator Conv is not \\\"valid.\\\"'\\n raise tvm.error.OpAttributeInvalid(msg)\\n\\n out = _op.nn.conv2d_transpose(\\n input_x,\\n kernel,\\n strides=strides,\\n padding=paddings,\\n dilation=dilations,\\n groups=groups,\\n channels=out_channels * groups,\\n kernel_size=k_size,\\n output_padding=output_padding,\\n )\\n g.add_node(op.output(\\\"Output\\\")[0], out)\",\n \"def __init__(self, img_size,\\n latent_dim=10):\\n \\n super(DecoderRezendeViola, self).__init__()\\n\\n # Layer parameters\\n hid_channels = 32\\n kernel_size = 4\\n hidden_dim = 256\\n self.img_size = img_size\\n # Shape required to start transpose convs\\n self.reshape = (hid_channels, kernel_size, kernel_size)\\n n_chan = self.img_size[0]\\n self.img_size = img_size\\n\\n # Fully connected layers\\n self.lin1 = nn.Linear(latent_dim, hidden_dim)\\n self.lin2 = nn.Linear(hidden_dim, hidden_dim)\\n self.lin3 = nn.Linear(hidden_dim, np.product(self.reshape))\\n\\n # Convolutional layers\\n cnn_kwargs = dict(stride=2, padding=1)\\n # If input image is 64x64 do fourth convolution\\n if self.img_size[1] == self.img_size[2] == 64:\\n self.convT_64 = nn.ConvTranspose2d(\\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\\n\\n self.convT1 = nn.ConvTranspose2d(\\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\\n self.convT2 = nn.ConvTranspose2d(\\n hid_channels, hid_channels, kernel_size, **cnn_kwargs)\\n self.convT3 = nn.ConvTranspose2d(\\n hid_channels, 2 * n_chan, kernel_size, **cnn_kwargs)\",\n \"def conv_transpose1d(self, kernel, **kwargs):\\n raise NotImplementedError(\\\"conv_transpose1d is not implemented\\\")\",\n \"def _create_conv_pool(cls, op, op_t):\\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\\n\\n k = [op.handle.kernel_h, op.handle.kernel_w]\\n s = [op.handle.stride_h, op.handle.stride_w]\\n oddp = op.odd_padding\\n p = [\\n op.handle.pad_h + oddp[0],\\n op.handle.pad_w + oddp[1],\\n op.handle.pad_w + oddp[2],\\n op.handle.pad_h + oddp[3],\\n ]\\n\\n node.attribute.extend([\\n helper.make_attribute('kernel_shape', k),\\n helper.make_attribute('pads', p),\\n helper.make_attribute('strides', s),\\n ])\\n if cls._get_singa_op_type(op) == '_Conv2d':\\n node.op_type = cls._rename_operators.get('_Conv2d')\\n node.attribute.extend([\\n helper.make_attribute('group', op.handle.group),\\n helper.make_attribute('auto_pad', 'NOTSET'),\\n ])\\n\\n elif op.handle.is_max_pooling:\\n node.op_type = cls._rename_operators.get('MaxPool2d')\\n else:\\n node.op_type = cls._rename_operators.get('AvgPool2d')\\n return node\",\n \"def __init__(self, in_channels, out_channels, kernel_size, num_layers=3,\\n use_conv_transpose=True):\\n super().__init__()\\n\\n _validate_args(in_channels, out_channels, kernel_size, num_layers)\\n\\n self.kernel_size = kernel_size\\n self.use_conv_transpose = use_conv_transpose\\n\\n self.padding = (kernel_size-1)//2\\n\\n # All deconv blocks must contain at least one block mapping the\\n # number of input channels to the number of output channels\\n conv_list = [\\n self._create_single_block(in_channels, out_channels)\\n ]\\n\\n # Create the rest of the blocks\\n for _ in range(num_layers - 1):\\n conv_list.append(\\n self._create_single_block(out_channels, out_channels)\\n )\\n\\n self.convs = nn.Sequential(*conv_list)\\n self.pool = nn.MaxUnpool2d((2, 2))\",\n \"def conv_transpose2d(self, kernel, **kwargs):\\n raise NotImplementedError(\\\"conv_transpose2d is not implemented\\\")\",\n \"def __call__(self, inputs):\\n with tf.variable_scope('conv_t_{}'.format(self.idx)):\\n activation_fn = get_act_fn(self.act_fn)\\n\\n if self.cfg.VAR_ON_CPU:\\n kernels = variable_on_cpu(\\n name='kernels',\\n shape=[self.kernel_size, self.kernel_size,\\n self.n_kernel, inputs.get_shape().as_list()[3]],\\n initializer=self.w_init_fn,\\n dtype=tf.float32)\\n conv_t = tf.nn.conv2d_transpose(\\n value=inputs,\\n filter=kernels,\\n output_shape=self.output_shape,\\n strides=[1, self.stride, self.stride, 1],\\n padding=self.padding)\\n\\n if self.use_bias:\\n biases = variable_on_cpu(\\n name='biases',\\n shape=[self.n_kernel],\\n initializer=tf.zeros_initializer(),\\n dtype=tf.float32)\\n conv_t = tf.nn.bias_add(conv_t, biases)\\n\\n if activation_fn is not None:\\n conv_t = activation_fn(conv_t)\\n\\n else:\\n biases_initializer = tf.zeros_initializer() if self.use_bias else None\\n conv_t = tf.contrib.layers.conv2d_transpose(\\n inputs=inputs,\\n num_outputs=self.n_kernel,\\n kernel_size=self.kernel_size,\\n stride=self.stride,\\n padding=self.padding,\\n activation_fn=activation_fn,\\n weights_initializer=self.w_init_fn,\\n biases_initializer=biases_initializer)\\n\\n return conv_t\",\n \"def __init__(self,\\n intermediate_channels,\\n output_channels,\\n pred_key,\\n name,\\n conv_type='depthwise_separable_conv',\\n bn_layer=tf.keras.layers.BatchNormalization):\\n super(PanopticDeepLabSingleHead, self).__init__(name=name)\\n self._pred_key = pred_key\\n\\n self.conv_block = convolutions.StackedConv2DSame(\\n conv_type=conv_type,\\n num_layers=1,\\n output_channels=intermediate_channels,\\n kernel_size=5,\\n name='conv_block',\\n use_bias=False,\\n use_bn=True,\\n bn_layer=bn_layer,\\n activation='relu')\\n self.final_conv = layers.Conv2D(\\n output_channels,\\n kernel_size=1,\\n name='final_conv',\\n kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.01))\",\n \"def __init__(self, in_channels, out_channels, kernel_size, padding=0, **kwargs):\\n ConstrainedLayer.__init__(self, nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding, bias=False), **kwargs)\",\n \"def _conv2d_transpose_block(in_f, out_f, *args, **kwargs):\\n return nn.Sequential(\\n nn.ConvTranspose2d(in_f, out_f, *args, **kwargs),\\n nn.BatchNorm2d(out_f),\\n nn.ReLU(),\\n nn.Dropout2d(p=0.2)\\n )\",\n \"def __init__(\\n self,\\n in_shape: Tuple,\\n kernel_size: int,\\n out_channels: int = None,\\n stride: int = 1,\\n aux_shape: Optional[Tuple] = None,\\n downsampling_mode: str = \\\"convolutional\\\",\\n upsampling_mode: str = \\\"convolutional\\\",\\n transposed: bool = False,\\n residual: bool = True,\\n weightnorm: bool = True,\\n gated: bool = True,\\n activation: nn.Module = nn.ReLU,\\n dropout: Optional[float] = None,\\n ):\\n super().__init__(in_shape=in_shape, transposed=transposed, residual=residual, aux_shape=aux_shape)\\n\\n # some parameters\\n self.channels_in = in_shape[0]\\n self.channels_out = out_channels\\n self.kernel_size = kernel_size\\n self.stride = stride\\n self.resample_mode = upsampling_mode if transposed else downsampling_mode\\n self.transposed = transposed\\n self.residual = residual\\n self.gated = gated\\n self.activation_pre = activation() if self.residual else None\\n\\n # first convolution is always non-transposed and stride 1\\n self.conv1 = TransposeableNormedSameConv2d(\\n in_shape=in_shape,\\n out_channels=out_channels,\\n kernel_size=kernel_size,\\n stride=1,\\n transposed=False,\\n resample_mode=\\\"convolutional\\\",\\n weightnorm=weightnorm,\\n )\\n\\n # aux op\\n if aux_shape is not None:\\n self.activation_aux = activation()\\n\\n if list(aux_shape[1:]) > list(self.conv1.out_shape[1:]):\\n # Downsample height and width (and match channels)\\n aux_stride = tuple(np.asarray(aux_shape[1:]) // np.asarray(self.conv1.out_shape[1:]))\\n self.aux_op = TransposeableNormedSameConv2d(\\n in_shape=aux_shape,\\n out_channels=self.conv1.out_shape[0],\\n kernel_size=kernel_size,\\n stride=aux_stride,\\n transposed=False,\\n resample_mode=self.resample_mode,\\n weightnorm=weightnorm,\\n )\\n elif list(aux_shape[1:]) < list(self.conv1.out_shape[1:]):\\n # Upsample height and width (and match channels)\\n aux_stride = tuple(np.asarray(self.conv1.out_shape[1:]) // np.asarray(aux_shape[1:]))\\n self.aux_op = TransposeableNormedSameConv2d(\\n in_shape=aux_shape,\\n out_channels=self.conv1.out_shape[0],\\n kernel_size=kernel_size,\\n stride=aux_stride,\\n transposed=True,\\n resample_mode=self.resample_mode,\\n weightnorm=weightnorm,\\n )\\n elif aux_shape[0] != self.conv1.out_shape[0]:\\n # Change only channels using 1x1 convolution\\n self.aux_op = TransposeableNormedSameConv2d(\\n in_shape=aux_shape,\\n out_channels=self.conv1.out_shape[0],\\n kernel_size=1,\\n stride=1,\\n transposed=False,\\n resample_mode=self.resample_mode,\\n weightnorm=weightnorm,\\n )\\n else:\\n # aux_shape and out_shape are the same\\n assert aux_shape == self.conv1.out_shape\\n self.aux_op = None\\n else:\\n self.aux_op = None\\n\\n self.activation_mid = activation()\\n\\n # dropout\\n self.dropout = nn.Dropout(dropout) if dropout else dropout\\n\\n # second convolution is potentially transposed and potentially resampling\\n gated_channels = 2 * out_channels if self.gated else out_channels\\n self.conv2 = TransposeableNormedSameConv2d(\\n in_shape=self.conv1.out_shape,\\n out_channels=gated_channels,\\n kernel_size=kernel_size,\\n stride=self.stride,\\n weightnorm=weightnorm,\\n transposed=transposed,\\n resample_mode=self.resample_mode,\\n ) # doubled out channels for gating\\n\\n # output shape\\n self._out_shape = (out_channels, *self.conv2.out_shape[1:]) # always out_channels regardless of gating\\n\\n # residual connections\\n self.residual_op = ResidualConnectionConv2d(self._in_shape, self._out_shape, residual)\",\n \"def BasicConv3d(in_planes, out_planes, kernel_size, stride=(1, 1, 1), padding=(0, 0, 0),\\n bias=False, dw_t_conv=False):\\n return nn.Conv3d(in_planes, out_planes, kernel_size=kernel_size,\\n stride=stride, padding=padding, bias=bias,\\n groups=in_planes if dw_t_conv else 1)\",\n \"def intermediate_layer(layer, filters, kernel_size):\\n layer = Conv2D(filters=filters, kernel_size=kernel_size,\\n strides=(2, 2), padding=\\\"same\\\")(layer)\\n layer = LeakyReLU(alpha=LEAKY_RELU_ALPHA)(layer)\\n return layer\",\n \"def conv_2d_transpose(incoming, nb_filter, filter_size, output_shape,\\n strides=1, padding='same', activation='linear',\\n bias=True, weights_init='uniform_scaling',\\n bias_init='zeros', regularizer=None, weight_decay=0.001,\\n trainable=True, restore=True, name=\\\"Conv2DTranspose\\\"):\\n assert padding in ['same', 'valid', 'SAME', 'VALID'], \\\\\\n \\\"Padding must be same' or 'valid'\\\"\\n\\n input_shape = utils.get_incoming_shape(incoming)\\n assert len(input_shape) == 4, \\\"Incoming Tensor shape must be 4-D\\\"\\n\\n filter_size = utils.autoformat_filter_conv2d(filter_size,\\n nb_filter,\\n input_shape[-1])\\n strides = utils.autoformat_kernel_2d(strides)\\n padding = utils.autoformat_padding(padding)\\n\\n with tf.name_scope(name) as scope:\\n\\n W_init = initializations.get(weights_init)()\\n W_regul = None\\n if regularizer:\\n W_regul = lambda x: losses.get(regularizer)(x, weight_decay)\\n W = vs.variable(scope + 'W', shape=filter_size,\\n regularizer=W_regul, initializer=W_init,\\n trainable=trainable, restore=restore)\\n # Track per layer variables\\n tf.add_to_collection(tf.GraphKeys.LAYER_VARIABLES + '/' + scope, W)\\n\\n b = None\\n if bias:\\n b_init = initializations.get(bias_init)()\\n b = vs.variable(scope + 'b', shape=nb_filter,\\n initializer=b_init, trainable=trainable,\\n restore=restore)\\n # Track per layer variables\\n tf.add_to_collection(tf.GraphKeys.LAYER_VARIABLES + '/' + scope, b)\\n\\n # Determine the complete shape of the output tensor.\\n batch_size = tf.gather(tf.shape(incoming), tf.constant([0]))\\n if len(output_shape) == 2:\\n output_shape = output_shape + [nb_filter]\\n elif len(output_shape) != 3:\\n raise Exception(\\\"output_shape length error: \\\" \\n + str(len(output_shape))\\n + \\\", only a length of 2 or 3 is supported.\\\")\\n complete_out_shape = tf.concat(0, [batch_size, tf.constant(output_shape)])\\n \\n inference = tf.nn.conv2d_transpose(incoming, W, complete_out_shape,\\n strides, padding)\\n \\n # Reshape tensor so its shape is correct.\\n inference.set_shape([None] + output_shape)\\n\\n if b: inference = tf.nn.bias_add(inference, b)\\n\\n if isinstance(activation, str):\\n inference = activations.get(activation)(inference)\\n elif hasattr(activation, '__call__'):\\n inference = activation(inference)\\n else:\\n raise ValueError(\\\"Invalid Activation.\\\")\\n\\n # Track activations.\\n tf.add_to_collection(tf.GraphKeys.ACTIVATIONS, inference)\\n\\n # Add attributes to Tensor to easy access weights.\\n inference.scope = scope\\n inference.W = W\\n inference.b = b\\n\\n return inference\",\n \"def __init__(self, last_channels, this_channels, repeat_time, max_pool = False):\\n super().__init__()\\n\\n self.repeat_time = repeat_time\\n self.activate = nn.SELU()\\n self.bn = nn.BatchNorm2d\\n self.max_pool = None\\n\\n if max_pool:\\n self.max_pool = nn.MaxPool2d(3, 2, 1)\\n else:\\n self.conv1_1 = nn.Sequential(\\n nn.Conv2d(last_channels, this_channels, 3, stride=2, padding=1),\\n self.bn(this_channels),\\n )\\n self.conv1_2 = nn.Sequential(\\n nn.Conv2d(this_channels, this_channels, 3, stride=1, padding=1),\\n self.bn(this_channels),\\n )\\n\\n self.conv2 = nn.Sequential(\\n nn.Conv2d(this_channels, this_channels, 3, stride=1, padding=1),\\n self.bn(this_channels),\\n self.activate,\\n nn.Conv2d(this_channels, this_channels, 3, stride=1, padding=1),\\n self.bn(this_channels),\\n )\",\n \"def __init__(self, channel_in, channel_out, kernel_size, stride, padding, output_padding=0):\\n super().__init__()\\n self.block = nn.Sequential(\\n nn.ConvTranspose2d(channel_in, channel_out, kernel_size, stride, padding, output_padding),\\n nn.BatchNorm2d(channel_out)\\n )\\n self.act = nn.ReLU()\",\n \"def _init_layers(self) -> None:\\n self.relu = nn.ReLU(inplace=True)\\n self.cls_convs = nn.ModuleList()\\n self.reg_convs = nn.ModuleList()\\n for i in range(self.stacked_convs):\\n chn = self.in_channels if i == 0 else self.feat_channels\\n self.cls_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.reg_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n pred_pad_size = self.pred_kernel_size // 2\\n self.atss_cls = nn.Conv2d(\\n self.feat_channels,\\n self.num_anchors * self.cls_out_channels,\\n self.pred_kernel_size,\\n padding=pred_pad_size)\\n self.atss_reg = nn.Conv2d(\\n self.feat_channels,\\n self.num_base_priors * 4,\\n self.pred_kernel_size,\\n padding=pred_pad_size)\\n self.atss_centerness = nn.Conv2d(\\n self.feat_channels,\\n self.num_base_priors * 1,\\n self.pred_kernel_size,\\n padding=pred_pad_size)\\n self.scales = nn.ModuleList(\\n [Scale(1.0) for _ in self.prior_generator.strides])\",\n \"def pretrained_conv_layer(name, input_tensor, params):\\n with tf.name_scope(name):\\n weights = tf.constant(params[name+'_W'])\\n biases = tf.constant(params[name+'_b'])\\n\\n conv = tf.nn.conv2d(input=input_tensor,\\n filter=weights,\\n strides=[1, 1, 1, 1],\\n padding='SAME',\\n name='convolution')\\n\\n preactivations = tf.nn.bias_add(conv, biases, name='bias_addition')\\n activations = tf.nn.relu(preactivations, name='activation')\\n return activations\",\n \"def _append_conv_layer(self, param):\\n self._parameterized_conv_layers.append(\\n tf.keras.layers.Conv3D(\\n padding='same',\\n use_bias=False,\\n kernel_regularizer=self._kernel_regularizer,\\n **param,\\n ))\\n norm_layer_params = self._build_norm_layer_params(param)\\n self._parameterized_conv_layers.append(self._norm(**norm_layer_params))\\n\\n relu_layer_params = self._build_activation_layer_params(param)\\n self._parameterized_conv_layers.append(\\n tf.keras.layers.Activation('relu', **relu_layer_params))\",\n \"def __init__(self, img_size, latent_dim=10):\\n super(EncoderBurgess, self).__init__()\\n\\n # Layer parameters\\n hid_channels = 32\\n kernel_size = 4\\n hidden_dim = 256\\n self.latent_dim = latent_dim\\n self.img_size = img_size\\n # Shape required to start transpose convs\\n self.reshape = (hid_channels, kernel_size, kernel_size)\\n n_chan = self.img_size[0]\\n\\n # Convolutional layers\\n cnn_kwargs = dict(stride=2, padding=1)\\n self.conv1 = nn.Conv2d(n_chan, hid_channels, kernel_size, **cnn_kwargs)\\n self.conv2 = nn.Conv2d(hid_channels, hid_channels, kernel_size, **cnn_kwargs)\\n self.conv3 = nn.Conv2d(hid_channels, hid_channels, kernel_size, **cnn_kwargs)\\n\\n # If input image is 64x64 do fourth convolution\\n if self.img_size[1] == self.img_size[2] == 64:\\n self.conv_64 = nn.Conv2d(\\n hid_channels, hid_channels, kernel_size, **cnn_kwargs\\n )\\n\\n # Fully connected layers\\n self.lin1 = nn.Linear(np.product(self.reshape), hidden_dim)\\n self.lin2 = nn.Linear(hidden_dim, hidden_dim)\\n\\n # Fully connected layers for mean and variance\\n self.mu_logvar_gen = nn.Linear(hidden_dim, self.latent_dim * 2)\",\n \"def __init__(self, incoming, W=None, b=tf.zeros, ksize: int = None, num_outputs: int = None,\\n weight_initializer=None, a=tf.nn.elu, strides=(1, 1, 1, 1), padding='ZEROPAD', dilation_rate=(1, 1),\\n name='ConvLayer'):\\n super(ConvLayer, self).__init__()\\n with tf.variable_scope(name) as self.layer_scope:\\n self.incoming, self.incoming_shape = get_input(incoming)\\n \\n # Set init for W and b\\n if all(p is not None for p in [weight_initializer, ksize, num_outputs]):\\n W = tofov(weight_initializer, shape=(ksize, ksize, self.incoming_shape[-1], num_outputs),\\n var_params=dict(name='W_conv'))\\n else:\\n W = tofov(W, shape=None, var_params=dict(name='W_conv'))\\n ksize = W.get_shape()[0].value\\n if b is not None:\\n b = tofov(b, shape=W.get_shape().as_list()[-1], var_params=dict(name='b_conv'))\\n \\n self.a = a\\n self.b = b\\n self.W = W\\n self.padding = padding\\n self.strides = strides\\n self.dilation_rate = dilation_rate\\n \\n self.out = None\\n self.name = name\",\n \"def declaration_conv2d_transpose_impl(data, kernel, strides, padding, out_dtype):\\n data_pad, kernel_transform = \\\\\\n conv2d_transpose_nchw_preprocess(data, kernel, strides, padding, out_dtype)\\n batch, in_c, in_h, in_w = data_pad.shape\\n out_c, _, filter_h, filter_w = kernel_transform.shape\\n stride_h, stride_w = strides\\n\\n # convolution stage\\n out_c = simplify(out_c)\\n out_h = simplify(in_h - filter_h + 1)\\n out_w = simplify(in_w - filter_w + 1)\\n dc = tvm.reduce_axis((0, in_c), name='dc')\\n dh = tvm.reduce_axis((0, filter_h), name='dh')\\n dw = tvm.reduce_axis((0, filter_w), name='dw')\\n\\n Output = tvm.compute(\\n (batch, out_c, out_h, out_w),\\n lambda b, c, h, w: tvm.sum(\\n data_pad[b, dc, h+dh, w+dw].astype(out_dtype) *\\n kernel_transform[c, dc, dh, dw].astype(out_dtype),\\n axis=[dc, dh, dw]), tag=\\\"conv2d_transpose_nchw\\\")\\n\\n return Output\",\n \"def _conv_transpose(\\n conv_type,\\n nd_util,\\n input,\\n weight,\\n bias=None,\\n stride=1,\\n padding=0,\\n output_padding=0,\\n groups=1,\\n dilation=1,\\n):\\n weight_shape = list(weight.shape)\\n return FunctionLib.apply(\\n conv_type,\\n input.device,\\n [input, weight] + ([bias] if bias else []),\\n in_channels=weight_shape[0],\\n out_channels=weight_shape[1],\\n kernel_shape=weight_shape[2:],\\n strides=nd_util(stride),\\n pads=nd_util(padding),\\n dilations=nd_util(dilation),\\n group=groups,\\n output_padding=nd_util(output_padding),\\n bias=bias is not None,\\n dtype=weight.dtype,\\n input_shape=list(input.shape),\\n )\",\n \"def _conv2d(self, prev_layer, layer_idx, layer_name):\\n W, b = self._weights(layer_idx, layer_name)\\n W = tf.constant(W)\\n b = tf.constant(np.reshape(b, (b.size)))\\n return tf.nn.conv2d(prev_layer, filter=W, strides=[1, 1, 1, 1], padding='SAME') + b\",\n \"def _init_layers(self) -> None:\\n super()._init_layers()\\n self.controller = nn.Conv2d(\\n self.feat_channels, self.num_params, 3, padding=1)\",\n \"def __init__(self,\\n channels: int,\\n kernel_size: int=15,\\n activation: nn.Layer=nn.ReLU(),\\n norm: str=\\\"batch_norm\\\",\\n causal: bool=False,\\n bias: bool=True,\\n adaptive_scale: bool=False,\\n init_weights: bool=False):\\n assert check_argument_types()\\n super().__init__()\\n self.bias = bias\\n self.channels = channels\\n self.kernel_size = kernel_size\\n self.adaptive_scale = adaptive_scale\\n if self.adaptive_scale:\\n ada_scale = self.create_parameter(\\n [1, 1, channels], default_initializer=I.Constant(1.0))\\n self.add_parameter('ada_scale', ada_scale)\\n ada_bias = self.create_parameter(\\n [1, 1, channels], default_initializer=I.Constant(0.0))\\n self.add_parameter('ada_bias', ada_bias)\\n\\n self.pointwise_conv1 = Conv1D(\\n channels,\\n 2 * channels,\\n kernel_size=1,\\n stride=1,\\n padding=0,\\n bias_attr=None\\n if bias else False, # None for True, using bias as default config\\n )\\n\\n # self.lorder is used to distinguish if it's a causal convolution,\\n # if self.lorder > 0:\\n # it's a causal convolution, the input will be padded with\\n # `self.lorder` frames on the left in forward (causal conv impl).\\n # else: it's a symmetrical convolution\\n if causal:\\n padding = 0\\n self.lorder = kernel_size - 1\\n else:\\n # kernel_size should be an odd number for none causal convolution\\n assert (kernel_size - 1) % 2 == 0\\n padding = (kernel_size - 1) // 2\\n self.lorder = 0\\n\\n self.depthwise_conv = Conv1D(\\n channels,\\n channels,\\n kernel_size,\\n stride=1,\\n padding=padding,\\n groups=channels,\\n bias_attr=None\\n if bias else False, # None for True, using bias as default config\\n )\\n\\n assert norm in ['batch_norm', 'layer_norm']\\n if norm == \\\"batch_norm\\\":\\n self.use_layer_norm = False\\n self.norm = BatchNorm1D(channels)\\n else:\\n self.use_layer_norm = True\\n self.norm = LayerNorm(channels)\\n\\n self.pointwise_conv2 = Conv1D(\\n channels,\\n channels,\\n kernel_size=1,\\n stride=1,\\n padding=0,\\n bias_attr=None\\n if bias else False, # None for True, using bias as default config\\n )\\n self.activation = activation\\n\\n if init_weights:\\n self.init_weights()\",\n \"def _dense_connect_layer(self, input_data, name):\\n with tf.variable_scope(name):\\n conv_out = self._composite_conv(input_data=input_data, out_channel=self._growth_rate,\\n name='composite_conv')\\n concate_cout = tf.concat(values=[conv_out, input_data], axis=3, name='concatenate')\\n\\n return concate_cout\",\n \"def __init__(self, nfeat, nhid, nclass, dropout, alpha):\\n super(GCN, self).__init__()\\n self.dropout = dropout\\n\\n self.conv1 = GraphConvolutionLayer(nfeat, nhid, dropout=dropout, alpha=alpha, not_final=True)\\n \\n self.add_module('conv1', self.conv1)\\n\\n self.conv2 = GraphConvolutionLayer(nhid, nclass, dropout=dropout, alpha=alpha, not_final=False)\",\n \"def __init__(\\n self,\\n latentspace,\\n first_reshape_shape,\\n channels=None,\\n kernel_widths=None,\\n strides=None,\\n up_sampling=None,\\n hidden_activation=\\\"relu\\\",\\n output_activation=\\\"tanh\\\",\\n **kwargs):\\n # assign the default values if they were not specified\\n channels = default_value([256, 128, 128, 64, 64, 3], channels)\\n kernel_widths = default_value([4, 4, 4, 4, 4, 4], kernel_widths)\\n strides = default_value([1, 1, 1, 1, 1, 1], strides)\\n up_sampling = default_value([2, 2, 2, 2, 1, 1], up_sampling)\\n\\n h_Activation = lambda activation: LeakyReLU(0.02) if activation == \\\"leaky_relu\\\" else Activation(activation)\\n initializer = tf.keras.initializers.RandomNormal(0, 0.02)\\n\\n inp = Input((latentspace,))\\n\\n # A Block\\n A = Dense(np.prod(first_reshape_shape), kernel_initializer=initializer)(inp)\\n A = LayerNormalization()(A)\\n A = h_Activation(hidden_activation)(A)\\n A = Reshape(first_reshape_shape)(A)\\n\\n # B Block\\n B = Dense(64)(inp)\\n B = LayerNormalization()(B)\\n B = h_Activation(hidden_activation)(B)\\n B = Reshape((1, 1, 64))(B)\\n B = UpSampling2D(first_reshape_shape[0])(B)\\n\\n for channel, kernel_width, stride, up in zip(channels[:-1], kernel_widths[:-1], strides[:-1], up_sampling[:-1]):\\n A, B = up_sampling_block(\\n A, B, # Concat A&B to A\\n up, # Up sampling for A&B\\n channel, kernel_width, stride, initializer, # Conv2D for A\\n # Layer normalization\\n h_Activation(hidden_activation) # Activation for A\\n ) # returns A, B\\n\\n # Final block which finally produces the output image.\\n A = Concatenate()([A, B])\\n A = Conv2D(channels[-1], kernel_widths[-1], strides[-1],\\n padding=\\\"same\\\", kernel_initializer=initializer)(A)\\n out = h_Activation(output_activation)(A)\\n\\n # Construct the functional model by calling the constructor of the Model super class.\\n super(Decoder, self).__init__(inp, out, **kwargs)\",\n \"def Conv2DTranspose(\\n inputs,\\n filters,\\n kernel_size,\\n strides=(1, 1),\\n padding='same',\\n data_format='channels_last',\\n activation=None,\\n use_bias=True,\\n kernel_initializer=None,\\n bias_initializer=tf.zeros_initializer(),\\n kernel_regularizer=None,\\n bias_regularizer=None,\\n activity_regularizer=None,\\n dyn_hw=None):\\n if kernel_initializer is None:\\n if get_tf_version_tuple() <= (1, 12):\\n kernel_initializer = tf.contrib.layers.variance_scaling_initializer(2.0)\\n else:\\n kernel_initializer = tf.keras.initializers.VarianceScaling(2.0, distribution='untruncated_normal')\\n\\n if get_tf_version_tuple() <= (1, 12):\\n with rename_get_variable({'kernel': 'W', 'bias': 'b'}):\\n layer = tf.layers.Conv2DTranspose(\\n filters,\\n kernel_size,\\n strides=strides,\\n padding=padding,\\n data_format=data_format,\\n activation=activation,\\n use_bias=use_bias,\\n kernel_initializer=kernel_initializer,\\n bias_initializer=bias_initializer,\\n kernel_regularizer=kernel_regularizer,\\n bias_regularizer=bias_regularizer,\\n activity_regularizer=activity_regularizer,\\n _reuse=tf.get_variable_scope().reuse)\\n ret = layer.apply(inputs, scope=tf.get_variable_scope())\\n ret = tf.identity(ret, name='output')\\n ret.variables = VariableHolder(W=layer.kernel)\\n if use_bias:\\n ret.variables.b = layer.bias\\n else:\\n # Our own implementation, to avoid Keras bugs. https://github.com/tensorflow/tensorflow/issues/25946\\n assert kernel_regularizer is None and bias_regularizer is None and activity_regularizer is None, \\\\\\n \\\"Unsupported arguments due to Keras bug in TensorFlow 1.13\\\"\\n data_format = get_data_format(data_format, keras_mode=False)\\n shape_dyn = tf.shape(inputs)\\n strides2d = shape2d(strides)\\n channels_in = inputs.shape[1 if data_format == 'NCHW' else 3]\\n if data_format == 'NCHW':\\n channels_in = inputs.shape[1]\\n out_shape_dyn = tf.stack(\\n [shape_dyn[0], filters,\\n shape_dyn[2] * strides2d[0],\\n shape_dyn[3] * strides2d[1]])\\n out_shape3_sta = [filters,\\n None if inputs.shape[2] is None else inputs.shape[2] * strides2d[0],\\n None if inputs.shape[3] is None else inputs.shape[3] * strides2d[1]]\\n else:\\n channels_in = inputs.shape[-1]\\n out_shape_dyn = tf.stack(\\n [shape_dyn[0],\\n shape_dyn[1] * strides2d[0],\\n shape_dyn[2] * strides2d[1],\\n filters])\\n out_shape3_sta = [None if inputs.shape[1] is None else inputs.shape[1] * strides2d[0],\\n None if inputs.shape[2] is None else inputs.shape[2] * strides2d[1],\\n filters]\\n\\n kernel_shape = shape2d(kernel_size)\\n W = tf.get_variable('W', kernel_shape + [filters, channels_in], initializer=kernel_initializer)\\n if use_bias:\\n b = tf.get_variable('b', [filters], initializer=bias_initializer)\\n conv = tf.nn.conv2d_transpose(\\n inputs, W, out_shape_dyn,\\n shape4d(strides, data_format=data_format),\\n padding=padding.upper(),\\n data_format=data_format)\\n conv.set_shape(tf.TensorShape([None] + out_shape3_sta))\\n ret = activation(tf.nn.bias_add(conv, b, data_format=data_format) if use_bias else conv, name='output')\\n\\n ret.variables = VariableHolder(W=W)\\n if use_bias:\\n ret.variables.b = b\\n return ret\",\n \"def __init__(self, input_channel_dim: int, hidden_channel_dim: int = 64):\\n\\n super().__init__()\\n layers = OrderedDict(\\n [\\n (\\n \\\"conv_1\\\",\\n nn.Sequential(\\n nn.Conv2d(\\n in_channels=input_channel_dim,\\n out_channels=hidden_channel_dim,\\n kernel_size=4,\\n stride=2,\\n ),\\n nn.LeakyReLU(0.2, True),\\n ),\\n ),\\n ]\\n )\\n current_dim = hidden_channel_dim\\n for i in range(1, 4):\\n prev_dim = current_dim\\n current_dim *= 2\\n layers[f\\\"conv_{i+1}\\\"] = nn.Sequential(\\n nn.Conv2d(\\n in_channels=prev_dim,\\n out_channels=current_dim,\\n kernel_size=4,\\n stride=2,\\n ),\\n nn.LeakyReLU(0.2, True),\\n )\\n layers[\\\"conv_5\\\"] = nn.Sequential(\\n nn.Conv2d(\\n in_channels=current_dim,\\n out_channels=1,\\n kernel_size=4,\\n stride=2,\\n )\\n )\\n self.layers = nn.Sequential(layers)\",\n \"def build(self, input_shape: tf.Tensor):\\n self.conv = tf.keras.layers.Conv2D(\\n self.channels, (1, 1), input_shape=input_shape)\\n self.bn = tf.keras.layers.BatchNormalization(momentum=self.momentum)\",\n \"def conv1d_transpose(inputs,\\n filters,\\n kernel_size,\\n strides=2,\\n padding='same',\\n data_format='channels_last',\\n activation=None,\\n use_bias=True,\\n kernel_initializer=None,\\n bias_initializer=tf.zeros_initializer(),\\n kernel_regularizer=None,\\n bias_regularizer=None,\\n activity_regularizer=None,\\n kernel_constraint=None,\\n bias_constraint=None,\\n trainable=True,\\n name=None,\\n reuse=None):\\n\\n # expand inputs dimension\\n inputs = tf.expand_dims(inputs,axis=1) # (batch_size, 1, N, d)\\n\\n params = {\\\"inputs\\\":inputs, \\\"filters\\\":filters, \\\"kernel_size\\\":(1,kernel_size),\\n \\\"strides\\\":(1,strides),\\\"padding\\\":padding,\\\"data_format\\\":data_format,\\n \\\"activation\\\":activation,\\\"use_bias\\\":use_bias,\\n \\\"kernel_initializer\\\":kernel_initializer,\\\"bias_initializer\\\":bias_initializer,\\n \\\"kernel_regularizer\\\":kernel_regularizer,\\\"bias_regularizer\\\":bias_regularizer,\\n \\\"activity_regularizer\\\":activity_regularizer,\\\"kernel_constraint\\\":kernel_constraint,\\n \\\"bias_constraint\\\":bias_constraint,\\\"trainable\\\":trainable,\\\"name\\\":name,\\\"reuse\\\":reuse} \\n\\n conv_out = tf.squeeze(tf.layers.conv2d_transpose(**params),axis=1) # (batch_size, 2N, kernel_size)\\n\\n return conv_out\",\n \"def __init__(self, momentum: float = .5):\\n super(VanillaEncoder, self).__init__()\\n self.conv1 = PointNetConv2Layer(64, momentum)\\n self.conv2 = PointNetConv2Layer(64, momentum)\\n self.conv3 = PointNetConv2Layer(64, momentum)\\n self.conv4 = PointNetConv2Layer(128, momentum)\\n self.conv5 = PointNetConv2Layer(1024, momentum)\",\n \"def declaration_conv2d_transpose_impl(data, kernel, strides, padding, out_dtype, output_padding):\\n data_pad, kernel_transform = conv2d_transpose_nchw_preprocess(\\n data, kernel, strides, padding, out_dtype, output_padding\\n )\\n batch, in_c, in_h, in_w = data_pad.shape\\n out_c, _, filter_h, filter_w = kernel_transform.shape\\n\\n # convolution stage\\n out_c = simplify(out_c)\\n\\n out_h = simplify(in_h - filter_h + 1)\\n out_w = simplify(in_w - filter_w + 1)\\n dc = te.reduce_axis((0, in_c), name=\\\"dc\\\")\\n dh = te.reduce_axis((0, filter_h), name=\\\"dh\\\")\\n dw = te.reduce_axis((0, filter_w), name=\\\"dw\\\")\\n\\n Output = te.compute(\\n (batch, out_c, out_h, out_w),\\n lambda b, c, h, w: te.sum(\\n data_pad[b, dc, h + dh, w + dw].astype(out_dtype)\\n * kernel_transform[c, dc, dh, dw].astype(out_dtype),\\n axis=[dc, dh, dw],\\n ),\\n tag=\\\"conv2d_transpose_nchw\\\",\\n )\\n\\n return Output\",\n \"def _composite_conv(self, input_data, out_channel, name):\\n with tf.variable_scope(name):\\n bn_1 = self.layer_bn(input_data=input_data, is_training=self._is_training, name='bn_1')\\n\\n relu_1 = self.relu(input_data=bn_1, name='relu_1')\\n\\n if self._with_bc:\\n conv_1 = self.conv2d(input_data=relu_1, out_channel=out_channel, kernel_size=1,\\n padding='SAME', stride=1, use_bias=False, name='conv_1')\\n\\n bn_2 = self.layer_bn(input_data=conv_1, is_training=self._is_training, name='bn_2')\\n relu_2 = self.relu(input_data=bn_2, name='relu_2')\\n conv_2 = self.conv2d(input_data=relu_2, out_channel=out_channel, kernel_size=3,\\n padding='SAME', stride=1, use_bias=False, name='conv_2')\\n\\n else:\\n conv_2 = self.conv2d(input_data=relu_1, out_channel=out_channel, kernel_size=3,\\n padding='SAME', stride=1, use_bias=False, name='conv_2')\\n\\n return conv_2\",\n \"def resblock(input_tensor, num_channels):\\n tensor = Conv2D(filters=num_channels, kernel_size=3, padding='same')(\\n input_tensor)\\n tensor = Activation('relu')(tensor)\\n tensor = Conv2D(filters=num_channels, kernel_size=3, padding='same')(\\n tensor)\\n tensor = Add()([tensor, input_tensor])\\n output_tensor = Activation('relu')(tensor)\\n return output_tensor\",\n \"def allocate_primal_variables_conv(layer):\\n\\n assert layer.isconv\\n\\n gpu_vars = ((layer.l, [1]),\\n (layer.k, [1]))\\n cpu_vars = ()\\n\\n heavy_vars = ((layer.W_i, [Cfg.n_batches] + layer.W_shape),\\n (layer.b_i, [Cfg.n_batches] + layer.b_shape),\\n (layer.l_i, [Cfg.n_batches]))\\n\\n if Cfg.store_on_gpu:\\n gpu_vars += heavy_vars\\n else:\\n cpu_vars += heavy_vars\\n\\n gpu_fun = update_gpu_fun(gpu_vars)\\n cpu_fun = update_cpu_fun(cpu_vars, layer)\\n\\n def update_all_fun():\\n gpu_fun()\\n cpu_fun()\\n\\n return update_all_fun\",\n \"def _conv2d_layer(self, inputs, filters_num, kernel_size, name, use_bias=False, strides=1):\\n if strides > 1: # modified 0327\\n inputs = tf.pad(inputs, paddings=[[0, 0], [1, 0], [1, 0], [0, 0]], mode='CONSTANT')\\n conv = tf.layers.conv2d(inputs=inputs, filters=filters_num,\\n kernel_size=kernel_size, strides=[strides, strides],\\n padding=('SAME' if strides == 1 else 'VALID'), # padding = 'SAME', #\\n use_bias=use_bias,\\n name=name) # , kernel_initializer = tf.contrib.layers.xavier_initializer()\\n return conv\",\n \"def build(self,\\r\\n conv_filters=196,\\r\\n conv_size=13,\\r\\n conv_strides=4,\\r\\n act='relu',\\r\\n rnn_layers=2,\\r\\n LSTM_units=128,\\r\\n drop_out=0.8):\\r\\n i = Input(shape=self.input_size, name='input')\\r\\n x = Conv1D(conv_filters,\\r\\n conv_size,\\r\\n strides=conv_strides,\\r\\n name='conv1d')(i)\\r\\n x = BatchNormalization()(x)\\r\\n x = Activation(act)(x)\\r\\n for _ in range(rnn_layers):\\r\\n x = Bidirectional(LSTM(LSTM_units,\\r\\n return_sequences=True))(x)\\r\\n x = Dropout(drop_out)(x)\\r\\n x = BatchNormalization()(x)\\r\\n y_pred = TimeDistributed(Dense(self.output_size,\\r\\n activation='softmax'))(x)\\r\\n # ctc inputs\\r\\n labels = Input(name='the_labels', shape=[None, ], dtype='int32')\\r\\n input_length = Input(name='input_length', shape=[1], dtype='int32')\\r\\n label_length = Input(name='label_length', shape=[1], dtype='int32')\\r\\n # Keras doesn't currently support loss funcs with extra parameters\\r\\n # so CTC loss is implemented in a lambda layer\\r\\n loss_out = Lambda(ctc_lambda_func,\\r\\n output_shape=(1,),\\r\\n name='ctc')([y_pred,\\r\\n labels,\\r\\n input_length,\\r\\n label_length])\\r\\n self.tm = Model(inputs=i,\\r\\n outputs=y_pred)\\r\\n self.m = Model(inputs=[i,\\r\\n labels,\\r\\n input_length,\\r\\n label_length],\\r\\n outputs=loss_out)\\r\\n return self.m, self.tm\",\n \"def up_conv_2d(input_tensor, nb_filters, name):\\n resize = UpSampling2D(size=(2, 2), interpolation='nearest')(input_tensor)\\n paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])\\n resize = tf.pad(resize, paddings, \\\"SYMMETRIC\\\")\\n output_layer = Conv2D(\\n filters=nb_filters,\\n kernel_size=(3, 3),\\n activation='relu',\\n name=name)(\\n resize)\\n\\n return output_layer\",\n \"def __init__(self,\\n in_channels: int,\\n out_channels: int,\\n kernel_size: Union[int, Sequence[int]],\\n stride: Union[int, Sequence[int]] = 1,\\n padding: PaddingArgType = PaddingMode.DEFAULT,\\n output_padding: Union[int, Sequence[int]] = 0,\\n dilation: Union[int, Sequence[int]] = 1,\\n resize_at_exit: bool = False,\\n use_shortcut: Optional[bool] = None,\\n shortcut: Optional[LayerOrLayerFactory] = None,\\n conv0: Optional[LayerOrLayerFactory] = None,\\n conv1: Optional[LayerOrLayerFactory] = None,\\n merge_context0: Optional[Module] = None,\\n merge_context1: Optional[Module] = None,\\n activation: Optional[LayerFactory] = None,\\n normalizer: Optional[NormalizerFactory] = None,\\n dropout: Optional[Union[float, LayerOrLayerFactory]] = None,\\n weight_norm: WeightNormArgType = False,\\n gated: bool = False,\\n gate_bias: float = DEFAULT_GATE_BIAS,\\n use_bias: Optional[bool] = None,\\n weight_init: TensorInitArgType = DEFAULT_WEIGHT_INIT,\\n bias_init: TensorInitArgType = DEFAULT_BIAS_INIT,\\n data_init: Optional[DataInitArgType] = None,\\n device: Optional[str] = None,\\n ):\\n def use_bias_or_else(default_val: bool):\\n if use_bias is None:\\n return default_val\\n return use_bias\\n\\n def compile_layer_list(layers: List[Module]) -> Module:\\n if len(layers) == 0:\\n return Identity()\\n elif len(layers) == 1:\\n return layers[0]\\n else:\\n return Sequential(layers)\\n\\n spatial_ndims = self._get_spatial_ndims()\\n is_deconv = self._is_deconv()\\n\\n # validate arguments\\n in_channels = int(in_channels)\\n out_channels = int(out_channels)\\n\\n kernel_size = validate_conv_size('kernel_size', kernel_size, spatial_ndims)\\n stride = validate_conv_size('strides', stride, spatial_ndims)\\n dilation = validate_conv_size('dilation', dilation, spatial_ndims)\\n padding = validate_padding(padding, kernel_size, dilation, spatial_ndims)\\n\\n if output_padding != 0 and not is_deconv:\\n raise ValueError(f'The `output_padding` argument is not allowed '\\n f'by {self.__class__.__qualname__}.')\\n output_padding = validate_output_padding(\\n output_padding, stride, dilation, spatial_ndims)\\n\\n if conv0 is None:\\n conv0 = self._default_conv_factory()\\n\\n if conv1 is None:\\n conv1 = self._default_conv_factory()\\n\\n orig_merge_context0 = merge_context0\\n if merge_context0 is None:\\n merge_context0 = IgnoreContext()\\n else:\\n merge_context0 = validate_layer('merge_context0', merge_context0)\\n\\n if merge_context1 is None:\\n merge_context1 = IgnoreContext()\\n else:\\n merge_context1 = validate_layer('merge_context1', merge_context1)\\n\\n if shortcut is not None:\\n use_shortcut = True\\n if use_shortcut is None:\\n use_shortcut = (\\n any(s != 1 for s in stride) or\\n any(p[0] + p[1] != (k - 1) * d\\n for p, k, d in zip(padding, kernel_size, dilation)) or\\n in_channels != out_channels)\\n\\n if activation is not None:\\n activation_factory = validate_layer_factory('activation', activation)\\n else:\\n activation_factory = None\\n\\n if normalizer is not None:\\n normalizer_factory = validate_layer_factory('normalizer', normalizer)\\n else:\\n normalizer_factory = None\\n\\n if isinstance(dropout, float):\\n dropout = Dropout(p=dropout)\\n elif dropout is not None:\\n dropout = get_layer_from_layer_or_factory('dropout', dropout)\\n\\n conv0_weight_norm = weight_norm\\n if conv0_weight_norm is True:\\n conv0_weight_norm = (\\n WeightNormMode.FULL if normalizer is None or dropout is not None\\n else WeightNormMode.NO_SCALE\\n )\\n\\n kwargs = {'weight_init': weight_init, 'bias_init': bias_init,\\n 'data_init': data_init, 'device': device}\\n\\n # build the shortcut path\\n if use_shortcut:\\n if shortcut is None:\\n shortcut = self._default_conv_factory()\\n if not isinstance(shortcut, Module):\\n shortcut = get_layer_from_layer_or_factory(\\n 'shortcut', shortcut, kwargs=dict(\\n in_channels=in_channels,\\n out_channels=out_channels,\\n kernel_size=kernel_size,\\n stride=stride,\\n padding=padding,\\n dilation=dilation,\\n use_bias=use_bias_or_else(gated),\\n weight_norm=weight_norm,\\n **self._add_output_padding_to_kwargs(output_padding, kwargs)\\n )\\n )\\n else:\\n shortcut = Identity()\\n\\n # prepare the arguments for the residual path\\n if resize_at_exit:\\n conv0_out_channels = in_channels\\n conv0_stride = 1\\n conv0_padding = PaddingMode.HALF # such that it can keep the output shape\\n conv0_kwargs = kwargs\\n conv1_stride = stride\\n conv1_padding = padding\\n conv1_kwargs = self._add_output_padding_to_kwargs(output_padding, kwargs)\\n else:\\n conv0_out_channels = out_channels\\n conv0_stride = stride\\n conv0_padding = padding\\n conv0_kwargs = self._add_output_padding_to_kwargs(output_padding, kwargs)\\n conv1_stride = 1\\n conv1_padding = PaddingMode.HALF # such that it can keep the output shape\\n conv1_kwargs = kwargs\\n\\n conv1_out_channels = out_channels\\n if gated:\\n conv1_out_channels *= 2\\n\\n # pre_conv0\\n pre_conv0 = []\\n if normalizer_factory is not None:\\n pre_conv0.append(normalizer_factory(in_channels))\\n if activation_factory is not None:\\n pre_conv0.append(activation_factory())\\n pre_conv0 = compile_layer_list(pre_conv0)\\n\\n # conv0\\n conv0 = get_layer_from_layer_or_factory( # conv0\\n 'conv0', conv0, kwargs=dict(\\n in_channels=in_channels,\\n out_channels=conv0_out_channels,\\n kernel_size=kernel_size,\\n stride=conv0_stride,\\n padding=conv0_padding,\\n dilation=dilation,\\n use_bias=use_bias_or_else(normalizer_factory is None or\\n dropout is not None or\\n orig_merge_context0 is not None),\\n weight_norm=conv0_weight_norm,\\n **conv0_kwargs,\\n )\\n )\\n\\n # pre_conv1\\n pre_conv1 = []\\n if dropout is not None:\\n pre_conv1.append(dropout)\\n if normalizer_factory is not None:\\n pre_conv1.append(normalizer_factory(conv0_out_channels))\\n if activation_factory is not None:\\n pre_conv1.append(activation_factory())\\n pre_conv1 = compile_layer_list(pre_conv1)\\n\\n # conv1\\n conv1 = get_layer_from_layer_or_factory(\\n 'conv1', conv1, kwargs=dict(\\n in_channels=conv0_out_channels,\\n out_channels=conv1_out_channels,\\n kernel_size=kernel_size,\\n stride=conv1_stride,\\n padding=conv1_padding,\\n dilation=dilation,\\n use_bias=use_bias_or_else(True),\\n weight_norm=weight_norm,\\n **conv1_kwargs,\\n )\\n )\\n\\n # post_conv1\\n if gated:\\n post_conv1 = Gated(\\n feature_axis=-(spatial_ndims + 1),\\n num_features=out_channels,\\n gate_bias=gate_bias,\\n )\\n else:\\n post_conv1 = Identity()\\n\\n # construct the layer\\n super().__init__()\\n self.shortcut = shortcut\\n self.pre_conv0 = pre_conv0\\n self.merge_context0 = merge_context0\\n self.conv0 = conv0\\n self.pre_conv1 = pre_conv1\\n self.merge_context1 = merge_context1\\n self.conv1 = conv1\\n self.post_conv1 = post_conv1\",\n \"def _make_conv_layers(self):\\n conv = nn.Sequential(\\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=1), # padding=3 so, output is 224.\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(kernel_size=2, stride=2),\\n\\n nn.Conv2d(64, 192, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(192, 128, 1, padding=1), ## kernel size = 1 이므로 padding = 0(defalut)\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(128, 256, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(1024, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(1024, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True)\\n )\\n return conv\",\n \"def initParams(self):\\n sizes = [self.inputDim]+self.layerSizes+[self.outputDim]\\n scales = [np.sqrt(6)/np.sqrt(n+m) for n,m in zip(sizes[:-1],sizes[1:])]\\n self.stack = [[np.random.rand(m,n)*2*s-s,np.zeros((m,1))] \\\\\\n for n,m,s in zip(sizes[:-1],sizes[1:],scales)]\\n self.hActs_M = [cm.empty((s,self.maxBatch)) for s in sizes]\\n\\n if self.train:\\n # Now assuming that all layers are the same size\\n self.grad = [[cm.empty(w.shape),cm.empty(b.shape)] for w,b in self.stack]\\n self.deltasC_M = cm.empty((self.outputDim,self.maxBatch))\\n self.deltasOut_M = cm.empty((sizes[1],self.maxBatch)) \\n self.deltasIn_M = cm.empty((sizes[1],self.maxBatch)) \\n self.tmpGrad_M = cm.empty((self.layerSize,self.maxBatch))\\n \\n # Allocate memory once here and reuse\\n # Store probs\\n self.probs_M = cm.empty((self.outputDim,self.maxBatch))\\n # Store col max\\n self.rowVec_M = cm.empty((1,self.maxBatch))\\n \\n self.stack = [[cm.CUDAMatrix(w),cm.CUDAMatrix(b)]\\n for w,b in self.stack]\\n\\n if self.temporalLayer > 0:\\n # dummy bias used for temporal layer\\n dummy = cm.empty((1,1))\\n dummy.assign(0.0)\\n\\n scale = np.sqrt(6)/np.sqrt(self.layerSize*2)\\n wtf = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\\n self.layerSize)-scale)\\n wtb = cm.CUDAMatrix(2*scale*np.random.rand(self.layerSize,\\n self.layerSize)-scale)\\n self.stack.append([wtf,dummy])\\n self.stack.append([wtb,dummy])\\n\\n # forward and backward activations for temporal layer\\n self.hActsFor_M = cm.empty((self.layerSize,self.maxBatch))\\n self.hActsBack_M = cm.empty((self.layerSize,self.maxBatch))\\n\\n if self.train:\\n dwtf = cm.empty(wtf.shape)\\n self.grad.append([dwtf,dummy])\\n dwtb = cm.empty(wtb.shape)\\n self.grad.append([dwtb,dummy])\\n\\n self.tmpGradBack_M = cm.empty((self.layerSize,self.maxBatch))\\n self.deltasFor_M = cm.empty((self.layerSize,self.maxBatch))\\n self.deltasBack_M = cm.empty((self.layerSize,self.maxBatch))\",\n \"def transition_layer(X, nb_filters, compression):\\n\\n init = K.initializers.he_normal(seed=None)\\n\\n bn1 = K.layers.BatchNormalization()(X)\\n activation1 = K.layers.Activation('relu')(bn1)\\n filters = int(nb_filters * compression)\\n conv1 = K.layers.Conv2D(\\n filters=filters,\\n kernel_size=(1, 1),\\n padding='same',\\n kernel_initializer=init\\n )(activation1)\\n\\n avgpool = K.layers.AveragePooling2D(\\n pool_size=(2, 2),\\n strides=(2, 2),\\n padding='same',\\n )(conv1)\\n\\n return avgpool, filters\",\n \"def test_multiple_transpose_conv2d(self):\\n\\n tf.compat.v1.reset_default_graph()\\n with tf.device('/cpu:0'):\\n model = tf.keras.Sequential()\\n model.add(tf.keras.layers.Conv2DTranspose(1, (4, 4), input_shape=(28, 28, 3)))\\n model.add(tf.keras.layers.MaxPooling2D((2, 2)))\\n model.add(tf.keras.layers.Conv2DTranspose(1, (4, 4), input_shape=(28, 28, 3)))\\n model.add(tf.keras.layers.MaxPooling2D((2, 2)))\\n model.summary()\\n\\n conn_graph = ConnectedGraph(tf.compat.v1.get_default_graph(), [model.input.op.name], [model.output.op.name])\\n self.assertEqual(conn_graph.get_all_ops()['conv2d_transpose/conv2d_transpose'].type, 'Conv2DTranspose')\\n self.assertEqual(conn_graph.get_all_ops()['conv2d_transpose_1/conv2d_transpose'].type, 'Conv2DTranspose')\",\n \"def test_on_conv_transpose_2d_padding(self):\\n x = jn.array([[[[2., 1., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.], [13., 14., 15., 16.]]]])\\n y = jn.array([[[[2., 5., 5., 10.], [11., 27., 32., 46.], [24., 66., 76., 86.], [40., 106., 116., 126.]]]])\\n w_init = lambda s: jn.array([[[[1., 2.], [3., 4.]]]]).transpose((2, 3, 0, 1))\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=objax.ConvPadding.SAME, w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='same', w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='Same', w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='SAME', w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=(1, 0), w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=[(1, 0), (1, 0)], w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n y = [[[[2., 5., 5., 10., 8.], [11., 27., 32., 46., 32.], [24., 66., 76., 86., 56.],\\n [40., 106., 116., 126., 80.], [39., 94., 101., 108., 64.]]]]\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=1, w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y)\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=(1, 1), w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y)\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=[(1, 1), (1, 1)], w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y)\",\n \"def create_cnn(num_half_rows, num_half_columns, num_channels):\\n\\n error_checking.assert_is_integer(num_half_rows)\\n error_checking.assert_is_integer(num_half_columns)\\n error_checking.assert_is_integer(num_channels)\\n\\n error_checking.assert_is_greater(num_half_rows, 0)\\n error_checking.assert_is_greater(num_half_columns, 0)\\n error_checking.assert_is_greater(num_channels, 0)\\n\\n regularizer_object = keras.regularizers.l1_l2(l1=L1_WEIGHT, l2=L2_WEIGHT)\\n\\n num_grid_rows = 2 * num_half_rows + 1\\n num_grid_columns = 2 * num_half_columns + 1\\n input_layer_object = keras.layers.Input(\\n shape=(num_grid_rows, num_grid_columns, num_channels)\\n )\\n\\n current_num_filters = None\\n current_layer_object = None\\n\\n # Add convolutional layers.\\n for _ in range(NUM_CONV_LAYER_SETS):\\n for _ in range(NUM_CONV_LAYERS_PER_SET):\\n\\n if current_num_filters is None:\\n current_num_filters = (\\n num_channels * NUM_CHANNELS_TO_FIRST_NUM_FILTERS)\\n this_input_layer_object = input_layer_object\\n\\n else:\\n current_num_filters *= 2\\n this_input_layer_object = current_layer_object\\n\\n current_layer_object = keras.layers.Conv2D(\\n filters=current_num_filters,\\n kernel_size=(NUM_CONV_FILTER_ROWS, NUM_CONV_FILTER_COLUMNS),\\n strides=(1, 1), padding='valid', data_format='channels_last',\\n dilation_rate=(1, 1), activation=None, use_bias=True,\\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\\n kernel_regularizer=regularizer_object\\n )(this_input_layer_object)\\n\\n current_layer_object = keras.layers.LeakyReLU(\\n alpha=SLOPE_FOR_RELU\\n )(current_layer_object)\\n\\n if CONV_LAYER_DROPOUT_FRACTION is not None:\\n current_layer_object = keras.layers.Dropout(\\n rate=CONV_LAYER_DROPOUT_FRACTION\\n )(current_layer_object)\\n\\n if USE_BATCH_NORMALIZATION:\\n current_layer_object = keras.layers.BatchNormalization(\\n axis=-1, center=True, scale=True\\n )(current_layer_object)\\n\\n current_layer_object = keras.layers.MaxPooling2D(\\n pool_size=(NUM_POOLING_ROWS, NUM_POOLING_COLUMNS),\\n strides=(NUM_POOLING_ROWS, NUM_POOLING_COLUMNS),\\n padding='valid', data_format='channels_last'\\n )(current_layer_object)\\n\\n these_dimensions = numpy.array(\\n current_layer_object.get_shape().as_list()[1:], dtype=int)\\n num_features = numpy.prod(these_dimensions)\\n\\n current_layer_object = keras.layers.Flatten()(current_layer_object)\\n\\n # Add intermediate dense layers.\\n _, num_outputs_by_dense_layer = (\\n architecture_utils.get_dense_layer_dimensions(\\n num_input_units=num_features, num_classes=NUM_CLASSES,\\n num_dense_layers=NUM_DENSE_LAYERS)\\n )\\n\\n for k in range(NUM_DENSE_LAYERS - 1):\\n current_layer_object = keras.layers.Dense(\\n num_outputs_by_dense_layer[k], activation=None, use_bias=True,\\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\\n kernel_regularizer=regularizer_object\\n )(current_layer_object)\\n\\n current_layer_object = keras.layers.LeakyReLU(\\n alpha=SLOPE_FOR_RELU\\n )(current_layer_object)\\n\\n if DENSE_LAYER_DROPOUT_FRACTION is not None:\\n current_layer_object = keras.layers.Dropout(\\n rate=DENSE_LAYER_DROPOUT_FRACTION\\n )(current_layer_object)\\n\\n if USE_BATCH_NORMALIZATION:\\n current_layer_object = keras.layers.BatchNormalization(\\n axis=-1, center=True, scale=True\\n )(current_layer_object)\\n\\n # Add output layer (also dense).\\n current_layer_object = keras.layers.Dense(\\n NUM_CLASSES, activation=None, use_bias=True,\\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\\n kernel_regularizer=regularizer_object\\n )(current_layer_object)\\n\\n current_layer_object = keras.layers.Activation(\\n 'softmax'\\n )(current_layer_object)\\n\\n if DENSE_LAYER_DROPOUT_FRACTION is not None and NUM_DENSE_LAYERS == 1:\\n current_layer_object = keras.layers.Dropout(\\n rate=DENSE_LAYER_DROPOUT_FRACTION\\n )(current_layer_object)\\n\\n # Put the whole thing together and compile.\\n cnn_model_object = keras.models.Model(\\n inputs=input_layer_object, outputs=current_layer_object)\\n cnn_model_object.compile(\\n loss=keras.losses.categorical_crossentropy,\\n optimizer=keras.optimizers.Adam(),\\n metrics=LIST_OF_METRIC_FUNCTIONS)\\n\\n cnn_model_object.summary()\\n return cnn_model_object\",\n \"def TCN_V3(\\n n_classes, \\n feat_dim,\\n max_len,\\n gap=1,\\n dropout=0.0,\\n activation=\\\"relu\\\"):\\n\\n ROW_AXIS = 1\\n CHANNEL_AXIS = 2\\n \\n initial_conv_len = 8\\n initial_conv_num = 128\\n\\n config = [ \\n [(1,8,128)],\\n [(1,8,128)],\\n [(1,8,128)],\\n [(2,8,256)],\\n [(1,8,256)],\\n [(1,8,256)],\\n ]\\n\\n input = Input(shape=(max_len,feat_dim))\\n model = input\\n\\n model = Convolution1D(initial_conv_num, \\n initial_conv_len,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=1)(model)\\n\\n for depth in range(0,len(config)):\\n blocks = []\\n for stride,filter_dim,num in config[depth]:\\n ## residual block\\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\\n relu = Activation(activation)(bn)\\n dr = Dropout(dropout)(relu)\\n conv = Convolution1D(num, \\n filter_dim,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=stride)(dr)\\n #dr = Dropout(dropout)(conv)\\n\\n\\n ## potential downsample\\n conv_shape = K.int_shape(conv)\\n model_shape = K.int_shape(model)\\n if conv_shape[CHANNEL_AXIS] != model_shape[CHANNEL_AXIS]:\\n model = Convolution1D(num, \\n 1,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=2)(model)\\n\\n ## merge block\\n model = merge([model,conv],mode='sum',concat_axis=CHANNEL_AXIS)\\n\\n ## final bn+relu\\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\\n model = Activation(activation)(bn)\\n\\n\\n if gap:\\n pool_window_shape = K.int_shape(model)\\n gap = AveragePooling1D(pool_window_shape[ROW_AXIS],\\n stride=1)(model)\\n flatten = Flatten()(gap)\\n else:\\n flatten = Flatten()(model)\\n\\n dense = Dense(output_dim=n_classes,\\n init=\\\"he_normal\\\",\\n activation=\\\"softmax\\\")(flatten)\\n\\n model = Model(input=input, output=dense)\\n # optimizer = SGD(lr=0.01, momentum=0.9, decay=0.0, nesterov=True) \\n # model.compile(loss='categorical_crossentropy', optimizer=optimizer,metrics=['accuracy'])\\n return model\",\n \"def __init__(self, dim, dim_head = 64, heads = 8, window_size = 16, skip_type = 'ConcatCross'):\\n super().__init__()\\n self.scale = dim_head ** -0.5\\n self.heads = heads\\n self.window_size = window_size\\n self.skip_type = skip_type\\n inner_dim = dim_head * heads\\n\\n self.to_q = nn.Conv3d(dim, inner_dim, 1, bias = False)\\n self.to_kv = nn.Conv3d(dim, inner_dim * 2, 1, bias = False)\\n self.to_out = nn.Conv3d(inner_dim, dim, 1)\",\n \"def convolutional(input_layer, filters_shape, downsample=False, activate=True, bn=True):\\n if downsample:\\n input_layer = ZeroPadding2D(((1, 0), (1, 0)))(input_layer)\\n padding = 'valid'\\n strides = 2\\n else:\\n strides = 1\\n padding = 'same'\\n\\n conv = Conv2D(filters=filters_shape[-1], kernel_size=filters_shape[0], strides=strides,\\n padding=padding, use_bias=not bn, kernel_regularizer=l2(0.0005),\\n kernel_initializer=tf.random_normal_initializer(stddev=0.01),\\n bias_initializer=tf.constant_initializer(0.))(input_layer)\\n if bn:\\n conv = BatchNormalization()(conv)\\n if activate == True:\\n conv = LeakyReLU(alpha=0.1)(conv)\\n\\n return conv\",\n \"def create_conv2d(x, W):\\n return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')\",\n \"def resblock(input_tensor, num_channels):\\r\\n step_1_conv = Conv2D(num_channels, (3, 3), padding='same')(input_tensor)\\r\\n step_2_relu = Activation('relu')(step_1_conv)\\r\\n step_3_conv = Conv2D(num_channels, (3, 3), padding='same')(step_2_relu)\\r\\n output = Add()([input_tensor, step_3_conv])\\r\\n return Activation('relu')(output)\",\n \"def _transition_layer(self, input_data, name):\\n input_channels = input_data.get_shape().as_list()[3]\\n\\n with tf.variable_scope(name):\\n # First batch norm\\n bn = self.layer_bn(input_data=input_data, is_training=self._is_training, name='bn')\\n\\n # Second 1 X 1 conv\\n if self._with_bc:\\n out_channels = int(input_channels * self._bc_theta)\\n conv = self.conv2d(input_data=bn, out_channel=out_channels, kernel_size=1,\\n stride=1, use_bias=False, name='conv')\\n # Third average pooling\\n avgpool_out = self.avg_pooling(input_data=conv, kernel_size=2, stride=2, name='avgpool')\\n else:\\n conv = self.conv2d(input_data=bn, out_channel=input_channels, kernel_size=1,\\n stride=1, use_bias=False, name='conv')\\n # Third average pooling\\n avgpool_out = self.avg_pooling(input_data=conv, kernel_size=2, stride=2, name='avgpool')\\n\\n return avgpool_out\",\n \"def deconv2d_bn_act(inputs, filters, kernel_size, kernel_init, activation, strides, padding=\\\"SAME\\\"):\\n _tmp = tf.layers.conv2d_transpose(inputs=inputs, filters=filters, kernel_size=kernel_size,\\n kernel_initializer=kernel_init, activation=None, strides=strides, padding=padding)\\n _tmp = tf.contrib.layers.batch_norm(_tmp, center=True, scale=True, is_training=phase)\\n _tmp = activation(_tmp)\\n\\n return _tmp\",\n \"def Conv2DTranspose_BN(x, filters, kernel_size, strides=(1,1), padding='same', activation='relu', kernel_initializer='he_normal', kernel_regularizer=None):\\n\\n x = Conv2DTranspose(filters, kernel_size=kernel_size, strides=strides, padding=padding, kernel_regularizer=kernel_regularizer)(x)\\n x = BatchNormalization()(x)\\n x = Activation(activation)(x)\\n return x\",\n \"def TCN_V2(\\n n_classes, \\n feat_dim,\\n max_len,\\n gap=1,\\n dropout=0.0,\\n activation=\\\"relu\\\"):\\n\\n ROW_AXIS = 1\\n CHANNEL_AXIS = 2\\n \\n initial_conv_len = 8\\n initial_conv_num = 64\\n\\n config = [ \\n [(1,8,64)],\\n [(1,8,64)],\\n [(1,8,64)],\\n [(1,8,64)],\\n [(1,8,64)],\\n [(2,8,128)],\\n [(1,8,128)],\\n [(1,8,128)],\\n [(1,8,128)],\\n [(1,8,128)],\\n ]\\n\\n input = Input(shape=(max_len,feat_dim))\\n model = input\\n\\n model = Convolution1D(initial_conv_num, \\n initial_conv_len,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=1)(model)\\n\\n for depth in range(0,len(config)):\\n blocks = []\\n for stride,filter_dim,num in config[depth]:\\n ## residual block\\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\\n relu = Activation(activation)(bn)\\n dr = Dropout(dropout)(relu)\\n conv = Convolution1D(num, \\n filter_dim,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=stride)(dr)\\n #dr = Dropout(dropout)(conv)\\n\\n\\n ## potential downsample\\n conv_shape = K.int_shape(conv)\\n model_shape = K.int_shape(model)\\n if conv_shape[CHANNEL_AXIS] != model_shape[CHANNEL_AXIS]:\\n model = Convolution1D(num, \\n 1,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=2)(model)\\n\\n ## merge block\\n model = merge([model,conv],mode='sum',concat_axis=CHANNEL_AXIS)\\n\\n ## final bn+relu\\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\\n model = Activation(activation)(bn)\\n\\n\\n if gap:\\n pool_window_shape = K.int_shape(model)\\n gap = AveragePooling1D(pool_window_shape[ROW_AXIS],\\n stride=1)(model)\\n flatten = Flatten()(gap)\\n else:\\n flatten = Flatten()(model)\\n\\n dense = Dense(output_dim=n_classes,\\n init=\\\"he_normal\\\",\\n activation=\\\"softmax\\\")(flatten)\\n\\n model = Model(input=input, output=dense)\\n # optimizer = SGD(lr=0.01, momentum=0.9, decay=0.0, nesterov=True) \\n # model.compile(loss='categorical_crossentropy', optimizer=optimizer,metrics=['accuracy'])\\n return model\",\n \"def contract(self, depth, kernel_cc_weight=0.0):\\n\\n def composite_layer(x):\\n name = 'contr_%d' % depth\\n num_filters = self.base_num_filters * 2 ** depth\\n x = self.conv_depth(num_filters=num_filters, name=name, kernel_cc_weight=kernel_cc_weight)(x)\\n self.contr_tensors[depth] = x\\n x = MaxPoolingND(x)(x)\\n return x\\n\\n return composite_layer\",\n \"def __init__(self, in_dim, activation):\\r\\n super(Self_Attn, self).__init__()\\r\\n self.input_channel = in_dim\\r\\n self.activation = activation\\r\\n self.k = 8\\r\\n self.query = nn.Conv2d(self.input_channel, self.input_channel // self.k, kernel_size=1)\\r\\n self.key = nn.Conv2d(self.input_channel, self.input_channel // self.k, kernel_size=1)\\r\\n self.value = nn.Conv2d(self.input_channel, self.input_channel, kernel_size=1)\\r\\n self.h = nn.Conv2d(self.input_channel, self.input_channel, kernel_size=1)\\r\\n self.gamma = nn.Parameter(torch.zeros(1), requires_grad=True)\\r\\n self.softmax = nn.Softmax(dim=-1)\",\n \"def _conv_block(x, filters, activation=True):\\n h = tf.keras.layers.Conv2D(\\n filters,\\n kernel_size=[3, 3],\\n kernel_initializer='he_normal',\\n bias_initializer='zeros',\\n strides=[1, 1],\\n padding='same',\\n use_bias=True)(\\n x)\\n if activation:\\n h = tf.keras.layers.LeakyReLU(0.2)(h)\\n return h\",\n \"def __init__(self, in_size, out_size, kernel_size=3, stride=2, padding=1, output_padding=1):\\n super().__init__()\\n ConvTransBlockList = nn.ModuleList()\\n ConvTransBlockList.append(nn.ConvTranspose2d(in_size, out_size,\\n kernel_size=kernel_size, stride=stride,\\n padding=padding, output_padding=output_padding,\\n bias=False)\\n )\\n ConvTransBlockList.append(nn.InstanceNorm2d(out_size))\\n ConvTransBlockList.append(nn.ReLU())\\n self.model = nn.Sequential(*ConvTransBlockList)\",\n \"def _init_layers(self):\\n self.relu = nn.ReLU(inplace=True)\\n self.cls_convs = nn.ModuleList()\\n self.reg_convs = nn.ModuleList()\\n for i in range(self.stacked_convs):\\n chn = self.in_channels if i == 0 else self.feat_channels\\n self.cls_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=dict(type='DCN', deform_groups=1)\\n if i == 0 and self.use_dcn else self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.reg_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=dict(type='DCN', deform_groups=1)\\n if i == 0 and self.use_dcn else self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.atss_cls = nn.Conv2d(\\n self.feat_channels,\\n self.num_base_priors * self.cls_out_channels,\\n 3,\\n padding=1)\\n self.atss_reg = nn.Conv2d(\\n self.feat_channels, self.num_base_priors * 4, 3, padding=1)\\n self.atss_iou = nn.Conv2d(\\n self.feat_channels, self.num_base_priors * 1, 3, padding=1)\\n self.scales = nn.ModuleList(\\n [Scale(1.0) for _ in self.prior_generator.strides])\\n\\n # we use the global list in loss\\n self.cls_num_pos_samples_per_level = [\\n 0. for _ in range(len(self.prior_generator.strides))\\n ]\\n self.reg_num_pos_samples_per_level = [\\n 0. for _ in range(len(self.prior_generator.strides))\\n ]\",\n \"def conv3x3(in_channels, out_channels, stride=1, \\n padding=1, bias=True, groups=1):\\n return nn.Conv2d(\\n in_channels, \\n out_channels, \\n kernel_size=3, \\n stride=stride,\\n padding=padding,\\n bias=bias,\\n groups=groups)\",\n \"def __init__(self, indim, outdim, ksize=3, stride=1, activation=nn.ReLU):\\n\\n # Run initialization for super class\\n super(ConvBlock, self).__init__()\\n\\n # Check ksize, stride requirements\\n assert (ksize % 2) == 1\\n assert stride == 1\\n assert indim == outdim\\n\\n # Store proper activation function depending on configuration\\n self.activ = activation\\n\\n # Compute padding according to `ksize`. Make sure\\n # that this will not cause image width and height to change.\\n padding = ksize // 2\\n\\n # We will follow the architecture in slide 76 of lecture 21, but with\\n # our `_conv` function as our conv ``block''. We'll also use\\n # nn.Sequential() and its `add_module' function. Note that the 64 and\\n # 256 in that slide are just examples, and you should instead use indim\\n # and outdim.\\n #\\n # Also note that we are creating these layers with support for\\n # different `ksize`, `stride`, `padding`, unlike previous assignment.\\n self.layers = nn.Sequential()\\n self.layers.add_module(\\\"conv_1\\\", self._conv(indim, indim, 1, 1, 0))\\n self.layers.add_module(\\\"conv_2\\\", self._conv(\\n indim, indim, ksize, 1, padding))\\n self.layers.add_module(\\\"conv_3\\\", self._conv(indim, outdim, 1, 1, 0))\",\n \"def conv_3d(self):\\n # Model.\\n model = Sequential()\\n model.add(Conv3D(32, (3,3,3), activation='relu', input_shape=self.input_shape))\\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))\\n model.add(Conv3D(64, (3,3,3), activation='relu'))\\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))\\n model.add(Conv3D(128, (3,3,3), activation='relu'))\\n model.add(Conv3D(128, (3,3,3), activation='relu'))\\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))\\n model.add(Conv3D(256, (2,2,2), activation='relu'))\\n model.add(Conv3D(256, (2,2,2), activation='relu'))\\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2)))\\n\\n model.add(Flatten())\\n model.add(Dense(1024))\\n model.add(Dropout(0.5))\\n model.add(Dense(1024))\\n model.add(Dropout(0.5))\\n model.add(Dense(self.nb_classes, activation='softmax'))\\n\\n return model\",\n \"def create(self) -> None:\\n if self.torch is not None: # type: ignore\\n return\\n self.torch = torch.nn.Conv2d(**self.args.arg_values)\",\n \"def _init_predictor(self):\\n self.conv_cls_prev = self._init_branch(\\n conv_channels=self.cls_branch,\\n conv_strides=(1, ) * len(self.cls_branch))\\n self.conv_cls = nn.Conv2d(self.cls_branch[-1], self.cls_out_channels,\\n 1)\\n # init regression head\\n self.conv_reg_prevs = nn.ModuleList()\\n # init output head\\n self.conv_regs = nn.ModuleList()\\n # group_reg_dims:\\n # ((4, ), (2, ), (20, ), (3, ), (3, ), (8, 8), (1, ), (1, ))\\n for i in range(len(self.group_reg_dims)):\\n reg_dims = self.group_reg_dims[i]\\n reg_branch_channels = self.reg_branch[i]\\n out_channel = self.out_channels[i]\\n reg_list = nn.ModuleList()\\n if len(reg_branch_channels) > 0:\\n self.conv_reg_prevs.append(\\n self._init_branch(\\n conv_channels=reg_branch_channels,\\n conv_strides=(1, ) * len(reg_branch_channels)))\\n for reg_dim in reg_dims:\\n reg_list.append(nn.Conv2d(out_channel, reg_dim, 1))\\n self.conv_regs.append(reg_list)\\n else:\\n self.conv_reg_prevs.append(None)\\n for reg_dim in reg_dims:\\n reg_list.append(nn.Conv2d(self.feat_channels, reg_dim, 1))\\n self.conv_regs.append(reg_list)\",\n \"def conv_mpool_activation(scope, input_layer, n_channels=2, mpool=False, kernel_conv=(5, 5), \\n stride_conv=(1, 1), kernel_pool=(2, 2), stride_pool=(2, 2), activation=tf.nn.relu):\\n with tf.variable_scope(scope):\\n # infer input_nchannels\\n inp_channels = input_layer.shape.as_list()[-1]\\n\\n # define var for conv-filter\\n filter_shape = tuple(kernel_conv) + (inp_channels, ) + (n_channels, )\\n filter_weights = tf.Variable(tf.truncated_normal(shape=filter_shape, stddev=0.01), name='weights')\\n\\n # bias\\n bias = tf.Variable(tf.zeros(shape=[n_channels]), name='bias')\\n\\n # apply the filter\\n strides = (1, ) + tuple(stride_conv) + (1, )\\n output = tf.nn.conv2d(input=input_layer, filter=filter_weights, strides=strides, padding='SAME')\\n\\n # bias\\n output = output + bias\\n\\n # apply mpooling if needed\\n if mpool:\\n ksize = (1, ) + tuple(kernel_pool) + (1, )\\n strides = (1, ) + tuple(stride_pool) + (1, )\\n output = tf.nn.max_pool(output, ksize=ksize, strides=strides, padding='SAME')\\n\\n return tf.identity(activation(output), name='output')\",\n \"def c3d(self):\\n model = Sequential()\\n # 1st layer group\\n model.add(Conv3D(64, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv1',\\n subsample=(1, 1, 1),\\n input_shape=self.input_shape))\\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2),\\n border_mode='valid', name='pool1'))\\n # 2nd layer group\\n model.add(Conv3D(128, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv2',\\n subsample=(1, 1, 1)))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='valid', name='pool2'))\\n # 3rd layer group\\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv3a',\\n subsample=(1, 1, 1)))\\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv3b',\\n subsample=(1, 1, 1)))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='valid', name='pool3'))\\n # 4th layer group\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv4a',\\n subsample=(1, 1, 1)))\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv4b',\\n subsample=(1, 1, 1)))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='valid', name='pool4'))\\n\\n # 5th layer group\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv5a',\\n subsample=(1, 1, 1)))\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv5b',\\n subsample=(1, 1, 1)))\\n model.add(ZeroPadding3D(padding=(0, 1, 1)))\\n # model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n # border_mode='valid', name='pool5', dim_ordering=\\\"tf\\\"))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='same', name='pool5', dim_ordering=\\\"tf\\\"))\\n model.add(Flatten())\\n\\n # FC layers group\\n model.add(Dense(4096, activation='relu', name='fc6'))\\n model.add(Dropout(0.5))\\n model.add(Dense(4096, activation='relu', name='fc7'))\\n model.add(Dropout(0.5))\\n model.add(Dense(self.nb_classes, activation='softmax'))\\n for layer in model.layers:\\n print(layer.output_shape)\\n return model\",\n \"def setUp(self):\\n\\n super(Conv2DTransposeTest, self).setUp()\\n\\n self.batch_size = 100\\n self.in_height = 32\\n self.in_width = 32\\n self.in_channels = 3\\n self.out_channels = 10\\n self.kernel_shape_h = 5\\n self.kernel_shape_w = 5\\n self.strides = (1, 1, 1, 1)\\n self.padding = snt.SAME\\n\\n self.in_shape = (self.batch_size, self.in_height, self.in_width,\\n self.in_channels)\\n\\n self.out_shape = (self.in_height, self.in_width)\\n\\n self.kernel_shape = (self.kernel_shape_h, self.kernel_shape_w)\\n\\n self.kernel_shape2 = (self.kernel_shape_h, self.kernel_shape_w,\\n self.out_channels, self.in_channels)\",\n \"def TCN_V1(\\n n_classes, \\n feat_dim,\\n max_len,\\n gap=1,\\n dropout=0.0,\\n activation=\\\"relu\\\"):\\n\\n ROW_AXIS = 1\\n CHANNEL_AXIS = 2\\n \\n initial_conv_len = 8\\n initial_conv_num = 64\\n\\n config = [ \\n [(1,8,64)],\\n [(1,8,64)],\\n [(1,8,64)],\\n [(2,8,128)],\\n [(1,8,128)],\\n [(1,8,128)],\\n [(2,8,256)],\\n [(1,8,256)],\\n [(1,8,256)],\\n ]\\n\\n input = Input(shape=(max_len,feat_dim))\\n model = input\\n\\n model = Convolution1D(initial_conv_num, \\n initial_conv_len,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=1)(model)\\n\\n for depth in range(0,len(config)):\\n blocks = []\\n for stride,filter_dim,num in config[depth]:\\n ## residual block\\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\\n relu = Activation(activation)(bn)\\n dr = Dropout(dropout)(relu)\\n conv = Convolution1D(num, \\n filter_dim,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=stride)(dr)\\n\\n ## potential downsample\\n conv_shape = K.int_shape(conv)\\n model_shape = K.int_shape(model)\\n if conv_shape[CHANNEL_AXIS] != model_shape[CHANNEL_AXIS]:\\n model = Convolution1D(num, \\n 1,\\n init=\\\"he_normal\\\",\\n border_mode=\\\"same\\\",\\n subsample_length=2)(model)\\n\\n ## merge block\\n model = merge([model,conv],mode='sum',concat_axis=CHANNEL_AXIS)\\n\\n ## final bn+relu\\n bn = BatchNormalization(mode=0, axis=CHANNEL_AXIS)(model)\\n model = Activation(activation)(bn)\\n\\n\\n if gap:\\n pool_window_shape = K.int_shape(model)\\n gap = AveragePooling1D(pool_window_shape[ROW_AXIS],\\n stride=1)(model)\\n flatten = Flatten()(gap)\\n else:\\n flatten = Flatten()(model)\\n\\n dense = Dense(output_dim=n_classes,\\n init=\\\"he_normal\\\",\\n activation=\\\"softmax\\\")(flatten)\\n\\n model = Model(input=input, output=dense)\\n # optimizer = SGD(lr=0.01, momentum=0.9, decay=0.0, nesterov=True) \\n # model.compile(loss='categorical_crossentropy', optimizer=optimizer,metrics=['accuracy'])\\n return model\",\n \"def transition_up(self, x, filters, name):\\n with tf.name_scope(name):\\n x = tf.layers.conv2d_transpose(x,\\n filters=filters,\\n kernel_size=[3, 3],\\n strides=[2, 2],\\n padding='SAME',\\n activation=None,\\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\\n name=name+'_trans_conv3x3')\\n\\n return x\",\n \"def preprocess_module(mod):\\n\\n def alter_conv(attrs, inputs, tinfos, out_type):\\n new_attrs = dict(attrs)\\n data_info = tinfos[0]\\n weight_info = tinfos[1]\\n (desired_data_layout, desired_kernel_layout) = (\\\"NCHW\\\", \\\"OIHW\\\")\\n new_attrs[\\\"data_layout\\\"] = desired_data_layout\\n new_attrs[\\\"kernel_layout\\\"] = desired_kernel_layout\\n\\n if is_depthwise_conv2d(\\n data_info.shape,\\n attrs[\\\"data_layout\\\"],\\n weight_info.shape,\\n attrs[\\\"kernel_layout\\\"],\\n attrs[\\\"groups\\\"],\\n ):\\n dkl = desired_kernel_layout\\n new_attrs[\\\"kernel_layout\\\"] = dkl[1] + dkl[0] + dkl[2] + dkl[3]\\n return relay.nn.conv2d(*inputs, **new_attrs)\\n\\n with OpAttrContext(\\\"nn.conv2d\\\", \\\"FTVMAlterOpLayout\\\", alter_conv):\\n seq = tvm.transform.Sequential(\\n [\\n transform.ConvertLayout({\\\"nn.conv2d\\\": [\\\"NCHW\\\", \\\"OIHW\\\"]}),\\n transform.ConvertLayout({\\\"nn.conv2d_transpose\\\": [\\\"NCHW\\\", \\\"OIHW\\\"]}),\\n transform.AlterOpLayout(),\\n transform.FoldConstant(),\\n ]\\n )\\n with tvm.transform.PassContext(opt_level=3):\\n preprocessed_mod = seq(mod)\\n return preprocessed_mod\",\n \"def _get_model(\\n shape,\\n kernel_h,\\n kernel_w,\\n input_zp,\\n input_sc,\\n kernel_zp,\\n kernel_sc,\\n output_zp,\\n output_sc,\\n stride,\\n dilation,\\n groups,\\n kernel_layout,\\n dtype,\\n out_channels,\\n bias,\\n):\\n a = relay.var(\\\"a\\\", shape=shape, dtype=dtype)\\n p = tei.get_same_padding((shape[1], shape[2]), (kernel_h, kernel_w), dilation, stride)\\n weight_shape = (shape[3], out_channels // groups, kernel_h, kernel_w)\\n\\n weight_data = tvm.nd.array(\\n np.random.randint(\\n np.iinfo(dtype).min,\\n high=(np.iinfo(dtype).max + 1),\\n size=weight_shape,\\n dtype=dtype,\\n )\\n )\\n weights = relay.const(weight_data, dtype)\\n op = relay.qnn.op.conv2d_transpose(\\n a,\\n weights,\\n input_zero_point=relay.const(input_zp, \\\"int32\\\"),\\n input_scale=relay.const(input_sc, \\\"float32\\\"),\\n kernel_zero_point=relay.const(kernel_zp, \\\"int32\\\"),\\n kernel_scale=relay.const(kernel_sc, \\\"float32\\\"),\\n kernel_size=(kernel_h, kernel_w),\\n padding=p,\\n strides=stride,\\n dilation=dilation,\\n data_layout=\\\"NHWC\\\",\\n kernel_layout=kernel_layout,\\n out_dtype=\\\"int32\\\",\\n channels=out_channels,\\n groups=groups,\\n )\\n if bias:\\n bias_data = tvm.nd.array(\\n np.random.randint(\\n np.iinfo(dtype).min,\\n high=np.iinfo(dtype).max + 1,\\n size=(out_channels,),\\n dtype=\\\"int32\\\",\\n )\\n )\\n biasc = relay.const(bias_data, \\\"int32\\\")\\n op = relay.nn.bias_add(op, biasc, axis=3)\\n\\n if isinstance(kernel_sc, tvm.runtime.ndarray.NDArray):\\n req_input_sc = [sc * input_sc for sc in kernel_sc.numpy()]\\n else:\\n req_input_sc = input_sc * kernel_sc\\n\\n op = relay.qnn.op.requantize(\\n op,\\n input_zero_point=relay.const(input_zp, \\\"int32\\\"),\\n input_scale=relay.const(req_input_sc, \\\"float32\\\"),\\n output_zero_point=relay.const(output_zp, \\\"int32\\\"),\\n output_scale=relay.const(output_sc, \\\"float32\\\"),\\n axis=3,\\n rounding=\\\"UPWARD\\\",\\n out_dtype=dtype,\\n )\\n params = {\\\"w\\\": weight_data}\\n if bias:\\n params[\\\"b\\\"] = bias_data\\n return op, params\",\n \"def ConvBlock(tensor, nb_filters, kernel_size=3, padding='same', initializer='he_normal', activation=\\\"relu\\\", regularization=None):\\n\\n\\n x = Conv2D(filters=nb_filters, kernel_size=kernel_size, padding=padding, kernel_initializer=initializer, kernel_regularizer=regularization)(tensor)\\n x = BatchNormalization()(x)\\n x = Activation(activation)(x)\\n x = Conv2D(filters=nb_filters, kernel_size=kernel_size, padding=padding, kernel_initializer=initializer, kernel_regularizer=regularization)(x)\\n x = BatchNormalization()(x)\\n x = Activation(activation)(x)\\n return x\",\n \"def create_conv2d(self, x, w, b, stride = 1, name = None):\\n x = tf.nn.conv2d(x, w, strides=[1, stride, stride, 1], padding='VALID', name = name)\\n x = tf.nn.bias_add(x, b)\\n return tf.nn.relu(x)\",\n \"def __init__(self):\\n # def __init__(self, embed_size, input_channels):\\n super(OffsetCNN, self).__init__()\\n self.conv0 = nn.Conv3d(1, 1, (1, 1, 1), padding=(0,0,0))\\n self.bn0 = nn.BatchNorm3d(1)\\n self.lrelu = nn.LeakyReLU()\",\n \"def tfconv2d_transpose(in_channels,\\n out_channels,\\n kernel_size,\\n stride=1,\\n output_padding = 0,\\n groups=1,\\n bias=True,\\n dilation=1,\\n tf_padding_type = None):\\n modules = []\\n if tf_padding_type == 'same':\\n padding = nn.ZeroPad2d(0)\\n hook = hook_factory_tf_inverse_padding_same(kernel_size, stride)\\n padding.register_forward_pre_hook(hook)\\n modules.append(padding)\\n\\n # eliminate the effect of the in-build padding (is not capable of asymmeric padding)\\n if isinstance(kernel_size, int):\\n padding = kernel_size - 1\\n else:\\n padding = (kernel_size[0] - 1, kernel_size[1] - 1)\\n\\n modules.append(nn.ConvTranspose2d(in_channels,\\n out_channels,\\n kernel_size,\\n stride,\\n padding,\\n output_padding,\\n groups,\\n bias,\\n dilation))\\n\\n return nn.Sequential(*modules)\",\n \"def _build_conv_layer_params(self, input_shape):\\n conv_layer_params = []\\n if self._conv_type == '3d':\\n conv_layer_params.append(\\n dict(\\n filters=self._filters,\\n kernel_size=[self._kernel_size] * 3,\\n strides=self._strides,\\n dilation_rate=self._rates,\\n kernel_initializer=tf_utils.clone_initializer(\\n self._kernel_initializer),\\n ))\\n elif self._conv_type == '2d':\\n conv_layer_params.append(\\n dict(\\n filters=self._filters,\\n kernel_size=[1, self._kernel_size, self._kernel_size],\\n strides=[1, self._strides[1], self._strides[2]],\\n dilation_rate=[1, self._rates[1], self._rates[2]],\\n kernel_initializer=tf_utils.clone_initializer(\\n self._kernel_initializer),\\n ))\\n elif self._conv_type == '1+2d':\\n channels_in = input_shape[self._channel_axis]\\n conv_layer_params.append(\\n dict(\\n filters=channels_in,\\n kernel_size=[self._kernel_size, 1, 1],\\n strides=[self._strides[0], 1, 1],\\n dilation_rate=[self._rates[0], 1, 1],\\n kernel_initializer=tf_utils.clone_initializer(\\n self._temporal_conv_initializer),\\n ))\\n conv_layer_params.append(\\n dict(\\n filters=self._filters,\\n kernel_size=[1, self._kernel_size, self._kernel_size],\\n strides=[1, self._strides[1], self._strides[2]],\\n dilation_rate=[1, self._rates[1], self._rates[2]],\\n kernel_initializer=tf_utils.clone_initializer(\\n self._kernel_initializer),\\n ))\\n elif self._conv_type == '2+1d':\\n conv_layer_params.append(\\n dict(\\n filters=self._filters,\\n kernel_size=[1, self._kernel_size, self._kernel_size],\\n strides=[1, self._strides[1], self._strides[2]],\\n dilation_rate=[1, self._rates[1], self._rates[2]],\\n kernel_initializer=tf_utils.clone_initializer(\\n self._kernel_initializer),\\n ))\\n conv_layer_params.append(\\n dict(\\n filters=self._filters,\\n kernel_size=[self._kernel_size, 1, 1],\\n strides=[self._strides[0], 1, 1],\\n dilation_rate=[self._rates[0], 1, 1],\\n kernel_initializer=tf_utils.clone_initializer(\\n self._temporal_conv_initializer),\\n ))\\n elif self._conv_type == '1+1+1d':\\n conv_layer_params.append(\\n dict(\\n filters=self._filters,\\n kernel_size=[1, 1, self._kernel_size],\\n strides=[1, 1, self._strides[2]],\\n dilation_rate=[1, 1, self._rates[2]],\\n kernel_initializer=tf_utils.clone_initializer(\\n self._kernel_initializer),\\n ))\\n conv_layer_params.append(\\n dict(\\n filters=self._filters,\\n kernel_size=[1, self._kernel_size, 1],\\n strides=[1, self._strides[1], 1],\\n dilation_rate=[1, self._rates[1], 1],\\n kernel_initializer=tf_utils.clone_initializer(\\n self._kernel_initializer),\\n ))\\n conv_layer_params.append(\\n dict(\\n filters=self._filters,\\n kernel_size=[self._kernel_size, 1, 1],\\n strides=[self._strides[0], 1, 1],\\n dilation_rate=[self._rates[0], 1, 1],\\n kernel_initializer=tf_utils.clone_initializer(\\n self._kernel_initializer),\\n ))\\n else:\\n raise ValueError('Unsupported conv_type: {}'.format(self._conv_type))\\n return conv_layer_params\",\n \"def TBLCCCNN_Model(pan_image_height_size, pan_image_width_size, ms_to_pan_ratio, n_bands, n1_pan, n2_pan, n3_pan, \\r\\n n1_ms, n2_ms, n3_ms, dropout_rate, n_classes, l_r):\\r\\n \\r\\n if (pan_image_height_size % ms_to_pan_ratio) != 0 or (pan_image_width_size % ms_to_pan_ratio) != 0:\\r\\n raise ValueError('Please make sure that both pan_image_height_size and pan_image_width_size can be divided by {}'.format(int(ms_to_pan_ratio)))\\r\\n \\r\\n pan_img_input = Input(shape = (pan_image_height_size, pan_image_width_size, 1))\\r\\n conv_1_pan = Conv2D(n1_pan, (7, 7), padding = 'same', activation = 'relu')(pan_img_input)\\r\\n max_pool_1_pan = MaxPooling2D(pool_size = (2, 2))(conv_1_pan)\\r\\n conv_2_pan = Conv2D(n2_pan, (3, 3), padding = 'same', activation = 'relu')(max_pool_1_pan)\\r\\n max_pool_2_pan = MaxPooling2D(pool_size = (2, 2))(conv_2_pan)\\r\\n conv_3_pan = Conv2D(n3_pan, (3, 3), padding = 'same', activation = 'relu')(max_pool_2_pan)\\r\\n glob_max_pool_pan = GlobalMaxPooling2D()(conv_3_pan)\\r\\n glob_max_pool_pan = Dropout(dropout_rate)(glob_max_pool_pan)\\r\\n \\r\\n ms_img_input = Input(shape = (int(pan_image_height_size / ms_to_pan_ratio), int(pan_image_width_size / ms_to_pan_ratio), \\r\\n n_bands))\\r\\n conv_1_ms = Conv2D(n1_ms, (3, 3), padding = 'same', activation = 'relu')(ms_img_input)\\r\\n conv_2_ms = Conv2D(n2_ms, (3, 3), padding = 'same', activation = 'relu')(conv_1_ms)\\r\\n conv_3_ms = Conv2D(n3_ms, (3, 3), padding = 'same', activation = 'relu')(conv_2_ms)\\r\\n glob_max_pool_ms = GlobalMaxPooling2D()(conv_3_ms)\\r\\n glob_max_pool_ms = Dropout(dropout_rate)(glob_max_pool_ms)\\r\\n \\r\\n all_features = concatenate([glob_max_pool_pan, glob_max_pool_ms])\\r\\n \\r\\n pred_layer = Dense(n_classes, activation = 'softmax')(all_features)\\r\\n \\r\\n tblcccnn_model = Model(inputs = [ms_img_input, pan_img_input], outputs = pred_layer)\\r\\n tblcccnn_model.compile(loss = 'categorical_crossentropy', optimizer = Adam(lr = l_r), \\r\\n metrics = ['categorical_crossentropy'])\\r\\n \\r\\n return tblcccnn_model\",\n \"def __init__(self, channels, momentum):\\n super(PointNetConv2Layer, self).__init__()\\n self.channels = channels\\n self.momentum = momentum\",\n \"def _init_layers(self):\\n self.relu = nn.ReLU(inplace=True)\\n self.cls_convs = nn.ModuleList()\\n self.reg_convs = nn.ModuleList()\\n for i in range(self.stacked_convs):\\n chn = self.in_channels if i == 0 else self.feat_channels\\n self.cls_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.reg_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.retina_cls = nn.Conv2d(\\n self.feat_channels,\\n self.num_anchors * self.cls_out_channels,\\n 3,\\n padding=1)\\n self.retina_reg = nn.Conv2d(\\n self.feat_channels, self.num_anchors * 4, 3, padding=1)\",\n \"def __init__(self, in_channels, num_classes):\\n super(InceptionAux, self).__init__()\\n self.relu = nn.LeakyReLU()\\n self.dropout1 = nn.Dropout(p=0.5)\\n self.pool = nn.AvgPool2d(kernel_size=5, stride=3)\\n self.conv = conv_block(in_channels, 128, kernel_size=1)\\n self.fc1 = nn.Linear(12800, 1024)\\n self.fc2 = nn.Linear(1024, 420)\\n self.dropout2 = nn.Dropout(p=0.4)\\n self.fc3 = nn.Linear(420,128)\\n self.dropout3 = nn.Dropout(p=0.4)\\n self.fc4 = nn.Linear(128,num_classes)\",\n \"def __init__(self, dropout=0, input_dim=(3, 32, 32), num_filters=32, filter_size=7,\\r\\n hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0, \\r\\n use_batch_norm=False, dtype=np.float32):\\r\\n self.use_dropout = dropout > 0\\r\\n self.use_batch_norm = use_batch_norm\\r\\n self.params = {}\\r\\n self.reg = reg\\r\\n self.num_layers = 3\\r\\n self.dtype = dtype\\r\\n self.pool_height = 2\\r\\n self.pool_width = 2\\r\\n self.pool_stride = 2\\r\\n\\r\\n ############################################################################\\r\\n # TODO: Initialize weights and biases for the three-layer convolutional #\\r\\n # network. Weights should be initialized from a Gaussian with standard #\\r\\n # deviation equal to weight_scale; biases should be initialized to zero. #\\r\\n # All weights and biases should be stored in the dictionary self.params. #\\r\\n # Store weights and biases for the convolutional layer using the keys 'W1' #\\r\\n # and 'b1'; use keys 'W2' and 'b2' for the weights and biases of the #\\r\\n # hidden affine layer, and keys 'W3' and 'b3' for the weights and biases #\\r\\n # of the output affine layer. #\\r\\n ############################################################################\\r\\n # NUmber of channels\\r\\n C, H, W = input_dim\\r\\n self.params['W1'] = np.random.randn(num_filters, C, filter_size, filter_size) * weight_scale\\r\\n self.params['b1'] = np.zeros(num_filters)\\r\\n H_pool = (H - self.pool_height) / 2 + 1\\r\\n W_pool = (W - self.pool_width) / 2 + 1\\r\\n self.params['W2'] = np.random.randn(np.prod((num_filters, H_pool, W_pool)), hidden_dim) * weight_scale\\r\\n self.params['b2'] = np.zeros(hidden_dim)\\r\\n self.params['W3'] = np.random.randn(hidden_dim, num_classes) * weight_scale\\r\\n self.params['b3'] = np.zeros(num_classes)\\r\\n\\r\\n # Initialize the parameters for batch normalization if necessary\\r\\n if self.use_batch_norm:\\r\\n self.params['gamma1'] = np.ones(num_filters) \\r\\n self.params['beta1'] = np.zeros(num_filters)\\r\\n self.params['gamma2'] = np.ones(hidden_dim)\\r\\n self.params['beta2'] = np.zeros(hidden_dim)\\r\\n\\r\\n # Set dropout parameters if necessary\\r\\n self.dropout_param={}\\r\\n if self.use_dropout:\\r\\n self.dropout_param ={'mode':'train', 'p':dropout}\\r\\n\\r\\n self.bn_params = []\\r\\n if self.use_batch_norm:\\r\\n self.bn_params = [{'mode': 'train'} for i in range(self.num_layers - 1)]\\r\\n\\r\\n ############################################################################\\r\\n # END OF YOUR CODE #\\r\\n ############################################################################\\r\\n\\r\\n for k, v in self.params.items():\\r\\n self.params[k] = v.astype(dtype)\",\n \"def __init__(self):\\n\\n super(ConvModule, self).__init__()\\n\\n self.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=5, stride=[1, 2])\\n self.conv1_bn = nn.BatchNorm2d(64)\\n self.conv2 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=5, stride=[1, 2])\\n self.conv2_bn = nn.BatchNorm2d(128)\\n self.pool1 = nn.MaxPool2d(kernel_size=4, stride=2)\\n self.dropout0 = nn.Dropout(p=0.4)\\n\\n self.conv3 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=[1, 2])\\n self.conv3_bn = nn.BatchNorm2d(256)\\n self.conv4 = nn.Conv2d(in_channels=256, out_channels=64, kernel_size=3, stride=[1, 2])\\n self.conv4_bn = nn.BatchNorm2d(64)\\n self.pool2 = nn.MaxPool2d(kernel_size=4, stride=2)\\n #\\n # self.conv5 = nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=[1, 2])\\n # self.conv5_bn = nn.BatchNorm2d(64)\\n # self.pool3 = nn.MaxPool2d(kernel_size=3, stride=[1, 2])\",\n \"def conv_layer( x, params, training ):\\n\\n batch_norm = params[4] # Boolean\\n\\n if batch_norm:\\n activation = None\\n else:\\n activation = tf.nn.relu\\n\\n kernel_initializer = tf.contrib.layers.variance_scaling_initializer()\\n bias_initializer = tf.constant_initializer( value=0.0 )\\n\\n top = tf.layers.conv2d( x, \\n filters=params[0],\\n kernel_size=params[1],\\n padding=params[2],\\n activation=activation,\\n kernel_initializer=kernel_initializer,\\n bias_initializer=bias_initializer,\\n name=params[3] )\\n if batch_norm:\\n top = norm_layer( top, training, params[3]+'/batch_norm' )\\n top = tf.nn.relu( top, name=params[3]+'/relu' )\\n\\n return top\",\n \"def init(self):\\n self.reparam_layers = []\\n if self.model_type == \\\"GCN\\\":\\n for i in range(self.num_layers):\\n if self.reparam_all_layers is True:\\n is_reparam = True\\n elif isinstance(self.reparam_all_layers, tuple):\\n reparam_all_layers = tuple([kk + self.num_layers if kk < 0 else kk for kk in self.reparam_all_layers])\\n is_reparam = i in reparam_all_layers\\n else:\\n raise\\n if is_reparam:\\n self.reparam_layers.append(i)\\n setattr(self, \\\"conv{}\\\".format(i + 1),\\n GCNConv(self.num_features if i == 0 else self.latent_size,\\n self.latent_size if i != self.num_layers - 1 else self.num_classes,\\n cached=True,\\n reparam_mode=self.reparam_mode if is_reparam else None,\\n prior_mode=self.prior_mode if is_reparam else None,\\n sample_size=self.sample_size,\\n bias=True if self.with_relu else False,\\n val_use_mean=self.val_use_mean,\\n normalize=self.normalize,\\n ))\\n # self.conv1 = ChebConv(self.num_features, 16, K=2)\\n # self.conv2 = ChebConv(16, self.num_features, K=2)\\n\\n elif self.model_type == \\\"GAT\\\":\\n latent_size = int(self.latent_size / 2) # Under the default setting, latent_size = 8\\n for i in range(self.num_layers):\\n if i == 0:\\n input_size = self.num_features\\n else:\\n if self.struct_dropout_mode[0] == 'DNsampling' or (self.struct_dropout_mode[0] == 'standard' and len(self.struct_dropout_mode) == 3):\\n input_size = latent_size * 8 * 2\\n else:\\n input_size = latent_size * 8\\n if self.reparam_all_layers is True:\\n is_reparam = True\\n elif isinstance(self.reparam_all_layers, tuple):\\n reparam_all_layers = tuple([kk + self.num_layers if kk < 0 else kk for kk in self.reparam_all_layers])\\n is_reparam = i in reparam_all_layers\\n else:\\n raise\\n if is_reparam:\\n self.reparam_layers.append(i)\\n setattr(self, \\\"conv{}\\\".format(i + 1), GATConv(\\n input_size,\\n latent_size if i != self.num_layers - 1 else self.num_classes,\\n heads=8 if i != self.num_layers - 1 else 1, concat=True,\\n reparam_mode=self.reparam_mode if is_reparam else None,\\n prior_mode=self.prior_mode if is_reparam else None,\\n val_use_mean=self.val_use_mean,\\n struct_dropout_mode=self.struct_dropout_mode,\\n sample_size=self.sample_size,\\n ))\\n if self.struct_dropout_mode[0] == 'DNsampling' or (self.struct_dropout_mode[0] == 'standard' and len(self.struct_dropout_mode) == 3):\\n setattr(self, \\\"conv{}_1\\\".format(i + 1), GATConv(\\n input_size,\\n latent_size if i != self.num_layers - 1 else self.num_classes,\\n heads=8 if i != self.num_layers - 1 else 1, concat=True,\\n reparam_mode=self.reparam_mode if is_reparam else None,\\n prior_mode=self.prior_mode if is_reparam else None,\\n val_use_mean=self.val_use_mean,\\n struct_dropout_mode=self.struct_dropout_mode,\\n sample_size=self.sample_size,\\n ))\\n # On the Pubmed dataset, use heads=8 in conv2.\\n \\n else:\\n raise Exception(\\\"Model_type {} is not valid!\\\".format(self.model_type))\\n\\n self.reparam_layers = sorted(self.reparam_layers)\\n \\n if self.model_type == \\\"GCN\\\":\\n if self.with_relu:\\n reg_params = [getattr(self, \\\"conv{}\\\".format(i+1)).parameters() for i in range(self.num_layers - 1)]\\n self.reg_params = itertools.chain(*reg_params)\\n self.non_reg_params = getattr(self, \\\"conv{}\\\".format(self.num_layers)).parameters()\\n else:\\n self.reg_params = OrderedDict()\\n self.non_reg_params = self.parameters()\\n else:\\n self.reg_params = self.parameters()\\n self.non_reg_params = OrderedDict()\\n self.to(self.device)\",\n \"def testTransposeNDHWC(self, use_bias):\\n\\n conv3_transpose = snt.Conv3DTranspose(\\n output_channels=self.out_channels,\\n output_shape=self.out_shape,\\n kernel_shape=self.kernel_shape,\\n padding=self.padding,\\n stride=self.strides,\\n name=\\\"conv3_transpose\\\",\\n use_bias=use_bias,\\n data_format=conv.DATA_FORMAT_NDHWC)\\n conv3 = conv3_transpose.transpose()\\n\\n # Check kernel shapes, strides and padding match.\\n self.assertEqual(conv3_transpose.kernel_shape, conv3.kernel_shape)\\n self.assertEqual((1,) + self.strides + (1,), conv3.stride)\\n self.assertEqual(conv3_transpose.padding, conv3.padding)\\n\\n # Before conv3_transpose is connected, we cannot know how many\\n # `output_channels` conv1 should have.\\n err = \\\"Variables in conv3_transpose not instantiated yet\\\"\\n with self.assertRaisesRegexp(snt.NotConnectedError, err):\\n _ = conv3.output_channels\\n\\n # After connection the number of `output_channels` is known.\\n x = tf.constant(np.random.randn(self.batch_size,\\n self.in_depth,\\n self.in_height,\\n self.in_width,\\n self.in_channels),\\n dtype=np.float32)\\n conv3_transpose(x)\\n self.assertEqual(self.in_channels, conv3.output_channels)\\n\\n # However, even after connection, the `input_shape` of the forward\\n # convolution is not known until it is itself connected (i.e. it can be\\n # connected to a different shape input from the `output_shape` of the\\n # transpose convolution!)\\n err = \\\"Variables in conv3_transpose_transpose not instantiated yet\\\"\\n with self.assertRaisesRegexp(snt.NotConnectedError, err):\\n self.assertEqual(conv3_transpose.output_shape, conv3.input_shape)\",\n \"def _cnn(self, state):\\n\\n x = self.relu(self.bn1(self.conv1(state)))\\n x = self.relu(self.bn2(self.conv2(x)))\\n x = self.relu(self.bn3(self.conv3(x)))\\n x = x.reshape(x.size(0), -1)\\n\\n return x\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63744015","0.5864105","0.586131","0.5837967","0.5762193","0.5750853","0.57461226","0.57346827","0.57076824","0.5697772","0.56805575","0.5673117","0.5603193","0.5555773","0.5510417","0.5501909","0.5458268","0.5454152","0.5436939","0.54160196","0.5399038","0.5372593","0.5354265","0.53359497","0.5329868","0.5324369","0.5316291","0.5275935","0.527529","0.5274735","0.52554935","0.5250095","0.5249805","0.5241396","0.52408975","0.5237673","0.5217749","0.52164125","0.5203961","0.51971924","0.5193027","0.5169981","0.5166881","0.5160659","0.51566744","0.5151312","0.5146965","0.5131167","0.5129982","0.51272506","0.51125085","0.5103719","0.51014584","0.5098909","0.50944656","0.50888586","0.5088253","0.50842744","0.5081012","0.5079887","0.50786436","0.5075608","0.5066643","0.506659","0.50654864","0.50645113","0.50586843","0.50512624","0.5050964","0.5050336","0.5045266","0.5042272","0.50382125","0.50376624","0.5027292","0.5026898","0.5022594","0.5020507","0.501732","0.5014824","0.5010148","0.5006858","0.50068164","0.5005773","0.50027585","0.49993378","0.49941555","0.49938512","0.49931356","0.49913782","0.49899685","0.49841","0.49810472","0.49802715","0.49791726","0.49772426","0.4971043","0.49682346","0.49646273","0.49598143"],"string":"[\n \"0.63744015\",\n \"0.5864105\",\n \"0.586131\",\n \"0.5837967\",\n \"0.5762193\",\n \"0.5750853\",\n \"0.57461226\",\n \"0.57346827\",\n \"0.57076824\",\n \"0.5697772\",\n \"0.56805575\",\n \"0.5673117\",\n \"0.5603193\",\n \"0.5555773\",\n \"0.5510417\",\n \"0.5501909\",\n \"0.5458268\",\n \"0.5454152\",\n \"0.5436939\",\n \"0.54160196\",\n \"0.5399038\",\n \"0.5372593\",\n \"0.5354265\",\n \"0.53359497\",\n \"0.5329868\",\n \"0.5324369\",\n \"0.5316291\",\n \"0.5275935\",\n \"0.527529\",\n \"0.5274735\",\n \"0.52554935\",\n \"0.5250095\",\n \"0.5249805\",\n \"0.5241396\",\n \"0.52408975\",\n \"0.5237673\",\n \"0.5217749\",\n \"0.52164125\",\n \"0.5203961\",\n \"0.51971924\",\n \"0.5193027\",\n \"0.5169981\",\n \"0.5166881\",\n \"0.5160659\",\n \"0.51566744\",\n \"0.5151312\",\n \"0.5146965\",\n \"0.5131167\",\n \"0.5129982\",\n \"0.51272506\",\n \"0.51125085\",\n \"0.5103719\",\n \"0.51014584\",\n \"0.5098909\",\n \"0.50944656\",\n \"0.50888586\",\n \"0.5088253\",\n \"0.50842744\",\n \"0.5081012\",\n \"0.5079887\",\n \"0.50786436\",\n \"0.5075608\",\n \"0.5066643\",\n \"0.506659\",\n \"0.50654864\",\n \"0.50645113\",\n \"0.50586843\",\n \"0.50512624\",\n \"0.5050964\",\n \"0.5050336\",\n \"0.5045266\",\n \"0.5042272\",\n \"0.50382125\",\n \"0.50376624\",\n \"0.5027292\",\n \"0.5026898\",\n \"0.5022594\",\n \"0.5020507\",\n \"0.501732\",\n \"0.5014824\",\n \"0.5010148\",\n \"0.5006858\",\n \"0.50068164\",\n \"0.5005773\",\n \"0.50027585\",\n \"0.49993378\",\n \"0.49941555\",\n \"0.49938512\",\n \"0.49931356\",\n \"0.49913782\",\n \"0.49899685\",\n \"0.49841\",\n \"0.49810472\",\n \"0.49802715\",\n \"0.49791726\",\n \"0.49772426\",\n \"0.4971043\",\n \"0.49682346\",\n \"0.49646273\",\n \"0.49598143\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61901104"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":94286,"cells":{"query":{"kind":"string","value":"Allocate an Embedding Layer."},"document":{"kind":"string","value":"def __init__(self, input, input_size, embedding_size):\n\n self.input = input\n self.output = layers.EmbeddingLayer(self.input, input_size, embedding_size, W=initialize_parameters()[0])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def embedding_layer(self):\n with tf.name_scope(\"Embedding_Layer\"):\n V_size = len(self.vocab)\n embed_dim = len(self.embed[0]) \n W_embed_ = tf.get_variable(\"W_embed\",shape=[V_size, embed_dim],trainable=False).assign(np.asarray(self.embed))\n W_analogy_embed_ = tf.get_variable(\"W_analogy_embed\",shape=[V_size, embed_dim],trainable=True,initializer=tf.random_uniform_initializer(minval=-1,maxval=1))\n return W_embed_, W_analogy_embed_","def build_embedding_layer(inputs_, vocab_size, embed_size):\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_size), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, inputs_)\n \n return embed","def __init__(self, layer_id,\n shape, X):\n prefix = 'Embedding' + layer_id\n self.n_words, self.in_size = shape\n\n # weights for embedding, the only parameters\n self.W = init_weights(shape=(self.n_words, self.in_size),\n name=prefix + '#W')\n\n self.params = [self.W]\n\n # Compute the embedded samples\n self.n_timesteps = X.shape[0]\n self.n_samples = X.shape[1]\n\n self.activation = self.W[X.flatten()].reshape([self.n_timesteps,\n self.n_samples,\n self.in_size])","def _embed(self):\n with tf.variable_scope('word_embedding'):\n self.pretrained_word_mat = tf.get_variable(\"word_emb_mat\",\n [self.vocab.word_size() - 2, self.vocab.word_embed_dim],\n dtype=tf.float32,\n initializer=tf.constant_initializer(\n self.vocab.word_embeddings[2:],\n dtype=tf.float32),\n trainable=False)\n self.word_pad_unk_mat = tf.get_variable(\"word_unk_pad\",\n [2, self.pretrained_word_mat.get_shape()[1]],\n dtype=tf.float32,\n initializer=tf.constant_initializer(\n self.vocab.word_embeddings[:2],\n dtype=tf.float32),\n trainable=True)\n\n self.word_mat = tf.concat([self.word_pad_unk_mat, self.pretrained_word_mat], axis=0)\n self.p_emb = tf.nn.embedding_lookup(self.word_mat, self.p)\n self.q_emb = tf.nn.embedding_lookup(self.word_mat, self.q)","def __init__(self, input_size, config):\r\n super(EmbeddingLayer, self).__init__()\r\n\r\n if config.emtraining:\r\n self.embedding = nn.Sequential(OrderedDict([\r\n ('embedding', nn.Embedding(input_size, config.emsize)),\r\n ('dropout', nn.Dropout(config.dropout))\r\n ]))\r\n else:\r\n self.embedding = nn.Embedding(input_size, config.emsize)\r\n self.embedding.weight.requires_grad = False","def __init__(self, cfg, name=''):\n nn.Layer.__init__(self)\n self.cfg = cfg\n d_model = cfg['hidden_size']\n d_emb = cfg.get('emb_size', cfg['hidden_size'])\n d_vocab = cfg['vocab_size']\n d_pos = cfg['max_position_embeddings']\n # d_sent = cfg.get(\"sent_type_vocab_size\", 4) or cfg.get('type_vocab_size', 4)\n if cfg.get('sent_type_vocab_size'):\n d_sent = cfg['sent_type_vocab_size']\n else:\n d_sent = cfg.get('type_vocab_size', 2)\n self.n_head = cfg['num_attention_heads']\n self.return_additional_info = cfg.get('return_additional_info', False)\n self.initializer = nn.initializer.TruncatedNormal(std=cfg['initializer_range'])\n\n self.ln = _build_ln(d_model, name=append_name(name, 'pre_encoder'))\n self.word_emb = nn.Embedding(d_vocab,\n d_emb,\n weight_attr=paddle.ParamAttr(name=append_name(name, 'word_embedding'),\n initializer=self.initializer))\n self.pos_emb = nn.Embedding(d_pos,\n d_emb,\n weight_attr=paddle.ParamAttr(name=append_name(name, 'pos_embedding'),\n initializer=self.initializer))\n # self.sent_emb = nn.Embedding(\n # d_sent,\n # d_emb,\n # weight_attr=paddle.ParamAttr(name=append_name(name, 'sent_embedding'), initializer=self.initializer))\n self._use_sent_id = cfg.get('use_sent_id', True)\n self._use_sent_id = False\n if self._use_sent_id:\n self.sent_emb = nn.Embedding(d_sent,\n d_emb,\n weight_attr=paddle.ParamAttr(name=append_name(name, 'sent_embedding'),\n initializer=self.initializer))\n self._use_task_id = cfg.get('use_task_id', False)\n self._use_task_id = False\n if self._use_task_id:\n self._task_types = cfg.get('task_type_vocab_size', 3)\n logging.info('using task_id, #task_types:{}'.format(self._task_types))\n self.task_emb = nn.Embedding(self._task_types,\n d_emb,\n weight_attr=paddle.ParamAttr(name=append_name(name, 'task_embedding'),\n initializer=self.initializer))\n\n prob = cfg['hidden_dropout_prob']\n self.dropout = nn.Dropout(p=prob)\n\n self.encoder_stack = ErnieEncoderStack(cfg, append_name(name, 'encoder'))\n\n if cfg.get('has_pooler', True):\n self.pooler = _build_linear(cfg['hidden_size'], cfg['hidden_size'], append_name(name, 'pooled_fc'),\n self.initializer)\n else:\n self.pooler = None\n\n self.key_tag = None\n self._checkpoints = []\n self.train()","def __init__(self, heropool_size, embedding_dim):\r\n super().__init__()\r\n self.embedding_dim = embedding_dim\r\n self.embeddings = nn.Embedding(heropool_size, embedding_dim)\r\n self.affine = nn.Linear(embedding_dim, heropool_size)\r\n self.init_emb()","def _embed(self):\n with tf.variable_scope('word_embedding'):\n self.word_embeddings = tf.get_variable(\n 'word_embeddings',\n shape=(self.term_vocab.size(), self.term_vocab.embed_dim),\n initializer=tf.constant_initializer(self.term_vocab.embeddings),\n trainable=True\n )\n self.p_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.p)\n self.q_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.q)\n\n with tf.variable_scope('char_embedding'):\n self.char_embeddings = tf.get_variable(\n 'char_embeddings',\n shape=(self.char_vocab.size(), self.char_vocab.embed_dim),\n initializer=tf.constant_initializer(self.char_vocab.embeddings),\n trainable=True\n )\n self.p_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.p_char) # [batch, seqlen, max_char_num, embedding_size]\n self.q_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.q_char)\n\n self.p_char_emb = self.cnn_emb(self.p_char_emb, \"p_emb\")\n self.q_char_emb = self.cnn_emb(self.q_char_emb, \"q_emb\")\n '''\n self.p_char_emb = tf.reshape(self.p_char_emb, [-1, self.max_char_num, self.emb_size])\n self.q_char_emb = tf.reshape(self.q_char_emb, [-1, self.max_char_num, self.emb_size])\n\n self.p_char_emb = cnn_layer.conv(self.p_char_emb, self.emb_size,\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\"char_conv\", reuse=None)\n self.q_char_emb = cnn_layer.conv(self.q_char_emb, self.emb_size,\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\"char_conv\", reuse=True)\n\n self.p_char_emb = tf.reduce_max(self.p_char_emb, axis=1) # [batch*seqlen, 1, emb_size]\n self.q_char_emb = tf.reduce_max(self.q_char_emb, axis=1)\n\n batch_size = tf.shape(self.p_word_emb)[0]\n self.p_char_emb = tf.reshape(self.p_char_emb, [batch_size, -1, self.emb_size])\n self.q_char_emb = tf.reshape(self.q_char_emb, [batch_size, -1, self.emb_size])\n\n self.p_char_emb = tf.nn.dropout(self.p_char_emb, 0.95)\n self.q_char_emb = tf.nn.dropout(self.q_char_emb, 0.95)\n '''\n self.p_emb = tf.concat([self.p_word_emb, self.p_char_emb], -1)\n self.q_emb = tf.concat([self.q_word_emb, self.q_char_emb], -1)","def __init__(self,\n embedding_dim: int = 64,\n scale: bool = False,\n vocab_size: int = 0,\n padding_idx: int = 1,\n freeze: bool = False,\n **kwargs):\n super(Embeddings, self).__init__()\n\n self.embedding_dim = embedding_dim\n self.scale = scale\n self.vocab_size = vocab_size\n self.lut = nn.Embedding(vocab_size, self.embedding_dim,\n padding_idx=padding_idx)\n\n if freeze:\n freeze_params(self)","def pretrained_embedding_layer(word_to_vec_map, word_to_index):\n \n vocab_size = len(word_to_index) + 1 # adding 1 to fit Keras embedding (requirement)\n any_word = list(word_to_vec_map.keys())[0]\n emb_dim = word_to_vec_map[any_word].shape[0] # define dimensionality of your GloVe word vectors (= 50)\n \n ### START CODE HERE ###\n # Step 1\n # Initialize the embedding matrix as a numpy array of zeros.\n # See instructions above to choose the correct shape.\n emb_matrix = np.zeros((vocab_size, emb_dim))\n \n # Step 2\n # Set each row \"idx\" of the embedding matrix to be \n # the word vector representation of the idx'th word of the vocabulary\n for word, idx in word_to_index.items():\n emb_matrix[idx, :] = word_to_vec_map[word]\n\n # Step 3\n # Define Keras embedding layer with the correct input and output sizes\n # Make it non-trainable.\n embedding_layer = tensorflow.keras.layers.Embedding(input_dim = vocab_size, output_dim = emb_dim, trainable = False)\n ### END CODE HERE ###\n\n # Step 4 (already done for you; please do not modify)\n # Build the embedding layer, it is required before setting the weights of the embedding layer. \n embedding_layer.build((None,)) # Do not modify the \"None\". This line of code is complete as-is.\n \n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\n embedding_layer.set_weights([emb_matrix])\n \n return embedding_layer","def pretrained_embedding_layer(word_to_vec_map, word_to_index):\n vocab_len = len(word_to_index) + 1 # adding 1 to fit Keras embedding (requirement)\n emb_dim = word_to_vec_map[\"cucumber\"].shape[0] # define dimensionality of your GloVe word vectors (= 50)\n emb_matrix = np.zeros((vocab_len, emb_dim)) # Initialize the embedding matrix as a numpy array of zeros of shape (vocab_len, dimensions of word vectors = emb_dim)\n for word, index in word_to_index.items(): # Set each row \"index\" of the embedding matrix to be the word vector representation of the \"index\"th word of the vocabulary\n emb_matrix[index, :] = word_to_vec_map[word]\n embedding_layer = Embedding(vocab_len, emb_dim, trainable = False) # Define Keras embedding layer with the correct output/input sizes, make it trainable. Use Embedding(...). Make sure to set trainable=False. \n embedding_layer.build((None,)) # Build the embedding layer, it is required before setting the weights of the embedding layer. Do not modify the \"None\".\n embedding_layer.set_weights([emb_matrix]) # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\n return embedding_layer","def add_embedding(self):\n ### YOUR CODE HERE (~4-6 lines)\n embeddingTensor = tf.Variable(self.pretrained_embeddings)\n embeddings = tf.nn.embedding_lookup(embeddingTensor, self.input_placeholder)\n embeddings = tf.reshape(embeddings, [-1, self.max_length, Config.n_features * Config.embed_size])\n ### END YOUR CODE\n return embeddings","def __init__(self, vocab_size, embedding_size, context_size, hid_dim, out_dim):\n super(Net, self).__init__()\n self.E = nn.Embedding(vocab_size, embedding_size) # Embedding matrix\n self.after_embed_size = embedding_size * context_size\n self.lin = nn.Linear(self.after_embed_size, hid_dim)\n self.lin2 = nn.Linear(hid_dim, out_dim)","def __init__(self, embed_size, device, pool_size, attribute_dim):\n super(EncoderClothing, self).__init__()\n self.device = device\n self.linear = nn.Linear(512*pool_size*pool_size, embed_size)\n self.relu = nn.ReLU()\n #self.module_list = nn.ModuleList([nn.Linear(embed_size, att_size) for att_size in attribute_dim])\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\n self.dropout = nn.Dropout(0.5)\n self.pool_size = pool_size\n\n self.module_list = nn.ModuleList([self.conv_bn(512, 256, 1, embed_size, att_size) for att_size in attribute_dim])","def __init__(self, input_dim, output_dim, name='embedding_layer'):\n self.input_dim = input_dim\n self.output_dim = output_dim\n self.name = name\n\n # Randomly generate weights\n self.embeddings = shared((input_dim, output_dim),\n self.name + '__embeddings')\n\n # Define parameters\n self.params = [self.embeddings]","def __init__(self, embed_size, device, pool_size, attribute_dim):\n super(EncoderClothing, self).__init__()\n self.device = device\n self.linear = nn.Linear(512*pool_size*pool_size, embed_size)\n self.module_list = nn.ModuleList([nn.Linear(512*pool_size*pool_size, att_size) for att_size in attribute_dim])\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\n self.pool_size = pool_size","def _get_embedding_layer(self, input_data, doc_input_data):\n opts = self._options\n word_embedding = tf.Variable(tf.random_uniform((self.vocab_size, opts.embed_dim), -1.0, 1.0))\n embed = []\n\n temp = tf.zeros([opts.batch_size, opts.embed_dim])\n embed_d = []\n for n in range(opts.sentence_sample):\n temp = tf.add(temp, tf.nn.embedding_lookup(word_embedding, doc_input_data[:, n]))\n embed_d.append(temp)\n\n if opts.concat == 'True':\n combined_embed_vector_length = opts.embed_dim * opts.window_size + opts.embed_dim\n for j in range(opts.window_size):\n embed_w = tf.nn.embedding_lookup(word_embedding, input_data[:, j])\n embed.append(embed_w)\n embed.append(embed_d)\n else:\n combined_embed_vector_length = opts.embed_dim\n embed_w = tf.zeros([opts.batch_size, opts.embed_dim])\n for j in range(opts.window_size):\n embed_w += tf.nn.embedding_lookup(word_embedding, input_data[:, j])\n embed_w += embed_d\n embed.append(embed_w)\n\n return tf.concat(embed, 1), word_embedding, combined_embed_vector_length","def embedding_layer(n_categories, embedding_dim, name=None):\n\n input_tensor = Input(shape=(1,))\n x = Embedding(n_categories, embedding_dim, name=name)(input_tensor)\n x = Reshape(target_shape=(embedding_dim,))(x)\n\n return input_tensor, x","def __init__(self, embed_size):\n super(ImgAttentionEncoder, self).__init__()\n vggnet_feat = models.vgg19(pretrained=True).features\n modules = list(vggnet_feat.children())[:-2]\n self.cnn = nn.Sequential(*modules)\n self.fc = nn.Sequential(nn.Linear(self.cnn[-3].out_channels, embed_size),\n nn.Tanh()) # feature vector of image","def add_embedding(self, prefix=''):\n with tf.variable_scope(prefix + 'embed'):\n if self.cfg.fix_emb:\n assert (hasattr(self.cfg, 'W_emb'))\n W_emb = pkl.load(open(self.cfg.W_emb_path, 'rb'))\n W = tf.get_variable('W', initializer= W_emb, trainable=True)\n print(\"iniitalize word embedding finished\")\n else:\n weightInit = tf.random_uniform_initializer(-0.001, 0.001)\n vocab = pkl.load(open(self.cfg.vocab_path, 'rb'))\n W = tf.get_variable('W', [len(vocab), self.cfg.emb_size], initializer=weightInit)\n if hasattr(self.cfg, 'relu_w') and self.cfg.relu_w:\n W = tf.nn.relu(W)\n return W","def __init__(self, vocab, embed_size=512, dropout_rate=0.1, max_len=200):\n super(DecoderEmbeddings, self).__init__()\n pad_token_idx = 0 #vocab.tokenizer.ids_to_tokens[0]\n assert vocab.tokenizer.ids_to_tokens[0] == '[PAD]'\n self.embeddings = nn.Embedding(len(vocab.tokenizer.ids_to_tokens), embed_size, padding_idx=pad_token_idx)\n self.positional_encoding = PositionalEncoding(d_model=embed_size, dropout=dropout_rate, max_len=max_len)","def add_embeddings(self):\n\n with tf.device('/cpu:0'):\n with tf.variable_scope('Embedding_Layer'):\n embeddings = tf.Variable(self.initial_embeddings,name = 'Embeddings')\n self.input_embeddings = tf.nn.embedding_lookup(embeddings, self.inputs_placeholder) #(N,S,D)\n self.question_embeddings = tf.nn.embedding_lookup(embeddings, self.questions_placeholder) #(N,S,D)","def pretrained_embedding_layer(model,model2,model3, word_to_index,emb_dim_max):\n words_ignored = []\n vocab_len = len(word_to_index) + 1 \n emb_matrix = np.zeros([vocab_len,emb_dim_max])\n \n print(' Total words would be processed : '+str(vocab_len))\n for word, idx in word_to_index.items():\n if word in model:\n emb_matrix[idx,:200] = model[word]\n emb_matrix[idx,200:] = 0\n if word in model2:\n emb_matrix[idx, :100] = model2[word]\n emb_matrix[idx, 100:] = 0\n if word in model3.keys():\n emb_matrix[idx,:] = model3[word]\n else:\n words_ignored.append(word)\n print(str(len(words_ignored))+\" words ignored\")\n print(emb_matrix.shape) \n \n \n embedding_layer = Embedding(vocab_len,emb_dim_max,trainable = True)\n \n # Build the embedding layer, it is required before setting the weights of the embedding layer. \n embedding_layer.build((None,)) # Do not modify the \"None\". This line of code is complete as-is.\n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\n embedding_layer.set_weights([emb_matrix])\n \n return embedding_layer,words_ignored","def __init__(self, embed_size, vocab):\n super(ModelEmbeddings, self).__init__()\n \n self.embed_size = embed_size\n self.char_embed_size = 50\n self.max_word_len = 21\n self.dropout_rate = 0.3\n self.vocab = vocab \n \n ## A4 code\n pad_token_idx = vocab.char2id['<pad>']\n self.embedding = nn.Embedding(num_embeddings =len(vocab.char2id),\n embedding_dim =self.char_embed_size,\n padding_idx =pad_token_idx,)\n \n self.CNN = CNN(char_embed_size=self.char_embed_size,\n num_filters=embed_size,\n max_word_length=self.max_word_len,)\n self.Highway = Highway(word_embed_size=self.embed_size)\n self.dropout = nn.Dropout(p=self.dropout_rate)\n ## End A4 code\n\n ### YOUR CODE HERE for part 1j\n\n\n ### END YOUR CODE","def _add_embedding_layer(model_1, model_2):\n result_layer = torch.nn.Embedding(\n model_1.num_embeddings, model_1.embedding_dim + model_2.embedding_dim\n )\n result_layer.weight = torch.nn.Parameter(\n torch.cat((model_1.weight.data, model_2.weight.data), dim=1)\n )\n return result_layer","def add_out_layer(self, embedding):\n self.ac_dim = self.ac_space.shape[-1] # num dims\n embedding = snt.Linear(output_size=self.ac_dim, name='final',\n initializers=self.out_initializers)(embedding)\n return embedding","def make_embedding(src_emb_hparams, src_token_to_id_map,\n tgt_emb_hparams=None, tgt_token_to_id_map=None,\n emb_init_share=False):\n src_embedding = MonoTextData.make_embedding(src_emb_hparams,\n src_token_to_id_map)\n\n if emb_init_share:\n tgt_embedding = src_embedding\n else:\n tgt_emb_file = tgt_emb_hparams[\"file\"]\n tgt_embedding = None\n if tgt_emb_file is not None and tgt_emb_file != \"\":\n tgt_embedding = Embedding(tgt_token_to_id_map, tgt_emb_hparams)\n\n return src_embedding, tgt_embedding","def __init__(self, embed_size):\n super(Encoder, self).__init__()\n resnet = models.resnet152(pretrained=True)\n modules = list(resnet.children())[:-1] # delete the last fc layer.\n self.resnet = nn.Sequential(*modules) \n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)","def __init__(self, embed_size):\n super(EncoderCNN, self).__init__()\n resnet = models.resnet152(pretrained=True)\n modules = list(resnet.children())[:-1] # delete the last fc layer.\n self.resnet = nn.Sequential(*modules)\n self.pooling = nn.MaxPool2d(2,stride = 2)\n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\n self.init_weights()","def __init__(self, embed_size):\n super(EncoderCNN, self).__init__()\n resnet = models.resnet152(pretrained=True)\n modules = list(resnet.children())[:-1] # delete the last fc layer.\n self.resnet = nn.Sequential(*modules)\n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\n self.init_weights()","def get_keras_layer(self, trainable=False, **kwargs):\n\n try:\n from keras.layers.embeddings import Embedding\n except:\n raise ImportError('Keras not found')\n\n return Embedding(self.vocab_size, self.dim, weights=[self._matrix], trainable=trainable, **kwargs)","def __init__(self, embed_size):\n super(EncoderCNN, self).__init__()\n resnet = models.resnet152(pretrained=True)\n modules = list(resnet.children())[:-1] # delete the last fc layer.\n self.resnet = nn.Sequential(*modules)\n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)","def __init__(self, num_words, embedding_size, use_cuda):\n super(StandardEmbedding, self).__init__()\n self.embedding_size = embedding_size\n self.num_hash_functions = 0\n self.embeddings = nn.Embedding(num_words, embedding_size)\n self.embeddings = self.embeddings.cuda() if use_cuda else self.embeddings","def build(self, unused_input_shapes):\n if self.embedding_lookup is None:\n self.embedding_lookup = layers.OnDeviceEmbedding(\n vocab_size=self.config.vocab_size,\n embedding_width=self.config.hidden_size,\n initializer=tf.keras.initializers.TruncatedNormal(\n stddev=self.config.initializer_range),\n name=\"target_embeddings\")\n self.embedding_postprocessor = EmbeddingPostprocessor(\n use_type_embeddings=False,\n use_position_embeddings=True,\n max_position_embeddings=self.config.max_position_embeddings,\n dropout_prob=self.config.hidden_dropout_prob,\n initializer=tf.keras.initializers.VarianceScaling(\n scale=self.config.initializer_gain,\n mode=\"fan_avg\",\n distribution=\"uniform\"),\n name=\"embedding_postprocessor\")\n # Decoder can use a different intermediate size.\n self.multi_channel_cross_attention = self.config.get(\n \"multi_channel_cross_attention\", False)\n self.decoder = TransformerDecoder(\n num_hidden_layers=self.config.num_decoder_layers,\n hidden_size=self.config.hidden_size,\n num_attention_heads=self.config.num_decoder_attn_heads,\n intermediate_size=self.config.decoder_intermediate_size,\n intermediate_activation=self.config.hidden_act,\n hidden_dropout_prob=self.config.hidden_dropout_prob,\n attention_probs_dropout_prob=self.config.attention_probs_dropout_prob,\n initializer_range=self.config.initializer_range,\n multi_channel_cross_attention=self.multi_channel_cross_attention,\n name=\"decoder\")\n super(Decoder, self).build(unused_input_shapes)","def _embed(self):\n batch_size = tf.shape(self.p)[0]\n with tf.variable_scope(\"emb\"):\n with tf.variable_scope(\"char\"):\n pc_emb = tf.reshape(tf.nn.embedding_lookup(\n self.char_embed, self.pc), \n [batch_size * self.max_p_len, self.max_w_len, self.vocab.char_embed_dim])\n qc_emb = tf.reshape(tf.nn.embedding_lookup(\n self.char_embed, self.qc), \n [batch_size * self.max_q_len, self.max_w_len, self.vocab.char_embed_dim])\n cell_fw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\n cell_bw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, pc_emb, self.pc_length, dtype=tf.float32)\n pc_emb = tf.concat([state_fw, state_bw], axis=1)\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, qc_emb, self.qc_length, dtype=tf.float32)\n qc_emb = tf.concat([state_fw, state_bw], axis=1)\n pc_emb = tf.reshape(pc_emb, [batch_size, self.max_p_len, 2 * self.char_hidden_size])\n qc_emb = tf.reshape(qc_emb, [batch_size, self.max_q_len, 2 * self.char_hidden_size])\n\n with tf.name_scope(\"word\"):\n p_emb = tf.nn.embedding_lookup(self.word_embed, self.p)\n q_emb = tf.nn.embedding_lookup(self.word_embed, self.q)\n\n with tf.name_scope(\"pos\"):\n p_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.p_pos)\n q_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.q_pos)\n \n with tf.name_scope(\"em\"):\n sh = tf.shape(self.p_em)\n resh = [sh[0], sh[1], 1]\n p_em_feat = tf.reshape(tf.cast(self.p_em, dtype=tf.float32), shape=resh)\n\n self.p_emb = tf.concat([p_emb, pc_emb, p_pos_emb, p_em_feat], axis=2)\n self.q_emb = tf.concat([q_emb, qc_emb, q_pos_emb], axis=2)","def __init__(self, embeddings, char_embeddings=None,\n pos_embeddings=None, **kwargs):\n super(WordRepresentationLayer, self).__init__()\n self.embeddings = embeddings\n self.embedding_dim = embeddings.embedding_dim\n self.char_embeddings = char_embeddings\n self.train_char_embeddings = kwargs.get('train_char_embeddings',\n False)\n self.use_cuda = kwargs.get('cuda', True)\n\n if self.char_embeddings:\n self.char_merging_method = kwargs.get('char_merging_method', 'sum')\n char_hidden_dim = kwargs.get('char_hidden_dim', 50)\n bidirectional = kwargs.get('bidirectional', False)\n\n if self.char_merging_method == 'lstm':\n self.char_encoder = LSTMCharEncoder(\n char_embeddings,\n char_hidden_dim,\n bidirectional,\n train_char_embeddings=self.train_char_embeddings,\n cuda=self.use_cuda)\n\n self.embedding_dim += char_hidden_dim\n\n elif self.char_merging_method in ['mean', 'sum']:\n self.char_encoder = LinearCharEncoder(\n char_embeddings,\n train_char_embeddings=self.train_char_embeddings,\n char_merging_method=self.char_merging_method)\n\n self.embedding_dim += self.char_embeddings.embedding_dim\n else:\n raise NotImplementedError\n\n self.pos_embeddings = pos_embeddings\n if self.pos_embeddings:\n self.embedding_dim += self.pos_embeddings.embedding_dim","def __init__(self, embed_size):\n super(ImgEncoder, self).__init__()\n model = models.vgg19(pretrained=True)\n in_features = model.classifier[-1].in_features # input size of feature vector\n model.classifier = nn.Sequential(\n *list(model.classifier.children())[:-1]) # remove last fc layer\n\n self.model = model # loaded model without last fc layer\n self.fc = nn.Linear(in_features, embed_size) # feature vector of image","def get_embedding(self, resp):\n\n feed_dict = {self.anchor: resp}\n embedding = self.sess.run(self.embed_anchor, feed_dict=feed_dict)\n return embedding","def instantiate_weights(self):\n with tf.variable_scope(\"embedding_projection\"), tf.device('/cpu:0'): # embedding matrix\n self.Embedding = tf.get_variable(\"Embedding\", shape=[self.vocab_size, self.embed_size],\n initializer=self.initializer)\n # self.Embedding_label = tf.get_variable(\"Embedding_label\", shape=[self.num_classes, self.embed_size],\n # dtype=tf.float32) # ,initializer=self.initializer\n # self.W_projection = tf.get_variable(\"W_projection\", shape=[self.sequence_length * self.d_model, self.num_classes],\n # initializer=self.initializer) # [embed_size,label_size]\n # self.b_projection = tf.get_variable(\"b_projection\", shape=[self.num_classes])","def __init__(self,\n vocab_size=None,\n embed_dim=None,\n existing_vocab=None,\n initializers=None,\n partitioners=None,\n regularizers=None,\n trainable=True,\n custom_getter=None,\n name=\"embed\"):\n if vocab_size is None and existing_vocab is None:\n raise ValueError(\"Must provide on of vocab_size or existing_vocab.\")\n\n if existing_vocab is not None and not all(\n x is None for x in [vocab_size, embed_dim, initializers, partitioners]):\n raise ValueError(\"If existing_vocab is provided, none of vocab_size, \"\n \"embedding_dim, initializers, or partitioners is \"\n \"needed.\")\n\n super(Embed, self).__init__(custom_getter=custom_getter, name=name)\n self._existing_vocab = None\n if existing_vocab is None:\n self._vocab_size = vocab_size\n self._embed_dim = embed_dim or _embedding_dim(self._vocab_size)\n else:\n self._existing_vocab = tf.convert_to_tensor(\n existing_vocab, dtype=tf.float32)\n existing_vocab_shape = self._existing_vocab.get_shape().with_rank(2)\n existing_vocab_shape.assert_is_fully_defined()\n self._vocab_size, self._embed_dim = existing_vocab_shape.as_list()\n\n self._initializers = util.check_initializers(\n initializers, self.POSSIBLE_INITIALIZER_KEYS)\n self._partitioners = util.check_partitioners(\n partitioners, self.POSSIBLE_INITIALIZER_KEYS)\n self._regularizers = util.check_regularizers(\n regularizers, self.POSSIBLE_INITIALIZER_KEYS)\n self._trainable = trainable","def _create_layer() -> Image:\n data = np.random.random((32, 16))\n return Image(data)","def add_layer(self, layer_pos, lay_dims, init_w_function, init_a_function, dropout, drop_prob, batch_norm):\n\n # If not within feasible bounds, return\n if layer_pos < 0 or layer_pos >= self.number_hidden_layers:\n return\n\n # We create the new layer and add it to the network descriptor\n self.dims = np.insert(self.dims, layer_pos, lay_dims)\n self.init_functions = np.insert(self.init_functions, layer_pos, init_w_function)\n self.act_functions = np.insert(self.act_functions, layer_pos, init_a_function)\n\n # Finally the number of hidden layers is updated\n self.number_hidden_layers = self.number_hidden_layers + 1\n if not (isinstance(self.batch_norm, tuple) or self.batch_norm.shape[0] == 0):\n self.batch_norm = np.insert(self.batch_norm, layer_pos, batch_norm)\n if not (isinstance(self.dropout, tuple) or self.dropout.shape[0] == 0):\n self.dropout = np.insert(self.dropout, layer_pos, dropout)\n self.dropout_probs = np.insert(self.dropout_probs, layer_pos, drop_prob)","def __init__(self, vocab_size, embedding_size, output_size, lat_dim):\n super(Encoder, self).__init__()\n\n self.vocab_size = vocab_size\n self.embedding = nn.Embedding(vocab_size, embedding_size)\n self.lstm = nn.LSTM(embedding_size, output_size)\n \n self.hidden2mean = nn.Linear(output_size, lat_dim)\n self.hidden2logv = nn.Linear(output_size, lat_dim)\n \n self.cell2mean = nn.Linear(output_size, lat_dim)\n self.cell2logv = nn.Linear(output_size, lat_dim)","def __init__(self, embed_size, hidden_size, vocab_size, num_layers, max_seq_length=20):\n super(Decoder, self).__init__()\n self.embed = nn.Embedding(vocab_size, embed_size)\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)\n self.linear = nn.Linear(hidden_size, vocab_size)\n self.max_seg_length = max_seq_length","def init_word_embed(config):\n embedding_mat_val = np.load(config.wordembed_params)\n with tf.variable_scope('vc'):\n with tf.variable_scope('lstm', reuse=True):\n embedding_mat = tf.get_variable(\"embedding_mat\", [config.num_vocab, config.embed_dim])\n init_we = tf.assign(embedding_mat, embedding_mat_val)\n return [init_we]","def __init__(self, embed_size, hidden_size, vocab_size, num_layers):\n super(DecoderRNN, self).__init__()\n self.embed = nn.Embedding(vocab_size, embed_size)\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)\n self.linear = nn.Linear(hidden_size, vocab_size)\n self.init_weights()","def add_embedding(self):\n #with tf.variable_scope(\"RNN\", reuse = tf.AUTO_REUSE):\n embeddings = tf.get_variable(\"embeddings\", initializer = self.pretrained_embeddings,trainable=True)\n inputs = self.input_placeholder\n inputs = tf.reshape(inputs, [self.config.batch_size, -1 , self.config.n_features])\n embeddings = tf.nn.embedding_lookup(embeddings, self.input_placeholder)\n embeddings = tf.reshape(embeddings, [self.config.batch_size, -1, self.config.n_features* self.config.embed_size])\n embeddings = tf.cast(embeddings, tf.float32)\n return embeddings","def __init__(self, embed_size, hidden_size, vocab_size, num_layers,\n max_seq_length=20):\n # Decoder\n super(CaptioningModel, self).__init__()\n resnet = models.resnet18(pretrained=True)\n modules = list(resnet.children())[:-1] # delete the last fc layer.\n self.resnet = nn.Sequential(*modules)\n self.linear1 = nn.Linear(resnet.fc.in_features, embed_size)\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01) \n # Encoder \n self.embed = nn.Embedding(vocab_size, embed_size)\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)\n self.linear2 = nn.Linear(hidden_size, vocab_size)\n self.max_seg_length = max_seq_length","def __init__(self, word_embed_size, vocab):\n super(ModelEmbeddings, self).__init__()\n\n ### YOUR CODE HERE for part 1h\n dropout_rate = 0.3\n n_chars = len(vocab.char2id)\n self.char_embed_size = 50\n self.word_embed_size = word_embed_size\n self.vocab = vocab\n self.char_embed = nn.Embedding(n_chars, self.char_embed_size)\n self.conv = CNN(self.char_embed_size, word_embed_size)\n self.highway = Highway(word_embed_size)\n self.dropout = nn.Dropout(dropout_rate)\n ### END YOUR CODE","def _use_embeddings(self, word):\n if word == \"@PAD@\":\n return torch.zeros(self.embeddings_dim)\n else:\n return self.embeddings[word]","def build(self,unused):\n # (word_embeddings_shape, _) = input_shapes\n # width = word_embeddings_shape.as_list()[-1]\n if self.use_type_embeddings:\n self.type_embeddings = self.add_weight(\n \"token_type_embeddings\",\n shape=[self.token_type_vocab_size, self.word_embedding_width],\n initializer=get_initializer(self.initializer_range),\n dtype=self.dtype)\n\n self.position_embeddings = None\n if self.use_position_embeddings:\n self.position_embeddings = self.add_weight(\n \"position_embeddings\",\n shape=[self.max_position_embeddings, self.word_embedding_width],\n initializer=get_initializer(self.initializer_range),\n dtype=self.dtype)\n\n self.output_layer_norm = tf.keras.layers.LayerNormalization(\n name=LAYER_NORM_NAME, axis=-1, epsilon=1e-12, dtype=tf.float32)\n self.output_dropout = tf.keras.layers.Dropout(\n rate=self.dropout_prob, dtype=tf.float32)\n super().build(unused)","def _add_pre_trained_embedding(self):\n\n if self.embedding_type['type'] == 'glove':\n self.logging.info('use pre-trained glove word2vec')\n # a. load pre trained glove\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\n import os\n import numpy as np\n\n embeddings_index = {}\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\n for line in f:\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\n f.close()\n\n self.logging.info('')\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\n\n # b. compute embedding matrix\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n\n elif self.embedding_type['type'] == 'gensim':\n self.logging.info('use pre-trained gensim word2vec')\n\n import gzip\n import gensim\n from keras.layers import Embedding\n import numpy as np\n\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\n\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\n pretrained_weights = model.wv.syn0\n vocab_size, vector_dim = pretrained_weights.shape\n\n method = 3\n if method == 1:\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\n # into our TensorFlow and Keras models\n\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\n for i in range(len(model.wv.vocab)):\n embedding_vector = model.wv[model.wv.index2word[i]]\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector\n\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\n output_dim=embedding_matrix.shape[1],\n # input_length=self.maxlen,\n weights=[embedding_matrix],\n trainable=False)\n elif method == 2:\n self.logging.info('word2vec simple embedding matching - simple complex')\n embedding_layer = Embedding(input_dim=vocab_size,\n output_dim=vector_dim,\n input_length=self.maxlen,\n weights=[pretrained_weights],\n trainable=False)\n elif method == 3:\n\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\n # b. compute embedding matrix\n\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\n\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n if word in model.wv:\n embedding_vector = model.wv[word]\n embedding_matrix[i] = embedding_vector\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt))\n\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n else:\n raise ValueError('unknown method value')\n\n else:\n raise ValueError('unknown embedding type')\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\n return embedding_layer","def __init__(self,\n vocab_size,\n embed_dim,\n dropout,\n pretrained,\n embedding=None,\n num_gpus=1,\n default_gpu_id=0,\n regularizer=None,\n random_seed=0,\n trainable=True,\n scope=\"word_feat\"):\n self.vocab_size = vocab_size\n self.embed_dim = embed_dim\n self.dropout = dropout\n self.pretrained = pretrained\n self.embedding = embedding\n self.num_gpus = num_gpus\n self.default_gpu_id = default_gpu_id\n self.regularizer = regularizer\n self.random_seed = random_seed\n self.trainable = trainable\n self.scope = scope\n \n with tf.variable_scope(self.scope, reuse=tf.AUTO_REUSE):\n self.embedding_layer = create_embedding_layer(self.vocab_size, self.embed_dim, self.pretrained,\n self.embedding, self.num_gpus, self.default_gpu_id, None, self.random_seed, self.trainable)\n \n self.dropout_layer = create_dropout_layer(self.dropout, self.num_gpus, self.default_gpu_id, self.random_seed)","def __init__(self, vocab_size, emb_size, bias=True, M=None, b=None, pretrained_emb=None, fix_w_emb=False):\n super(AttentionEncoder, self).__init__()\n\n self.lookup = nn.Embedding(vocab_size, emb_size)\n if pretrained_emb is None:\n xavier_uniform(self.lookup.weight.data)\n else:\n assert pretrained_emb.size() == (vocab_size, emb_size), \\\n \"Word embedding matrix has incorrect size: {} instead of {}\".format(w_emb.size(), (vocab_size, emb_size))\n self.lookup.weight.data.copy_(pretrained_emb)\n self.lookup.weight.requires_grad = not fix_w_emb\n\n self.M = nn.Parameter(torch.Tensor(emb_size, emb_size))\n if M is None:\n xavier_uniform(self.M.data)\n else:\n self.M.data.copy_(M)\n if bias:\n self.b = nn.Parameter(torch.Tensor(1))\n if b is None:\n self.b.data.zero_()\n else:\n self.b.data.copy_(b)\n else:\n self.b = None","def load_embedding(src: str, embedding_type, layers) -> TransformerEmbedding:\n emb = TransformerEmbedding(src, embedding_type=embedding_type, layers=layers)\n return emb","def embedding_setup(self, embedding, emb_trainable):\n if emb_trainable == True:\n emb_variable = tf.get_variable(\n name=\"embedding_matrix\", shape=embedding.shape,\n initializer = tf.constant_initializer(embedding))\n return emb_variable\n else:\n return embedding","def __init__(self, vocab_size, embedding_size, output_size):\n super(VanillaEncoder, self).__init__()\n\n self.vocab_size = vocab_size\n self.embedding = nn.Embedding(vocab_size, embedding_size)\n self.gru = nn.GRU(embedding_size, output_size)","def construct_embedding(self):\n i = 0\n self.load_dicts()\n embedding_shape = (max(self.word2idx.values()) + 1,\n self.embedding_size)\n self.embedding = np.zeros(embedding_shape)\n\n with open(self.config.word_vec_fi_glove, 'r') as fi:\n for line in fi:\n word_vec = line.split(\" \")[1:]\n self.embedding[i, :] = np.array(word_vec, dtype=np.float32)\n i += 1\n\n self.write_embedding()","def pool(embed, seq_len):\n attention_w = ops.last_dim_weighted_sum(embed, \"w\")\n attention_w = ops.mask_logits(attention_w, seq_len)\n attention_w = tf.expand_dims(tf.nn.softmax(attention_w), 1)\n\n # [batch, 1, len] * [batch, len, dim] -> [batch, 1, dim]\n return tf.squeeze(tf.matmul(attention_w, embed), 1)","def build(self, input_shapes):\n (word_embeddings_shape, _) = input_shapes\n width = word_embeddings_shape.as_list()[-1]\n self.type_embeddings = None\n if self.use_type_embeddings:\n self.type_embeddings = self.add_weight(\n \"type_embeddings\",\n shape=[self.token_type_vocab_size, width],\n initializer=tf.keras.initializers.TruncatedNormal(\n stddev=self.initializer_range),\n dtype=self.dtype)\n\n self.position_embeddings = None\n if self.use_position_embeddings:\n self.position_embeddings = self.add_weight(\n \"position_embeddings\",\n shape=[self.max_position_embeddings, width],\n initializer=tf.keras.initializers.TruncatedNormal(\n stddev=self.initializer_range),\n dtype=self.dtype)\n\n self.output_layer_norm = tf.keras.layers.LayerNormalization(\n name=\"layer_norm\", axis=-1, epsilon=1e-12, dtype=tf.float32)\n self.output_dropout = tf.keras.layers.Dropout(\n rate=self.dropout_prob, dtype=tf.float32)\n super(EmbeddingPostprocessor, self).build(input_shapes)","def EmbeddingLayers_pooling(pretrained=False, progress=True, **kwargs):\n kwargs['groups'] = 32\n kwargs['width_per_group'] = 4\n # return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress,\n # **kwargs) \n return _resnet('resnext50_32x4d', Bottleneck, [3, 4, 6, 3],\n pretrained, progress, **kwargs)","def __init__(self, emb_dim=100, window_size=3, init_emb=None,\n hidden_dim=100, vocab_size=0, splitter=u' ', add_dim=0,\n PAD_IDX=None):\n assert window_size % 2 == 1, 'window_size must be odd.'\n dim = emb_dim\n hidden_dim = hidden_dim + add_dim\n self.add_dim = add_dim\n self.hidden_dim = hidden_dim\n super(BaseCNNEncoder, self).__init__(emb=L.EmbedID(vocab_size, emb_dim, ignore_label=-1),\n conv=L.Convolution2D(1, hidden_dim, ksize=(window_size, dim),\n stride=(1, dim), pad=(window_size // 2, 0)))\n self.splitter = splitter\n self.char_level_flag = True if self.splitter is None else False\n self.word_level_flag = not self.char_level_flag\n self.emb_dim = emb_dim\n self.window_size = window_size\n self.dim = dim\n self.PAD_IDX = PAD_IDX\n self.train = True\n # initialize embeddings\n if init_emb is not None:\n self.emb.W = init_emb","def __init__(self,embedding_size):\n super(ResNetEncoder,self).__init__()\n resnet = models.resnet50(pretrained=True)\n modules = list(resnet.children())[:-1]\n #Create a sequential models upto top fc layer add a custom fc layer compatible with embedding size of decoder RNN\n self.resnet = nn.Sequential(*modules)\n self.embed = nn.Linear(resnet.fc.in_features,embedding_size)\n self.bn = nn.BatchNorm1d(embedding_size,momentum=0.01)\n self.init_weights()","def _build(self, ids):\n # Construct embeddings.\n if self._existing_vocab is None:\n if self.EMBEDDINGS not in self._initializers:\n self._initializers[self.EMBEDDINGS] = basic.create_linear_initializer(\n self._vocab_size)\n self._embeddings = tf.get_variable(\n \"embeddings\",\n shape=[self._vocab_size, self._embed_dim],\n dtype=tf.float32,\n initializer=self._initializers[self.EMBEDDINGS],\n partitioner=self._partitioners.get(self.EMBEDDINGS, None),\n regularizer=self._regularizers.get(self.EMBEDDINGS, None),\n trainable=self._trainable)\n else:\n self._embeddings = tf.get_variable(\n \"embeddings\",\n dtype=tf.float32,\n initializer=self._existing_vocab,\n regularizer=self._regularizers.get(self.EMBEDDINGS, None),\n trainable=self._trainable)\n\n # Lookup embeddings\n return tf.nn.embedding_lookup(\n self._embeddings, ids, name=\"embedding_lookup\")","def get_embed(input_data, vocab_size, embed_dim):\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_dim), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, input_data)\n\n return embed","def get_embed(input_data, vocab_size, embed_dim):\n # todo 需要编程：\n # 1、构建嵌入矩阵的查找表\n lookup_w = tf.Variable(\n initial_value=tf.random_uniform([vocab_size, embed_dim], -1.0, 1.0)\n )\n # 2、获得嵌入输出\n embed = tf.nn.embedding_lookup(params=lookup_w, ids=input_data)\n # [N, n_steps, embed_size]\n return embed","def build_embeddings(opt, word_dict, for_encoder='src'):\n if for_encoder=='src':\n embedding_dim = opt.src_word_vec_size #512\n elif for_encoder=='tgt':\n embedding_dim = opt.tgt_word_vec_size\n elif for_encoder=='structure':\n embedding_dim = 64\n\n word_padding_idx = word_dict.stoi[Constants.PAD_WORD]\n num_word_embeddings = len(word_dict)\n \n if for_encoder=='src' or for_encoder=='tgt':\n\n return Embeddings(word_vec_size=embedding_dim,\n position_encoding=opt.position_encoding,\n dropout=opt.dropout,\n word_padding_idx=word_padding_idx,\n word_vocab_size=num_word_embeddings,\n sparse=opt.optim == \"sparseadam\")\n elif for_encoder=='structure':\n return Embeddings(word_vec_size=embedding_dim,\n position_encoding=False,\n dropout=opt.dropout,\n word_padding_idx=word_padding_idx,\n word_vocab_size=num_word_embeddings,\n sparse=opt.optim == \"sparseadam\")","def _configure_embeddings(self):\r\n # TODO(omalleyt): Add integration tests.\r\n from tensorflow.python.keras.layers import embeddings\r\n try:\r\n from tensorboard.plugins import projector\r\n except ImportError:\r\n raise ImportError('Failed to import TensorBoard. Please make sure that '\r\n 'TensorBoard integration is complete.\"')\r\n config = projector.ProjectorConfig()\r\n for layer in self.model.layers:\r\n if isinstance(layer, embeddings.Embedding):\r\n embedding = config.embeddings.add()\r\n embedding.tensor_name = layer.embeddings.name\r\n\r\n if self.embeddings_metadata is not None:\r\n if isinstance(self.embeddings_metadata, str):\r\n embedding.metadata_path = self.embeddings_metadata\r\n else:\r\n if layer.name in embedding.metadata_path:\r\n embedding.metadata_path = self.embeddings_metadata.pop(layer.name)\r\n\r\n if self.embeddings_metadata:\r\n raise ValueError('Unrecognized `Embedding` layer names passed to '\r\n '`keras.callbacks.TensorBoard` `embeddings_metadata` '\r\n 'argument: ' + str(self.embeddings_metadata.keys()))\r\n\r\n class DummyWriter(object):\r\n \"\"\"Dummy writer to conform to `Projector` API.\"\"\"\r\n\r\n def __init__(self, logdir):\r\n self.logdir = logdir\r\n\r\n def get_logdir(self):\r\n return self.logdir\r\n\r\n writer = DummyWriter(self.log_dir)\r\n projector.visualize_embeddings(writer, config)","def TransformerTokenEmbedding(\n num_embeddings, embedding_dim, padding_idx, freeze_embed=False\n):\n m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx)\n nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5)\n nn.init.constant_(m.weight[padding_idx], 0)\n if freeze_embed:\n m.weight.requires_grad = False\n return m","def _load_byte_embedding(self):\n char_embed_weights = self.npz_weights['char_embed']\n num_tags = TAGS.__len__()\n weights = np.zeros((char_embed_weights.shape[0] + num_tags + 1, char_embed_weights.shape[1]), dtype='float32')\n weights[1:-num_tags, :] = char_embed_weights\n self.embed_chars = rnn.Embedding(num_embeddings=self.num_embeddings, embedding_dim=self.char_embed_dim, padding_idx=self.padding_idx, freeze_embed=self._finetune_pretrained_weights)\n self.embed_chars.weight.data.copy_(torch.FloatTensor(weights))","def __init__(self, embed_size, dropout=0.5, image_model='resnet101', simple=False, pretrained=True):\n super(EncoderCNNFeatures, self).__init__()\n resnet = globals()[image_model](pretrained=pretrained)\n\n self.linear = nn.Sequential(nn.Conv2d(resnet.fc.in_features, embed_size, kernel_size=1, padding=0),\n nn.Dropout2d(dropout))\n\n self.simple = simple\n if simple:\n self.avgpool = nn.AdaptiveAvgPool2d((1, 1))","def embed(self, features, feature_name, params):\n with tf.variable_scope(\"%s_embed\" % feature_name):\n embed_matrix = tf.get_variable(\"embedding_matrix\",\n [getattr(params, \"%s_vocab_size\" % feature_name), \n getattr(params, \"%s_embed_size\" % feature_name)])\n return tf.nn.embedding_lookup(embed_matrix, features[feature_name])","def Aut(A):\n return Embeddings(A,A)","def __init__(self, # noqa: R0913\n hid_dim,\n n_layers,\n n_heads,\n pf_dim,\n dropout,\n max_length=100):\n super().__init__()\n\n self.pos_embedding = nn.Embedding(max_length, hid_dim)\n\n self.layers = nn.ModuleList([TransformerEncoderLayer(hid_dim,\n n_heads,\n pf_dim,\n dropout)\n for _ in range(n_layers)])\n\n self.dropout = nn.Dropout(dropout)\n\n self.register_buffer('scale', torch.sqrt(torch.FloatTensor([hid_dim])))","def add_embedding(self, token, embedding):\n self.word2idx[token] = self.vocab_size\n self.vocab_size += 1\n\n self.embedding = np.vstack((self.embedding, embedding))","def __init__(self, \n k=DEFAULT_EMBEDDING_SIZE, \n eta=DEFAULT_ETA, \n epochs=DEFAULT_EPOCH, \n batches_count=DEFAULT_BATCH_COUNT, \n seed=DEFAULT_SEED,\n embedding_model_params={'norm':DEFAULT_NORM_TRANSE, \n 'normalize_ent_emb':DEFAULT_NORMALIZE_EMBEDDINGS,\n 'negative_corruption_entities':DEFAULT_CORRUPTION_ENTITIES},\n optimizer=DEFAULT_OPTIM, \n optimizer_params={'lr':DEFAULT_LR},\n loss=DEFAULT_LOSS, \n loss_params={},\n regularizer=DEFAULT_REGULARIZER, \n regularizer_params={},\n verbose=DEFAULT_VERBOSE):\n super().__init__(k=k, eta=eta, epochs=epochs, batches_count=batches_count, seed=seed,\n embedding_model_params=embedding_model_params,\n optimizer=optimizer, optimizer_params=optimizer_params,\n loss=loss, loss_params=loss_params,\n regularizer=regularizer, regularizer_params=regularizer_params,\n verbose=verbose)","def CreateWavelet(self):\n self.__context.builder.WaveletCreate(self.GetId())","def create_embedding(skills):\n corpus = list(skills[\"description\"].values)\n embedder = SentenceTransformer(config[\"sentence_transformer\"][\"model\"])\n embedding = embedder.encode(corpus, show_progress_bar=True)\n return embedding","def __init__(self, name, config, embed_mat):\n if 'tune_embeds' not in config.keys():\n raise ValueError('config must define \"tune_embeds\".')\n super(TextModel, self).__init__(name, config)\n self.embeds = nn.Embedding(embed_mat.shape[0], embed_mat.shape[1])\n self.embeds.weight = nn.Parameter(torch.from_numpy(embed_mat),\n requires_grad=self.tune_embeds)","def __init__(self, out_embed_dims, vocab_size, vocab_reduction_module=None, fixed_weights=None, hidden_layer_size=32, activation_fn=torch.nn.ReLU, logit_fn=torch.exp):\n super().__init__(out_embed_dims, vocab_size, vocab_reduction_module)\n if fixed_weights is None:\n self.fixed_weights = None\n self.gating_network = nn.Sequential(Linear(sum(out_embed_dims), hidden_layer_size, bias=True), activation_fn(), Linear(hidden_layer_size, len(out_embed_dims), bias=True))\n self.logit_fn = logit_fn\n else:\n assert len(fixed_weights) == len(out_embed_dims)\n self.fixed_weights = maybe_cuda(torch.Tensor(fixed_weights).view(1, 1, -1))","def init_embedding(self):\n self.embedding.weight.data.uniform_(-1./self.num_embeddings, 1./self.num_embeddings)","def build(self, input_shape):\n hidden_dim = input_shape[2]\n self.W = self.add_weight(\n name='{}_W'.format(self.name),\n shape=(hidden_dim, hidden_dim,),\n initializer='uniform',\n trainable=True)\n self.b = self.add_weight(\n name='{}_b'.format(self.name),\n shape=(hidden_dim,),\n initializer='zeros',\n trainable=True)\n self.u = self.add_weight(\n name='{}_u'.format(self.name),\n shape=(hidden_dim,),\n initializer='uniform',\n trainable=True)\n super(AttentionLayer, self).build(input_shape)","def add_embedding_layer(self, emb_matrix, ans2id, context2id, use_same=True):\n with vs.variable_scope(\"embeddings\"):\n qn_embedding_matrix = tf.Variable(emb_matrix, dtype=tf.float32,\n name=\"qn_emb_matrix\") # shape (400002, embedding_size)\n self.qn_embs = embedding_ops.embedding_lookup(qn_embedding_matrix, self.qn_ids)\n\n self.context_embedding_matrix = tf.Variable(tf.one_hot(range(len(context2id)), len(context2id)),\n name=\"context_emb_matrix\")\n if not use_same:\n self.ans_embedding_matrix = tf.Variable(tf.one_hot(range(len(ans2id)), len(ans2id)),\n dtype=tf.float32, name=\"ans_emb_matrix\")\n else:\n self.ans_embedding_matrix = tf.identity(self.context_embedding_matrix, name=\"ans_emb_matrix\")\n\n if self.FLAGS.use_raw_graph:\n self.context_embs = embedding_ops.embedding_lookup(self.context_embedding_matrix, self.context_ids)\n else:\n self.context_embs = tf.identity(self.context_embedding)\n self.ans_embs = embedding_ops.embedding_lookup(self.ans_embedding_matrix, self.ans_ids)","def embed_word(self):\n return self.emb.get_keras_embedding(dropout = self.emb_dropout,\n trainable = self.trainable_emb,\n input_length = self.sent_maxlen)","def __init__(self, embed_size, dropout=0.5, image_model='resnet101', simple=False, pretrained=True):\n super(EncoderCNN, self).__init__()\n resnet = globals()[image_model](pretrained=pretrained)\n modules = list(resnet.children())[:-2] # delete the last fc layer.\n self.resnet = nn.Sequential(*modules)\n \n self.linear = nn.Sequential(nn.Conv2d(resnet.fc.in_features, embed_size, kernel_size=1, padding=0),\n nn.Dropout2d(dropout))\n\n self.simple = simple\n if simple:\n self.avgpool = nn.AdaptiveAvgPool2d((1, 1))","def __init__(self, embed_size, hidden_size, vocab_size, vocab, num_layers, max_seq_length=30):\n super(DecoderClothing, self).__init__()\n self.embed = nn.Embedding(vocab_size, embed_size)\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)\n self.linear = nn.Linear(hidden_size, vocab_size)\n self.max_seg_length = max_seq_length\n self.vocab = vocab\n self.clothing_class = {\n 'shirt':0, 'jumper':1, 'jacket':2, 'vest':3, 'coat':4,\n 'dress':5, 'pants':6, 'skirt':7, 'scarf':8, 'cane':9, 'bag':10, 'shoes':11,\n 'hat':12, 'face':13, 'glasses':14 }","def forward(self, tgt, m, enc_embed, mask):\n bs = tgt.shape[0]\n enc_embed = enc_embed.permute(2, 0, 1)\n m = m.permute(2, 0, 1)\n tgt = tgt.permute(2, 0, 1)\n dec_embed = self.dec_embed.weight.unsqueeze(1).repeat(1, bs, 1)\n\n out = tgt\n for layer in self.decoder_layers:\n out = layer(out, m, \n pos=enc_embed,\n query_pos=dec_embed\n )\n \n return self.decoder_norm(out).permute(1, 2, 0), dec_embed.permute(1, 2, 0)","def embedding(org_input):\n # Create the embedding list\n for f in range(Config.num_feature):\n num_cat_value = Config.schema[f]\n\n if num_cat_value == 1:\n pass\n elif num_cat_value > 1:\n embed_dict[f] = tf.get_variable(\n name=\"embed_\" + str(f),\n shape=[num_cat_value, Config.embed_size[f]],\n trainable=True)\n else:\n raise ValueError(\"Schema values should be positive integers!\")\n\n # Create embedded inputs\n f_size = np.sum(Config.embed_size)\n embedded_input = embed_events(org_input, f_size)\n\n return embedded_input","def build(self, input_shape):\n self.embedding = layers.Embedding(MAX_WORDS, 7, input_length=MAX_LEN)\n self.conv_1 = layers.Conv1D(16, kernel_size=5, name=\"conv_1\", activation=\"relu\")\n self.pool_1 = layers.MaxPool1D(name=\"pool_1\")\n self.conv_2 = layers.Conv1D(\n 128, kernel_size=2, name=\"conv_2\", activation=\"relu\"\n )\n self.pool_2 = layers.MaxPool1D(name=\"pool_2\")\n self.flatten = layers.Flatten()\n self.dense = layers.Dense(1, activation=\"sigmoid\")\n super(CnnModel, self).build(input_shape)","def embed(self, word: Any) -> dy.Expression:\n raise NotImplementedError('embed must be implemented in Embedder subclasses')","def embed_word(self):\n return self.emb.get_keras_embedding(trainable = self.trainable_emb,\n input_length = self.sent_maxlen)","def randomly_init_embeddings(self, embed_dim):\n self.embed_dim = embed_dim\n self.embeddings = np.random.rand(self.size(), embed_dim)\n for term in [self.pad_term, self.unk_term, self.eos_term]:\n self.embeddings[self.get_id(term)] = np.zeros([self.embed_dim])","def __init__(self, \n k=DEFAULT_EMBEDDING_SIZE, \n eta=DEFAULT_ETA, \n epochs=DEFAULT_EPOCH, \n batches_count=DEFAULT_BATCH_COUNT, \n seed=DEFAULT_SEED,\n embedding_model_params={'normalize_ent_emb':DEFAULT_NORMALIZE_EMBEDDINGS,\n 'negative_corruption_entities':DEFAULT_CORRUPTION_ENTITIES},\n optimizer=DEFAULT_OPTIM, \n optimizer_params={'lr':DEFAULT_LR},\n loss=DEFAULT_LOSS, \n loss_params={},\n regularizer=DEFAULT_REGULARIZER, \n regularizer_params={},\n verbose=DEFAULT_VERBOSE):\n super().__init__(k=k, eta=eta, epochs=epochs, batches_count=batches_count, seed=seed,\n embedding_model_params=embedding_model_params,\n optimizer=optimizer, optimizer_params=optimizer_params,\n loss=loss, loss_params=loss_params,\n regularizer=regularizer, regularizer_params=regularizer_params,\n verbose=verbose)","def build(self, observation):\n raise NotImplementedError(\n 'Needs to be implemented as part of Embedder Interface')","def set_embeddings(self):","def initialize_model(self):\n\n input_layer = Input(\n shape=(self.input_length,), \n dtype='int32', \n name='input'\n )\n\n if self.embedding_matrix is None:\n embedding = Embedding(\n output_dim=self.embedding_size,\n input_dim=self.vocabulary_size + 1, # for mask\n input_length=self.input_length,\n mask_zero=True,\n name='embedding'\n )(input_layer)\n else:\n embedding = Embedding(\n output_dim=self.embedding_size,\n input_dim=self.vocabulary_size + 1,\n input_length=self.input_length,\n mask_zero=True,\n weights=[np.vstack((np.zeros((1, self.embedding_size)),\n self.embedding_matrix))],\n name='embedding'\n )(input_layer)\n\n encoder = self.recurrent_cell(\n self.latent_dim,\n dropout=self.dropout,\n recurrent_dropout=self.dropout,\n name='encoder',\n recurrent_regularizer=l1_l2(*self.regularization)\n )\n\n if self.use_bidirection:\n encoder = Bidirectional(\n encoder,\n merge_mode='concat'\n )\n\n encoder = encoder(embedding)\n\n dense_1 = Dense(\n 1024,\n activation='tanh',\n name='dense_1',\n kernel_regularizer=l1_l2(*self.regularization)\n )(encoder)\n\n dense_2 = Dense(\n 512,\n activation='tanh',\n name='dense_2',\n kernel_regularizer=l1_l2(*self.regularization)\n )(dense_1)\n\n dropout = Dropout(self.dropout)(\n dense_2\n )\n\n prediction = Dense(\n 1,\n activation='sigmoid',\n name='prediction'\n )(dropout)\n\n model = Model(inputs=input_layer, outputs=prediction)\n\n # sparse_categorical_crossentropy\n model.compile(optimizer=Adam(lr=self.learning_rate),\n loss='binary_crossentropy',\n metrics=['acc'])\n\n self.model = model\n\n if self.verbose > 0:\n model.summary()\n\n return [model]","def init_emb(self):\n # Initialize users and items' embeddings\n nn.init.xavier_uniform_(self.user_embedding.weight)\n nn.init.xavier_uniform_(self.item_embedding.weight)","def __init__(self, embed_size, hidden_size, vocab_size, num_layers, max_seq_length=20):\n super(DecoderRNN, self).__init__()\n self.embed = nn.Embedding(vocab_size, embed_size)\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)\n self.linear = nn.Linear(hidden_size, vocab_size)\n self.max_seg_length = max_seq_length","def embeddings_layers_init(self):\n\n user_embeddings = tf.keras.layers.Embedding(\n self.n_users, self.user_dim, input_length=1)\n\n item_embeddings = tf.keras.layers.Embedding(\n self.n_items, self.item_dim, input_length=1)\n\n return user_embeddings, item_embeddings","def get_embed(input_data, vocab_size, embed_dim):\n embedding = tf.Variable(tf.random_uniform((vocab_size,embed_dim), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, input_data)\n #print (\"embed_dim: \",embed_dim) # 向量表达维度为 256\n #print (\"input_data.shape: \",input_data.shape) # (50, 5)\n #print (\"embed.shap: \", embed.shape) # word 的向量表达 ==特征 (50, 5, 256) ==(batch_size, num_step, embed_dim)\n return embed # 返回input的向量表达"],"string":"[\n \"def embedding_layer(self):\\n with tf.name_scope(\\\"Embedding_Layer\\\"):\\n V_size = len(self.vocab)\\n embed_dim = len(self.embed[0]) \\n W_embed_ = tf.get_variable(\\\"W_embed\\\",shape=[V_size, embed_dim],trainable=False).assign(np.asarray(self.embed))\\n W_analogy_embed_ = tf.get_variable(\\\"W_analogy_embed\\\",shape=[V_size, embed_dim],trainable=True,initializer=tf.random_uniform_initializer(minval=-1,maxval=1))\\n return W_embed_, W_analogy_embed_\",\n \"def build_embedding_layer(inputs_, vocab_size, embed_size):\\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_size), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, inputs_)\\n \\n return embed\",\n \"def __init__(self, layer_id,\\n shape, X):\\n prefix = 'Embedding' + layer_id\\n self.n_words, self.in_size = shape\\n\\n # weights for embedding, the only parameters\\n self.W = init_weights(shape=(self.n_words, self.in_size),\\n name=prefix + '#W')\\n\\n self.params = [self.W]\\n\\n # Compute the embedded samples\\n self.n_timesteps = X.shape[0]\\n self.n_samples = X.shape[1]\\n\\n self.activation = self.W[X.flatten()].reshape([self.n_timesteps,\\n self.n_samples,\\n self.in_size])\",\n \"def _embed(self):\\n with tf.variable_scope('word_embedding'):\\n self.pretrained_word_mat = tf.get_variable(\\\"word_emb_mat\\\",\\n [self.vocab.word_size() - 2, self.vocab.word_embed_dim],\\n dtype=tf.float32,\\n initializer=tf.constant_initializer(\\n self.vocab.word_embeddings[2:],\\n dtype=tf.float32),\\n trainable=False)\\n self.word_pad_unk_mat = tf.get_variable(\\\"word_unk_pad\\\",\\n [2, self.pretrained_word_mat.get_shape()[1]],\\n dtype=tf.float32,\\n initializer=tf.constant_initializer(\\n self.vocab.word_embeddings[:2],\\n dtype=tf.float32),\\n trainable=True)\\n\\n self.word_mat = tf.concat([self.word_pad_unk_mat, self.pretrained_word_mat], axis=0)\\n self.p_emb = tf.nn.embedding_lookup(self.word_mat, self.p)\\n self.q_emb = tf.nn.embedding_lookup(self.word_mat, self.q)\",\n \"def __init__(self, input_size, config):\\r\\n super(EmbeddingLayer, self).__init__()\\r\\n\\r\\n if config.emtraining:\\r\\n self.embedding = nn.Sequential(OrderedDict([\\r\\n ('embedding', nn.Embedding(input_size, config.emsize)),\\r\\n ('dropout', nn.Dropout(config.dropout))\\r\\n ]))\\r\\n else:\\r\\n self.embedding = nn.Embedding(input_size, config.emsize)\\r\\n self.embedding.weight.requires_grad = False\",\n \"def __init__(self, cfg, name=''):\\n nn.Layer.__init__(self)\\n self.cfg = cfg\\n d_model = cfg['hidden_size']\\n d_emb = cfg.get('emb_size', cfg['hidden_size'])\\n d_vocab = cfg['vocab_size']\\n d_pos = cfg['max_position_embeddings']\\n # d_sent = cfg.get(\\\"sent_type_vocab_size\\\", 4) or cfg.get('type_vocab_size', 4)\\n if cfg.get('sent_type_vocab_size'):\\n d_sent = cfg['sent_type_vocab_size']\\n else:\\n d_sent = cfg.get('type_vocab_size', 2)\\n self.n_head = cfg['num_attention_heads']\\n self.return_additional_info = cfg.get('return_additional_info', False)\\n self.initializer = nn.initializer.TruncatedNormal(std=cfg['initializer_range'])\\n\\n self.ln = _build_ln(d_model, name=append_name(name, 'pre_encoder'))\\n self.word_emb = nn.Embedding(d_vocab,\\n d_emb,\\n weight_attr=paddle.ParamAttr(name=append_name(name, 'word_embedding'),\\n initializer=self.initializer))\\n self.pos_emb = nn.Embedding(d_pos,\\n d_emb,\\n weight_attr=paddle.ParamAttr(name=append_name(name, 'pos_embedding'),\\n initializer=self.initializer))\\n # self.sent_emb = nn.Embedding(\\n # d_sent,\\n # d_emb,\\n # weight_attr=paddle.ParamAttr(name=append_name(name, 'sent_embedding'), initializer=self.initializer))\\n self._use_sent_id = cfg.get('use_sent_id', True)\\n self._use_sent_id = False\\n if self._use_sent_id:\\n self.sent_emb = nn.Embedding(d_sent,\\n d_emb,\\n weight_attr=paddle.ParamAttr(name=append_name(name, 'sent_embedding'),\\n initializer=self.initializer))\\n self._use_task_id = cfg.get('use_task_id', False)\\n self._use_task_id = False\\n if self._use_task_id:\\n self._task_types = cfg.get('task_type_vocab_size', 3)\\n logging.info('using task_id, #task_types:{}'.format(self._task_types))\\n self.task_emb = nn.Embedding(self._task_types,\\n d_emb,\\n weight_attr=paddle.ParamAttr(name=append_name(name, 'task_embedding'),\\n initializer=self.initializer))\\n\\n prob = cfg['hidden_dropout_prob']\\n self.dropout = nn.Dropout(p=prob)\\n\\n self.encoder_stack = ErnieEncoderStack(cfg, append_name(name, 'encoder'))\\n\\n if cfg.get('has_pooler', True):\\n self.pooler = _build_linear(cfg['hidden_size'], cfg['hidden_size'], append_name(name, 'pooled_fc'),\\n self.initializer)\\n else:\\n self.pooler = None\\n\\n self.key_tag = None\\n self._checkpoints = []\\n self.train()\",\n \"def __init__(self, heropool_size, embedding_dim):\\r\\n super().__init__()\\r\\n self.embedding_dim = embedding_dim\\r\\n self.embeddings = nn.Embedding(heropool_size, embedding_dim)\\r\\n self.affine = nn.Linear(embedding_dim, heropool_size)\\r\\n self.init_emb()\",\n \"def _embed(self):\\n with tf.variable_scope('word_embedding'):\\n self.word_embeddings = tf.get_variable(\\n 'word_embeddings',\\n shape=(self.term_vocab.size(), self.term_vocab.embed_dim),\\n initializer=tf.constant_initializer(self.term_vocab.embeddings),\\n trainable=True\\n )\\n self.p_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.p)\\n self.q_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.q)\\n\\n with tf.variable_scope('char_embedding'):\\n self.char_embeddings = tf.get_variable(\\n 'char_embeddings',\\n shape=(self.char_vocab.size(), self.char_vocab.embed_dim),\\n initializer=tf.constant_initializer(self.char_vocab.embeddings),\\n trainable=True\\n )\\n self.p_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.p_char) # [batch, seqlen, max_char_num, embedding_size]\\n self.q_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.q_char)\\n\\n self.p_char_emb = self.cnn_emb(self.p_char_emb, \\\"p_emb\\\")\\n self.q_char_emb = self.cnn_emb(self.q_char_emb, \\\"q_emb\\\")\\n '''\\n self.p_char_emb = tf.reshape(self.p_char_emb, [-1, self.max_char_num, self.emb_size])\\n self.q_char_emb = tf.reshape(self.q_char_emb, [-1, self.max_char_num, self.emb_size])\\n\\n self.p_char_emb = cnn_layer.conv(self.p_char_emb, self.emb_size,\\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\\\"char_conv\\\", reuse=None)\\n self.q_char_emb = cnn_layer.conv(self.q_char_emb, self.emb_size,\\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\\\"char_conv\\\", reuse=True)\\n\\n self.p_char_emb = tf.reduce_max(self.p_char_emb, axis=1) # [batch*seqlen, 1, emb_size]\\n self.q_char_emb = tf.reduce_max(self.q_char_emb, axis=1)\\n\\n batch_size = tf.shape(self.p_word_emb)[0]\\n self.p_char_emb = tf.reshape(self.p_char_emb, [batch_size, -1, self.emb_size])\\n self.q_char_emb = tf.reshape(self.q_char_emb, [batch_size, -1, self.emb_size])\\n\\n self.p_char_emb = tf.nn.dropout(self.p_char_emb, 0.95)\\n self.q_char_emb = tf.nn.dropout(self.q_char_emb, 0.95)\\n '''\\n self.p_emb = tf.concat([self.p_word_emb, self.p_char_emb], -1)\\n self.q_emb = tf.concat([self.q_word_emb, self.q_char_emb], -1)\",\n \"def __init__(self,\\n embedding_dim: int = 64,\\n scale: bool = False,\\n vocab_size: int = 0,\\n padding_idx: int = 1,\\n freeze: bool = False,\\n **kwargs):\\n super(Embeddings, self).__init__()\\n\\n self.embedding_dim = embedding_dim\\n self.scale = scale\\n self.vocab_size = vocab_size\\n self.lut = nn.Embedding(vocab_size, self.embedding_dim,\\n padding_idx=padding_idx)\\n\\n if freeze:\\n freeze_params(self)\",\n \"def pretrained_embedding_layer(word_to_vec_map, word_to_index):\\n \\n vocab_size = len(word_to_index) + 1 # adding 1 to fit Keras embedding (requirement)\\n any_word = list(word_to_vec_map.keys())[0]\\n emb_dim = word_to_vec_map[any_word].shape[0] # define dimensionality of your GloVe word vectors (= 50)\\n \\n ### START CODE HERE ###\\n # Step 1\\n # Initialize the embedding matrix as a numpy array of zeros.\\n # See instructions above to choose the correct shape.\\n emb_matrix = np.zeros((vocab_size, emb_dim))\\n \\n # Step 2\\n # Set each row \\\"idx\\\" of the embedding matrix to be \\n # the word vector representation of the idx'th word of the vocabulary\\n for word, idx in word_to_index.items():\\n emb_matrix[idx, :] = word_to_vec_map[word]\\n\\n # Step 3\\n # Define Keras embedding layer with the correct input and output sizes\\n # Make it non-trainable.\\n embedding_layer = tensorflow.keras.layers.Embedding(input_dim = vocab_size, output_dim = emb_dim, trainable = False)\\n ### END CODE HERE ###\\n\\n # Step 4 (already done for you; please do not modify)\\n # Build the embedding layer, it is required before setting the weights of the embedding layer. \\n embedding_layer.build((None,)) # Do not modify the \\\"None\\\". This line of code is complete as-is.\\n \\n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\\n embedding_layer.set_weights([emb_matrix])\\n \\n return embedding_layer\",\n \"def pretrained_embedding_layer(word_to_vec_map, word_to_index):\\n vocab_len = len(word_to_index) + 1 # adding 1 to fit Keras embedding (requirement)\\n emb_dim = word_to_vec_map[\\\"cucumber\\\"].shape[0] # define dimensionality of your GloVe word vectors (= 50)\\n emb_matrix = np.zeros((vocab_len, emb_dim)) # Initialize the embedding matrix as a numpy array of zeros of shape (vocab_len, dimensions of word vectors = emb_dim)\\n for word, index in word_to_index.items(): # Set each row \\\"index\\\" of the embedding matrix to be the word vector representation of the \\\"index\\\"th word of the vocabulary\\n emb_matrix[index, :] = word_to_vec_map[word]\\n embedding_layer = Embedding(vocab_len, emb_dim, trainable = False) # Define Keras embedding layer with the correct output/input sizes, make it trainable. Use Embedding(...). Make sure to set trainable=False. \\n embedding_layer.build((None,)) # Build the embedding layer, it is required before setting the weights of the embedding layer. Do not modify the \\\"None\\\".\\n embedding_layer.set_weights([emb_matrix]) # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\\n return embedding_layer\",\n \"def add_embedding(self):\\n ### YOUR CODE HERE (~4-6 lines)\\n embeddingTensor = tf.Variable(self.pretrained_embeddings)\\n embeddings = tf.nn.embedding_lookup(embeddingTensor, self.input_placeholder)\\n embeddings = tf.reshape(embeddings, [-1, self.max_length, Config.n_features * Config.embed_size])\\n ### END YOUR CODE\\n return embeddings\",\n \"def __init__(self, vocab_size, embedding_size, context_size, hid_dim, out_dim):\\n super(Net, self).__init__()\\n self.E = nn.Embedding(vocab_size, embedding_size) # Embedding matrix\\n self.after_embed_size = embedding_size * context_size\\n self.lin = nn.Linear(self.after_embed_size, hid_dim)\\n self.lin2 = nn.Linear(hid_dim, out_dim)\",\n \"def __init__(self, embed_size, device, pool_size, attribute_dim):\\n super(EncoderClothing, self).__init__()\\n self.device = device\\n self.linear = nn.Linear(512*pool_size*pool_size, embed_size)\\n self.relu = nn.ReLU()\\n #self.module_list = nn.ModuleList([nn.Linear(embed_size, att_size) for att_size in attribute_dim])\\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\\n self.dropout = nn.Dropout(0.5)\\n self.pool_size = pool_size\\n\\n self.module_list = nn.ModuleList([self.conv_bn(512, 256, 1, embed_size, att_size) for att_size in attribute_dim])\",\n \"def __init__(self, input_dim, output_dim, name='embedding_layer'):\\n self.input_dim = input_dim\\n self.output_dim = output_dim\\n self.name = name\\n\\n # Randomly generate weights\\n self.embeddings = shared((input_dim, output_dim),\\n self.name + '__embeddings')\\n\\n # Define parameters\\n self.params = [self.embeddings]\",\n \"def __init__(self, embed_size, device, pool_size, attribute_dim):\\n super(EncoderClothing, self).__init__()\\n self.device = device\\n self.linear = nn.Linear(512*pool_size*pool_size, embed_size)\\n self.module_list = nn.ModuleList([nn.Linear(512*pool_size*pool_size, att_size) for att_size in attribute_dim])\\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\\n self.pool_size = pool_size\",\n \"def _get_embedding_layer(self, input_data, doc_input_data):\\n opts = self._options\\n word_embedding = tf.Variable(tf.random_uniform((self.vocab_size, opts.embed_dim), -1.0, 1.0))\\n embed = []\\n\\n temp = tf.zeros([opts.batch_size, opts.embed_dim])\\n embed_d = []\\n for n in range(opts.sentence_sample):\\n temp = tf.add(temp, tf.nn.embedding_lookup(word_embedding, doc_input_data[:, n]))\\n embed_d.append(temp)\\n\\n if opts.concat == 'True':\\n combined_embed_vector_length = opts.embed_dim * opts.window_size + opts.embed_dim\\n for j in range(opts.window_size):\\n embed_w = tf.nn.embedding_lookup(word_embedding, input_data[:, j])\\n embed.append(embed_w)\\n embed.append(embed_d)\\n else:\\n combined_embed_vector_length = opts.embed_dim\\n embed_w = tf.zeros([opts.batch_size, opts.embed_dim])\\n for j in range(opts.window_size):\\n embed_w += tf.nn.embedding_lookup(word_embedding, input_data[:, j])\\n embed_w += embed_d\\n embed.append(embed_w)\\n\\n return tf.concat(embed, 1), word_embedding, combined_embed_vector_length\",\n \"def embedding_layer(n_categories, embedding_dim, name=None):\\n\\n input_tensor = Input(shape=(1,))\\n x = Embedding(n_categories, embedding_dim, name=name)(input_tensor)\\n x = Reshape(target_shape=(embedding_dim,))(x)\\n\\n return input_tensor, x\",\n \"def __init__(self, embed_size):\\n super(ImgAttentionEncoder, self).__init__()\\n vggnet_feat = models.vgg19(pretrained=True).features\\n modules = list(vggnet_feat.children())[:-2]\\n self.cnn = nn.Sequential(*modules)\\n self.fc = nn.Sequential(nn.Linear(self.cnn[-3].out_channels, embed_size),\\n nn.Tanh()) # feature vector of image\",\n \"def add_embedding(self, prefix=''):\\n with tf.variable_scope(prefix + 'embed'):\\n if self.cfg.fix_emb:\\n assert (hasattr(self.cfg, 'W_emb'))\\n W_emb = pkl.load(open(self.cfg.W_emb_path, 'rb'))\\n W = tf.get_variable('W', initializer= W_emb, trainable=True)\\n print(\\\"iniitalize word embedding finished\\\")\\n else:\\n weightInit = tf.random_uniform_initializer(-0.001, 0.001)\\n vocab = pkl.load(open(self.cfg.vocab_path, 'rb'))\\n W = tf.get_variable('W', [len(vocab), self.cfg.emb_size], initializer=weightInit)\\n if hasattr(self.cfg, 'relu_w') and self.cfg.relu_w:\\n W = tf.nn.relu(W)\\n return W\",\n \"def __init__(self, vocab, embed_size=512, dropout_rate=0.1, max_len=200):\\n super(DecoderEmbeddings, self).__init__()\\n pad_token_idx = 0 #vocab.tokenizer.ids_to_tokens[0]\\n assert vocab.tokenizer.ids_to_tokens[0] == '[PAD]'\\n self.embeddings = nn.Embedding(len(vocab.tokenizer.ids_to_tokens), embed_size, padding_idx=pad_token_idx)\\n self.positional_encoding = PositionalEncoding(d_model=embed_size, dropout=dropout_rate, max_len=max_len)\",\n \"def add_embeddings(self):\\n\\n with tf.device('/cpu:0'):\\n with tf.variable_scope('Embedding_Layer'):\\n embeddings = tf.Variable(self.initial_embeddings,name = 'Embeddings')\\n self.input_embeddings = tf.nn.embedding_lookup(embeddings, self.inputs_placeholder) #(N,S,D)\\n self.question_embeddings = tf.nn.embedding_lookup(embeddings, self.questions_placeholder) #(N,S,D)\",\n \"def pretrained_embedding_layer(model,model2,model3, word_to_index,emb_dim_max):\\n words_ignored = []\\n vocab_len = len(word_to_index) + 1 \\n emb_matrix = np.zeros([vocab_len,emb_dim_max])\\n \\n print(' Total words would be processed : '+str(vocab_len))\\n for word, idx in word_to_index.items():\\n if word in model:\\n emb_matrix[idx,:200] = model[word]\\n emb_matrix[idx,200:] = 0\\n if word in model2:\\n emb_matrix[idx, :100] = model2[word]\\n emb_matrix[idx, 100:] = 0\\n if word in model3.keys():\\n emb_matrix[idx,:] = model3[word]\\n else:\\n words_ignored.append(word)\\n print(str(len(words_ignored))+\\\" words ignored\\\")\\n print(emb_matrix.shape) \\n \\n \\n embedding_layer = Embedding(vocab_len,emb_dim_max,trainable = True)\\n \\n # Build the embedding layer, it is required before setting the weights of the embedding layer. \\n embedding_layer.build((None,)) # Do not modify the \\\"None\\\". This line of code is complete as-is.\\n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\\n embedding_layer.set_weights([emb_matrix])\\n \\n return embedding_layer,words_ignored\",\n \"def __init__(self, embed_size, vocab):\\n super(ModelEmbeddings, self).__init__()\\n \\n self.embed_size = embed_size\\n self.char_embed_size = 50\\n self.max_word_len = 21\\n self.dropout_rate = 0.3\\n self.vocab = vocab \\n \\n ## A4 code\\n pad_token_idx = vocab.char2id['<pad>']\\n self.embedding = nn.Embedding(num_embeddings =len(vocab.char2id),\\n embedding_dim =self.char_embed_size,\\n padding_idx =pad_token_idx,)\\n \\n self.CNN = CNN(char_embed_size=self.char_embed_size,\\n num_filters=embed_size,\\n max_word_length=self.max_word_len,)\\n self.Highway = Highway(word_embed_size=self.embed_size)\\n self.dropout = nn.Dropout(p=self.dropout_rate)\\n ## End A4 code\\n\\n ### YOUR CODE HERE for part 1j\\n\\n\\n ### END YOUR CODE\",\n \"def _add_embedding_layer(model_1, model_2):\\n result_layer = torch.nn.Embedding(\\n model_1.num_embeddings, model_1.embedding_dim + model_2.embedding_dim\\n )\\n result_layer.weight = torch.nn.Parameter(\\n torch.cat((model_1.weight.data, model_2.weight.data), dim=1)\\n )\\n return result_layer\",\n \"def add_out_layer(self, embedding):\\n self.ac_dim = self.ac_space.shape[-1] # num dims\\n embedding = snt.Linear(output_size=self.ac_dim, name='final',\\n initializers=self.out_initializers)(embedding)\\n return embedding\",\n \"def make_embedding(src_emb_hparams, src_token_to_id_map,\\n tgt_emb_hparams=None, tgt_token_to_id_map=None,\\n emb_init_share=False):\\n src_embedding = MonoTextData.make_embedding(src_emb_hparams,\\n src_token_to_id_map)\\n\\n if emb_init_share:\\n tgt_embedding = src_embedding\\n else:\\n tgt_emb_file = tgt_emb_hparams[\\\"file\\\"]\\n tgt_embedding = None\\n if tgt_emb_file is not None and tgt_emb_file != \\\"\\\":\\n tgt_embedding = Embedding(tgt_token_to_id_map, tgt_emb_hparams)\\n\\n return src_embedding, tgt_embedding\",\n \"def __init__(self, embed_size):\\n super(Encoder, self).__init__()\\n resnet = models.resnet152(pretrained=True)\\n modules = list(resnet.children())[:-1] # delete the last fc layer.\\n self.resnet = nn.Sequential(*modules) \\n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\",\n \"def __init__(self, embed_size):\\n super(EncoderCNN, self).__init__()\\n resnet = models.resnet152(pretrained=True)\\n modules = list(resnet.children())[:-1] # delete the last fc layer.\\n self.resnet = nn.Sequential(*modules)\\n self.pooling = nn.MaxPool2d(2,stride = 2)\\n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\\n self.init_weights()\",\n \"def __init__(self, embed_size):\\n super(EncoderCNN, self).__init__()\\n resnet = models.resnet152(pretrained=True)\\n modules = list(resnet.children())[:-1] # delete the last fc layer.\\n self.resnet = nn.Sequential(*modules)\\n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\\n self.init_weights()\",\n \"def get_keras_layer(self, trainable=False, **kwargs):\\n\\n try:\\n from keras.layers.embeddings import Embedding\\n except:\\n raise ImportError('Keras not found')\\n\\n return Embedding(self.vocab_size, self.dim, weights=[self._matrix], trainable=trainable, **kwargs)\",\n \"def __init__(self, embed_size):\\n super(EncoderCNN, self).__init__()\\n resnet = models.resnet152(pretrained=True)\\n modules = list(resnet.children())[:-1] # delete the last fc layer.\\n self.resnet = nn.Sequential(*modules)\\n self.linear = nn.Linear(resnet.fc.in_features, embed_size)\\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)\",\n \"def __init__(self, num_words, embedding_size, use_cuda):\\n super(StandardEmbedding, self).__init__()\\n self.embedding_size = embedding_size\\n self.num_hash_functions = 0\\n self.embeddings = nn.Embedding(num_words, embedding_size)\\n self.embeddings = self.embeddings.cuda() if use_cuda else self.embeddings\",\n \"def build(self, unused_input_shapes):\\n if self.embedding_lookup is None:\\n self.embedding_lookup = layers.OnDeviceEmbedding(\\n vocab_size=self.config.vocab_size,\\n embedding_width=self.config.hidden_size,\\n initializer=tf.keras.initializers.TruncatedNormal(\\n stddev=self.config.initializer_range),\\n name=\\\"target_embeddings\\\")\\n self.embedding_postprocessor = EmbeddingPostprocessor(\\n use_type_embeddings=False,\\n use_position_embeddings=True,\\n max_position_embeddings=self.config.max_position_embeddings,\\n dropout_prob=self.config.hidden_dropout_prob,\\n initializer=tf.keras.initializers.VarianceScaling(\\n scale=self.config.initializer_gain,\\n mode=\\\"fan_avg\\\",\\n distribution=\\\"uniform\\\"),\\n name=\\\"embedding_postprocessor\\\")\\n # Decoder can use a different intermediate size.\\n self.multi_channel_cross_attention = self.config.get(\\n \\\"multi_channel_cross_attention\\\", False)\\n self.decoder = TransformerDecoder(\\n num_hidden_layers=self.config.num_decoder_layers,\\n hidden_size=self.config.hidden_size,\\n num_attention_heads=self.config.num_decoder_attn_heads,\\n intermediate_size=self.config.decoder_intermediate_size,\\n intermediate_activation=self.config.hidden_act,\\n hidden_dropout_prob=self.config.hidden_dropout_prob,\\n attention_probs_dropout_prob=self.config.attention_probs_dropout_prob,\\n initializer_range=self.config.initializer_range,\\n multi_channel_cross_attention=self.multi_channel_cross_attention,\\n name=\\\"decoder\\\")\\n super(Decoder, self).build(unused_input_shapes)\",\n \"def _embed(self):\\n batch_size = tf.shape(self.p)[0]\\n with tf.variable_scope(\\\"emb\\\"):\\n with tf.variable_scope(\\\"char\\\"):\\n pc_emb = tf.reshape(tf.nn.embedding_lookup(\\n self.char_embed, self.pc), \\n [batch_size * self.max_p_len, self.max_w_len, self.vocab.char_embed_dim])\\n qc_emb = tf.reshape(tf.nn.embedding_lookup(\\n self.char_embed, self.qc), \\n [batch_size * self.max_q_len, self.max_w_len, self.vocab.char_embed_dim])\\n cell_fw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\\n cell_bw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, pc_emb, self.pc_length, dtype=tf.float32)\\n pc_emb = tf.concat([state_fw, state_bw], axis=1)\\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, qc_emb, self.qc_length, dtype=tf.float32)\\n qc_emb = tf.concat([state_fw, state_bw], axis=1)\\n pc_emb = tf.reshape(pc_emb, [batch_size, self.max_p_len, 2 * self.char_hidden_size])\\n qc_emb = tf.reshape(qc_emb, [batch_size, self.max_q_len, 2 * self.char_hidden_size])\\n\\n with tf.name_scope(\\\"word\\\"):\\n p_emb = tf.nn.embedding_lookup(self.word_embed, self.p)\\n q_emb = tf.nn.embedding_lookup(self.word_embed, self.q)\\n\\n with tf.name_scope(\\\"pos\\\"):\\n p_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.p_pos)\\n q_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.q_pos)\\n \\n with tf.name_scope(\\\"em\\\"):\\n sh = tf.shape(self.p_em)\\n resh = [sh[0], sh[1], 1]\\n p_em_feat = tf.reshape(tf.cast(self.p_em, dtype=tf.float32), shape=resh)\\n\\n self.p_emb = tf.concat([p_emb, pc_emb, p_pos_emb, p_em_feat], axis=2)\\n self.q_emb = tf.concat([q_emb, qc_emb, q_pos_emb], axis=2)\",\n \"def __init__(self, embeddings, char_embeddings=None,\\n pos_embeddings=None, **kwargs):\\n super(WordRepresentationLayer, self).__init__()\\n self.embeddings = embeddings\\n self.embedding_dim = embeddings.embedding_dim\\n self.char_embeddings = char_embeddings\\n self.train_char_embeddings = kwargs.get('train_char_embeddings',\\n False)\\n self.use_cuda = kwargs.get('cuda', True)\\n\\n if self.char_embeddings:\\n self.char_merging_method = kwargs.get('char_merging_method', 'sum')\\n char_hidden_dim = kwargs.get('char_hidden_dim', 50)\\n bidirectional = kwargs.get('bidirectional', False)\\n\\n if self.char_merging_method == 'lstm':\\n self.char_encoder = LSTMCharEncoder(\\n char_embeddings,\\n char_hidden_dim,\\n bidirectional,\\n train_char_embeddings=self.train_char_embeddings,\\n cuda=self.use_cuda)\\n\\n self.embedding_dim += char_hidden_dim\\n\\n elif self.char_merging_method in ['mean', 'sum']:\\n self.char_encoder = LinearCharEncoder(\\n char_embeddings,\\n train_char_embeddings=self.train_char_embeddings,\\n char_merging_method=self.char_merging_method)\\n\\n self.embedding_dim += self.char_embeddings.embedding_dim\\n else:\\n raise NotImplementedError\\n\\n self.pos_embeddings = pos_embeddings\\n if self.pos_embeddings:\\n self.embedding_dim += self.pos_embeddings.embedding_dim\",\n \"def __init__(self, embed_size):\\n super(ImgEncoder, self).__init__()\\n model = models.vgg19(pretrained=True)\\n in_features = model.classifier[-1].in_features # input size of feature vector\\n model.classifier = nn.Sequential(\\n *list(model.classifier.children())[:-1]) # remove last fc layer\\n\\n self.model = model # loaded model without last fc layer\\n self.fc = nn.Linear(in_features, embed_size) # feature vector of image\",\n \"def get_embedding(self, resp):\\n\\n feed_dict = {self.anchor: resp}\\n embedding = self.sess.run(self.embed_anchor, feed_dict=feed_dict)\\n return embedding\",\n \"def instantiate_weights(self):\\n with tf.variable_scope(\\\"embedding_projection\\\"), tf.device('/cpu:0'): # embedding matrix\\n self.Embedding = tf.get_variable(\\\"Embedding\\\", shape=[self.vocab_size, self.embed_size],\\n initializer=self.initializer)\\n # self.Embedding_label = tf.get_variable(\\\"Embedding_label\\\", shape=[self.num_classes, self.embed_size],\\n # dtype=tf.float32) # ,initializer=self.initializer\\n # self.W_projection = tf.get_variable(\\\"W_projection\\\", shape=[self.sequence_length * self.d_model, self.num_classes],\\n # initializer=self.initializer) # [embed_size,label_size]\\n # self.b_projection = tf.get_variable(\\\"b_projection\\\", shape=[self.num_classes])\",\n \"def __init__(self,\\n vocab_size=None,\\n embed_dim=None,\\n existing_vocab=None,\\n initializers=None,\\n partitioners=None,\\n regularizers=None,\\n trainable=True,\\n custom_getter=None,\\n name=\\\"embed\\\"):\\n if vocab_size is None and existing_vocab is None:\\n raise ValueError(\\\"Must provide on of vocab_size or existing_vocab.\\\")\\n\\n if existing_vocab is not None and not all(\\n x is None for x in [vocab_size, embed_dim, initializers, partitioners]):\\n raise ValueError(\\\"If existing_vocab is provided, none of vocab_size, \\\"\\n \\\"embedding_dim, initializers, or partitioners is \\\"\\n \\\"needed.\\\")\\n\\n super(Embed, self).__init__(custom_getter=custom_getter, name=name)\\n self._existing_vocab = None\\n if existing_vocab is None:\\n self._vocab_size = vocab_size\\n self._embed_dim = embed_dim or _embedding_dim(self._vocab_size)\\n else:\\n self._existing_vocab = tf.convert_to_tensor(\\n existing_vocab, dtype=tf.float32)\\n existing_vocab_shape = self._existing_vocab.get_shape().with_rank(2)\\n existing_vocab_shape.assert_is_fully_defined()\\n self._vocab_size, self._embed_dim = existing_vocab_shape.as_list()\\n\\n self._initializers = util.check_initializers(\\n initializers, self.POSSIBLE_INITIALIZER_KEYS)\\n self._partitioners = util.check_partitioners(\\n partitioners, self.POSSIBLE_INITIALIZER_KEYS)\\n self._regularizers = util.check_regularizers(\\n regularizers, self.POSSIBLE_INITIALIZER_KEYS)\\n self._trainable = trainable\",\n \"def _create_layer() -> Image:\\n data = np.random.random((32, 16))\\n return Image(data)\",\n \"def add_layer(self, layer_pos, lay_dims, init_w_function, init_a_function, dropout, drop_prob, batch_norm):\\n\\n # If not within feasible bounds, return\\n if layer_pos < 0 or layer_pos >= self.number_hidden_layers:\\n return\\n\\n # We create the new layer and add it to the network descriptor\\n self.dims = np.insert(self.dims, layer_pos, lay_dims)\\n self.init_functions = np.insert(self.init_functions, layer_pos, init_w_function)\\n self.act_functions = np.insert(self.act_functions, layer_pos, init_a_function)\\n\\n # Finally the number of hidden layers is updated\\n self.number_hidden_layers = self.number_hidden_layers + 1\\n if not (isinstance(self.batch_norm, tuple) or self.batch_norm.shape[0] == 0):\\n self.batch_norm = np.insert(self.batch_norm, layer_pos, batch_norm)\\n if not (isinstance(self.dropout, tuple) or self.dropout.shape[0] == 0):\\n self.dropout = np.insert(self.dropout, layer_pos, dropout)\\n self.dropout_probs = np.insert(self.dropout_probs, layer_pos, drop_prob)\",\n \"def __init__(self, vocab_size, embedding_size, output_size, lat_dim):\\n super(Encoder, self).__init__()\\n\\n self.vocab_size = vocab_size\\n self.embedding = nn.Embedding(vocab_size, embedding_size)\\n self.lstm = nn.LSTM(embedding_size, output_size)\\n \\n self.hidden2mean = nn.Linear(output_size, lat_dim)\\n self.hidden2logv = nn.Linear(output_size, lat_dim)\\n \\n self.cell2mean = nn.Linear(output_size, lat_dim)\\n self.cell2logv = nn.Linear(output_size, lat_dim)\",\n \"def __init__(self, embed_size, hidden_size, vocab_size, num_layers, max_seq_length=20):\\n super(Decoder, self).__init__()\\n self.embed = nn.Embedding(vocab_size, embed_size)\\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)\\n self.linear = nn.Linear(hidden_size, vocab_size)\\n self.max_seg_length = max_seq_length\",\n \"def init_word_embed(config):\\n embedding_mat_val = np.load(config.wordembed_params)\\n with tf.variable_scope('vc'):\\n with tf.variable_scope('lstm', reuse=True):\\n embedding_mat = tf.get_variable(\\\"embedding_mat\\\", [config.num_vocab, config.embed_dim])\\n init_we = tf.assign(embedding_mat, embedding_mat_val)\\n return [init_we]\",\n \"def __init__(self, embed_size, hidden_size, vocab_size, num_layers):\\n super(DecoderRNN, self).__init__()\\n self.embed = nn.Embedding(vocab_size, embed_size)\\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)\\n self.linear = nn.Linear(hidden_size, vocab_size)\\n self.init_weights()\",\n \"def add_embedding(self):\\n #with tf.variable_scope(\\\"RNN\\\", reuse = tf.AUTO_REUSE):\\n embeddings = tf.get_variable(\\\"embeddings\\\", initializer = self.pretrained_embeddings,trainable=True)\\n inputs = self.input_placeholder\\n inputs = tf.reshape(inputs, [self.config.batch_size, -1 , self.config.n_features])\\n embeddings = tf.nn.embedding_lookup(embeddings, self.input_placeholder)\\n embeddings = tf.reshape(embeddings, [self.config.batch_size, -1, self.config.n_features* self.config.embed_size])\\n embeddings = tf.cast(embeddings, tf.float32)\\n return embeddings\",\n \"def __init__(self, embed_size, hidden_size, vocab_size, num_layers,\\n max_seq_length=20):\\n # Decoder\\n super(CaptioningModel, self).__init__()\\n resnet = models.resnet18(pretrained=True)\\n modules = list(resnet.children())[:-1] # delete the last fc layer.\\n self.resnet = nn.Sequential(*modules)\\n self.linear1 = nn.Linear(resnet.fc.in_features, embed_size)\\n self.bn = nn.BatchNorm1d(embed_size, momentum=0.01) \\n # Encoder \\n self.embed = nn.Embedding(vocab_size, embed_size)\\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)\\n self.linear2 = nn.Linear(hidden_size, vocab_size)\\n self.max_seg_length = max_seq_length\",\n \"def __init__(self, word_embed_size, vocab):\\n super(ModelEmbeddings, self).__init__()\\n\\n ### YOUR CODE HERE for part 1h\\n dropout_rate = 0.3\\n n_chars = len(vocab.char2id)\\n self.char_embed_size = 50\\n self.word_embed_size = word_embed_size\\n self.vocab = vocab\\n self.char_embed = nn.Embedding(n_chars, self.char_embed_size)\\n self.conv = CNN(self.char_embed_size, word_embed_size)\\n self.highway = Highway(word_embed_size)\\n self.dropout = nn.Dropout(dropout_rate)\\n ### END YOUR CODE\",\n \"def _use_embeddings(self, word):\\n if word == \\\"@PAD@\\\":\\n return torch.zeros(self.embeddings_dim)\\n else:\\n return self.embeddings[word]\",\n \"def build(self,unused):\\n # (word_embeddings_shape, _) = input_shapes\\n # width = word_embeddings_shape.as_list()[-1]\\n if self.use_type_embeddings:\\n self.type_embeddings = self.add_weight(\\n \\\"token_type_embeddings\\\",\\n shape=[self.token_type_vocab_size, self.word_embedding_width],\\n initializer=get_initializer(self.initializer_range),\\n dtype=self.dtype)\\n\\n self.position_embeddings = None\\n if self.use_position_embeddings:\\n self.position_embeddings = self.add_weight(\\n \\\"position_embeddings\\\",\\n shape=[self.max_position_embeddings, self.word_embedding_width],\\n initializer=get_initializer(self.initializer_range),\\n dtype=self.dtype)\\n\\n self.output_layer_norm = tf.keras.layers.LayerNormalization(\\n name=LAYER_NORM_NAME, axis=-1, epsilon=1e-12, dtype=tf.float32)\\n self.output_dropout = tf.keras.layers.Dropout(\\n rate=self.dropout_prob, dtype=tf.float32)\\n super().build(unused)\",\n \"def _add_pre_trained_embedding(self):\\n\\n if self.embedding_type['type'] == 'glove':\\n self.logging.info('use pre-trained glove word2vec')\\n # a. load pre trained glove\\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\\n import os\\n import numpy as np\\n\\n embeddings_index = {}\\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\\n for line in f:\\n values = line.split()\\n word = values[0]\\n coefs = np.asarray(values[1:], dtype='float32')\\n embeddings_index[word] = coefs\\n f.close()\\n\\n self.logging.info('')\\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\\n\\n # b. compute embedding matrix\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n embedding_vector = embeddings_index.get(word)\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n\\n elif self.embedding_type['type'] == 'gensim':\\n self.logging.info('use pre-trained gensim word2vec')\\n\\n import gzip\\n import gensim\\n from keras.layers import Embedding\\n import numpy as np\\n\\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\\n\\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\\n pretrained_weights = model.wv.syn0\\n vocab_size, vector_dim = pretrained_weights.shape\\n\\n method = 3\\n if method == 1:\\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\\n # into our TensorFlow and Keras models\\n\\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\\n for i in range(len(model.wv.vocab)):\\n embedding_vector = model.wv[model.wv.index2word[i]]\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector\\n\\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\\n output_dim=embedding_matrix.shape[1],\\n # input_length=self.maxlen,\\n weights=[embedding_matrix],\\n trainable=False)\\n elif method == 2:\\n self.logging.info('word2vec simple embedding matching - simple complex')\\n embedding_layer = Embedding(input_dim=vocab_size,\\n output_dim=vector_dim,\\n input_length=self.maxlen,\\n weights=[pretrained_weights],\\n trainable=False)\\n elif method == 3:\\n\\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\\n # b. compute embedding matrix\\n\\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\\n\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n if word in model.wv:\\n embedding_vector = model.wv[word]\\n embedding_matrix[i] = embedding_vector\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt))\\n\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n else:\\n raise ValueError('unknown method value')\\n\\n else:\\n raise ValueError('unknown embedding type')\\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\\n return embedding_layer\",\n \"def __init__(self,\\n vocab_size,\\n embed_dim,\\n dropout,\\n pretrained,\\n embedding=None,\\n num_gpus=1,\\n default_gpu_id=0,\\n regularizer=None,\\n random_seed=0,\\n trainable=True,\\n scope=\\\"word_feat\\\"):\\n self.vocab_size = vocab_size\\n self.embed_dim = embed_dim\\n self.dropout = dropout\\n self.pretrained = pretrained\\n self.embedding = embedding\\n self.num_gpus = num_gpus\\n self.default_gpu_id = default_gpu_id\\n self.regularizer = regularizer\\n self.random_seed = random_seed\\n self.trainable = trainable\\n self.scope = scope\\n \\n with tf.variable_scope(self.scope, reuse=tf.AUTO_REUSE):\\n self.embedding_layer = create_embedding_layer(self.vocab_size, self.embed_dim, self.pretrained,\\n self.embedding, self.num_gpus, self.default_gpu_id, None, self.random_seed, self.trainable)\\n \\n self.dropout_layer = create_dropout_layer(self.dropout, self.num_gpus, self.default_gpu_id, self.random_seed)\",\n \"def __init__(self, vocab_size, emb_size, bias=True, M=None, b=None, pretrained_emb=None, fix_w_emb=False):\\n super(AttentionEncoder, self).__init__()\\n\\n self.lookup = nn.Embedding(vocab_size, emb_size)\\n if pretrained_emb is None:\\n xavier_uniform(self.lookup.weight.data)\\n else:\\n assert pretrained_emb.size() == (vocab_size, emb_size), \\\\\\n \\\"Word embedding matrix has incorrect size: {} instead of {}\\\".format(w_emb.size(), (vocab_size, emb_size))\\n self.lookup.weight.data.copy_(pretrained_emb)\\n self.lookup.weight.requires_grad = not fix_w_emb\\n\\n self.M = nn.Parameter(torch.Tensor(emb_size, emb_size))\\n if M is None:\\n xavier_uniform(self.M.data)\\n else:\\n self.M.data.copy_(M)\\n if bias:\\n self.b = nn.Parameter(torch.Tensor(1))\\n if b is None:\\n self.b.data.zero_()\\n else:\\n self.b.data.copy_(b)\\n else:\\n self.b = None\",\n \"def load_embedding(src: str, embedding_type, layers) -> TransformerEmbedding:\\n emb = TransformerEmbedding(src, embedding_type=embedding_type, layers=layers)\\n return emb\",\n \"def embedding_setup(self, embedding, emb_trainable):\\n if emb_trainable == True:\\n emb_variable = tf.get_variable(\\n name=\\\"embedding_matrix\\\", shape=embedding.shape,\\n initializer = tf.constant_initializer(embedding))\\n return emb_variable\\n else:\\n return embedding\",\n \"def __init__(self, vocab_size, embedding_size, output_size):\\n super(VanillaEncoder, self).__init__()\\n\\n self.vocab_size = vocab_size\\n self.embedding = nn.Embedding(vocab_size, embedding_size)\\n self.gru = nn.GRU(embedding_size, output_size)\",\n \"def construct_embedding(self):\\n i = 0\\n self.load_dicts()\\n embedding_shape = (max(self.word2idx.values()) + 1,\\n self.embedding_size)\\n self.embedding = np.zeros(embedding_shape)\\n\\n with open(self.config.word_vec_fi_glove, 'r') as fi:\\n for line in fi:\\n word_vec = line.split(\\\" \\\")[1:]\\n self.embedding[i, :] = np.array(word_vec, dtype=np.float32)\\n i += 1\\n\\n self.write_embedding()\",\n \"def pool(embed, seq_len):\\n attention_w = ops.last_dim_weighted_sum(embed, \\\"w\\\")\\n attention_w = ops.mask_logits(attention_w, seq_len)\\n attention_w = tf.expand_dims(tf.nn.softmax(attention_w), 1)\\n\\n # [batch, 1, len] * [batch, len, dim] -> [batch, 1, dim]\\n return tf.squeeze(tf.matmul(attention_w, embed), 1)\",\n \"def build(self, input_shapes):\\n (word_embeddings_shape, _) = input_shapes\\n width = word_embeddings_shape.as_list()[-1]\\n self.type_embeddings = None\\n if self.use_type_embeddings:\\n self.type_embeddings = self.add_weight(\\n \\\"type_embeddings\\\",\\n shape=[self.token_type_vocab_size, width],\\n initializer=tf.keras.initializers.TruncatedNormal(\\n stddev=self.initializer_range),\\n dtype=self.dtype)\\n\\n self.position_embeddings = None\\n if self.use_position_embeddings:\\n self.position_embeddings = self.add_weight(\\n \\\"position_embeddings\\\",\\n shape=[self.max_position_embeddings, width],\\n initializer=tf.keras.initializers.TruncatedNormal(\\n stddev=self.initializer_range),\\n dtype=self.dtype)\\n\\n self.output_layer_norm = tf.keras.layers.LayerNormalization(\\n name=\\\"layer_norm\\\", axis=-1, epsilon=1e-12, dtype=tf.float32)\\n self.output_dropout = tf.keras.layers.Dropout(\\n rate=self.dropout_prob, dtype=tf.float32)\\n super(EmbeddingPostprocessor, self).build(input_shapes)\",\n \"def EmbeddingLayers_pooling(pretrained=False, progress=True, **kwargs):\\n kwargs['groups'] = 32\\n kwargs['width_per_group'] = 4\\n # return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress,\\n # **kwargs) \\n return _resnet('resnext50_32x4d', Bottleneck, [3, 4, 6, 3],\\n pretrained, progress, **kwargs)\",\n \"def __init__(self, emb_dim=100, window_size=3, init_emb=None,\\n hidden_dim=100, vocab_size=0, splitter=u' ', add_dim=0,\\n PAD_IDX=None):\\n assert window_size % 2 == 1, 'window_size must be odd.'\\n dim = emb_dim\\n hidden_dim = hidden_dim + add_dim\\n self.add_dim = add_dim\\n self.hidden_dim = hidden_dim\\n super(BaseCNNEncoder, self).__init__(emb=L.EmbedID(vocab_size, emb_dim, ignore_label=-1),\\n conv=L.Convolution2D(1, hidden_dim, ksize=(window_size, dim),\\n stride=(1, dim), pad=(window_size // 2, 0)))\\n self.splitter = splitter\\n self.char_level_flag = True if self.splitter is None else False\\n self.word_level_flag = not self.char_level_flag\\n self.emb_dim = emb_dim\\n self.window_size = window_size\\n self.dim = dim\\n self.PAD_IDX = PAD_IDX\\n self.train = True\\n # initialize embeddings\\n if init_emb is not None:\\n self.emb.W = init_emb\",\n \"def __init__(self,embedding_size):\\n super(ResNetEncoder,self).__init__()\\n resnet = models.resnet50(pretrained=True)\\n modules = list(resnet.children())[:-1]\\n #Create a sequential models upto top fc layer add a custom fc layer compatible with embedding size of decoder RNN\\n self.resnet = nn.Sequential(*modules)\\n self.embed = nn.Linear(resnet.fc.in_features,embedding_size)\\n self.bn = nn.BatchNorm1d(embedding_size,momentum=0.01)\\n self.init_weights()\",\n \"def _build(self, ids):\\n # Construct embeddings.\\n if self._existing_vocab is None:\\n if self.EMBEDDINGS not in self._initializers:\\n self._initializers[self.EMBEDDINGS] = basic.create_linear_initializer(\\n self._vocab_size)\\n self._embeddings = tf.get_variable(\\n \\\"embeddings\\\",\\n shape=[self._vocab_size, self._embed_dim],\\n dtype=tf.float32,\\n initializer=self._initializers[self.EMBEDDINGS],\\n partitioner=self._partitioners.get(self.EMBEDDINGS, None),\\n regularizer=self._regularizers.get(self.EMBEDDINGS, None),\\n trainable=self._trainable)\\n else:\\n self._embeddings = tf.get_variable(\\n \\\"embeddings\\\",\\n dtype=tf.float32,\\n initializer=self._existing_vocab,\\n regularizer=self._regularizers.get(self.EMBEDDINGS, None),\\n trainable=self._trainable)\\n\\n # Lookup embeddings\\n return tf.nn.embedding_lookup(\\n self._embeddings, ids, name=\\\"embedding_lookup\\\")\",\n \"def get_embed(input_data, vocab_size, embed_dim):\\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_dim), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, input_data)\\n\\n return embed\",\n \"def get_embed(input_data, vocab_size, embed_dim):\\n # todo 需要编程：\\n # 1、构建嵌入矩阵的查找表\\n lookup_w = tf.Variable(\\n initial_value=tf.random_uniform([vocab_size, embed_dim], -1.0, 1.0)\\n )\\n # 2、获得嵌入输出\\n embed = tf.nn.embedding_lookup(params=lookup_w, ids=input_data)\\n # [N, n_steps, embed_size]\\n return embed\",\n \"def build_embeddings(opt, word_dict, for_encoder='src'):\\n if for_encoder=='src':\\n embedding_dim = opt.src_word_vec_size #512\\n elif for_encoder=='tgt':\\n embedding_dim = opt.tgt_word_vec_size\\n elif for_encoder=='structure':\\n embedding_dim = 64\\n\\n word_padding_idx = word_dict.stoi[Constants.PAD_WORD]\\n num_word_embeddings = len(word_dict)\\n \\n if for_encoder=='src' or for_encoder=='tgt':\\n\\n return Embeddings(word_vec_size=embedding_dim,\\n position_encoding=opt.position_encoding,\\n dropout=opt.dropout,\\n word_padding_idx=word_padding_idx,\\n word_vocab_size=num_word_embeddings,\\n sparse=opt.optim == \\\"sparseadam\\\")\\n elif for_encoder=='structure':\\n return Embeddings(word_vec_size=embedding_dim,\\n position_encoding=False,\\n dropout=opt.dropout,\\n word_padding_idx=word_padding_idx,\\n word_vocab_size=num_word_embeddings,\\n sparse=opt.optim == \\\"sparseadam\\\")\",\n \"def _configure_embeddings(self):\\r\\n # TODO(omalleyt): Add integration tests.\\r\\n from tensorflow.python.keras.layers import embeddings\\r\\n try:\\r\\n from tensorboard.plugins import projector\\r\\n except ImportError:\\r\\n raise ImportError('Failed to import TensorBoard. Please make sure that '\\r\\n 'TensorBoard integration is complete.\\\"')\\r\\n config = projector.ProjectorConfig()\\r\\n for layer in self.model.layers:\\r\\n if isinstance(layer, embeddings.Embedding):\\r\\n embedding = config.embeddings.add()\\r\\n embedding.tensor_name = layer.embeddings.name\\r\\n\\r\\n if self.embeddings_metadata is not None:\\r\\n if isinstance(self.embeddings_metadata, str):\\r\\n embedding.metadata_path = self.embeddings_metadata\\r\\n else:\\r\\n if layer.name in embedding.metadata_path:\\r\\n embedding.metadata_path = self.embeddings_metadata.pop(layer.name)\\r\\n\\r\\n if self.embeddings_metadata:\\r\\n raise ValueError('Unrecognized `Embedding` layer names passed to '\\r\\n '`keras.callbacks.TensorBoard` `embeddings_metadata` '\\r\\n 'argument: ' + str(self.embeddings_metadata.keys()))\\r\\n\\r\\n class DummyWriter(object):\\r\\n \\\"\\\"\\\"Dummy writer to conform to `Projector` API.\\\"\\\"\\\"\\r\\n\\r\\n def __init__(self, logdir):\\r\\n self.logdir = logdir\\r\\n\\r\\n def get_logdir(self):\\r\\n return self.logdir\\r\\n\\r\\n writer = DummyWriter(self.log_dir)\\r\\n projector.visualize_embeddings(writer, config)\",\n \"def TransformerTokenEmbedding(\\n num_embeddings, embedding_dim, padding_idx, freeze_embed=False\\n):\\n m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx)\\n nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5)\\n nn.init.constant_(m.weight[padding_idx], 0)\\n if freeze_embed:\\n m.weight.requires_grad = False\\n return m\",\n \"def _load_byte_embedding(self):\\n char_embed_weights = self.npz_weights['char_embed']\\n num_tags = TAGS.__len__()\\n weights = np.zeros((char_embed_weights.shape[0] + num_tags + 1, char_embed_weights.shape[1]), dtype='float32')\\n weights[1:-num_tags, :] = char_embed_weights\\n self.embed_chars = rnn.Embedding(num_embeddings=self.num_embeddings, embedding_dim=self.char_embed_dim, padding_idx=self.padding_idx, freeze_embed=self._finetune_pretrained_weights)\\n self.embed_chars.weight.data.copy_(torch.FloatTensor(weights))\",\n \"def __init__(self, embed_size, dropout=0.5, image_model='resnet101', simple=False, pretrained=True):\\n super(EncoderCNNFeatures, self).__init__()\\n resnet = globals()[image_model](pretrained=pretrained)\\n\\n self.linear = nn.Sequential(nn.Conv2d(resnet.fc.in_features, embed_size, kernel_size=1, padding=0),\\n nn.Dropout2d(dropout))\\n\\n self.simple = simple\\n if simple:\\n self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\",\n \"def embed(self, features, feature_name, params):\\n with tf.variable_scope(\\\"%s_embed\\\" % feature_name):\\n embed_matrix = tf.get_variable(\\\"embedding_matrix\\\",\\n [getattr(params, \\\"%s_vocab_size\\\" % feature_name), \\n getattr(params, \\\"%s_embed_size\\\" % feature_name)])\\n return tf.nn.embedding_lookup(embed_matrix, features[feature_name])\",\n \"def Aut(A):\\n return Embeddings(A,A)\",\n \"def __init__(self, # noqa: R0913\\n hid_dim,\\n n_layers,\\n n_heads,\\n pf_dim,\\n dropout,\\n max_length=100):\\n super().__init__()\\n\\n self.pos_embedding = nn.Embedding(max_length, hid_dim)\\n\\n self.layers = nn.ModuleList([TransformerEncoderLayer(hid_dim,\\n n_heads,\\n pf_dim,\\n dropout)\\n for _ in range(n_layers)])\\n\\n self.dropout = nn.Dropout(dropout)\\n\\n self.register_buffer('scale', torch.sqrt(torch.FloatTensor([hid_dim])))\",\n \"def add_embedding(self, token, embedding):\\n self.word2idx[token] = self.vocab_size\\n self.vocab_size += 1\\n\\n self.embedding = np.vstack((self.embedding, embedding))\",\n \"def __init__(self, \\n k=DEFAULT_EMBEDDING_SIZE, \\n eta=DEFAULT_ETA, \\n epochs=DEFAULT_EPOCH, \\n batches_count=DEFAULT_BATCH_COUNT, \\n seed=DEFAULT_SEED,\\n embedding_model_params={'norm':DEFAULT_NORM_TRANSE, \\n 'normalize_ent_emb':DEFAULT_NORMALIZE_EMBEDDINGS,\\n 'negative_corruption_entities':DEFAULT_CORRUPTION_ENTITIES},\\n optimizer=DEFAULT_OPTIM, \\n optimizer_params={'lr':DEFAULT_LR},\\n loss=DEFAULT_LOSS, \\n loss_params={},\\n regularizer=DEFAULT_REGULARIZER, \\n regularizer_params={},\\n verbose=DEFAULT_VERBOSE):\\n super().__init__(k=k, eta=eta, epochs=epochs, batches_count=batches_count, seed=seed,\\n embedding_model_params=embedding_model_params,\\n optimizer=optimizer, optimizer_params=optimizer_params,\\n loss=loss, loss_params=loss_params,\\n regularizer=regularizer, regularizer_params=regularizer_params,\\n verbose=verbose)\",\n \"def CreateWavelet(self):\\n self.__context.builder.WaveletCreate(self.GetId())\",\n \"def create_embedding(skills):\\n corpus = list(skills[\\\"description\\\"].values)\\n embedder = SentenceTransformer(config[\\\"sentence_transformer\\\"][\\\"model\\\"])\\n embedding = embedder.encode(corpus, show_progress_bar=True)\\n return embedding\",\n \"def __init__(self, name, config, embed_mat):\\n if 'tune_embeds' not in config.keys():\\n raise ValueError('config must define \\\"tune_embeds\\\".')\\n super(TextModel, self).__init__(name, config)\\n self.embeds = nn.Embedding(embed_mat.shape[0], embed_mat.shape[1])\\n self.embeds.weight = nn.Parameter(torch.from_numpy(embed_mat),\\n requires_grad=self.tune_embeds)\",\n \"def __init__(self, out_embed_dims, vocab_size, vocab_reduction_module=None, fixed_weights=None, hidden_layer_size=32, activation_fn=torch.nn.ReLU, logit_fn=torch.exp):\\n super().__init__(out_embed_dims, vocab_size, vocab_reduction_module)\\n if fixed_weights is None:\\n self.fixed_weights = None\\n self.gating_network = nn.Sequential(Linear(sum(out_embed_dims), hidden_layer_size, bias=True), activation_fn(), Linear(hidden_layer_size, len(out_embed_dims), bias=True))\\n self.logit_fn = logit_fn\\n else:\\n assert len(fixed_weights) == len(out_embed_dims)\\n self.fixed_weights = maybe_cuda(torch.Tensor(fixed_weights).view(1, 1, -1))\",\n \"def init_embedding(self):\\n self.embedding.weight.data.uniform_(-1./self.num_embeddings, 1./self.num_embeddings)\",\n \"def build(self, input_shape):\\n hidden_dim = input_shape[2]\\n self.W = self.add_weight(\\n name='{}_W'.format(self.name),\\n shape=(hidden_dim, hidden_dim,),\\n initializer='uniform',\\n trainable=True)\\n self.b = self.add_weight(\\n name='{}_b'.format(self.name),\\n shape=(hidden_dim,),\\n initializer='zeros',\\n trainable=True)\\n self.u = self.add_weight(\\n name='{}_u'.format(self.name),\\n shape=(hidden_dim,),\\n initializer='uniform',\\n trainable=True)\\n super(AttentionLayer, self).build(input_shape)\",\n \"def add_embedding_layer(self, emb_matrix, ans2id, context2id, use_same=True):\\n with vs.variable_scope(\\\"embeddings\\\"):\\n qn_embedding_matrix = tf.Variable(emb_matrix, dtype=tf.float32,\\n name=\\\"qn_emb_matrix\\\") # shape (400002, embedding_size)\\n self.qn_embs = embedding_ops.embedding_lookup(qn_embedding_matrix, self.qn_ids)\\n\\n self.context_embedding_matrix = tf.Variable(tf.one_hot(range(len(context2id)), len(context2id)),\\n name=\\\"context_emb_matrix\\\")\\n if not use_same:\\n self.ans_embedding_matrix = tf.Variable(tf.one_hot(range(len(ans2id)), len(ans2id)),\\n dtype=tf.float32, name=\\\"ans_emb_matrix\\\")\\n else:\\n self.ans_embedding_matrix = tf.identity(self.context_embedding_matrix, name=\\\"ans_emb_matrix\\\")\\n\\n if self.FLAGS.use_raw_graph:\\n self.context_embs = embedding_ops.embedding_lookup(self.context_embedding_matrix, self.context_ids)\\n else:\\n self.context_embs = tf.identity(self.context_embedding)\\n self.ans_embs = embedding_ops.embedding_lookup(self.ans_embedding_matrix, self.ans_ids)\",\n \"def embed_word(self):\\n return self.emb.get_keras_embedding(dropout = self.emb_dropout,\\n trainable = self.trainable_emb,\\n input_length = self.sent_maxlen)\",\n \"def __init__(self, embed_size, dropout=0.5, image_model='resnet101', simple=False, pretrained=True):\\n super(EncoderCNN, self).__init__()\\n resnet = globals()[image_model](pretrained=pretrained)\\n modules = list(resnet.children())[:-2] # delete the last fc layer.\\n self.resnet = nn.Sequential(*modules)\\n \\n self.linear = nn.Sequential(nn.Conv2d(resnet.fc.in_features, embed_size, kernel_size=1, padding=0),\\n nn.Dropout2d(dropout))\\n\\n self.simple = simple\\n if simple:\\n self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\",\n \"def __init__(self, embed_size, hidden_size, vocab_size, vocab, num_layers, max_seq_length=30):\\n super(DecoderClothing, self).__init__()\\n self.embed = nn.Embedding(vocab_size, embed_size)\\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)\\n self.linear = nn.Linear(hidden_size, vocab_size)\\n self.max_seg_length = max_seq_length\\n self.vocab = vocab\\n self.clothing_class = {\\n 'shirt':0, 'jumper':1, 'jacket':2, 'vest':3, 'coat':4,\\n 'dress':5, 'pants':6, 'skirt':7, 'scarf':8, 'cane':9, 'bag':10, 'shoes':11,\\n 'hat':12, 'face':13, 'glasses':14 }\",\n \"def forward(self, tgt, m, enc_embed, mask):\\n bs = tgt.shape[0]\\n enc_embed = enc_embed.permute(2, 0, 1)\\n m = m.permute(2, 0, 1)\\n tgt = tgt.permute(2, 0, 1)\\n dec_embed = self.dec_embed.weight.unsqueeze(1).repeat(1, bs, 1)\\n\\n out = tgt\\n for layer in self.decoder_layers:\\n out = layer(out, m, \\n pos=enc_embed,\\n query_pos=dec_embed\\n )\\n \\n return self.decoder_norm(out).permute(1, 2, 0), dec_embed.permute(1, 2, 0)\",\n \"def embedding(org_input):\\n # Create the embedding list\\n for f in range(Config.num_feature):\\n num_cat_value = Config.schema[f]\\n\\n if num_cat_value == 1:\\n pass\\n elif num_cat_value > 1:\\n embed_dict[f] = tf.get_variable(\\n name=\\\"embed_\\\" + str(f),\\n shape=[num_cat_value, Config.embed_size[f]],\\n trainable=True)\\n else:\\n raise ValueError(\\\"Schema values should be positive integers!\\\")\\n\\n # Create embedded inputs\\n f_size = np.sum(Config.embed_size)\\n embedded_input = embed_events(org_input, f_size)\\n\\n return embedded_input\",\n \"def build(self, input_shape):\\n self.embedding = layers.Embedding(MAX_WORDS, 7, input_length=MAX_LEN)\\n self.conv_1 = layers.Conv1D(16, kernel_size=5, name=\\\"conv_1\\\", activation=\\\"relu\\\")\\n self.pool_1 = layers.MaxPool1D(name=\\\"pool_1\\\")\\n self.conv_2 = layers.Conv1D(\\n 128, kernel_size=2, name=\\\"conv_2\\\", activation=\\\"relu\\\"\\n )\\n self.pool_2 = layers.MaxPool1D(name=\\\"pool_2\\\")\\n self.flatten = layers.Flatten()\\n self.dense = layers.Dense(1, activation=\\\"sigmoid\\\")\\n super(CnnModel, self).build(input_shape)\",\n \"def embed(self, word: Any) -> dy.Expression:\\n raise NotImplementedError('embed must be implemented in Embedder subclasses')\",\n \"def embed_word(self):\\n return self.emb.get_keras_embedding(trainable = self.trainable_emb,\\n input_length = self.sent_maxlen)\",\n \"def randomly_init_embeddings(self, embed_dim):\\n self.embed_dim = embed_dim\\n self.embeddings = np.random.rand(self.size(), embed_dim)\\n for term in [self.pad_term, self.unk_term, self.eos_term]:\\n self.embeddings[self.get_id(term)] = np.zeros([self.embed_dim])\",\n \"def __init__(self, \\n k=DEFAULT_EMBEDDING_SIZE, \\n eta=DEFAULT_ETA, \\n epochs=DEFAULT_EPOCH, \\n batches_count=DEFAULT_BATCH_COUNT, \\n seed=DEFAULT_SEED,\\n embedding_model_params={'normalize_ent_emb':DEFAULT_NORMALIZE_EMBEDDINGS,\\n 'negative_corruption_entities':DEFAULT_CORRUPTION_ENTITIES},\\n optimizer=DEFAULT_OPTIM, \\n optimizer_params={'lr':DEFAULT_LR},\\n loss=DEFAULT_LOSS, \\n loss_params={},\\n regularizer=DEFAULT_REGULARIZER, \\n regularizer_params={},\\n verbose=DEFAULT_VERBOSE):\\n super().__init__(k=k, eta=eta, epochs=epochs, batches_count=batches_count, seed=seed,\\n embedding_model_params=embedding_model_params,\\n optimizer=optimizer, optimizer_params=optimizer_params,\\n loss=loss, loss_params=loss_params,\\n regularizer=regularizer, regularizer_params=regularizer_params,\\n verbose=verbose)\",\n \"def build(self, observation):\\n raise NotImplementedError(\\n 'Needs to be implemented as part of Embedder Interface')\",\n \"def set_embeddings(self):\",\n \"def initialize_model(self):\\n\\n input_layer = Input(\\n shape=(self.input_length,), \\n dtype='int32', \\n name='input'\\n )\\n\\n if self.embedding_matrix is None:\\n embedding = Embedding(\\n output_dim=self.embedding_size,\\n input_dim=self.vocabulary_size + 1, # for mask\\n input_length=self.input_length,\\n mask_zero=True,\\n name='embedding'\\n )(input_layer)\\n else:\\n embedding = Embedding(\\n output_dim=self.embedding_size,\\n input_dim=self.vocabulary_size + 1,\\n input_length=self.input_length,\\n mask_zero=True,\\n weights=[np.vstack((np.zeros((1, self.embedding_size)),\\n self.embedding_matrix))],\\n name='embedding'\\n )(input_layer)\\n\\n encoder = self.recurrent_cell(\\n self.latent_dim,\\n dropout=self.dropout,\\n recurrent_dropout=self.dropout,\\n name='encoder',\\n recurrent_regularizer=l1_l2(*self.regularization)\\n )\\n\\n if self.use_bidirection:\\n encoder = Bidirectional(\\n encoder,\\n merge_mode='concat'\\n )\\n\\n encoder = encoder(embedding)\\n\\n dense_1 = Dense(\\n 1024,\\n activation='tanh',\\n name='dense_1',\\n kernel_regularizer=l1_l2(*self.regularization)\\n )(encoder)\\n\\n dense_2 = Dense(\\n 512,\\n activation='tanh',\\n name='dense_2',\\n kernel_regularizer=l1_l2(*self.regularization)\\n )(dense_1)\\n\\n dropout = Dropout(self.dropout)(\\n dense_2\\n )\\n\\n prediction = Dense(\\n 1,\\n activation='sigmoid',\\n name='prediction'\\n )(dropout)\\n\\n model = Model(inputs=input_layer, outputs=prediction)\\n\\n # sparse_categorical_crossentropy\\n model.compile(optimizer=Adam(lr=self.learning_rate),\\n loss='binary_crossentropy',\\n metrics=['acc'])\\n\\n self.model = model\\n\\n if self.verbose > 0:\\n model.summary()\\n\\n return [model]\",\n \"def init_emb(self):\\n # Initialize users and items' embeddings\\n nn.init.xavier_uniform_(self.user_embedding.weight)\\n nn.init.xavier_uniform_(self.item_embedding.weight)\",\n \"def __init__(self, embed_size, hidden_size, vocab_size, num_layers, max_seq_length=20):\\n super(DecoderRNN, self).__init__()\\n self.embed = nn.Embedding(vocab_size, embed_size)\\n self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True)\\n self.linear = nn.Linear(hidden_size, vocab_size)\\n self.max_seg_length = max_seq_length\",\n \"def embeddings_layers_init(self):\\n\\n user_embeddings = tf.keras.layers.Embedding(\\n self.n_users, self.user_dim, input_length=1)\\n\\n item_embeddings = tf.keras.layers.Embedding(\\n self.n_items, self.item_dim, input_length=1)\\n\\n return user_embeddings, item_embeddings\",\n \"def get_embed(input_data, vocab_size, embed_dim):\\n embedding = tf.Variable(tf.random_uniform((vocab_size,embed_dim), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, input_data)\\n #print (\\\"embed_dim: \\\",embed_dim) # 向量表达维度为 256\\n #print (\\\"input_data.shape: \\\",input_data.shape) # (50, 5)\\n #print (\\\"embed.shap: \\\", embed.shape) # word 的向量表达 ==特征 (50, 5, 256) ==(batch_size, num_step, embed_dim)\\n return embed # 返回input的向量表达\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69322747","0.64097595","0.64067","0.63635826","0.63276964","0.6208275","0.6184051","0.6084168","0.60155404","0.6006011","0.6005224","0.6002711","0.60010916","0.59911853","0.5990504","0.5958701","0.5928769","0.592201","0.59150296","0.59118164","0.591048","0.5881971","0.58623266","0.58346045","0.5829561","0.5825973","0.58034843","0.5797413","0.5789574","0.5770195","0.5751782","0.57445216","0.57393354","0.57042795","0.5690474","0.5676684","0.56438285","0.5636173","0.563384","0.56259835","0.56242114","0.55724645","0.5550681","0.554225","0.5516452","0.55067986","0.5503801","0.5492672","0.54789984","0.54765326","0.5467126","0.54629487","0.54627794","0.54477084","0.54386514","0.5437972","0.5432589","0.5426777","0.5410019","0.53922826","0.5386396","0.5374121","0.5373288","0.5370031","0.5369764","0.5369487","0.53670293","0.5366179","0.53563356","0.5355865","0.5350761","0.53452796","0.5340862","0.5336025","0.5334177","0.5326047","0.5324481","0.5314751","0.5314164","0.5312264","0.5307636","0.53076035","0.53020674","0.52993596","0.5289326","0.5288775","0.5261143","0.52540314","0.52507263","0.52435184","0.52415895","0.5235062","0.52336156","0.5223143","0.52226466","0.5220503","0.521546","0.5208608","0.52029437","0.51843596"],"string":"[\n \"0.69322747\",\n \"0.64097595\",\n \"0.64067\",\n \"0.63635826\",\n \"0.63276964\",\n \"0.6208275\",\n \"0.6184051\",\n \"0.6084168\",\n \"0.60155404\",\n \"0.6006011\",\n \"0.6005224\",\n \"0.6002711\",\n \"0.60010916\",\n \"0.59911853\",\n \"0.5990504\",\n \"0.5958701\",\n \"0.5928769\",\n \"0.592201\",\n \"0.59150296\",\n \"0.59118164\",\n \"0.591048\",\n \"0.5881971\",\n \"0.58623266\",\n \"0.58346045\",\n \"0.5829561\",\n \"0.5825973\",\n \"0.58034843\",\n \"0.5797413\",\n \"0.5789574\",\n \"0.5770195\",\n \"0.5751782\",\n \"0.57445216\",\n \"0.57393354\",\n \"0.57042795\",\n \"0.5690474\",\n \"0.5676684\",\n \"0.56438285\",\n \"0.5636173\",\n \"0.563384\",\n \"0.56259835\",\n \"0.56242114\",\n \"0.55724645\",\n \"0.5550681\",\n \"0.554225\",\n \"0.5516452\",\n \"0.55067986\",\n \"0.5503801\",\n \"0.5492672\",\n \"0.54789984\",\n \"0.54765326\",\n \"0.5467126\",\n \"0.54629487\",\n \"0.54627794\",\n \"0.54477084\",\n \"0.54386514\",\n \"0.5437972\",\n \"0.5432589\",\n \"0.5426777\",\n \"0.5410019\",\n \"0.53922826\",\n \"0.5386396\",\n \"0.5374121\",\n \"0.5373288\",\n \"0.5370031\",\n \"0.5369764\",\n \"0.5369487\",\n \"0.53670293\",\n \"0.5366179\",\n \"0.53563356\",\n \"0.5355865\",\n \"0.5350761\",\n \"0.53452796\",\n \"0.5340862\",\n \"0.5336025\",\n \"0.5334177\",\n \"0.5326047\",\n \"0.5324481\",\n \"0.5314751\",\n \"0.5314164\",\n \"0.5312264\",\n \"0.5307636\",\n \"0.53076035\",\n \"0.53020674\",\n \"0.52993596\",\n \"0.5289326\",\n \"0.5288775\",\n \"0.5261143\",\n \"0.52540314\",\n \"0.52507263\",\n \"0.52435184\",\n \"0.52415895\",\n \"0.5235062\",\n \"0.52336156\",\n \"0.5223143\",\n \"0.52226466\",\n \"0.5220503\",\n \"0.521546\",\n \"0.5208608\",\n \"0.52029437\",\n \"0.51843596\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63652354"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":94287,"cells":{"query":{"kind":"string","value":"Return list of filename corresponding to JobSpider"},"document":{"kind":"string","value":"def get_spiders_files(spiders_directory=None):\n if spiders_directory is None:\n spiders_directory = dirname(__file__) + '/spiders/'\n return [file for file in glob.glob(spiders_directory + \"/*.py\")\n if isfile(file)\n and not file.endswith('__init__.py')]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_job_names(self):\n return []","def filenames(self):\n pass","def get_job_list():\n\tdirlist = os.listdir(\".\")\n\tjoblist = [x for x in dirlist if \"job.sh\" in x and x in job_dict]\n\ttmplist = [x for x in dirlist if \"job.sh\" in x and x not in job_dict]\n\tdef compare_function(s: str):\n\t\treturn job_dict[s].order\n\tjoblist.sort(key=compare_function)\n\tjoblist.extend(tmplist)\n\treturn joblist","def get_filenames(self):\n return self.filenames","def list_output_files(self):\r\n fname = self.__get_output_filename()\r\n return [fname] if fname else []","def GetFileNames(self):\n return self.files","def get_jobs():\n jobs = [os.path.join(JOBS_DIR, job)\n for job in os.listdir(JOBS_DIR)\n if job != '.gitignore']\n return jobs","def get_file_names(self, prediction=False):\n if prediction is False:\n filename_list = []\n for objects in self.bucket.objects.filter(Prefix=self.training_data_dir):\n filename = str(objects.key).split('/')[-1]\n if filename != \"\":\n filename_list.append(filename)\n return filename_list\n else:\n filename_list = []\n for objects in self.bucket.objects.filter(Prefix=self.prediction_data_dir):\n filename_list.append(str(objects.key).split('/')[-1])\n return filename_list","def get_filenames(is_training, data_dir):\n if is_training:\n return [os.path.join(data_dir, 'LIP_train5.record')]\n else:\n return [os.path.join(data_dir, 'LIP_val5.record')]","def filenames(self):\n return self._filenames","def get_all_job_files(jobFolder):\n job_files = {}\n for job_file in glob.glob(os.path.join(jobFolder, '*.json')):\n __, j = os.path.split(job_file)\n job_files[j] = ''\n return job_files","def get_filenames(is_training, data_dir):\n if is_training:\n return [\n os.path.join(data_dir, 'train-%05d-of-01024' % i)\n for i in range(_NUM_TRAIN_FILES)]\n else:\n return [\n os.path.join(data_dir, 'validation-%05d-of-00128' % i)\n for i in range(_NUM_VAL_FILES)]","def filenames(self):\n names = []\n for furi in np.asarray(self.fileuris).flat:\n names.append(furi)\n return names","def processed_file_names(self):\n # For 'trainval', we use files from 'train' and 'val' to save\n # memory\n if self.stage == 'trainval' and self.val_mixed_in_train:\n return [\n osp.join('train', self.pre_transform_hash, f'{w}.h5')\n for s in ('train', 'val')\n for w in self.all_cloud_ids[s]]\n if self.stage == 'trainval':\n return [\n osp.join(s, self.pre_transform_hash, f'{w}.h5')\n for s in ('train', 'val')\n for w in self.all_cloud_ids[s]]\n return [\n osp.join(self.stage, self.pre_transform_hash, f'{w}.h5')\n for w in self.cloud_ids]","def _ls_waiting_jobs(self):\n \n jobs = [j for j in os.listdir(pjoin(self._jobsdir, \"00_waiting\")) if j.endswith(self._job_ext)]\n \n if self._job_filter:\n jobs = [j for j in jobs if self._job_filter(pjoin(self._jobsdir, \"00_waiting\", j), j)]\n \n return jobs","def get_job_list(self):\n return self.job_list","def get_job_list(self):\n return self.job_list","def files(self):\n files = [self.submission]\n if self.kind == 'script':\n files.append(self.exec_script)\n if self.kind == 'function':\n files.append(self.function)\n return files","def get_filenames(self):\n return [doc['filename'] for doc in self.vocab]","def GetExpectationFilepaths(self) -> List[str]:\n raise NotImplementedError()","def get_filenames(is_training, data_dir):\n\n return [ os.path.join(data_dir, 'train_'+str(shard_id)+'.tfrecord') for shard_id in range(_NUM_SHARDS)]","def GetWorkloadFileList() -> list[str]:\n return [data.ResourcePath(workload) for workload in FLAGS.ycsb_workload_files]","def processed_file_names(self):\n if self.force_reprocess == True:\n self.force_reprocess = False\n return 'reprocess.pt'\n \n ''' HR 01/06/22 Workaround to avoid FileNotFoundError '''\n print('self.processed_dir:', self.processed_dir)\n # folder,file = os.path.split(self.processed_dir)\n folder = self.processed_dir\n if not os.path.isdir(folder):\n print(' Making folder', folder)\n os.makedirs(folder)\n \n processedfiles = [f for f in os.listdir(self.processed_dir) if os.path.isfile(\n os.path.join(self.processed_dir, f))]\n if 'pre_filter.pt' in processedfiles:\n processedfiles.remove('pre_filter.pt')\n if 'pre_transform.pt' in processedfiles:\n processedfiles.remove('pre_transform.pt')\n # 'not_implimented.pt' #[f'data_{i}.pt' for i in list(self.data.index)]\n return processedfiles","def get_filenames(self):\n if self.mode == tf.estimator.ModeKeys.TRAIN:\n lookup_name = 'train'\n elif self.mode == tf.estimator.ModeKeys.EVAL:\n lookup_name = 'validation'\n elif self.mode == tf.estimator.ModeKeys.PREDICT:\n lookup_name = self.predict_split\n filenames = tf.gfile.Glob(\n os.path.join(self.data_dir, '{}-*-of-*'.format(lookup_name)))\n if tf.estimator.ModeKeys.PREDICT:\n # Sort so that TFRecords will be read out deterministically.\n filenames = sorted(filenames)\n return filenames","def get_filenames(self):\n if self.mode == tf.estimator.ModeKeys.TRAIN:\n lookup_name = 'train'\n elif self.mode == tf.estimator.ModeKeys.EVAL:\n lookup_name = 'validation'\n elif self.mode == tf.estimator.ModeKeys.PREDICT:\n lookup_name = self.predict_split\n filenames = tf.gfile.Glob(\n os.path.join(self.data_dir, '{}-*-of-*'.format(lookup_name)))\n if tf.estimator.ModeKeys.PREDICT:\n # Sort so that TFRecords will be read out deterministically.\n filenames = sorted(filenames)\n return filenames","def _get_filepaths(self):\n self._printer(str(self.__len__()) + \" file paths have been parsed in \" + str(self.timer.end))\n if self._hash_files:\n return pool_hash(self.filepaths)\n else:\n return self.filepaths","def get_file_names():\n all_file_names = []\n cwd = os.getcwd()\n # Change to dir with result files to analyze\n os.chdir(args.dir)\n \n for file in glob.glob(\"*.csv\"):\n all_file_names.append(file)\n\n # Return to current working directory\n os.chdir(cwd)\n return all_file_names","def get_jobs_list(self, response):\n pass","def get_file_names(self):\n return glob.glob(os.path.join(self.path, '*.csv'))","def get_file_list() -> List[str]:\n filenames = []\n os.makedirs(\"sequence\", exist_ok=True)\n for file in glob.glob(\"sequence/*.smp\"):\n filenames.append(file.replace(\"sequence/\", \"\"))\n return filenames","def _find_files(job_schedule_info):\n files = []\n\n job_status = _status_info(job_schedule_info)\n assert job_status is not None, \\\n \"We should not have received an empty status\"\n\n properties = job_status.get(\"properties\")\n\n if not properties:\n LOG.error(str(job_status))\n raise Exception(\"The status of the job is expected to have a \"\n \"properties key, however, it is missing.\")\n\n LOG.debug(\"We want to find the files needed to trigger %s\" %\n properties[\"buildername\"])\n\n if \"packageUrl\" in properties:\n files.append(properties[\"packageUrl\"])\n if \"testsUrl\" in properties:\n files.append(properties[\"testsUrl\"])\n\n return files","def output_files(self):\n output_files = []\n for split in self.split_files:\n output_files.extend(split.filepaths)\n return output_files","def mapping_names(self):\n return [self.basename]","def get_filenames():\n filenames = []\n for filename in Path('.').glob('*.pdf'):\n if 'reordered' not in filename.stem:\n filenames.append(filename)\n\n return filenames","def list_filenames(self):\n l = []\n for path, dirs, files in os.walk(self.archive_path):\n for file in files:\n l.append(os.path.relpath(os.path.join(path,file),self.archive_path))\n l.sort()\n return l","def get_jobs(dumpruninfo):\n if \"jobs\" not in dumpruninfo:\n return []\n return dumpruninfo[\"jobs\"].keys()","def get_result_filenames(self,directory):\n return [os.path.join(directory,name) for name in os.listdir(directory)\n if os.path.isfile(os.path.join(directory,name)) and\n os.path.splitext(name)[1].lower() == '.trf']","def _getfilenames(self):\n\n # Set up the path and file prefix depending on the filetype.\n if self._filetype == 'nightwatch':\n fileprefix = 'qcframe'\n\n if self._location == 'nersc':\n prefix = '/global/project/projectdirs/desi/spectro/nightwatch/kpno'\n elif self._location == 'kpno':\n prefix = '/exposures/desi' # not correct path!\n else:\n raise ValueError('Unknown location {}'.format(self._location))\n elif self._filetype == 'redux':\n fileprefix = 'sframe'\n\n if self._location == 'nersc':\n prefix = '/global/project/projectdirs/desi/spectro/redux/daily/exposures'\n elif self._location == 'kpno':\n prefix = '/exposures/desi' # not correct path!\n else:\n raise ValueError('Unknown location {}'.format(self._location))\n else:\n raise ValueError('Unknown file type {}'.format(self._filetype))\n\n # Find the exposures files.\n exfiles = {}\n for ex in self._exposures:\n folder = '{}/{}/{:08d}'.format(prefix, self._date, ex)\n files = sorted(glob('{}/{}*.fits'.format(folder, fileprefix)))\n exfiles[ex] = files\n\n return exfiles","def get_filenames_reid(is_training, data_dir):\n if is_training:\n return [os.path.join(data_dir, 'train-512-170.tfrecords')]\n else:\n return [os.path.join(data_dir, 'val-512-170.tfrecords')]","def getHTMLFileNames(self):\n HTMLFiles = []\n for _file in os.listdir(self.dir):\n if _file.lower().endswith(\".html\"):\n HTMLFiles.append(_file)\n elif _file.lower().endswith(\".htm\"):\n HTMLFiles.append(_file)\n HTMLFiles.append(\"statistics.html\")\n return HTMLFiles","def raw_file_names(self):\n return self.filename","def list(self):\n return self.rpc.call(MsfRpcMethod.JobList)","def output_files(self):\n return [self.input_files()[0].replace(\".lhe.gz\", \".stdhep\").replace(\".lhe\", \".stdhep\")]","def get_submission():\n result_files = []\n for filename in os.listdir(\".\"):\n if filename.endswith(\"_output.csv\"):\n result_files.append(filename)\n return result_files[0]","def get_urls(self):\r\n if self.mod.filename:\r\n return [x + self.mod.filename for x in self.mod.service.get_mirrors()]","def index_files(self) -> List[str]:\n return self.get(\"index_files\", [\"index.html\", \"index.htm\"])","def extract_files(self) -> list:\n pass","def _get_parsed_files(self):\n\n parsed = []\n with Historical_ROAs_Parsed_Table() as t:\n for row in t.execute(f'SELECT * FROM {t.name}'):\n parsed.append(row['file'])\n return parsed","def namelist(self):\n\n # try to create a name from the archive name\n # because a gzipped file doesn't have information about the\n # original filename\n # gzipping a file creates the archive name by appending \".gz\"\n genericfilename = self._archivename\n\n if not genericfilename:\n genericfilename = \"generic.unknown.gz\"\n\n try:\n # get list of file extensions\n fileendinglist = Archivehandle.avail_archive_extensionlist4type['gz']\n replacedict = {\"wmz\": \"wmf\",\n \"emz\": \"emf\"}\n for ending in fileendinglist:\n endingwithdot = \".\"+ending\n if genericfilename.endswith(endingwithdot):\n if ending in replacedict:\n genericfilename = genericfilename[:-len(ending)]+replacedict[ending]\n else:\n genericfilename = genericfilename[:-len(endingwithdot)]\n break\n\n except Exception as e:\n print(e)\n pass\n return [genericfilename]","def genJobList():\n nit=10\n reply=[]\n while len(reply)<10: #assume qstat fails if less that 10 jobs on cluster\n reply=chomp(os.popen('qstat|expand|tr -s \\' \\'|cut -d\\' \\' -f 1,2,5').readlines())\n nit+=1\n if nit>10: break\n return reply","def getLogFileNames():\r\n return [\"Server1.txt\", \"Server2.txt\", \"Client1.txt\", \"Client2.txt\"]","def discover(self):\n ids = []\n for f in os.listdir(self.dirname):\n if self.file_prefix in f:\n ids.append(self.inv_filename(f))\n return sorted(ids)","def getMemberNames(self):\r\n # On Windows NT/2k/XP and Unix, if path is a Unicode object, the result \r\n # will be a list of Unicode objects. \r\n # Undecodable filenames will still be returned as string objects \r\n # If we don't request unicode, for example Vista may return a '?' \r\n # instead of a special character. The name would then be unusable to\r\n # build a distinct URL that references this resource.\r\n\r\n nameList = []\r\n\r\n for item in self.nibbler.listdir(self.path):\r\n name = to_str(item.name)\r\n nameList.append(name)\r\n\r\n for item in self.provider.cache_fs.get_dir_content(self.path):\r\n if item not in nameList:\r\n nameList.append(to_str(item))\r\n\r\n #this magic does not allow load the whole content for crazy Finder on MacOS\r\n magic_files = ['.ql_disablecache', '.ql_disablethumbnails']\r\n if nameList:\r\n for magic_file in magic_files:\r\n if magic_file not in nameList:\r\n f_obj = FSItem(magic_file, is_dir=False) \r\n self.provider.cache_fs.put(os.path.join(self.path, magic_file), f_obj)\r\n nameList.append(magic_file)\r\n\r\n return nameList","def getExternalFiles(self):\n return []","def get_files(self):\n m = []\n for post in self:\n m.append(post.FileName)\n return list(sorted(set(m), reverse=True))","def ListJobs(cls):\n return [key.parent().string_id() for key in cls.query().fetch(\n 100, keys_only=True)]","def list_of_expected_arrow_fq_files(self):\n def iter_script_to_get_fq(script_filename):\n for line in open(script_filename):\n # line might be like:\n # bash <arrow_dir>/c0to9.sh\n sh_file = line.strip().split()[-1]\n assert sh_file.endswith('.sh')\n yield sh_file[:-3] + '.arrowed.fastq'\n\n\n sge_ids = []\n submitted = {} # expected fq --> (\"local\" or SGE jobid, script used to get this)\n for line in open(self.arrow_submission_run_file):\n jobid, script = line.strip().split('\\t')\n # read the script to see which c<i>to<j>.sh files are associated with this\n for fq in iter_script_to_get_fq(script):\n submitted[fq] = (jobid, script)\n if jobid!='local':\n sge_ids.append(jobid)\n\n return sge_ids, submitted","def list_jobs(exproot, **kwargs):\n for jobname, args, results in load_all(exproot):\n print jobname, args, results","def files(self) -> List[str]:\n return [packet.name for packet in self.packets.file_description.values()]","def filenames(self):\n return self._files.keys()","def filenames(self):\n return self._files.keys()","def get_files(self):\n # self.folder= +str(int(time.time()))\n if not os.path.exists(self.folder):\n os.mkdir(self.folder)\n while len(self.url_queue): # If we have URLs to crawl - we crawl\n href = self.url_queue.popleft() # We grab a URL from the left of the list\n filename = href.rsplit('/', 1)[-1]\n print(\"Downloading %s to %s...\" % (href, filename))\n fullname = os.path.join(self.folder, filename)\n urlretrieve(href, fullname)\n self.xlfnames.append(filename)","def list_files(self):\n ret = []\n for fname in self.files:\n ret.append('filename: %s\\t replica locations: %s' %\n (fname, ','.join(self.files[fname])))\n return ret","def find_files():\n \n p = re.compile(REGEX_PART_NUMBER)\n job_files = []\n \n for root, dirs, files in os.walk(project_path): # r at start of string need to prevent unicode error\n for filename in files:\n re_part_number = p.match(filename)\n if re_part_number:\n file_ext = filename.split(\".\")[-1].lower() # extract file extension \n file_size = os.path.getsize((os.path.join(root, filename))) # filesize in bytes \n \n part_number = re_part_number.group() # extract part number from regular expression match\n part_code = part_number.split(\"-\")[0]\n \n destinations = [] # destinations is a list in case a filetype is both a source and output filetype\n \n if (file_ext in EXTS_SOURCE_FILES) and flag_find_source_files:\n destinations.append(os.path.join(target_source_path,part_code,part_number)) \n \n if (file_ext in EXTS_OUTPUT_FILES) and flag_find_output_files:\n destinations.append(os.path.join(target_source_path,part_code,part_number)) \n \n if destinations: \n job_files.append(File(filename,root,file_size,destinations,part_number,part_code))\n print(f\"Found: {filename}\")\n \n return job_files","def job_names(self):\n resp = self._cmd(uri = '/jenkins_jobs')\n names = []\n for item in resp.get('jobs'):\n names.append(item.get('job_name'))\n return sorted(names)","def get_pipeline_names() -> Iterable[str]:\n for item in sorted((SRC / \"pipelines\").iterdir()):\n if not item.name.startswith(\"_\") and not item.is_file():\n yield item.name","def _get_file_paths(self):\n return [os.path.join(self.path, self.mode, 'waveforms', file_name + '.npy') for file_name in self.file_names]","def filenames(self) -> dict[str, str]:\r\n ...","def get_files(self) -> list:\n files = []\n for file in os.listdir(self.root):\n if file.endswith(f\".{self.suffix}\"):\n files.append(os.path.join(self.root, file))\n return files","def ListJobs(self, token=None):\n return aff4.FACTORY.Open(self.CRON_JOBS_PATH, token=token).ListChildren()","def list_state_files(self, force_update: bool = False) -> List[str]:\n self._update_results(force_update)\n state_files = self._detailedOutputs['states']\n file_prefix = self._detailedOutputs['jobOutputPath']\n return [f\"{file_prefix}/{s}\" for s in state_files]","def listFiles(self):\n pass","def jobs(self):\n return self.get_jobs()","def filepaths(self):\n pass","def job_ids(self) -> List[str]:\n return self._db_data.job_ids","def handle_list(self, job):\n print(\"User requested list of files.\")\n # Send LIST job to all servers\n self.put_job_in_all_queues(job)\n list_job_results = self.get_internal_results_from_all_servers()\n if len(list_job_results) == 0:\n # There were no servers active\n self.put_external_result(self.generate_failure_job(\"Unsuccessful, no servers running\"))\n return\n\n # Concatenate the lists of files\n total_files_list = []\n for result in list_job_results:\n files_list = result.result[\"files_list\"]\n for each_file in files_list:\n if each_file not in total_files_list:\n total_files_list.append(each_file)\n\n # Return the files list\n response_result = copy.deepcopy(list_job_results[0])\n response_result.result[\"files_list\"] = total_files_list\n\n self.put_external_result(response_result)","def _filenames(self, dir_or_file):\n if os.path.isdir(dir_or_file):\n return glob(os.path.join(dir_or_file, \"*.txt\"))\n else:\n return [dir_or_file]","def _get_filenames():\n src_dir = os.path.join(FLAGS.dataset_dir, FLAGS.src_dir)\n filenames = [os.path.join(src_dir, f) for f in os.listdir(src_dir) if\n f.endswith(\".tfrecord\") and\n all([blackflag not in f for blackflag in TEMP_BLACK_LIST])]\n shuffle(filenames)\n return filenames","def list(self):\n return [os.splitext(el)[0] for el in\n os.listdir(str(self.model_dir))]","def _get_files_list(self):\n ts_filepaths = []\n conn_filepaths = []\n ts_filepaths_from_dir = sorted(os.listdir(self.ts_dir))\n conn_filepaths_from_dir = sorted(os.listdir(self.conn_dir))\n for sub_id in self.ids:\n for ts_file in ts_filepaths_from_dir:\n if sub_id in ts_file:\n ts_filepaths += [os.path.join(self.ts_dir, ts_file)]\n ts_filepaths_from_dir.remove(ts_file)\n break\n for conn_file in conn_filepaths_from_dir:\n if sub_id in conn_file:\n conn_filepaths += [os.path.join(self.conn_dir, conn_file)]\n conn_filepaths_from_dir.remove(conn_file)\n break\n\n return ts_filepaths, conn_filepaths","def get_job_list(self):\n job_list = []\n if mysql.job_list() == None:\n return job_list\n return mysql.job_list()","def list_requested_files(request):\n request_datetime_range = datetime_range(\n request.start_datetime,\n request.end_datetime,\n request.time_resolution\n )\n # Translate request datetime into files\n request_file_names = [\n datetime_to_file_name(ts) for ts in request_datetime_range\n ]\n return request_file_names","def process_jobs_(jobs):\n out = []\n for job in jobs:\n out_ = MultiProcessingFunctions.expand_call(job)\n out.append(out_)\n return out","def joplin_file_name(joplin_dir: str) -> str:\n for (_, _, files) in os.walk(joplin_dir):\n for filename in files:\n file_full_name = os.path.join(joplin_dir, filename)\n if os.path.isfile(file_full_name):\n yield file_full_name","def _get_file_names():\n file_names = {}\n file_names['train'] = ['data_batch_%d' % i for i in xrange(1, 6)]\n file_names['test'] = ['test_batch']\n\n return file_names","def get_jobs(self):\n return list(self._jobs.values())","def get_path_list(self, suffix=img_type):\n img_list = list(filter(lambda x: x.endswith(suffix), self.path_list))\n return img_list","def getFiles(self):\n\t\treturn os.listdir(self.getPath())","def _list(self):\n\n files = self.read_all_pages(\n self.metadata_url + 'nodes/' + self.backup_target_id +\n '/children?filters=kind:FILE')\n\n self.names_to_ids = {f['name']: f['id'] for f in files}\n\n return self.names_to_ids.keys()","def _get_output_filenames(output_path, dpp=None):\n ret = []\n for fname in os.listdir(output_path):\n ext = _ext(dpp)\n if re.match(r\"get[^_]+[_free\\d?]?\" + ext, fname):\n ret.append(fname)\n return ret","def get_filenames_strains(self, file_path_template_newick_tree):\n\t\tassert self.validate_file(file_path_template_newick_tree)\n\t\tlist_of_filenames_strains = []\n\t\ttree = Phylo.read(file_path_template_newick_tree, 'newick')\n\t\tfor leaf in tree.get_terminals():\n\t\t\tprefix = leaf.name\n\t\t\tif prefix.lower() == \"ancestor\":\n\t\t\t\tcontinue\n\t\t\tlist_of_filenames_strains.append(\"{prefix}.fasta\".format(prefix=prefix))\n\t\treturn list_of_filenames_strains","def get_files(self) -> tp.Iterable[str]:\n return os.listdir(self.path)","def getFilenameList(path, pattern='*.nii.gz'):\n\n filename = [os.path.basename(x) for x in sorted(glob.glob(os.path.join(path, pattern)))]\n\n return filename","def importMethodFileNames(directory):\n\n allfileNames = os.listdir(directory)\n methodsRunList = []\n\n for filename in allfileNames:\n if \"_MethodRunLog_\" in filename:\n methodsRunList.append(filename)\n return methodsRunList","def get_files_to_be_indexed(self):\n\t\tfiles = self.get_all_files()\n\t\tfiles_list = []\n\t\tfor name in files:\n\t\t\tif(name.split('.')[-1] in self.accepted_formats and os.stat(os.path.join(self.root, name)).st_size < 5000000):\n\t\t\t\tfiles_list.append(os.path.join(self.root, name))\n\t\treturn files_list[0:-1]","def urls(self) -> list[str]:\r\n ...","def queue_job_names(self):\n return [attrs[self.QCOL_NAME] for attrs in self.queue.values()]","def get_filename(self, dt):\n if self.period:\n flist = self.files_matching(dt)\n else:\n raise NotImplementedError\n #Now figure out the priority..","def get_filenames(self, bucket, directory, delimiter=''):\n b = self.conn.get_bucket(bucket)\n rs = b.list(directory, delimiter)\n return [key.name for key in rs if '$folder$' not in key.name]","def _get_files(self):\n # pylint: disable=unused-variable\n for dirpath, __, filenames in os.walk(self.start_location):\n for file_ in filenames:\n if file_.endswith('.py'):\n yield \"{0}{1}\".format(dirpath, file_)","def get_html_filenames():\n filenames = []\n file_folder = os.getcwd() + \"\\\\htmls\"\n for file in os.listdir(file_folder):\n if file.endswith(\".html\"):\n filenames.append('htmls\\\\' + file)\n return filenames"],"string":"[\n \"def get_job_names(self):\\n return []\",\n \"def filenames(self):\\n pass\",\n \"def get_job_list():\\n\\tdirlist = os.listdir(\\\".\\\")\\n\\tjoblist = [x for x in dirlist if \\\"job.sh\\\" in x and x in job_dict]\\n\\ttmplist = [x for x in dirlist if \\\"job.sh\\\" in x and x not in job_dict]\\n\\tdef compare_function(s: str):\\n\\t\\treturn job_dict[s].order\\n\\tjoblist.sort(key=compare_function)\\n\\tjoblist.extend(tmplist)\\n\\treturn joblist\",\n \"def get_filenames(self):\\n return self.filenames\",\n \"def list_output_files(self):\\r\\n fname = self.__get_output_filename()\\r\\n return [fname] if fname else []\",\n \"def GetFileNames(self):\\n return self.files\",\n \"def get_jobs():\\n jobs = [os.path.join(JOBS_DIR, job)\\n for job in os.listdir(JOBS_DIR)\\n if job != '.gitignore']\\n return jobs\",\n \"def get_file_names(self, prediction=False):\\n if prediction is False:\\n filename_list = []\\n for objects in self.bucket.objects.filter(Prefix=self.training_data_dir):\\n filename = str(objects.key).split('/')[-1]\\n if filename != \\\"\\\":\\n filename_list.append(filename)\\n return filename_list\\n else:\\n filename_list = []\\n for objects in self.bucket.objects.filter(Prefix=self.prediction_data_dir):\\n filename_list.append(str(objects.key).split('/')[-1])\\n return filename_list\",\n \"def get_filenames(is_training, data_dir):\\n if is_training:\\n return [os.path.join(data_dir, 'LIP_train5.record')]\\n else:\\n return [os.path.join(data_dir, 'LIP_val5.record')]\",\n \"def filenames(self):\\n return self._filenames\",\n \"def get_all_job_files(jobFolder):\\n job_files = {}\\n for job_file in glob.glob(os.path.join(jobFolder, '*.json')):\\n __, j = os.path.split(job_file)\\n job_files[j] = ''\\n return job_files\",\n \"def get_filenames(is_training, data_dir):\\n if is_training:\\n return [\\n os.path.join(data_dir, 'train-%05d-of-01024' % i)\\n for i in range(_NUM_TRAIN_FILES)]\\n else:\\n return [\\n os.path.join(data_dir, 'validation-%05d-of-00128' % i)\\n for i in range(_NUM_VAL_FILES)]\",\n \"def filenames(self):\\n names = []\\n for furi in np.asarray(self.fileuris).flat:\\n names.append(furi)\\n return names\",\n \"def processed_file_names(self):\\n # For 'trainval', we use files from 'train' and 'val' to save\\n # memory\\n if self.stage == 'trainval' and self.val_mixed_in_train:\\n return [\\n osp.join('train', self.pre_transform_hash, f'{w}.h5')\\n for s in ('train', 'val')\\n for w in self.all_cloud_ids[s]]\\n if self.stage == 'trainval':\\n return [\\n osp.join(s, self.pre_transform_hash, f'{w}.h5')\\n for s in ('train', 'val')\\n for w in self.all_cloud_ids[s]]\\n return [\\n osp.join(self.stage, self.pre_transform_hash, f'{w}.h5')\\n for w in self.cloud_ids]\",\n \"def _ls_waiting_jobs(self):\\n \\n jobs = [j for j in os.listdir(pjoin(self._jobsdir, \\\"00_waiting\\\")) if j.endswith(self._job_ext)]\\n \\n if self._job_filter:\\n jobs = [j for j in jobs if self._job_filter(pjoin(self._jobsdir, \\\"00_waiting\\\", j), j)]\\n \\n return jobs\",\n \"def get_job_list(self):\\n return self.job_list\",\n \"def get_job_list(self):\\n return self.job_list\",\n \"def files(self):\\n files = [self.submission]\\n if self.kind == 'script':\\n files.append(self.exec_script)\\n if self.kind == 'function':\\n files.append(self.function)\\n return files\",\n \"def get_filenames(self):\\n return [doc['filename'] for doc in self.vocab]\",\n \"def GetExpectationFilepaths(self) -> List[str]:\\n raise NotImplementedError()\",\n \"def get_filenames(is_training, data_dir):\\n\\n return [ os.path.join(data_dir, 'train_'+str(shard_id)+'.tfrecord') for shard_id in range(_NUM_SHARDS)]\",\n \"def GetWorkloadFileList() -> list[str]:\\n return [data.ResourcePath(workload) for workload in FLAGS.ycsb_workload_files]\",\n \"def processed_file_names(self):\\n if self.force_reprocess == True:\\n self.force_reprocess = False\\n return 'reprocess.pt'\\n \\n ''' HR 01/06/22 Workaround to avoid FileNotFoundError '''\\n print('self.processed_dir:', self.processed_dir)\\n # folder,file = os.path.split(self.processed_dir)\\n folder = self.processed_dir\\n if not os.path.isdir(folder):\\n print(' Making folder', folder)\\n os.makedirs(folder)\\n \\n processedfiles = [f for f in os.listdir(self.processed_dir) if os.path.isfile(\\n os.path.join(self.processed_dir, f))]\\n if 'pre_filter.pt' in processedfiles:\\n processedfiles.remove('pre_filter.pt')\\n if 'pre_transform.pt' in processedfiles:\\n processedfiles.remove('pre_transform.pt')\\n # 'not_implimented.pt' #[f'data_{i}.pt' for i in list(self.data.index)]\\n return processedfiles\",\n \"def get_filenames(self):\\n if self.mode == tf.estimator.ModeKeys.TRAIN:\\n lookup_name = 'train'\\n elif self.mode == tf.estimator.ModeKeys.EVAL:\\n lookup_name = 'validation'\\n elif self.mode == tf.estimator.ModeKeys.PREDICT:\\n lookup_name = self.predict_split\\n filenames = tf.gfile.Glob(\\n os.path.join(self.data_dir, '{}-*-of-*'.format(lookup_name)))\\n if tf.estimator.ModeKeys.PREDICT:\\n # Sort so that TFRecords will be read out deterministically.\\n filenames = sorted(filenames)\\n return filenames\",\n \"def get_filenames(self):\\n if self.mode == tf.estimator.ModeKeys.TRAIN:\\n lookup_name = 'train'\\n elif self.mode == tf.estimator.ModeKeys.EVAL:\\n lookup_name = 'validation'\\n elif self.mode == tf.estimator.ModeKeys.PREDICT:\\n lookup_name = self.predict_split\\n filenames = tf.gfile.Glob(\\n os.path.join(self.data_dir, '{}-*-of-*'.format(lookup_name)))\\n if tf.estimator.ModeKeys.PREDICT:\\n # Sort so that TFRecords will be read out deterministically.\\n filenames = sorted(filenames)\\n return filenames\",\n \"def _get_filepaths(self):\\n self._printer(str(self.__len__()) + \\\" file paths have been parsed in \\\" + str(self.timer.end))\\n if self._hash_files:\\n return pool_hash(self.filepaths)\\n else:\\n return self.filepaths\",\n \"def get_file_names():\\n all_file_names = []\\n cwd = os.getcwd()\\n # Change to dir with result files to analyze\\n os.chdir(args.dir)\\n \\n for file in glob.glob(\\\"*.csv\\\"):\\n all_file_names.append(file)\\n\\n # Return to current working directory\\n os.chdir(cwd)\\n return all_file_names\",\n \"def get_jobs_list(self, response):\\n pass\",\n \"def get_file_names(self):\\n return glob.glob(os.path.join(self.path, '*.csv'))\",\n \"def get_file_list() -> List[str]:\\n filenames = []\\n os.makedirs(\\\"sequence\\\", exist_ok=True)\\n for file in glob.glob(\\\"sequence/*.smp\\\"):\\n filenames.append(file.replace(\\\"sequence/\\\", \\\"\\\"))\\n return filenames\",\n \"def _find_files(job_schedule_info):\\n files = []\\n\\n job_status = _status_info(job_schedule_info)\\n assert job_status is not None, \\\\\\n \\\"We should not have received an empty status\\\"\\n\\n properties = job_status.get(\\\"properties\\\")\\n\\n if not properties:\\n LOG.error(str(job_status))\\n raise Exception(\\\"The status of the job is expected to have a \\\"\\n \\\"properties key, however, it is missing.\\\")\\n\\n LOG.debug(\\\"We want to find the files needed to trigger %s\\\" %\\n properties[\\\"buildername\\\"])\\n\\n if \\\"packageUrl\\\" in properties:\\n files.append(properties[\\\"packageUrl\\\"])\\n if \\\"testsUrl\\\" in properties:\\n files.append(properties[\\\"testsUrl\\\"])\\n\\n return files\",\n \"def output_files(self):\\n output_files = []\\n for split in self.split_files:\\n output_files.extend(split.filepaths)\\n return output_files\",\n \"def mapping_names(self):\\n return [self.basename]\",\n \"def get_filenames():\\n filenames = []\\n for filename in Path('.').glob('*.pdf'):\\n if 'reordered' not in filename.stem:\\n filenames.append(filename)\\n\\n return filenames\",\n \"def list_filenames(self):\\n l = []\\n for path, dirs, files in os.walk(self.archive_path):\\n for file in files:\\n l.append(os.path.relpath(os.path.join(path,file),self.archive_path))\\n l.sort()\\n return l\",\n \"def get_jobs(dumpruninfo):\\n if \\\"jobs\\\" not in dumpruninfo:\\n return []\\n return dumpruninfo[\\\"jobs\\\"].keys()\",\n \"def get_result_filenames(self,directory):\\n return [os.path.join(directory,name) for name in os.listdir(directory)\\n if os.path.isfile(os.path.join(directory,name)) and\\n os.path.splitext(name)[1].lower() == '.trf']\",\n \"def _getfilenames(self):\\n\\n # Set up the path and file prefix depending on the filetype.\\n if self._filetype == 'nightwatch':\\n fileprefix = 'qcframe'\\n\\n if self._location == 'nersc':\\n prefix = '/global/project/projectdirs/desi/spectro/nightwatch/kpno'\\n elif self._location == 'kpno':\\n prefix = '/exposures/desi' # not correct path!\\n else:\\n raise ValueError('Unknown location {}'.format(self._location))\\n elif self._filetype == 'redux':\\n fileprefix = 'sframe'\\n\\n if self._location == 'nersc':\\n prefix = '/global/project/projectdirs/desi/spectro/redux/daily/exposures'\\n elif self._location == 'kpno':\\n prefix = '/exposures/desi' # not correct path!\\n else:\\n raise ValueError('Unknown location {}'.format(self._location))\\n else:\\n raise ValueError('Unknown file type {}'.format(self._filetype))\\n\\n # Find the exposures files.\\n exfiles = {}\\n for ex in self._exposures:\\n folder = '{}/{}/{:08d}'.format(prefix, self._date, ex)\\n files = sorted(glob('{}/{}*.fits'.format(folder, fileprefix)))\\n exfiles[ex] = files\\n\\n return exfiles\",\n \"def get_filenames_reid(is_training, data_dir):\\n if is_training:\\n return [os.path.join(data_dir, 'train-512-170.tfrecords')]\\n else:\\n return [os.path.join(data_dir, 'val-512-170.tfrecords')]\",\n \"def getHTMLFileNames(self):\\n HTMLFiles = []\\n for _file in os.listdir(self.dir):\\n if _file.lower().endswith(\\\".html\\\"):\\n HTMLFiles.append(_file)\\n elif _file.lower().endswith(\\\".htm\\\"):\\n HTMLFiles.append(_file)\\n HTMLFiles.append(\\\"statistics.html\\\")\\n return HTMLFiles\",\n \"def raw_file_names(self):\\n return self.filename\",\n \"def list(self):\\n return self.rpc.call(MsfRpcMethod.JobList)\",\n \"def output_files(self):\\n return [self.input_files()[0].replace(\\\".lhe.gz\\\", \\\".stdhep\\\").replace(\\\".lhe\\\", \\\".stdhep\\\")]\",\n \"def get_submission():\\n result_files = []\\n for filename in os.listdir(\\\".\\\"):\\n if filename.endswith(\\\"_output.csv\\\"):\\n result_files.append(filename)\\n return result_files[0]\",\n \"def get_urls(self):\\r\\n if self.mod.filename:\\r\\n return [x + self.mod.filename for x in self.mod.service.get_mirrors()]\",\n \"def index_files(self) -> List[str]:\\n return self.get(\\\"index_files\\\", [\\\"index.html\\\", \\\"index.htm\\\"])\",\n \"def extract_files(self) -> list:\\n pass\",\n \"def _get_parsed_files(self):\\n\\n parsed = []\\n with Historical_ROAs_Parsed_Table() as t:\\n for row in t.execute(f'SELECT * FROM {t.name}'):\\n parsed.append(row['file'])\\n return parsed\",\n \"def namelist(self):\\n\\n # try to create a name from the archive name\\n # because a gzipped file doesn't have information about the\\n # original filename\\n # gzipping a file creates the archive name by appending \\\".gz\\\"\\n genericfilename = self._archivename\\n\\n if not genericfilename:\\n genericfilename = \\\"generic.unknown.gz\\\"\\n\\n try:\\n # get list of file extensions\\n fileendinglist = Archivehandle.avail_archive_extensionlist4type['gz']\\n replacedict = {\\\"wmz\\\": \\\"wmf\\\",\\n \\\"emz\\\": \\\"emf\\\"}\\n for ending in fileendinglist:\\n endingwithdot = \\\".\\\"+ending\\n if genericfilename.endswith(endingwithdot):\\n if ending in replacedict:\\n genericfilename = genericfilename[:-len(ending)]+replacedict[ending]\\n else:\\n genericfilename = genericfilename[:-len(endingwithdot)]\\n break\\n\\n except Exception as e:\\n print(e)\\n pass\\n return [genericfilename]\",\n \"def genJobList():\\n nit=10\\n reply=[]\\n while len(reply)<10: #assume qstat fails if less that 10 jobs on cluster\\n reply=chomp(os.popen('qstat|expand|tr -s \\\\' \\\\'|cut -d\\\\' \\\\' -f 1,2,5').readlines())\\n nit+=1\\n if nit>10: break\\n return reply\",\n \"def getLogFileNames():\\r\\n return [\\\"Server1.txt\\\", \\\"Server2.txt\\\", \\\"Client1.txt\\\", \\\"Client2.txt\\\"]\",\n \"def discover(self):\\n ids = []\\n for f in os.listdir(self.dirname):\\n if self.file_prefix in f:\\n ids.append(self.inv_filename(f))\\n return sorted(ids)\",\n \"def getMemberNames(self):\\r\\n # On Windows NT/2k/XP and Unix, if path is a Unicode object, the result \\r\\n # will be a list of Unicode objects. \\r\\n # Undecodable filenames will still be returned as string objects \\r\\n # If we don't request unicode, for example Vista may return a '?' \\r\\n # instead of a special character. The name would then be unusable to\\r\\n # build a distinct URL that references this resource.\\r\\n\\r\\n nameList = []\\r\\n\\r\\n for item in self.nibbler.listdir(self.path):\\r\\n name = to_str(item.name)\\r\\n nameList.append(name)\\r\\n\\r\\n for item in self.provider.cache_fs.get_dir_content(self.path):\\r\\n if item not in nameList:\\r\\n nameList.append(to_str(item))\\r\\n\\r\\n #this magic does not allow load the whole content for crazy Finder on MacOS\\r\\n magic_files = ['.ql_disablecache', '.ql_disablethumbnails']\\r\\n if nameList:\\r\\n for magic_file in magic_files:\\r\\n if magic_file not in nameList:\\r\\n f_obj = FSItem(magic_file, is_dir=False) \\r\\n self.provider.cache_fs.put(os.path.join(self.path, magic_file), f_obj)\\r\\n nameList.append(magic_file)\\r\\n\\r\\n return nameList\",\n \"def getExternalFiles(self):\\n return []\",\n \"def get_files(self):\\n m = []\\n for post in self:\\n m.append(post.FileName)\\n return list(sorted(set(m), reverse=True))\",\n \"def ListJobs(cls):\\n return [key.parent().string_id() for key in cls.query().fetch(\\n 100, keys_only=True)]\",\n \"def list_of_expected_arrow_fq_files(self):\\n def iter_script_to_get_fq(script_filename):\\n for line in open(script_filename):\\n # line might be like:\\n # bash <arrow_dir>/c0to9.sh\\n sh_file = line.strip().split()[-1]\\n assert sh_file.endswith('.sh')\\n yield sh_file[:-3] + '.arrowed.fastq'\\n\\n\\n sge_ids = []\\n submitted = {} # expected fq --> (\\\"local\\\" or SGE jobid, script used to get this)\\n for line in open(self.arrow_submission_run_file):\\n jobid, script = line.strip().split('\\\\t')\\n # read the script to see which c<i>to<j>.sh files are associated with this\\n for fq in iter_script_to_get_fq(script):\\n submitted[fq] = (jobid, script)\\n if jobid!='local':\\n sge_ids.append(jobid)\\n\\n return sge_ids, submitted\",\n \"def list_jobs(exproot, **kwargs):\\n for jobname, args, results in load_all(exproot):\\n print jobname, args, results\",\n \"def files(self) -> List[str]:\\n return [packet.name for packet in self.packets.file_description.values()]\",\n \"def filenames(self):\\n return self._files.keys()\",\n \"def filenames(self):\\n return self._files.keys()\",\n \"def get_files(self):\\n # self.folder= +str(int(time.time()))\\n if not os.path.exists(self.folder):\\n os.mkdir(self.folder)\\n while len(self.url_queue): # If we have URLs to crawl - we crawl\\n href = self.url_queue.popleft() # We grab a URL from the left of the list\\n filename = href.rsplit('/', 1)[-1]\\n print(\\\"Downloading %s to %s...\\\" % (href, filename))\\n fullname = os.path.join(self.folder, filename)\\n urlretrieve(href, fullname)\\n self.xlfnames.append(filename)\",\n \"def list_files(self):\\n ret = []\\n for fname in self.files:\\n ret.append('filename: %s\\\\t replica locations: %s' %\\n (fname, ','.join(self.files[fname])))\\n return ret\",\n \"def find_files():\\n \\n p = re.compile(REGEX_PART_NUMBER)\\n job_files = []\\n \\n for root, dirs, files in os.walk(project_path): # r at start of string need to prevent unicode error\\n for filename in files:\\n re_part_number = p.match(filename)\\n if re_part_number:\\n file_ext = filename.split(\\\".\\\")[-1].lower() # extract file extension \\n file_size = os.path.getsize((os.path.join(root, filename))) # filesize in bytes \\n \\n part_number = re_part_number.group() # extract part number from regular expression match\\n part_code = part_number.split(\\\"-\\\")[0]\\n \\n destinations = [] # destinations is a list in case a filetype is both a source and output filetype\\n \\n if (file_ext in EXTS_SOURCE_FILES) and flag_find_source_files:\\n destinations.append(os.path.join(target_source_path,part_code,part_number)) \\n \\n if (file_ext in EXTS_OUTPUT_FILES) and flag_find_output_files:\\n destinations.append(os.path.join(target_source_path,part_code,part_number)) \\n \\n if destinations: \\n job_files.append(File(filename,root,file_size,destinations,part_number,part_code))\\n print(f\\\"Found: {filename}\\\")\\n \\n return job_files\",\n \"def job_names(self):\\n resp = self._cmd(uri = '/jenkins_jobs')\\n names = []\\n for item in resp.get('jobs'):\\n names.append(item.get('job_name'))\\n return sorted(names)\",\n \"def get_pipeline_names() -> Iterable[str]:\\n for item in sorted((SRC / \\\"pipelines\\\").iterdir()):\\n if not item.name.startswith(\\\"_\\\") and not item.is_file():\\n yield item.name\",\n \"def _get_file_paths(self):\\n return [os.path.join(self.path, self.mode, 'waveforms', file_name + '.npy') for file_name in self.file_names]\",\n \"def filenames(self) -> dict[str, str]:\\r\\n ...\",\n \"def get_files(self) -> list:\\n files = []\\n for file in os.listdir(self.root):\\n if file.endswith(f\\\".{self.suffix}\\\"):\\n files.append(os.path.join(self.root, file))\\n return files\",\n \"def ListJobs(self, token=None):\\n return aff4.FACTORY.Open(self.CRON_JOBS_PATH, token=token).ListChildren()\",\n \"def list_state_files(self, force_update: bool = False) -> List[str]:\\n self._update_results(force_update)\\n state_files = self._detailedOutputs['states']\\n file_prefix = self._detailedOutputs['jobOutputPath']\\n return [f\\\"{file_prefix}/{s}\\\" for s in state_files]\",\n \"def listFiles(self):\\n pass\",\n \"def jobs(self):\\n return self.get_jobs()\",\n \"def filepaths(self):\\n pass\",\n \"def job_ids(self) -> List[str]:\\n return self._db_data.job_ids\",\n \"def handle_list(self, job):\\n print(\\\"User requested list of files.\\\")\\n # Send LIST job to all servers\\n self.put_job_in_all_queues(job)\\n list_job_results = self.get_internal_results_from_all_servers()\\n if len(list_job_results) == 0:\\n # There were no servers active\\n self.put_external_result(self.generate_failure_job(\\\"Unsuccessful, no servers running\\\"))\\n return\\n\\n # Concatenate the lists of files\\n total_files_list = []\\n for result in list_job_results:\\n files_list = result.result[\\\"files_list\\\"]\\n for each_file in files_list:\\n if each_file not in total_files_list:\\n total_files_list.append(each_file)\\n\\n # Return the files list\\n response_result = copy.deepcopy(list_job_results[0])\\n response_result.result[\\\"files_list\\\"] = total_files_list\\n\\n self.put_external_result(response_result)\",\n \"def _filenames(self, dir_or_file):\\n if os.path.isdir(dir_or_file):\\n return glob(os.path.join(dir_or_file, \\\"*.txt\\\"))\\n else:\\n return [dir_or_file]\",\n \"def _get_filenames():\\n src_dir = os.path.join(FLAGS.dataset_dir, FLAGS.src_dir)\\n filenames = [os.path.join(src_dir, f) for f in os.listdir(src_dir) if\\n f.endswith(\\\".tfrecord\\\") and\\n all([blackflag not in f for blackflag in TEMP_BLACK_LIST])]\\n shuffle(filenames)\\n return filenames\",\n \"def list(self):\\n return [os.splitext(el)[0] for el in\\n os.listdir(str(self.model_dir))]\",\n \"def _get_files_list(self):\\n ts_filepaths = []\\n conn_filepaths = []\\n ts_filepaths_from_dir = sorted(os.listdir(self.ts_dir))\\n conn_filepaths_from_dir = sorted(os.listdir(self.conn_dir))\\n for sub_id in self.ids:\\n for ts_file in ts_filepaths_from_dir:\\n if sub_id in ts_file:\\n ts_filepaths += [os.path.join(self.ts_dir, ts_file)]\\n ts_filepaths_from_dir.remove(ts_file)\\n break\\n for conn_file in conn_filepaths_from_dir:\\n if sub_id in conn_file:\\n conn_filepaths += [os.path.join(self.conn_dir, conn_file)]\\n conn_filepaths_from_dir.remove(conn_file)\\n break\\n\\n return ts_filepaths, conn_filepaths\",\n \"def get_job_list(self):\\n job_list = []\\n if mysql.job_list() == None:\\n return job_list\\n return mysql.job_list()\",\n \"def list_requested_files(request):\\n request_datetime_range = datetime_range(\\n request.start_datetime,\\n request.end_datetime,\\n request.time_resolution\\n )\\n # Translate request datetime into files\\n request_file_names = [\\n datetime_to_file_name(ts) for ts in request_datetime_range\\n ]\\n return request_file_names\",\n \"def process_jobs_(jobs):\\n out = []\\n for job in jobs:\\n out_ = MultiProcessingFunctions.expand_call(job)\\n out.append(out_)\\n return out\",\n \"def joplin_file_name(joplin_dir: str) -> str:\\n for (_, _, files) in os.walk(joplin_dir):\\n for filename in files:\\n file_full_name = os.path.join(joplin_dir, filename)\\n if os.path.isfile(file_full_name):\\n yield file_full_name\",\n \"def _get_file_names():\\n file_names = {}\\n file_names['train'] = ['data_batch_%d' % i for i in xrange(1, 6)]\\n file_names['test'] = ['test_batch']\\n\\n return file_names\",\n \"def get_jobs(self):\\n return list(self._jobs.values())\",\n \"def get_path_list(self, suffix=img_type):\\n img_list = list(filter(lambda x: x.endswith(suffix), self.path_list))\\n return img_list\",\n \"def getFiles(self):\\n\\t\\treturn os.listdir(self.getPath())\",\n \"def _list(self):\\n\\n files = self.read_all_pages(\\n self.metadata_url + 'nodes/' + self.backup_target_id +\\n '/children?filters=kind:FILE')\\n\\n self.names_to_ids = {f['name']: f['id'] for f in files}\\n\\n return self.names_to_ids.keys()\",\n \"def _get_output_filenames(output_path, dpp=None):\\n ret = []\\n for fname in os.listdir(output_path):\\n ext = _ext(dpp)\\n if re.match(r\\\"get[^_]+[_free\\\\d?]?\\\" + ext, fname):\\n ret.append(fname)\\n return ret\",\n \"def get_filenames_strains(self, file_path_template_newick_tree):\\n\\t\\tassert self.validate_file(file_path_template_newick_tree)\\n\\t\\tlist_of_filenames_strains = []\\n\\t\\ttree = Phylo.read(file_path_template_newick_tree, 'newick')\\n\\t\\tfor leaf in tree.get_terminals():\\n\\t\\t\\tprefix = leaf.name\\n\\t\\t\\tif prefix.lower() == \\\"ancestor\\\":\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tlist_of_filenames_strains.append(\\\"{prefix}.fasta\\\".format(prefix=prefix))\\n\\t\\treturn list_of_filenames_strains\",\n \"def get_files(self) -> tp.Iterable[str]:\\n return os.listdir(self.path)\",\n \"def getFilenameList(path, pattern='*.nii.gz'):\\n\\n filename = [os.path.basename(x) for x in sorted(glob.glob(os.path.join(path, pattern)))]\\n\\n return filename\",\n \"def importMethodFileNames(directory):\\n\\n allfileNames = os.listdir(directory)\\n methodsRunList = []\\n\\n for filename in allfileNames:\\n if \\\"_MethodRunLog_\\\" in filename:\\n methodsRunList.append(filename)\\n return methodsRunList\",\n \"def get_files_to_be_indexed(self):\\n\\t\\tfiles = self.get_all_files()\\n\\t\\tfiles_list = []\\n\\t\\tfor name in files:\\n\\t\\t\\tif(name.split('.')[-1] in self.accepted_formats and os.stat(os.path.join(self.root, name)).st_size < 5000000):\\n\\t\\t\\t\\tfiles_list.append(os.path.join(self.root, name))\\n\\t\\treturn files_list[0:-1]\",\n \"def urls(self) -> list[str]:\\r\\n ...\",\n \"def queue_job_names(self):\\n return [attrs[self.QCOL_NAME] for attrs in self.queue.values()]\",\n \"def get_filename(self, dt):\\n if self.period:\\n flist = self.files_matching(dt)\\n else:\\n raise NotImplementedError\\n #Now figure out the priority..\",\n \"def get_filenames(self, bucket, directory, delimiter=''):\\n b = self.conn.get_bucket(bucket)\\n rs = b.list(directory, delimiter)\\n return [key.name for key in rs if '$folder$' not in key.name]\",\n \"def _get_files(self):\\n # pylint: disable=unused-variable\\n for dirpath, __, filenames in os.walk(self.start_location):\\n for file_ in filenames:\\n if file_.endswith('.py'):\\n yield \\\"{0}{1}\\\".format(dirpath, file_)\",\n \"def get_html_filenames():\\n filenames = []\\n file_folder = os.getcwd() + \\\"\\\\\\\\htmls\\\"\\n for file in os.listdir(file_folder):\\n if file.endswith(\\\".html\\\"):\\n filenames.append('htmls\\\\\\\\' + file)\\n return filenames\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6951387","0.6711222","0.6683628","0.6501705","0.64207095","0.6337588","0.6322085","0.6264899","0.62041765","0.6117254","0.61150414","0.6107383","0.6075868","0.60367036","0.6032433","0.6024823","0.6024823","0.6017","0.6010282","0.5977642","0.59388155","0.5893192","0.58910984","0.5885156","0.5885156","0.58743596","0.58691245","0.58625114","0.5851566","0.5829595","0.5815875","0.5813537","0.58107287","0.58093995","0.5801752","0.5791863","0.578466","0.5782432","0.5777231","0.57763326","0.5756263","0.57313377","0.57166743","0.5678608","0.56747305","0.5671772","0.5668712","0.5666337","0.5653752","0.56384534","0.56355464","0.5634077","0.5632714","0.56298697","0.56268454","0.5624901","0.5619775","0.5590431","0.5586394","0.55804753","0.55804753","0.558037","0.5578246","0.5577049","0.5571723","0.55703366","0.55631286","0.55614835","0.5557646","0.55511683","0.5539901","0.5537065","0.55368024","0.55327445","0.5530444","0.5528505","0.55279344","0.55197763","0.5515078","0.55092037","0.5506776","0.55044216","0.54955655","0.54911655","0.5487684","0.548213","0.5480755","0.546994","0.5467194","0.5458641","0.54573023","0.5454444","0.54531425","0.5447987","0.54479134","0.5433635","0.5431097","0.54287976","0.54248","0.5422535","0.5418382"],"string":"[\n \"0.6951387\",\n \"0.6711222\",\n \"0.6683628\",\n \"0.6501705\",\n \"0.64207095\",\n \"0.6337588\",\n \"0.6322085\",\n \"0.6264899\",\n \"0.62041765\",\n \"0.6117254\",\n \"0.61150414\",\n \"0.6107383\",\n \"0.6075868\",\n \"0.60367036\",\n \"0.6032433\",\n \"0.6024823\",\n \"0.6024823\",\n \"0.6017\",\n \"0.6010282\",\n \"0.5977642\",\n \"0.59388155\",\n \"0.5893192\",\n \"0.58910984\",\n \"0.5885156\",\n \"0.5885156\",\n \"0.58743596\",\n \"0.58691245\",\n \"0.58625114\",\n \"0.5851566\",\n \"0.5829595\",\n \"0.5815875\",\n \"0.5813537\",\n \"0.58107287\",\n \"0.58093995\",\n \"0.5801752\",\n \"0.5791863\",\n \"0.578466\",\n \"0.5782432\",\n \"0.5777231\",\n \"0.57763326\",\n \"0.5756263\",\n \"0.57313377\",\n \"0.57166743\",\n \"0.5678608\",\n \"0.56747305\",\n \"0.5671772\",\n \"0.5668712\",\n \"0.5666337\",\n \"0.5653752\",\n \"0.56384534\",\n \"0.56355464\",\n \"0.5634077\",\n \"0.5632714\",\n \"0.56298697\",\n \"0.56268454\",\n \"0.5624901\",\n \"0.5619775\",\n \"0.5590431\",\n \"0.5586394\",\n \"0.55804753\",\n \"0.55804753\",\n \"0.558037\",\n \"0.5578246\",\n \"0.5577049\",\n \"0.5571723\",\n \"0.55703366\",\n \"0.55631286\",\n \"0.55614835\",\n \"0.5557646\",\n \"0.55511683\",\n \"0.5539901\",\n \"0.5537065\",\n \"0.55368024\",\n \"0.55327445\",\n \"0.5530444\",\n \"0.5528505\",\n \"0.55279344\",\n \"0.55197763\",\n \"0.5515078\",\n \"0.55092037\",\n \"0.5506776\",\n \"0.55044216\",\n \"0.54955655\",\n \"0.54911655\",\n \"0.5487684\",\n \"0.548213\",\n \"0.5480755\",\n \"0.546994\",\n \"0.5467194\",\n \"0.5458641\",\n \"0.54573023\",\n \"0.5454444\",\n \"0.54531425\",\n \"0.5447987\",\n \"0.54479134\",\n \"0.5433635\",\n \"0.5431097\",\n \"0.54287976\",\n \"0.54248\",\n \"0.5422535\",\n \"0.5418382\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94288,"cells":{"query":{"kind":"string","value":"Do the crawn job (see crawl function) from spider class name (eg. pyjobs_crawlers.spiders.myspider.MySpiderClass)"},"document":{"kind":"string","value":"def crawl_from_class_name(spider_class_name, connector, spider_error_callback=None):\n module_name = '.'.join(spider_class_name.split('.')[:-1])\n class_name = spider_class_name.split('.')[-1]\n\n spider_module = import_module(module_name)\n spider_class = getattr(spider_module, class_name)\n\n return crawl([spider_class], connector, spider_error_callback)[0]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def runSpider(spiderClass):\n\n\tprocess = CrawlerProcess({\n\t\t# 'USER_AGENT': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'\n\t})\n\n\tprocess.crawl(spiderClass)\n\tprocess.start() # the script will block here until the crawling is finished","def crawl(spider: str, book_id: int):\n proc = CrawlerProcess(get_project_settings())\n\n proc.crawl(spider, book_id=book_id)\n\n proc.start()","def crawl(spiders_classes, connector, debug=False, spider_error_callback=stdout_error_callback):\n if debug:\n dispatcher.connect(spider_error_callback, signals.spider_error)\n\n process = CrawlerProcess({\n 'ITEM_PIPELINES': {\n 'pyjobs_crawlers.pipelines.RecordJobPipeline': 1,\n },\n 'connector': connector,\n 'LOG_ENABLED': False\n })\n\n for spider_class in spiders_classes:\n process.crawl(spider_class)\n\n spiders = []\n for crawler in list(process.crawlers):\n spiders.append(crawler.spider)\n process.start()\n\n return spiders","def spidercls_for_request(spider_loader, request, default_spidercls: Optional[Any] = ..., log_none: bool = ..., log_multiple: bool = ...):\n ...","def runSpider(spider, searchterm = None, fullink = None, spiderbotid = -1):\n sclogic.runSpider(spider, searchterm, fullink, spiderbotid)","def main():\n\n from scrapy.crawler import CrawlerProcess\n from scrapy.utils.project import get_project_settings\n\n process = CrawlerProcess(get_project_settings())\n process.crawl(NCBIGeoSpider)\n process.start()","def run_spider_on_zyte(spider_name):\n print(f'Running spider {spider_name}...')\n data = dict(project=project_id, spider=spider_name)\n response = requests.post('https://app.scrapinghub.com/api/run.json', data=data, auth=(api_key, ''))\n return response.json()['jobid']","def runCrawler(crawlerid):\n sclogic.runCrawler(crawlerid)","def crawl(self):\n try:\n self.crawl_pages()\n self.crawl_posts()\n self.crawl_comments()\n except Exception as exception:\n self.handle_request_limit(exception)","def main():\n # get input params\n args = parm_parser.get_args()\n # init log config\n log.init_log('./log/mini_spider')\n if args:\n # read config file spider.conf\n conf_params = parm_parser.set_config_by_file(args.conf)\n # use config set up spider initial params\n spider = SpiderWorker(conf_params)\n # init result_path, make it complete\n spider.set_path()\n # init url queue\n spider.set_url_queue()\n # start to crawl url\n spider.start_crawl_work()\n\n return","def start_crawling(crawler_instance: Crawler):\n print('start crawling!')\n logger.info('started a new crawl!')\n crawler_instance.crawl()\n threading.Timer(Config.CRAWL_TIMEOUT, start_crawling,\n [crawler_instance]).start()","def crawl(self):\n\n # create helper process and setup IPC\n self.socket.listen(1)\n help_out_fd = open(self.helper_outfile, \"w\")\n with subprocess.Popen(\"./crawl_helper.py\", stdout=help_out_fd, stderr=subprocess.STDOUT) as proc:\n self.helper_pid = proc.pid\n try:\n conn, _ = self.socket.accept()\n # create initial params for crawler helper and send them\n new_urls = set()\n setup_params = {\"start_urls\": self.start_urls, \"allowed_domains\": [self.domain],\n \"cookies\": self.cookies, \"user_agent\": self.config[\"user_agent\"]}\n ipc_operations.send_object(conn, setup_params)\n\n # loop: receive a response object, then send new URLs to crawl. Catch & handle problems.\n while True:\n try:\n proc.wait(timeout=0.001)\n break\n except subprocess.TimeoutExpired:\n response = ipc_operations.receive_object(conn)\n if not response: # socket is dead / closed\n break\n new_urls = self.process_response(response)\n ipc_operations.send_object(conn, new_urls)\n except socket.timeout:\n util.printit(\"Unix socket connection to scrapy crawler unexpectedly broke. \" +\n \"Quitting crawling of %s\" % self.base_url, color=util.RED)\n break\n finally:\n # ensure connection is closed and helper process killed in any case\n conn.close()\n proc.kill()\n\n # after the actual crawling, extract all the gathered cookies from Selenium\n if self.config[\"use_selenium\"].lower() == \"true\":\n selenium_cookies = self.driver.get_cookies()\n for cookie in selenium_cookies:\n if not any(cookie[\"name\"] == c[\"name\"] and cookie[\"path\"] == c[\"path\"] and\n cookie[\"domain\"] == c[\"domain\"] for c in self.found_cookies):\n parsed_cookie = {}\n for key in (\"name\", \"path\", \"domain\", \"httpOnly\", \"secure\"):\n parsed_cookie[key] = cookie[key]\n self.found_cookies.append(parsed_cookie)\n\n help_out_fd.close()\n return self.create_results()","def WebscraperTask(job_id):\n logger.debug(\"Entering dispatch_wordscraper with job ID: %s\" % str(job_id))\n\n # Obtain all required crawler arguments\n job = Job.objects.get(pk=job_id)\n word_list = [(term.term_id, term.term)\n for term in Term.objects.filter(job=job)]\n site_list = [(site.site_id, site.url, job.max_depth, 'English')\n for site in Site.objects.filter(job=job)]\n\n # Initialize the crawling process\n logger.debug(\"Configuring crawl controller with job_id: \" +\n \"%d, terms: %s, sites: %s\" % (job_id, str(word_list),\n str(site_list),))\n controller = init_controller()\n controller.crawl(job_id, site_list, word_list)\n logger.debug(\"Crawl complete for job: %d\" % job_id)\n\n # Cache the results in the database so the results are dated as close to the\n # crawl date as possible.\n results = controller.query(site_list, word_list)\n result_cache = Result()\n result_cache.job = job\n result_cache.output = results\n result_cache.save()","def run_crawl(self, args):\n\n # Crawler process declaration\n process = CrawlerProcess({\n 'USER_AGENT': 'David Avs Crawler',\n 'FEED_FORMAT': 'json',\n 'FEED_URI': 'stdout:',\n 'LOG_ENABLED': args.verbose,\n })\n kwargs = dict(\n start_urls=[args.url],\n allowed_domains=[urlparse.urlparse(args.url).netloc.lower()],\n )\n\n # Run crawling\n old_stdout = sys.stdout\n sys.stdout = args.file\n try:\n process.crawl(DavidAvsSpider, **kwargs)\n process.start()\n finally:\n sys.stdout = old_stdout","def start_crawlers(spider_name: str, rules: List[Rule]) -> None:\n runner = CrawlerRunner(settings)\n crawlers = runner.spider_loader.list()\n crawlers = [c for c in crawlers if c.__contains__(spider_name)]\n if crawlers:\n for rule in rules:\n runner.crawl(crawlers[0], rule=rule)\n d = runner.join()\n d.addBoth(lambda _: reactor.stop())\n reactor.run()\n launch_logger.debug('all finished.')\n else:\n launch_logger.warning('provide the right spider name.')","def start(self):\n self.start_spider()\n self.start_ranker()\n\n concurrent.futures.wait(self.spider_thread_futures) # wait for spiders to finish\n self.logger.info(\"Done crawling\")\n self.ranker.done_crawling.set()\n\n self.ranker.print_ranks()","def open_spider(self,Spider):\n pass","def crawl_start(crawl_obj):\n \n res = None\n\n if crawl_obj.type in ['user', 'song'] :\n res = eval('crawl_' + crawl_obj.type)(crawl_obj)\n elif crawl_obj.type in ['artist', 'album'] :\n web_data = requests.get(crawl_obj.url, headers = cheat_headers)\n soup = bs4.BeautifulSoup(web_data.text, 'lxml')\n\n res = eval('crawl_' + crawl_obj.type)(crawl_obj.type, soup)\n else:\n print(\"Object type UNKNOWN!\")\n \n return res","def from_crawler(cls, crawler, *args, **kwargs):\n\n spider = super(autos_detran_terceiros_sp_spider, cls).from_crawler(\n crawler, *args, **kwargs)\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\n return spider","def run_spiders():\n hour_limit = 3600 # in seconds\n\n settings = get_project_settings()\n\n # Uncomment the following block of code if you want to test the manager on\n # the \"onepagetest\" to make sure the manager is working.\n \"\"\"\n settings[\"HTTPCACHE_ENABLED\"] = 1\n settings[\"HTTPCACHE_EXPIRATION_SECS\"] = 0\n settings[\"HTTPCACHE_STORAGE\"] = \"scrapy.extensions.httpcache.FilesystemCacheStorage\"\n settings[\"HTTPCACHE_IGNORE_MISSING\"] = 1\n settings[\"HTTPCACHE_DIR\"] = \"onepagetest\"\n \"\"\"\n\n runner = CrawlerRunner(settings)\n begin_time = datetime.now()\n\n d = runner.crawl(\"sb_spider\")\n d.addBoth(lambda _: continue_crawl(d, runner, begin_time, hour_limit))\n reactor.run()","def run_generic_spider( user_id\t\t\t\t= None,\n\t\t\t\t\t\tspider_id\t\t\t= None,\n\t\t\t\t\t\tdatamodel\t\t\t= None,\n\t\t\t\t\t\trun_spider_config\t= None,\n\t\t\t\t\t\ttest_limit\t\t\t= None\n\t\t\t\t\t\t):\n\n\tprint ()\n\tlog_scrap.info(\"--- run_generic_spider / spider_id : %s \", spider_id )\n\n\t### WARNING !!! --> TEMPORARY SOLUTION\n\t### remove spider folder for spider_id in JOBDIR\n\tlog_scrap.debug(u\"--- run_generic_spider / cwd : %s\", os.getcwd() )\n\ttry :\n\t\tshutil.rmtree( os.getcwd() + \"/\" + JOBDIR_FOLDER + \"/\" + spider_id )\n\texcept:\n\t\tpass\n\tlog_scrap.debug(u\"--- run_generic_spider / removed folder : {}/{}\".format(JOBDIR_FOLDER, spider_id) )\n\n\t# !!! spider is launched from main.py level !!!\n\t# all relative routes referring to this...\n\tlog_scrap.info(\"--- run_generic_spider / os.getcwd() : %s \", os.getcwd() )\n\n\t### flattening run_spider_config : from nested to flat dict\n\tlog_scrap.info(\"--- run_generic_spider / 'flattenSpiderConfig()' on 'run_spider_config' --> 'spider_config_flat' ...\" )\n\tspider_config_flat = flattenSpiderConfig( run_spider_config )\n\n\n\t### settings for crawler\n\t# cf : https://hackernoon.com/how-to-crawl-the-web-politely-with-scrapy-15fbe489573d\n\n\t### global settings for scrapy processes (see upper)\n\tlog_scrap.info(\"--- run_generic_spider / BOT_NAME : %s \", settings.get('BOT_NAME') )\n\tlog_scrap.info(\"--- run_generic_spider / USER_AGENT : %s \", settings.get('USER_AGENT') )\n\tlog_scrap.info(\"--- run_generic_spider / ITEM_PIPELINES : %s \", settings.get('ITEM_PIPELINES').__dict__ )\n\n\n\t# specific settings for this scrapy process\n\n\t# settings.set( \"RETRY_TIMES\"\t\t\t\t\t\t, RETRY_TIMES )\n\t# settings.set( \"CONCURRENT_ITEMS\"\t\t\t\t, CONCURRENT_ITEMS )\n\t# settings.set( \"CONCURRENT_REQUESTS\"\t\t\t\t, CONCURRENT_REQUESTS )\n\t# settings.set( \"CONCURRENT_REQUESTS_PER_DOMAIN\"\t, CONCURRENT_REQUESTS_PER_DOMAIN )\n\t# settings.set( \"REDIRECT_MAX_TIMES\"\t\t\t\t, REDIRECT_MAX_TIMES )\n\t# settings.set( \"DOWNLOAD_MAXSIZE\" \t\t\t\t, DOWNLOAD_MAXSIZE )\n\t# settings.set( \"DEPTH_PRIORITY\"\t\t\t\t\t, DEPTH_PRIORITY )\n\t# settings.set( \"SCHEDULER_DISK_QUEUE\"\t\t\t, SCHEDULER_DISK_QUEUE )\n\t# settings.set( \"DEPTH_PRIORITY\"\t\t\t\t\t, SCHEDULER_MEMORY_QUEUE )\n\n\t# settings.set( \"RANDOMIZE_DOWNLOAD_DELAY\"\t\t, RANDOMIZE_DOWNLOAD_DELAY )\n\t# cf : https://doc.scrapy.org/en/latest/topics/jobs.html#job-directory\n\tsettings.set( \"JOBDIR\"\t\t\t\t\t\t\t, JOBDIR_FOLDER + \"/\" + spider_id )\n\n\t## https://scrapy.readthedocs.io/en/0.12/topics/extensions.html#module-scrapy.contrib.closespider\n\n\tsettings.set( \"CURRENT_SPIDER_ID\" \t\t\t, spider_id )\n\tsettings.set( \"RETRY_TIMES\"\t\t\t\t\t\t\t, spider_config_flat[\"RETRY_TIMES\"] )\n\tsettings.set( \"CLOSESPIDER_ITEMCOUNT\"\t\t, spider_config_flat[\"LIMIT_ITEMS\"] )\n\t# settings.set( \"CLOSESPIDER_PAGECOUNT\"\t\t, spider_config_flat[\"LIMIT_PAGES\"] )\n\tsettings.set( \"DOWNLOAD_DELAY\" \t\t\t\t\t, spider_config_flat[\"download_delay\"] )\n\tsettings.set( \"CONCURRENT_ITEMS\"\t\t\t\t, spider_config_flat[\"CONCURRENT_ITEMS\"] )\n\tsettings.set( \"CONCURRENT_REQUESTS\"\t\t\t, spider_config_flat[\"CONCURRENT_REQUESTS\"] )\n\t# settings.set( \"DOWNLOAD_DELAY\" \t\t\t\t, DOWNLOAD_DELAY )\n\n\tsettings.set( \"BOT_NAME\"\t\t\t\t\t\t\t\t\t, spider_config_flat[\"BOT_NAME\"] )\n\tsettings.set( \"USER_AGENT\"\t\t\t\t\t\t\t\t, spider_config_flat[\"USER_AGENT\"] )\n\tsettings.set( \"ROBOTSTXT_OBEY\"\t\t\t\t\t\t, spider_config_flat[\"ROBOTSTXT_OBEY\"] )\n\tsettings.set( \"AUTOTHROTTLE_ENABLED\"\t\t\t, spider_config_flat[\"AUTOTHROTTLE_ENABLED\"] )\n\tsettings.set( \"HTTPCACHE_ENABLED\"\t\t\t\t\t, spider_config_flat[\"HTTPCACHE_ENABLED\"] )\n\tsettings.set( \"RANDOMIZE_DOWNLOAD_DELAY\"\t, spider_config_flat[\"RANDOMIZE_DOWNLOAD_DELAY\"] )\n\n\t### initiating crawler process\n\tlog_scrap.info(\"--- run_generic_spider / instanciate process ...\" \t )\n\tprocess = CrawlerRunner( settings = settings )\n\n\t### adding CrawlerRunner as deferred\n\tdef f(q):\n\t\ttry:\n\t\t\t### send/create custom spider from run_spider_config\n\t\t\t### cf : https://stackoverflow.com/questions/35662146/dynamic-spider-generation-with-scrapy-subclass-init-error\n\n\t\t\tdeferred = process.crawl( \tGenericSpider,\n\t\t\t\t\t\t\t\t\t\t\tuser_id\t\t\t\t\t\t\t= user_id,\n\t\t\t\t\t\t\t\t\t\t\tdatamodel \t\t\t\t\t= datamodel ,\n\t\t\t\t\t\t\t\t\t\t\tspider_id \t\t\t\t\t= spider_id ,\n\t\t\t\t\t\t\t\t\t\t\tspider_config_flat\t= spider_config_flat,\n\t\t\t\t\t\t\t\t\t\t\ttest_limit\t\t\t\t\t= test_limit\n\t\t\t\t\t\t\t\t\t)\n\t\t\tdeferred.addBoth(lambda _: reactor.stop())\n\t\t\treactor.run()\n\t\t\tq.put(None)\n\t\texcept Exception as e:\n\t\t\tq.put(e)\n\n\t### putting task in queue and start\n\tq = Queue()\n\tp = Process(target=f, args=(q,))\n\tp.start()\n\tresult = q.get()\n\tp.join()\n\n\tif result is not None:\n\t\traise result\n\n\n\n\tprint (\"\\n\\n{}\\n\".format(\"> > > \"*20))","def crawl(self):\n self.get('http://code.google.com/p/webscraping/')\n self.get('http://code.google.com/p/sitescraper/')\n QTimer.singleShot(5000, self.app.quit)","def from_crawler(cls, crawler, *args, **kwargs):\n\n spider = super(telecom_vivo_movel_spider, cls).from_crawler(\n crawler, *args, **kwargs)\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\n return spider","def run(self):\n \n try:\n logging.info('Thread:{} starting'.format(self.thread_id))\n\n self.crawl_url()\n self.parse_html()\n except IOError as e:\n self.thread_post_processing()\n logging.error('CrawlUrlError url:{} msg:{}'.format(self.url, e))\n\n self.thread_post_processing()","def run_crawler(self) -> List[JobEventSchema]:\n print(f\"Ready for scraping, current task: {self.tasks}\")\n\n crawling_result = []\n for task in self.tasks:\n result = task.run()\n crawling_result.extend(result)\n return crawling_result","def open_spider(self, spider):\n pass","def _scrape(self):","def crawl(self):\n if os.path.exists(self.__work_path):\n shutil.rmtree(self.__work_path)\n print '\\nOld Data Was Found And Removed.\\n'\n\n initial_first_run = True\n initial_recursion_depth = 0\n initial_prev_link_size = 0\n for url in self.__urls:\n self.__start_recursion(url, initial_first_run,\n initial_recursion_depth, initial_prev_link_size)\n\n Crawler.mission_report(self.__work_path)","def parse(self, response):\n page_jobs=[]\n\n # Calling abstarct method get_jobs_list() and iterating...\n jobs_div_list=self.get_jobs_list(response)\n for div in jobs_div_list:\n \n # Calling abstarct method get_job_dict()\n job_dict=self.get_job_dict(div)\n\n if not job_dict['url'] or not job_dict['title'] :\n # At least url, title data is loaded from the list of job posting ...\n raise ValueError( \"Could not find valid job information ('url' and 'title') in data:\\n\" + \n str(div.get()) + \"\\nScraped infos:\\n\" + str(job_dict) + \"\\nReport this issue on github!\" )\n \n # Store source as the name of the spider aka website\n job_dict['source']=self.name\n page_jobs.append(job_dict)\n \n \"\"\"\n Load full job page only if:\n - it's a new job (not in database)\n - load_full_jobs=Yes\n - the method parse_full_job_page() has been re-wrote by the Scraper subclass\n \"\"\"\n if ( (not self.db or self.db.find_job(job_dict)==None)\n and self.load_full_jobs ):\n if type(self).parse_full_job_page != Scraper.parse_full_job_page:\n # load_full_jobs=Yes and it's supported by scraper\n # Call parse_full_job_page() with job URL\n\n # Handle SeleniumRequest if use_selenium=True\n if self.use_selenium:\n yield SeleniumRequest(url=job_dict['url'], \n callback=self.parse_full_job_page,\n cb_kwargs=dict(job_dict=job_dict),\n wait_time=self.selenium_wait_time, script=SCROLL_DOWN)\n else:\n yield response.follow(url=job_dict['url'], \n callback=self.parse_full_job_page,\n cb_kwargs=dict(job_dict=job_dict))\n else:\n yield Job(job_dict)\n else:\n yield Job(job_dict)\n\n \"\"\" Just printing in one line \"\"\"\n if self.load_full_jobs:\n if type(self).parse_full_job_page == Scraper.parse_full_job_page:\n if self.load_all_new_pages==False:\n self.log.info(\"Scraped {} jobs from {}. Scraper {} does not support load_full_jobs=True and load_all_new_pages=False, some new job postings and job informations might be missing\".format(len(page_jobs), response.url, self.name))\n else:\n self.log.info(\"Scraped {} jobs from {}. Scraper {} does not support load_full_jobs=True, some informations might be missing\".format(len(page_jobs), response.url, self.name))\n else:\n self.log.info(\"Scraping {} jobs from {}...\".format(len(page_jobs), response.url))\n else:\n if self.load_all_new_pages==False:\n self.log.info(\"Scraped {} jobs from {}. load_all_new_pages=False and load_full_jobs=False, some new job postings and job informations might be missing\".format(len(page_jobs), response.url))\n else:\n self.log.info(\"Scraped {} jobs from {}. load_full_jobs=False, some informations might be missing\".format(len(page_jobs), response.url))\n \n \"\"\"\n If all page jobs are new and \n The method get_next_page_url() has been re-wrote by the Scraper subclass\n Scrape next page\n \"\"\"\n if self.load_all_new_pages==True:\n if self.db and any( [self.db.find_job(job_dict)!=None for job_dict in page_jobs] ):\n # All new job postings loaded\n pass\n else:\n if self.get_next_page_url(response)!=None :\n # Loading next page...\n if self.use_selenium:\n yield SeleniumRequest(\n url=self.get_next_page_url(response),\n callback=self.parse,\n wait_time=self.selenium_wait_time, script=SCROLL_DOWN)\n else:\n yield response.follow(\n url=self.get_next_page_url(response),\n callback=self.parse)\n else:\n if type(self).get_next_page_url != Scraper.get_next_page_url:\n # Last page loaded\n pass\n else:\n self.log.info(\"Scraper {} does not support load_all_new_pages=True, some new job postings might be missing\".format(self.name))","def crawl(self, url):\n return None","def addCrawler(name):\n global allCrawlerNames\n if name == 'scihub':\n allCrawlers.append(ScihubCrawler())\n allCrawlerNames = [ c.name for c in allCrawlers ]","def spider_and_save_thread(\n self, source_url, crawl_timeout, target_url_patten, max_depth, output_directory):\n url_result = self.crawl(\n source_url,\n crawl_timeout,\n target_url_patten,\n max_depth)\n self.save_url(url_result, crawl_timeout, output_directory)","def scrape(self):\n\n self.jobs_load()\n self.new_jobs = []\n\n for bot in self.bot_squad:\n self.new_jobs += bot.scrape_all_pages()\n\n self.statistics(self.new_jobs)\n print('SCRAPE COMPLETE. NOTE: Resulting job list still in RAM')\n print('We observed %d new jobs' % len(self.new_jobs))","def crawl(self, keyword, since=None, to=None):\n no_of_pages = self.get_no_of_pages(keyword, since, to)\n print('pages: ' + str(no_of_pages))\n self.keyword = keyword\n self.since = since\n self.to = to\n p = Pool()\n p.map(self.distribute, range(1, no_of_pages+1))","def __init__(self):\n self.SPIDER = \"spider\"","def parse(self, response):\n\n\t\t### close spider if exception\n\t\tif 'Bandwidth exceeded' in response.body:\n\t\t\traise CloseSpider('bandwidth_exceeded')\n\n\t\tlog_scrap.debug(u\"\\n>>> NEW PARSING >>>\\n\" )\n\t\tlog_scrap.info(\"--- GenericSpider.parse ...\" )\n\n\t\tlog_scrap.info(\"\\n--- GenericSpider.parse /response : \\n%s\" , response)\n\t\tlog_scrap.info(\"\\n--- GenericSpider.parse /response : \\n%s \\n\" , response.__dict__.keys() )\n\n\t\t# for k, v in response.__dict__.iteritems() :\n\t\t# \tlog_scrap.info(\"\\n--- [k] {} : [v] {} : \".format(k,v))\n\t\t# print response._body\n\t\tstart_url = response.meta[\"start_url\"]\n\t\tlog_scrap.info(\"--- GenericSpider.parse / start_url : %s\", start_url )\n\n\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t### start request with API crawler\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t# if self.spider_config_flat[\"parse_api\"] == True :\n\t\tif self.parse_api == True :\n\n\t\t\tlog_scrap.info(\"\\n--- GenericSpider.parse / starting request on API endpoint... \" )\n\t\t\tjsonresponse = json.loads(response.body_as_unicode())\n\t\t\t# log_scrap.info(\"--- GenericSpider.parse / jsonresponse : \\n%s\", jsonresponse )\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / jsonresponse received...\" )\n\n\t\t\traw_items_list = get_dictvalue_from_xpath(jsonresponse, self.item_xpath)\n\t\t\t# raw_items_list = jsonresponse[self.item_xpath]\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / raw_items_list[0] : \\n%s\\n...\", pformat(raw_items_list[0]) )\n\n\t\t\t### - - - - - - - - - - ###\n\t\t\t### PARSING PAGE - API\n\t\t\t### start parsing page : loop through data items in page in response\n\t\t\tif len(raw_items_list) != 0 :\n\n\t\t\t\tlog_scrap.info(\"--- GenericSpider. / START LOOPING raw_items_list WITH API ...\" )\n\n\t\t\t\t# while self.there_is_more_items_to_scrap_dict[start_url] :\n\n\t\t\t\tfor raw_data in raw_items_list :\n\n\t\t\t\t\tself.item_count += 1\n\n\t\t\t\t\t### check if can continue depending on item_count\n\t\t\t\t\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\n\n\t\t\t\t\t\tprint()\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - API - item n°{} >>> \\n\".format(self.item_count) )\n\n\t\t\t\t\t\t### instantiate Item to fill from datamodel --> cf items.py\n\t\t\t\t\t\titemclass \t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\n\t\t\t\t\t\titem \t\t= itemclass()\n\n\t\t\t\t\t\t### add global info to item : i.e. core fields in dm_core_item_related list\n\t\t\t\t\t\titem[ 'spider_id' ]\t= self.spider_id\n\t\t\t\t\t\titem[ 'added_by' ]\t= self.user_id\n\t\t\t\t\t\titem[ 'added_at' ]\t= time.time()\t\t# timestamp\n\t\t\t\t\t\titem[ 'link_src' ]\t= response._url\n\n\t\t\t\t\t\titem[ 'page_n' ]\t\t= self.page_count\n\t\t\t\t\t\titem[ 'item_n' ]\t\t= self.item_count\n\n\t\t\t\t\t\t### extract data and feed it to the Item instance based on spider_config_flat\n\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, is_api_rest=True, item_n=self.item_count)\n\n\n\t\t\t\t\t\t### - - - - - - - - - - ###\n\t\t\t\t\t\t### FOLLOW LINK - API\n\t\t\t\t\t\t### if need to follow to extract all data\n\t\t\t\t\t\tif self.spider_config_flat[\"parse_follow\"] == True :\n\n\t\t\t\t\t\t\tlog_scrap.debug(u\">>> FOLLOW LINK - API - item n°{} / page n°{} >>>>>> \\n\".format(self.item_count, self.page_count) )\n\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_xpath : %s\", self.follow_xpath )\n\n\t\t\t\t\t\t\t# follow_link_raw = raw_data[ self.follow_xpath ]\n\t\t\t\t\t\t\tfollow_link_raw = get_dictvalue_from_xpath(raw_data, self.follow_xpath)\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link RAW ({}) : {} \".format(type(follow_link_raw),follow_link_raw) )\n\n\t\t\t\t\t\t\turl_follow = \"\"\n\t\t\t\t\t\t\tif self.api_follow_root != \"\" :\n\t\t\t\t\t\t\t\t\turl_follow = self.api_follow_root\n\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\turl_follow = self.page_url\n\n\t\t\t\t\t\t\t# complete follow link if needed\n\t\t\t\t\t\t\tfollow_link = self.clean_link(follow_link_raw, url_root=url_follow)\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link CLEAN : %s \", follow_link )\n\n\t\t\t\t\t\t\t# store follow_link\n\t\t\t\t\t\t\titem[ 'link_data' ]\t= follow_link\n\t\t\t\t\t\t\turl \t\t\t\t= item['link_data']\n\n\t\t\t\t\t\t\tfollow_is_api = self.follow_is_api\n\n\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url, 'item_n' : self.item_count , 'parse_api' : follow_is_api })\n\n\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t### if no follow link\n\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\n\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t# log_scrap.info(\" --> item : \\n %s \\n\", pformat(item) )\n\t\t\t\t\t\tlog_scrap.debug(u\" --> item ...\" )\n\n\t\t\t\t\telse :\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\t# log_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\n\n\t\t\t\telse :\n\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t# raise CloseSpider('OUT OF ITEMS')\n\n\t\t\t### - - - - - - - - - - - - ###\n\t\t\t### NEXT PAGE - API\n\t\t\tif self.test_limit == None or self.page_count < self.test_limit :\n\n\t\t\t\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\n\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse (API) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\n\".format(self.page_count) )\n\n\t\t\t\t\t### get and go to next page\n\t\t\t\t\tself.page_count += 1\n\n\t\t\t\t\turl_next = \"\"\n\t\t\t\t\tif self.api_pagination_root != \"\" :\n\t\t\t\t\t\turl_next = self.api_pagination_root\n\t\t\t\t\telse :\n\t\t\t\t\t\turl_next = self.page_url\n\n\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\tnext_page = url_next + str(self.page_count)\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse >>> NEXT PAGE II : %s\", next_page )\n\n\t\t\t\t\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\n\n\t\t\t\telse :\n\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} \".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\t\t\telse :\n\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} \".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t### start requests with pure Scrapy requests\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\telif self.spider_config_flat[\"parse_reactive\"] == False :\n\t\t# elif self.parse_reactive == False :\n \n\t\t\tlog_scrap.info(\"\\n--- GenericSpider.parse / starting requests with Scrapy... \" )\n\t\t\t# self.parse_scrapy(response)\n\n\t\t\t### find items list\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / self.item_xpath : %s\", self.item_xpath )\n\t\t\traw_items_list = response.xpath(self.item_xpath)\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / len(raw_items_list) : %d \", len(raw_items_list) )\n\n\n\t\t\t### - - - - - - - - - - - ###\n\t\t\t### PARSING PAGE - SCRAPY\n\t\t\t### start parsing page : loop through data items in page in response\n\t\t\tif len(raw_items_list) != 0 :\n\n\t\t\t\tlog_scrap.info(\"--- GenericSpider. / START LOOPING raw_items_list WITH SCRAPY ...\" )\n\n\t\t\t\tfor raw_data in raw_items_list :\n\n\t\t\t\t\tself.item_count += 1\n\n\t\t\t\t\t### check if can continue depending on item_count\n\t\t\t\t\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\n\n\t\t\t\t\t\tprint()\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - Scrapy - item n°{} / page n°{} >>> \\n\".format(self.item_count, self.page_count) )\n\n\t\t\t\t\t\t# print \">>> raw_data : \\n\", raw_data.extract()\n\n\t\t\t\t\t\t### instantiate Item to fill from datamodel --> cf items.py\n\t\t\t\t\t\titemclass \t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\n\t\t\t\t\t\titem \t\t= itemclass()\n\n\t\t\t\t\t\t### add global info to item : i.e. core fields in dm_core_item_related list\n\t\t\t\t\t\titem[ 'spider_id' ]\t\t= self.spider_id\n\t\t\t\t\t\titem[ 'added_by' ]\t\t= self.user_id\n\t\t\t\t\t\titem[ 'added_at' ]\t\t= time.time()\t\t# timestamp\n\t\t\t\t\t\titem[ 'link_src' ]\t\t= response._url\n\n\t\t\t\t\t\titem[ 'page_n' ]\t\t= self.page_count\n\t\t\t\t\t\titem[ 'item_n' ]\t\t= self.item_count\n\n\t\t\t\t\t\t### extract data and feed it to the Item instance based on spider_config_flat\n\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, item_n=self.item_count)\n\n\n\t\t\t\t\t\t### - - - - - - - - - - - ###\n\t\t\t\t\t\t### FOLLOW LINK - SCRAPY\n\t\t\t\t\t\t### if need to follow to extract all data\n\t\t\t\t\t\tif self.spider_config_flat[\"parse_follow\"] == True :\n\n\t\t\t\t\t\t\tlog_scrap.debug(u\">>> FOLLOW LINK - SCRAPY - item n°{} / page n°{} >>>>>> \\n\".format(self.item_count, self.page_count) )\n\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_xpath : %s\", self.follow_xpath )\n\n\t\t\t\t\t\t\tfollow_link \t= raw_data.xpath( self.follow_xpath ).extract_first()\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link RAW ({}) : {} \".format(type(follow_link),follow_link) )\n\n\t\t\t\t\t\t\turl_follow = \"\"\n\t\t\t\t\t\t\tif self.api_follow_root != \"\" :\n\t\t\t\t\t\t\t\turl_follow = self.api_follow_root\n\n\t\t\t\t\t\t\t# complete follow link if needed\n\t\t\t\t\t\t\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\n\t\t\t\t\t\t\t# log_scrap.info(\" --> follow_link CLEAN : %s \", follow_link )\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link CLEAN ({}) : {} \".format(type(follow_link),follow_link) )\n\n\t\t\t\t\t\t\t# store follow_link\n\t\t\t\t\t\t\titem[ 'link_data' ]\t= follow_link\n\t\t\t\t\t\t\turl \t\t\t\t= item['link_data']\n\n\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOWING LINK --> url : {} \".format(url) )\n\t\t\t\t\t\t\t\t# yield Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url } )\n\t\t\t\t\t\t\t\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False} )\n\t\t\t\t\t\t\t\t# log_scrap.warning(u\">>> FOLLOWING LINK --> url : {} / WORKED !!! \".format(url) )\n\n\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOW LINK - NOT WORKING : {} \".format(url) )\n\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t### if no follow link\n\t\t\t\t\t\telse :\n\n\t\t\t\t\t\t\tlog_scrap.warning(u\">>> NO FOLLOW LINK ... \" )\n\t\t\t\t\t\t\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\n\t\t\t\t\t\t\t# log_scrap.info(\">>> GenericSpider.parse - item.items() : \\n %s\", item.items() )\n\t\t\t\t\t\t\t# log_scrap.info(\">>> GenericSpider.parse - item.keys() : \\n %s\", item.items() )\n\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t# print (\"\\n>>> NEXT ITEM \" + \">>> >>> \"*10, \"\\n\")\n\n\t\t\t\t\t\t# log_scrap.info(\" --> item : \\n %s \\n\", pformat(item) )\n\t\t\t\t\t\tlog_scrap.debug(u\" --> item ...\" )\n\n\t\t\t\t\telse :\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\n\n\t\t\telse :\n\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t# raise CloseSpider('OUT OF ITEMS')\n\n\t\t\t### - - - - - - - - - - ###\n\t\t\t### NEXT PAGE - SCRAPY\n\t\t\t### check if there is a test_limit\n\t\t\tif self.test_limit == None or self.page_count < self.test_limit :\n\n\t\t\t\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\n\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse (Scrapy) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\n\".format(self.page_count) )\n\n\t\t\t\t\t### get and go to next page\n\t\t\t\t\tis_next_page, next_page = self.get_next_page(response, start_url)\n\n\t\t\t\t\tif is_next_page :\n\n\t\t\t\t\t\tself.page_count += 1\n\n\t\t\t\t\t\turl_next = \"\"\n\t\t\t\t\t\tif self.api_pagination_root != \"\" :\n\t\t\t\t\t\t\turl_next = self.api_pagination_root\n\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse >>> NEXT PAGE I : %s\", next_page )\n\t\t\t\t\t\tnext_page = self.clean_link(next_page, url_root=url_next)\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse >>> NEXT PAGE II : %s\", next_page )\n\n\t\t\t\t\t\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\n\n\t\t\t\t\telse :\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / NO MORE PAGE TO SCRAP - pages count : {} \".format(self.page_count) )\n\t\t\t\t\t\t# raise CloseSpider('NO MORE PAGE TO SCRAP')\n\n\t\t\t\telse :\n\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\t\t\telse :\n\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t### start requests with Selenium\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\telse :\n\t\t\t### initiate selenium browser\n\t\t\t### cf : https://github.com/voliveirajr/seleniumcrawler/blob/master/seleniumcrawler/spiders/seleniumcrawler_spider.py\n\t\t\tlog_scrap.info(\"\\n--- GenericSpider.parse / starting Selenium driver... \" )\n\n\t\t\t# retrieve exec path for chromedriver from settings_scrapy.py\n\t\t\t### GET APP MODE FROM ENV VARS\n\t\t\tapp_mode \t\t\t\t\t\t= os.environ.get('APP_MODE', 'default')\n\t\t\tlog_scrap.debug(u\"--- GenericSpider.parse / APP_MODE : %s\", app_mode)\n\t\t\tchromedriver_path \t= CHROMEDRIVER_PATH_LIST[ app_mode ]\n\t\t\tlog_scrap.debug(u\"--- GenericSpider.parse / chromedriver_path : %s\", chromedriver_path)\n\n\t\t\t### specify executable path to launch webdriver-->\n\t\t\t# cf : where chromedriver was installed when `brew install chromedriver`\n\t\t\tself.driver = webdriver.Chrome(executable_path=chromedriver_path, chrome_options=options_selenium)\n\t\t\t# self.driver = webdriver.Chrome(chrome_options=options_selenium)\n\t\t\t# self.driver = webdriver.Firefox()\n\t\t\t# self.driver = webdriver.Chrome()\n\t\t\t# self.driver = webdriver.PhantomJS() ### deprecated\n\n\t\t\t### setup waiting times\n\t\t\t# self.driver.set_page_load_timeout(60)\n\t\t\tself.wait_driver\t= WebDriverWait(self.driver, self.delay_driver)\n\t\t\tself.wait_page \t\t= WebDriverWait(self.driver, self.delay_new_page)\n\t\t\tself.driver.implicitly_wait(self.delay_implicit)\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / self.delay_driver : %s\", self.delay_driver )\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / self.delay_new_page : %s\", self.delay_new_page )\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / self.delay_implicit : %s\", self.delay_implicit )\n\n\n\t\t\t### start parsing with selenium\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / response._url : %s\", response._url )\n\t\t\ttry :\n\t\t\t\tself.driver.get(response._url)\n\n\t\t\t\t### try scroll_down if needed in config\n\t\t\t\tif self.spider_config_flat['scroll_down'] : \n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / scroll_down is TRUE ... \" )\n\t\t\t\t\t# log_scrap.debug(u\"--- GenericsSpider. / scroll_down - self.spider_config_flat : \\n%s\", pformat(self.spider_config_flat) )\n\n\t\t\t\t\tscroll_pause_time = self.spider_config_flat[\"scroll_pause_time\"]\n\t\t\t\t\tmax_loops \t\t\t\t= self.spider_config_flat[\"scroll_loops\"]\n\t\t\t\t\tself.driver = scroll_down(self.driver, scroll_pause_time, max_loops)\n\t\t\t\t\t# scroll_down(self.driver, scroll_pause_time, max_loops)\n\t\t\t\tlog_scrap.info(\"--- GenericSpider. / url '{}' is loaded ... \".format( response._url ))\n\t\t\t\n\t\t\texcept :\n\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tself.driver.close()\n\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\traise CloseSpider('DRIVER NOT RESPONDING')\n\n\n\t\t\t### clean original xpath from strings\n\t\t\tstrings_to_clean = [\n\t\t\t\t'/@src',\n\t\t\t\t'/@href',\n\t\t\t\t'/text()',\n\t\t\t\t'/@*[name()=\"xlink:href\"]',\n\t\t\t\t'/@datetime'\n\t\t\t]\n\n\t\t\t# while self.there_is_more_items_to_scrap :\n\t\t\twhile self.there_is_more_items_to_scrap_dict[start_url] :\n\n\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / while loop continues : %s\", self.there_is_more_items_to_scrap )\n\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / while loop continues : %s\", self.there_is_more_items_to_scrap_dict[start_url] )\n\n\t\t\t\ttry :\n\n\t\t\t\t\t### wait / debug page content\n\t\t\t\t\tpage_source_code = self.driver.page_source.encode(\"utf-8\")\n\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / page_source_code : \\n %s \", page_source_code )\n\t\t\t\t\ttime.sleep(self.delay_new_page)\n\n\t\t\t\t\t### start parsing page :\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.item_xpath : %s\", self.item_xpath )\n\t\t\t\t\traw_items_list \t= self.driver.find_elements_by_xpath(self.item_xpath)\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / raw_items_list length : %s\", len(raw_items_list) )\n\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / raw_items_list[0].text : \\n%s\", raw_items_list[0].text )\n\n\t\t\t\t\t# current_item_index = 0\n\n\t\t\t\t\t### - - - - - - - - - - - - ###\n\t\t\t\t\t### PARSING PAGE - SELENIUM\n\t\t\t\t\t# loop through data items in page in response\n\t\t\t\t\tif len(raw_items_list) != 0 :\n\n\t\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / START PARSING WITH SELENIUM ...\\n\" )\n\n\t\t\t\t\t\tfor raw_data in raw_items_list :\n\n\t\t\t\t\t\t\tprint()\n\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / START LOOPING raw_items_list WITH SELENIUM ...\" )\n\n\t\t\t\t\t\t\t### add +1 to items count\n\t\t\t\t\t\t\tself.item_count += 1\n\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} - there_is_more_items_to_scrap_dict[start_url] : {} \".format(str(self.spider_name), self.item_count, self.there_is_more_items_to_scrap_dict[start_url]) )\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} \".format(self.spider_name, self.item_count) )\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - item n°{} \".format(self.item_count) )\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - spider_name : '%s' - item n°%s \" %(self.spider_name, self.item_count) )\n\n\t\t\t\t\t\t\t### check if can continue depending on item_count\n\t\t\t\t\t\t\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\n\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - Selenium - item n°{} / page n°{} >>> \\n\".format(self.item_count, self.page_count) )\n\n\t\t\t\t\t\t\t\t### instantiate Item to fill from datamodel --> cf items.py\n\t\t\t\t\t\t\t\titemclass \t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\n\t\t\t\t\t\t\t\titem \t\t= itemclass()\n\n\t\t\t\t\t\t\t\t### add global info to item : i.e. core fields in dm_core_item_related list\n\t\t\t\t\t\t\t\titem[ 'spider_id' ]\t\t= self.spider_id\n\t\t\t\t\t\t\t\titem[ 'added_by' ]\t\t= self.user_id\n\t\t\t\t\t\t\t\titem[ 'added_at' ]\t\t= time.time()\t\t# timestamp\n\t\t\t\t\t\t\t\titem[ 'link_src' ]\t\t= response._url\n\n\t\t\t\t\t\t\t\titem[ 'page_n' ]\t\t= self.page_count\n\t\t\t\t\t\t\t\titem[ 'item_n' ]\t\t= self.item_count\n\n\t\t\t\t\t\t\t\t### extract data and feed it to the Item instance based on spider_config_flat\n\t\t\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\n\n\t\t\t\t\t\t\t\t### - - - - - - - - - - ###\n\t\t\t\t\t\t\t\t### FOLLOW LINK - SELENIUM\n\t\t\t\t\t\t\t\t### find follow link to open detailled item view\n\t\t\t\t\t\t\t\tif self.spider_config_flat[\"parse_follow\"] == True :\n\n\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> FOLLOW LINK - SELENIUM - item n°{} / page n°{} >>>>>> \\n\".format(self.item_count, self.page_count) )\n\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_xpath : %s\", self.follow_xpath )\n\n\t\t\t\t\t\t\t\t\t### follow link with Scrapy\n\t\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / follow link with Scrapy ...\" )\n\n\t\t\t\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / get href of follow_link ...\" )\n\t\t\t\t\t\t\t\t\t\tfollow_link_xpath \t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link_xpath : %s \", follow_link_xpath )\n\n\t\t\t\t\t\t\t\t\t\tfollow_link\t\t\t= raw_data.find_element_by_xpath( follow_link_xpath ).get_attribute('href')\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link RAW : %s \", follow_link )\n\n\t\t\t\t\t\t\t\t\t\turl_follow = \"\"\n\t\t\t\t\t\t\t\t\t\tif self.api_follow_root != \"\" :\n\t\t\t\t\t\t\t\t\t\t\t\turl_follow = self.api_follow_root\n\n\t\t\t\t\t\t\t\t\t\t# complete follow link if needed\n\t\t\t\t\t\t\t\t\t\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link CLEAN ({}) : {}\".format(type(follow_link), follow_link ) )\n\n\t\t\t\t\t\t\t\t\t\t# store follow_link\n\t\t\t\t\t\t\t\t\t\titem[ 'link_data' ]\t= follow_link\n\t\t\t\t\t\t\t\t\t\turl\t\t\t= item['link_data']\n\n\t\t\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOWING LINK --> url : {} \".format(url) )\n\t\t\t\t\t\t\t\t\t\t\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False})\n\n\t\t\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOW LINK - NOT WORKING : {} \".format(url) )\n\t\t\t\t\t\t\t\t\t\t\tyield item\n\n\n\t\t\t\t\t\t\t\t\t### follow link with Selenium\n\t\t\t\t\t\t\t\t\t### FIND A WEBSITE TEST FOR REACTIVE DETAILLED PAGES\n\t\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / follow link with Selenium ...\" )\n\n\t\t\t\t\t\t\t\t\t\tfollow_link_xpath \t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_link_xpath : %s\", self.follow_link_xpath )\n\t\t\t\t\t\t\t\t\t\tfollow_link \t\t= raw_data.find_element_by_xpath( follow_link_xpath )\n\n\t\t\t\t\t\t\t\t\t\t### open link in new tab ?\n\t\t\t\t\t\t\t\t\t\tfollow_link.click()\n\n\t\t\t\t\t\t\t\t\t\t### get data and save data\n\t\t\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / get data and save data ...\" )\n\t\t\t\t\t\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\n\n\t\t\t\t\t\t\t\t\t\t\t### back to previous page and scrap from where it left\n\t\t\t\t\t\t\t\t\t\t\t### cf : https://selenium-python.readthedocs.io/navigating.html#navigation-history-and-location\n\t\t\t\t\t\t\t\t\t\t\tself.driver.back()\n\n\t\t\t\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t\t### if no follow link\n\t\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t\t# log_scrap.info(\" --> item : \\n %s \\n\", pformat(item) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\" --> item ...\" )\n\n\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\t\t\t\traise CloseSpider('OUT OF LIMIT_ITEMS')\n\t\t\t\t\t\t\t\tbreak\n\n\t\t\t\t\telse :\n\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF ITEMS - page n°{} - limit : {} - test_limit : {} / except -> break\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\t\t\t\t\t\tbreak\n\n\t\t\t\t\t### - - - - - - - - - - - - ###\n\t\t\t\t\t### NEXT PAGE - SELENIUM\n\t\t\t\t\tif self.test_limit == None or self.page_count < self.test_limit :\n\n\t\t\t\t\t\tif self.there_is_more_items_to_scrap_dict[start_url] :\n\n\t\t\t\t\t\t\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\n\n\t\t\t\t\t\t\t\tprint ()\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\t\t\t\tlog_scrap.info(\" --- GenericSpider.parse (Selenium) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\n\".format(self.page_count) )\n\n\t\t\t\t\t\t\t\t### add +1 to parsed pages\n\t\t\t\t\t\t\t\tself.page_count += 1\n\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - current start_url : {} >>>\".format(start_url) )\n\n\t\t\t\t\t\t\t\t### find next page btn in current view\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.next_page : %s\", self.next_page )\n\t\t\t\t\t\t\t\tnext_page_xpath = clean_xpath_for_reactive(self.next_page, strings_to_clean)\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page_xpath : %s\", next_page_xpath )\n\t\t\t\t\t\t\t\t# next_page \t= re.sub(\"|\".join(strings_to_clean), \"\", next_page )\n\n\t\t\t\t\t\t\t\t# try :\n\t\t\t\t\t\t\t\t# element_present = EC.presence_of_element_located((By.XPATH, next_page_xpath ))\n\t\t\t\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / next_page present : %s\", element_present )\n\t\t\t\t\t\t\t\t# self.wait.until(element_present)\n\t\t\t\t\t\t\t\t# next_page = self.wait.until( EC.element_to_be_clickable(element_present) )\n\t\t\t\t\t\t\t\t# next_page \t\t= self.driver.find_element_by_xpath( next_page_xpath )\n\t\t\t\t\t\t\t\tnext_page \t\t= self.driver.find_element(By.XPATH, next_page_xpath )\n\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page : %s\", next_page )\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page.text : %s\", next_page.text )\n\n\t\t\t\t\t\t\t\t# except TimeoutException:\n\t\t\t\t\t\t\t\t# except :\n\t\t\t\t\t\t\t\t# \tlog_scrap.error(\"--- GenericSpider. / Timed out waiting for page to load\")\n\n\t\t\t\t\t\t\t\t### click next button and wait for ajax calls to complete (post and get)\n\t\t\t\t\t\t\t\t### cf : http://www.obeythetestinggoat.com/how-to-get-selenium-to-wait-for-page-load-after-a-click.html\n\n\t\t\t\t\t\t\t\t# def wait_for(condition_function):\n\t\t\t\t\t\t\t\t# \t\tstart_time = time.time()\n\t\t\t\t\t\t\t\t# \twhile time.time() < start_time + 3:\n\t\t\t\t\t\t\t\t# \t\tif condition_function():\n\t\t\t\t\t\t\t\t# \t\t\treturn True\n\t\t\t\t\t\t\t\t# \t\telse:\n\t\t\t\t\t\t\t\t# \t\t\ttime.sleep(0.1)\n\t\t\t\t\t\t\t\t# \traise Exception ('Timeout waiting for {}'.format(condition_function.__name__) )\n\n\t\t\t\t\t\t\t\t# def link_has_gone_stale():\n\t\t\t\t\t\t\t\t# \t\ttry:\n\t\t\t\t\t\t\t\t# \t\t# poll the link with an arbitrary call\n\t\t\t\t\t\t\t\t# \t\tnext_page.find_elements_by_xpath(self.item_xpath)\n\t\t\t\t\t\t\t\t# \t\treturn False\n\t\t\t\t\t\t\t\t# \texcept StaleElementReferenceException :\n\t\t\t\t\t\t\t\t# \t\treturn True\n\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- ... ---\")\n\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page.click() \" )\n\t\t\t\t\t\t\t\t\tnext_page.click()\n\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / next_page.send_keys( \\ n )\" )\n\t\t\t\t\t\t\t\t\t# next_page.send_keys(\"\\n\")\n\t\t\t\t\t\t\t\t\t# added this step for compatibility of scrolling to the view\n\t\t\t\t\t\t\t\t\tlog_scrap.error(\"--- GenericSpider. / ALTERNATIVE next_page.click() \" )\n\t\t\t\t\t\t\t\t\t# self.driver.execute_script(\"return arguments[0].scrollIntoView();\", next_page)\n\t\t\t\t\t\t\t\t\t# next_page.click()\n\t\t\t\t\t\t\t\t\tself.driver.execute_script(\"arguments[0].click();\", next_page)\n\n\t\t\t\t\t\t\t\t### wait after click\n\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / wait for ajax to finish... \" )\n\t\t\t\t\t\t\t\t\t# wait_for(link_has_gone_stale)\n\t\t\t\t\t\t\t\t\tself.wait_page.until(lambda driver: self.driver.execute_script('return jQuery.active') == 0)\n\t\t\t\t\t\t\t\t\tself.wait_page.until(lambda driver: self.driver.execute_script('return document.readyState') == 'complete')\n\t\t\t\t\t\t\t\t\t# time.sleep(self.delay_implicit)\n\t\t\t\t\t\t\t\t\ttime.sleep(self.delay_new_page)\n\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\tlog_scrap.error(\"--- GenericSpider. / !!! FAIL / wait for ajax to finish... \" )\n\n\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF PAGES TO SCRAP - page n°{} / except -> break\".format(self.page_count) )\n\t\t\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\t\t\traise CloseSpider('OUT OF PAGES TO SCRAP')\n\t\t\t\t\t\t\t\tbreak\n\n\t\t\t\t\telse :\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\t\t\t\t\t\tbreak\n\n\t\t\t\texcept :\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / NO MORE ITEMS TO SCRAP - item_count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\tself.driver.close()\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\traise CloseSpider('NO MORE ITEMS TO SCRAP')\n\t\t\t\t\tbreak","def parse_item(self, response):\n NewhouseSpider.crawled_urls.append(response.url)\n item = FocusedScrapyCrawlerItem()\n item['url'] = response.url\n item['link_text'] = response.meta.get('link_text', '') if response.meta else ''\n soup = BeautifulSoup(response.body, 'html.parser')\n\n item['body_p_tags'] = self._getBodyText(soup)\n item['head_title'] = self._getHeadTitle(soup)\n item['last_crawled'] = time.time()\n links = self._getLinks(response, soup)\n\n # get score of the page based upon classifier\n if self.classifier:\n score = self.classifier.score(item['link_text'], item['head_title'], item['body_p_tags'])\n else:\n score = 0.0\n\n item['score'] = score\n yield item\n if score <= 0:\n self.log(\"item={} does not belong to new home so stop crawling\".format(item),\n logging.INFO)\n else:\n for link in links:\n req = Request(link, priority=int(score * 1000000), # after the request is done, run parse_item to train the apprentice\n callback=self.parse_item)\n yield req","def generate_crawler(self):\n \n targets = ['https://community.upwork.com/t5/Announcements/bd-p/news', \\\n 'https://community.upwork.com/t5/Freelancers/bd-p/freelancers', \\\n 'https://community.upwork.com/t5/Clients/bd-p/clients', \\\n 'https://community.upwork.com/t5/Agencies/bd-p/Agencies']\n target = None\n for tar in targets:\n if tar in sys.argv:\n target = tar\n\n #Regenerate crawler object depending on params\n if target is None:\n if '-d' in sys.argv:\n crawler = Crawler(self.webdriver, self.db, debug=True)\n else:\n crawler = Crawler(self.webdriver, self.db)\n else:\n if '-d' in sys.argv:\n crawler = Crawler(self.webdriver, self.db, debug=True, link=target)\n else:\n crawler = Crawler(self.webdriver, self.db, link=target)\n\n return crawler","def scrap_keywords():\n ParScr = ParallelScraper()\n ParScr.create_and_run_threads()\n return","def scrap_site(link):\n pass # Scrapy or BeautifulSoup","def parse(self, response):\n content = response.body\n if not content:\n return\n sel = Selector(response)\n #print sel.xpath('//table[@class=\"board-list tiz\"]/tr').extract()\n for job in sel.xpath('//ul[@class=\"sojob-list\"]/li'):\n #print 'd',job\n info = job.xpath('div[@class=\"sojob-item-main clearfix\"]/div[@class=\"job-info\"]')\n com_info = job.xpath('div[@class=\"sojob-item-main clearfix\"]/div[@class=\"company-info nohover\"]')\n title = info.xpath('h3/a/text()').extract_first().lower()\n if title.find('python') != -1:\n url = info.xpath('h3/a/@href').extract_first()\n request = scrapy.Request(url=url,\n callback=self.parse_items,\n headers=self.spider.headers,\n cookies=self.cookies)\n company_item, job_item = CompanyItem(), JobItem()\n company_item['name'] = com_info.xpath('p[@class=\"company-name\"]/a/text()').extract_first()\n company_item['homepage'] = com_info.xpath('p[@class=\"company-name\"]/a/@href').extract_first()\n job_item['pub_time'] = info.xpath('p[@class=\"time-info clearfix\"]/time/text()').extract_first()\n year = str(date.today().year)\n if str(year) not in job_item['pub_time']:\n if job_item['pub_time'] == u'昨天':\n job_item['pub_time'] = (date.today()-timedelta(days=1)).strftime(\"%Y-%m-%d\")\n elif job_item['pub_time'] == u'前天':\n job_item['pub_time'] = (date.today() - timedelta(days=2)).strftime(\"%Y-%m-%d\")\n else:\n job_item['pub_time'] = date.today().strftime(\"%Y-%m-%d\")\n job_item['title'] = title\n job_item['welfare'] = ' '.join(com_info.xpath('p[@class=\"temptation clearfix\"]/span/text()').extract())\n job_item['salary'] = info.xpath('p[@class=\"condition clearfix\"]/span[@class=\"text-warning\"]/text()').extract_first()\n request.meta['company_item'] = company_item\n request.meta['job_item'] = job_item\n yield request","def scrape(location='', *args, **kwargs):\n if not location:\n location = Courses.location\n\n logger = setup_logging()\n\n logger.info('Starting Courses scrape')\n queue = Queue()\n\n for _ in Courses.LETTERS:\n course_worker = CourseWorker(queue, location)\n course_worker.daemon = True\n course_worker.start()\n\n for letter in Courses.LETTERS:\n queue.put(letter)\n\n queue.join()\n logger.info('Completed Courses scrape')","def scrape(self):\n pass","def crawlSite(siteUrl, siteName):\n\n\t#add the site to crawl & resources list. Also get the site name\n\tvariables.crawlFrontier = [siteUrl]\n\tvariables.resources = [siteUrl]\n\n\t#scan the site's home page\n\tscanPage(siteUrl, siteName)\n\n\t#repeatedly scan all the pages in crawlFrontier\n\tposLink = 1\t\t#at 0th index is the site's home page\n\n\twhile posLink < len(variables.crawlFrontier):\n\t\tprint('url=',variables.crawlFrontier[posLink])\n\n\t\turl = variables.crawlFrontier[posLink]\n\t\tscanPage(url, siteName)\n\n\t\tposLink += 1","def run(self):\n print(\"INFO: start crawling comic, \" + self.comicSource.getComicName())\n\n if not self.onlyGetCurVol:\n pageNotFoundCounter = 0\n while self.comicSource.isCrawlAtEnd() == False:\n print(\"INFO: crawling volume \" + str(self.volumeNum) + \"...\")\n\n if self.comicSource.crawler(self.volumeNum, self.downloadDir) == False:\n pageNotFoundCounter += 1\n else:\n pageNotFoundCounter = 0\n\n if pageNotFoundCounter >= 400:\n print(\"ERROR: comic \" + self.comicSource.getComicName() + \" not found, exit\")\n break\n\n self.volumeNum += 1\n else:\n print(\"INFO: crawling volume \" + str(self.volumeNum) + \"...\")\n self.comicSource.crawl(self.volumeNum)\n\n print(\"INFO: retrieve comic\" + self.comicSource.getComicName() + \" end!\")\n self.comicSource.quit()","def __init__(self, urls_file_, file_spider_='no', target_format_='', ignored_links_file_='',\n allow_clean_url_='no', time_out_=60, work_path_='./',\n max_recursion_depth_=0, one_bite_='no', white_list_path_=\"\"):\n self.__urls = Crawler.__read_file(urls_file_)\n self.__file_spider = file_spider_\n self.__target_format = target_format_\n self.__allow_clean_url = allow_clean_url_\n self.__one_bite = one_bite_\n self.__white_list_path = white_list_path_\n self.__white_list = []\n\n # loads white list in beginning in case an argument was passed for it\n if self.__file_spider == 'yes' and self.__white_list_path != '':\n self.__white_list = Crawler.__read_white_list(self.__white_list_path)\n\n # link titles that should be ignored during recursions\n self.__ignored_links = Crawler.__read_file(ignored_links_file_)\n\n self.__time_out = time_out_\n self.__work_path = os.path.join(work_path_.rstrip('/')+'/', 'DATA')\n self.__recursion_max_depth = max_recursion_depth_\n self.__extensions = ['txt', 'html', 'csv', 'tsv', 'tar', 'raw']\n\n logging.info('''Crawler Has been Initialized With The Below Configurations:\n-------------------------------------------------------------------\n-urls: %s\n-file_spider: %s\n-target_format: %s\n-ignored_links_file: %s\n-allow_clean_url: %s\n-time_out: %s\n-work_path: %s\n-max_recursion_depth: %s\n-one_bite: %s\n-white_list_path: %s\n''', self.__urls, self.__file_spider, self.__target_format, self.__ignored_links,\n self.__allow_clean_url, self.__time_out, self.__work_path,\n self.__recursion_max_depth, self.__one_bite, self.__white_list_path)","def setup_crawler(self, crawlers: List[BaseCrawler]) -> None:\n self.tasks.extend(crawlers)","def threaded_crawler(seed_url, delay=5, cache=None, scrape_callback=None, proxies=None, num_retries=1, max_threads=10):\n crawl_queue = MongoQueue(timeout=30)\n crawl_queue.clear()\n crawl_queue.push(seed_url)\n D = Downloader(\n cache=cache,\n delay=delay,\n proxies=proxies,\n num_retries=num_retries\n )\n\n def process_queue():\n while True:\n try:\n url = crawl_queue.pop()\n # print(url)\n except KeyError:\n # crawl queue is empty\n break\n else:\n html = D(url)\n if scrape_callback:\n try:\n links = scrape_callback(url, html) or []\n crawl_queue.complete(url)\n except Exception as e:\n print('Error in callback for: {}: {}'.format(url, e))\n\n # wait for all download threads to finish\n threads = []\n while threads or crawl_queue:\n # the crawl is still active\n for thread in threads:\n if not thread.is_alive():\n # remove the stopped threads\n threads.remove(thread)\n while len(threads) < max_threads and crawl_queue:\n # can start some more threads\n thread = threading.Thread(target=process_queue)\n thread.setDaemon(True) # set daemon so main thread can exit when receives ctrl-c\n thread.start()\n threads.append(thread)\n # all threads have been processed\n # sleep temporarily so CPU can focus execution on other threads\n time.sleep(SLEEP_TIME)","def crawl_page(self, keyword, since=None, to=None, page=None):\n data = self.get_news(keyword, since, to, page)\n print(current_process())\n print('crawling page no.: ' + str(page))\n urls = self.get_urls(data)\n p = Process()\n p.start(urls)","def genspider(ctx, name, agency_name, start_urls):\n start_urls = start_urls.split(',')\n domains = _get_domains(start_urls)\n _gen_spider(name, agency_name, domains, start_urls)\n _gen_tests(name)\n _gen_html(name, start_urls)","def parse(self, response):\n page_source = self.upwork_controller.get_source_home()\n\n # Hand-off between Selenium and Scrapy happens here\n sel = Selector(text=page_source)\n # Extract data\n sections = sel.xpath(\"//section/div\")\n\n for section in sections:\n selector = Selector(text=section.get())\n jobtitle = selector.xpath(\"//div/div/div/h4/a/text()\")\n jobdescription = selector.xpath(\"//div/div/div/div/div/div/div/span/span/text()\")\n hourlypay = selector.xpath(\"//div/div/div/div/small/span/strong/text()\")\n proposals = selector.xpath(\"//div/div/div/div/div/span/small/strong/text()\")\n country = selector.xpath(\"//div/div/div/div/small/span/span/span/span/strong[@class='text-muted client-location ng-binding']/text()\")\n\n job = Job(jobtitle=jobtitle.get(),\n jobdescription=jobdescription.get(),\n hourlypay=hourlypay.get(),\n proposals=proposals.get(),\n country=country.get())\n job.serialize()\n yield job.dict()","def parse_inner_urls(self, response):\n s = Selector(response)\n\n jobs_per_site = s.xpath('//div[@class=\"col-lg-12 col-md-12 col-sm-12 aggelia-view-title\"]//a/@href').extract()\n print(jobs_per_site)\n\n for inner_site in jobs_per_site:\n url = urljoin(\"https://www.skywalker.gr/\", inner_site)\n yield scrapy.Request(url, callback=self.parse_items)","def scrape(site=''):\n scraper.scrape(get_site_config(site))","def continue_crawl(d, runner, begin_time, hour_limit):\n end_time = datetime.now()\n\n # Convert elapsed time to seconds\n elapsed_time = end_time - begin_time\n elapsed_time_seconds = elapsed_time.days * 86400\n elapsed_time_seconds += elapsed_time.seconds\n\n if elapsed_time_seconds < hour_limit:\n wait_time = hour_limit - elapsed_time_seconds\n # print(\"Waiting for {0} seconds\".format(wait_time))\n time.sleep(wait_time)\n\n d = runner.crawl(\"sb_spider\")\n\n # end_time is the new \"start\" time for this iteration of the spider.\n # Pass it in as the 3rd argument.\n d.addBoth(lambda _: continue_crawl(d, runner, end_time, hour_limit))","def crawler():\n job_entries = []\n for job in job_info(URL):\n labels = \"\"\n if job[\"labels\"]:\n for label in job[\"labels\"]:\n labels += label[\"name\"]\n if job[\"labels\"].index(label) != len(job[\"labels\"]) - 1:\n labels += \",\"\n job_entries.append((job[\"number\"], job[\"id\"],\n job[\"title\"], job[\"html_url\"], labels))\n\n conn = sqlite3.connect('jobber/jobber.db')\n c = conn.cursor()\n c.executemany(('INSERT OR IGNORE INTO job_entries '\n 'VALUES (?,?,?,?,?)'), job_entries)\n conn.commit()\n conn.close()","def __init__(self, *args, **kwargs):\n super(AlibabaCompanySpider, self).__init__(*args, **kwargs)","def run(self):\n\n # The url is too deep, skip the url.. Work is done!\n if self.depth_ > self.depth:\n return\n\n # Get doc id corresponds to the url. Add a new entry into doc index if there is no entry.\n doc_id = self.crawler.document_id(self.curr_url)\n\n # Check if the doc_id has been visited/processed by any of crawler_threads. Add doc_id to seen if not so.\n if self.crawler.checkDocVisitedAndUpdate(doc_id):\n return\n\n # Process the document corresponds to the url\n socket = None\n try:\n socket = urllib2.urlopen(self.curr_url, timeout=self.timeout)\n soup = BeautifulSoup(socket.read())\n self._curr_depth = self.depth_ + 1\n self._curr_doc_id = doc_id\n # Traverse the document as deep as possible and add those newly discovered urls into url queue\n self._index_document(soup)\n # Store (wordId, docId) and (word, url) into inverted_index and resolved_inverted_index respectively.\n self.crawler._add_words_to_document(self._curr_words, self._curr_doc_id)\n except:\n pass\n finally:\n if socket:\n socket.close()","def single_crawl(self, urlitem: str):\n # print(\"Item: \", urlitem)\n try:\n hdr = {\n \"User-Agent\": \"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36 \",\n \"Accept\": \"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\",\n \"Accept-Charset\": \"ISO-8859-1,utf-8;q=0.7,*;q=0.3\",\n \"Accept-Encoding\": \"none\",\n \"Accept-Language\": \"en-US,en;q=0.8\",\n \"Connection\": \"keep-alive\",\n }\n try:\n req = Request(urlitem, headers=hdr)\n html_page = urlopen(req)\n soup = BeautifulSoup(html_page, \"lxml\")\n links = [\n requests.compat.urljoin(urlitem, link.get(\"href\"))\n for link in soup.findAll(\"a\")\n ]\n links = [x for x in links if \"#\" not in x]\n except Exception as e:\n # print(e)\n pass\n return links\n\n except:\n pass","def crawl(self, query, start_date, end_date, *args, **kwargs):\n pass","def __init__(self, board='Gossiping', pages=1, file='tmp.json', title_lim=[], jsonf=None, copy_data=[], simple_mode=True):\n if copy_data:\n self.extend(copy_data)\n return\n os.chdir(os.path.split(os.path.realpath(__file__))[0])\n print(os.getcwd())\n com = 'scrapy crawl ptt ' if not simple_mode else 'scrapy crawl ptt_url '\n # output json file name\n com += '-o %s ' % (file)\n # page\n com += '-a pages=%d ' % (pages)\n # board\n com += '-a board=%s ' % (board)\n\n # title limit\n if title_lim:\n com += '-a title_lim=\"'\n for lim in title_lim:\n com += \"%s,\" % (str(lim))\n com += '\" '\n # not opened by json_file\n if not jsonf:\n # start crawl\n print('Command: ' + com)\n os.system('rm -f {}'.format(file))\n os.system('{}'.format(com))\n # opened by json file\n else:\n file = jsonf\n\n # all data save in self\n self.load_json(file)\n self.com = com\n self.file = file","def scrape_pipeline(args):\n kickoff = args.kickoff\n fname = args.fname\n d = DbHelper()\n s = Scraper()\n c = Crawler(20)\n if fname is not None:\n app_names = pd.read_csv(fname)['packageName'].tolist()\n apps = [list(a) for a in zip(app_names, d.app_names_to_uuids(app_names))]\n else:\n apps = None\n\n # start by updating top apps\n if not args.skip_top:\n logger.info(\"getting top apps...\")\n new_top_list = c.get_top_apps_list()\n logger.info(\"scraping top apps not in DB...\")\n s.scrape_missing(new_top_list, compare_top=True)\n logger.info(\"updating top apps...\")\n d.update_top_apps(new_top_list)\n\n if kickoff == True:\n s = None\n if fname is None:\n # use crawler to get list of package names\n logger.error(\"Crawler for package names not implemented yet\")\n return\n else:\n # use specified file of package names\n s = Scraper(input_file=fname)\n\n # use scraper\n logger.info(\"Starting efficient scrape...\")\n s.efficient_scrape()\n logger.info(\"...efficient scrape done\")\n else:\n # use updater\n logger.info(\"Starting updater...\")\n if fname is None:\n u = Updater()\n else:\n u = Updater(input_file=fname)\n u.update_apps()\n logger.info(\"...update done\")\n\n # crawl privacy policies\n c.crawl_app_privacy_policies(app_list=apps)\n\n if args.no_decompile:\n # download only\n logger.info(\"Starting download...\")\n downloader = Downloader()\n if apps is None:\n downloader.download_all_from_db(top=True)\n else:\n downloader.download(apps)\n logger.info(\"...done\")\n else:\n # download/decompile\n logger.info(\"Starting download and decompile...\")\n download_decompile_all()\n logger.info(\"...download and decompile done\")\n logger.info(\"run analysis pipeline now\")","def parse(self, response):\n content_type = self.get_content_type(response.headers)\n\n sitescan = response.meta.get('sitescan')\n\n if 'text/html' not in self.get_content_type(response.headers):\n\n # For linked content, find the urlscan it linked from\n urlscan = model.URLScan.objects.get(\n site_scan=sitescan,\n page_url_hash=sha256(response.meta['referrer']).hexdigest())\n else:\n # Only create urlscans for text/html\n urlscan, us_created = model.URLScan.objects.get_or_create(\n\n site_scan=sitescan,\n page_url_hash=sha256(response.url).hexdigest(),\n defaults={'page_url': response.url,\n 'timestamp': self.get_now_time()})\n\n # Continue crawling\n # Parse stylesheet links, scripts, and hyperlinks\n hxs = HtmlXPathSelector(response)\n\n # Extract other target links\n try:\n css_links = hxs.select('//link/@href').extract()\n except TypeError:\n css_links = []\n\n try:\n js_links = hxs.select('//script/@src').extract()\n except TypeError:\n js_links = []\n\n try:\n hyperlinks = hxs.select('//a/@href').extract()\n except TypeError:\n hyperlinks = []\n\n # Using a set removes duplicate links.\n all_links = set(hyperlinks + js_links + css_links)\n\n # Examine links, yield requests if they are valid\n for url in all_links:\n\n if not url.startswith('http://'):\n # ensure that links are to real sites\n if url.startswith('javascript:'):\n continue\n else:\n url = urljoin(response.url, url)\n\n ua = response.meta['user_agent']\n\n request = Request(url)\n request.headers.setdefault('User-Agent', ua.ua_string)\n request.meta['referrer'] = response.url\n request.meta['sitescan'] = sitescan\n request.meta['user_agent'] = ua\n request.meta['content_type'] = None\n\n yield request\n\n # The response contains a user agent, we should yield an item\n item = MarkupItem()\n item['content_type'] = self.get_content_type(response.headers)\n item['filename'] = os.path.basename(urlparse(response.url).path)\n item['headers'] = unicode(response.headers)\n item['meta'] = response.meta\n item['raw_content'] = response.body\n item['sitescan'] = sitescan\n item['urlscan'] = urlscan\n item['url'] = response.url\n item['user_agent'] = response.meta.get('user_agent')\n item['redirected_from'] = response.meta.get('redirected_from',\n u'')\n yield item","def kickoff(self):\n settings = Settings()\n\n # settings.set(\"USER_AGENT\", \"Test\")\n settings.set('JOBDIR', self.args.data_dir)\n self.spider = MavenDataSpider()\n\n # Wrap with crawler, configure\n crawler = Crawler(self.spider, settings)\n crawler.signals.connect(spider_closing, signal=signals.spider_closed)\n\n logger.info('Starting crawler')\n crawler.crawl(self.spider, app=self, dbsess=self.session)\n\n self.spider = crawler.spider\n self.spider.link_queue_mode = False\n if self.args.debug:\n coloredlogs.install(level=logging.DEBUG)\n\n # Keeping thread working\n reactor.run()","def start_requests(self):\n url = self.start_urls[0]\n yield scrapy.Request(url=url, callback=self.parse)","def run(self):\n print \"CAlled run in querythread\"\n #global config.mqchannel\n self.qstatus = \"Running\"\n start = time.clock()\n \n self.crawl_async_result = crawl.apply_async(args=[self.start_url, self.max_depth, self.parser], serializer=\"json\")\n while not self.crawl_async_result.ready():\n time.sleep(0)\n \n # self.crawl_async_result is a list of { URLs, links, htmls } to be parsed\n \n self.crawlstatus = \"Done\"\n self.elapsed = (time.clock() - start)\n print \"Crawl Done\"\n print json.dumps(self.crawl_async_result.result, indent=4)\n \n self.__insert_into_db(self.crawl_async_result.result)\n content = json.dumps({\"query_id\":self.qid, \"message\":\"done\", \"dbkey\":str(self.dbkey), \"time\":self.elapsed});\n config.mqchannel.basic_publish(exchange=config.get(\"MQEXCHANGE\"), routing_key='', body=content)","def __init__(self, config, processors):\n source = HackernewsStories()\n source.configure(config)\n\n super(HackernewsCrawlJob, self).__init__(source, processors)","def from_crawler(cls, crawler, *args, **kwargs):\n pipeline = cls()\n crawler.signals.connect(pipeline.handle_list_of_items, signal=signals.spider_idle)\n return pipeline","def start_requests(self):\n\n with open(os.path.join(os.path.dirname(__file__), \"../resources/mapemall_categories.csv\")) as categories:\n for category in csv.DictReader(categories):\n category_text=category[\"category\"]\n url=str(MapemallCrawlerSpider.start_urls[0])+category_text\n # The meta is used to send our search text into the parser as metadata\n yield scrapy.Request(url, callback = self.parse, meta = {\"category_text\": category_text})","def iter_spider_classes(module):\n ...","def main(call_args):\n\n args = parse_args(call_args)\n init_logging(args.loglevel)\n\n _log.info(\"'scrape-jobs' called with args: %s\", args)\n runner.run_with_config_file(args.site, args.config_file)","def next_spider(self, spider):\n for spidercls, urls, isdata in self.nextnodes:\n if self.spider_name(spider) == self.spider_name(spidercls):\n if isinstance(spidercls, (str, unicode,)):\n if '.' in spidercls:\n modulestr, classtr = spidercls.rsplit('.', 1)\n else:\n modulestr, classtr = self.__class__.__module__, spidercls\n spidercls = getattr(__import__(modulestr),classtr)\n return spidercls, urls, isdata\n \n raise ValueError(\"The spider of {0} not in nextnodes of spidernode {1}\".format(\n self.spider_name(spider), self.__class__.__name__))","def __init__(self):\n self.gdc = GdocsCrawler()","def crawler(self):\n\n\t\tfor page in range(self.first_page, self.last_page+1):\n\t\t\tprint(\"\\nCrawling Page \" + str(page))\n\t\t\tpage_url = self.site_url + \"?page=\" + str(page) +\\\n\t\t\t \"&index=prod_all_products_term_optimization\"\n\t\t\t\n\t\t\tself.scrape_features(page_url)","def _genspider(self, module, name, domain, template_name, template_file):\n tvars = {\n 'project_name': settings.get('BOT_NAME'),\n 'ProjectName': string_camelcase(settings.get('BOT_NAME')),\n 'module': module,\n 'name': name,\n 'domain': domain,\n 'classname': '%sSpider' % ''.join([s.capitalize() \\\n for s in module.split('_')])\n }\n\n spiders_module = __import__(settings['NEWSPIDER_MODULE'], {}, {}, [''])\n spiders_dir = abspath(dirname(spiders_module.__file__))\n spider_file = \"%s.py\" % join(spiders_dir, module)\n\n shutil.copyfile(template_file, spider_file)\n render_templatefile(spider_file, **tvars)\n print \"Created spider %r using template %r in module:\" % (name, \\\n template_name)\n print \" %s.%s\" % (spiders_module.__name__, module)","def genspider(ctx, name, domain):\n spider_filename = _gen_spider(name, domain)\n print('Created {0}'.format(spider_filename))\n\n test_filename = _gen_tests(name, domain)\n print('Created {0}'.format(test_filename))","def run(self):\n if self.is_full():\n return\n for crawler in self.crawlers:\n logger.info(f'crawler {crawler} to get proxy')\n proxies = crawler.run()\n if proxies:\n for proxy in proxies:\n self.redis.add(proxy)\n logger.info(f'crawled {len(proxies)} proxies from {crawler}')\n else:\n logger.info(f'cannot crawl proxies from {crawler}')","def open_spider(self, spider):\n now = spider.get_now_time()\n\n # Create initial batch\n spider.batch = model.Batch.objects.create(\n kickoff_time=now, finish_time=now)\n spider.batch.save()\n\n # save initial site list\n file_content = ContentFile('\\n'.join(spider.start_urls))\n filename = str(spider.batch).replace(' ', '')\n spider.batch.sitelist.save(filename, file_content)\n spider.batch.sitelist.close()\n spider.batch.save()\n\n spider.batch_user_agents = []\n\n # Give the spider a set of batch user agents, which preserve historical\n # user agent data\n for ua in list(model.UserAgent.objects.all()):\n batch_user_agent = model.BatchUserAgent.objects.create(\n batch=spider.batch,\n ua_string=ua.ua_string,\n primary_ua=ua.primary_ua,\n ua_type=ua.ua_type,\n ua_human_name=ua.ua_human_name\n )\n spider.batch_user_agents.append(batch_user_agent)\n\n if not spider.batch_user_agents:\n raise ValueError(\n \"No user agents; add some with 'manage.py useragents --add'\")","def distribute(self, page):\n self.crawl_page(self.keyword, self.since, self.to, page)","def __init__(self, thread_id, depth, spider_config, url, pattern):\n\n super(CrawlUrl, self).__init__()\n\n self.thread_id = thread_id\n self.depth = depth\n self.spider_config = spider_config\n self.url = url\n self.pattern = pattern\n self.page = ''","def crawler(self):\n\n def decorator(f: Callable) -> Callable:\n self.register_crawler(f)\n return f\n\n return decorator","def start_requests(self):\n for url in self.start_urls:\n yield scrapy.Request(url, callback=self.parse)","def start_requests(self):\n self.spider = Base_Spider(LpCfg)\n self.first_url = 'https://www.liepin.com/zhaopin/' \\\n '?industries=&dqs=010&salary=15%2440' \\\n '&jobKind=2&pubTime=3&compkind=&compscale=' \\\n '&industryType=&searchType=1&clean_condition=' \\\n '&isAnalysis=&init=1&sortFlag=15&flushckid=1' \\\n '&fromSearchBtn=2&headckid=0b5a9690a5cb1d82&key=Python'\n urls = []\n s = self.spider.get_content(self.first_url)\n self.cookies = self.spider.session.cookies.get_dict()\n del s\n self.spider.headers.update({'Cookie': self.cookies})\n for page in range(1,5):\n url = self.first_url + '&curPage=%d'%page\n urls.append(url)\n for url in urls:\n print url\n yield scrapy.Request(url=url,\n callback=self.parse,\n headers=self.spider.headers,\n cookies=self.cookies\n )","def scrape_main() -> None:\n\n logger.info(\"Starting scrape\")\n search_info = construct_scrape_regex_patterns(grab_scrape_info())\n links = run_scrape(\n url=search_info['url'],\n seasons_regex=search_info['seasons'],\n episodes_regex=search_info['episodes']\n )\n if links:\n logger.debug(\"Writing urls to file\")\n with open('urls.txt', 'w') as f:\n for link in links:\n f.write(link + '\\n')\n else:\n logger.warning(\"No links available\")","def run(self):\n\n for url in self.urls:\n try:\n # Use requests to retrieve web page data\n print(url)\n response = session.get(url, ) # allow_redirects=True)\n\n if response.status_code != 200:\n print('Failed to retrieve page, URL: {0}, error: {1}\\n'.format(url, response.status_code))\n return\n\n # Get web page data from HTML response\n content = get_json_data(response.text)\n\n # Compile data into dictionary to be used for reporting\n summary_data = generate_report(content)\n\n # Generate/print report\n print_report(summary_data)\n\n except Exception as error:\n print('Scraper failed to run for URL {0}, error: {1}, {2}\\n'.format(\n url, type(error).__name__, error\n ))\n\n # time.sleep(1) # for load concerns","def parse(self, response):\n for cate_selector in response.css(\"div.sub-nav-cont ul li a\"):\n link = cate_selector.css(\"::attr(href)\").extract_first()\n if response.urljoin(link) in self.start_urls:\n continue\n cate_name = cate_selector.css(\"::attr(c-bname)\").extract_first()\n meta = {\"cate_name\": cate_name, \"page_num\": 1,\n \"base_url\": link.rsplit(\".\", 1)[0]}\n yield response.follow(link, callback=self.parse_category, meta=meta)","def start_requests(self):\r\n try:\r\n\r\n for url in self.start_urls:\r\n yield scrapy.Request(url,\r\n callback=self.navigate_to)\r\n except Exception as err:\r\n logger.error(f'TekDefenceScraper : start_requests : {err}')\r\n raise err","def start_requests(self):\n # Load sitemap JSON - generate queues\n if self.args.sitemap_json is None:\n yield Request('https://repo1.maven.org/maven2/', callback=self.spider.parse_page, meta=dict())\n return\n\n for req in self.gen_links(self.args.sitemap_json):\n yield req","def crawlerAdd(name):\n sclogic.crawlerAdd(name)","def __init__(self):\n self.redis = RedisClient()\n self.crawlers = [crawler_cls() for crawler_cls in crawlers_cls]","def test_with_progress_start_requests_all_visited(mock_spider_state_cls, mock_site_pager_cls, _):\n data = CategoryBasedSpiderData(\"some-progress-file-dir\", \"some-spider-name\", \"http://some-recipes.com\")\n mock_request_factory = Mock()\n\n mock_current_category_parent = Mock()\n mock_current_category_parent.parent = None\n mock_current_category_parent.children = [Mock(), Mock()]\n mock_current_category_parent.children[0].visit_state = VisitState.VISITED\n mock_current_category_parent.children[1].visit_state = VisitState.VISITED\n mock_current_category_node = Mock()\n mock_current_category_node.parent = mock_current_category_parent\n\n mock_spider_state_instance = __prepare_mock_spider_instance(True)\n mock_spider_state_instance.site_structure.get_node_at_path.return_value = mock_current_category_node\n mock_spider_state_cls.return_value = mock_spider_state_instance\n\n mock_site_pager_cls_instance = Mock()\n mock_site_pager_cls.return_value = mock_site_pager_cls_instance\n\n spider = CategoryBasedSpider(Mock(), Mock(), data)\n spider.request_factory = mock_request_factory\n list(spider.start_requests())\n mock_site_pager_cls_instance.start.assert_called()\n\n site_page_callbacks = mock_site_pager_cls.call_args[0][3]\n site_page_callbacks.on_page_finished(\"http://some-recipes.com/next-page\")\n site_page_callbacks.on_paging_finished()\n mock_spider_state_instance.save.assert_called()\n mock_current_category_parent.set_visit_state.assert_called()","def main(state=None, overwrite=False):\n \n # Initialize process\n process = initialize_process()\n\n if overwrite:\n # TODO: delete all (and only) files to be regenerated\n pass\n\n # Add a spider instance for each state to be run\n if state:\n add_state_to_process(state, process=process)\n else:\n for s in list(CONFIG.keys()):\n add_state_to_process(s, process=process)\n\n # Run scrape\n process.start()","def crawl(self):\n retrievedSubs = []\n reddit = praw.Reddit(\n client_id='QRl_4bwjckcg9A',\n client_secret='dsavqFoOk5NgWEOWtMf9NknwxRIoIw',\n password='P@ssword123',\n user_agent='cluelessv1',\n username='theclueless1009'\n )\n submissions = reddit.subreddit('all').search(self.keyword, sort='relevance', limit=50, time_filter='week')\n\n for sub in submissions:\n self.data = [sub.selftext, sub.upvote_ratio, sub.score,\n sub.title, sub.id, sub.total_awards_received, sub.created_utc]\n self.data = tuple(self.data)\n retrievedSubs.append(self.data)\n\n return retrievedSubs","def add_crawler(self, crawler: BaseCrawler) -> None:\n self.tasks.append(crawler)","def crawl(url):\n\n if not url in visited_urls:\n try:\n r = sess.get(url, headers={'User-Agent': user_agent}, stream=True)\n visited_urls.add(url)\n # Don't download non html files\n if r.headers['content-type'].startswith(\"text/html\"):\n # TODO: Use console logger\n print url, datetime.datetime.now()\n links = extract_links(r.text.encode(\"utf-8\"))\n update_queue(url, links)\n return r.text.encode('utf-8', 'ignore')\n # what if url is email address\n except requests.exceptions.MissingSchema, e:\n print(e)\n return \"\"\n except requests.ConnectionError, e:\n # Any requests exception, log and don't quit.\n print(e)\n logger.error(e)","def scrape_pdfs(db):\n process = CrawlerProcess()\n process.crawl(PdfSpider, db=db)\n process.start()","def work(self):\n while True:\n url, depth = self.crawl_queue.get(timeout=self.crawl_queue_time_out)\n self.crawl_queue.task_done()\n try:\n if depth <= self.depth_limit:\n with Spider.seen_urls_lock:\n seen_already = url in self.seen_urls\n if not seen_already:\n page, links = self.crawl_page(url, depth, self.domain_name)\n self._add_links_to_crawl_queue(links, depth)\n self._add_page_to_rank_queue(page)\n self._add_page_to_storage(page)\n with Spider.seen_urls_lock:\n self.seen_urls.add(url)\n except Exception as e:\n self.logger.debug(e)","def main(args):\n parser = create_parser()\n\n if not args:\n parser.print_usage()\n sys.exit(1)\n\n parsed_args = parser.parse_args(args)\n scrape_url(parsed_args.url)","async def crawl(self):\n fetch_urls = [self.start_url]\n results = []\n while len(fetch_urls):\n \"\"\"\n slicing array urls with max_async_call arg and then run extract_data_urls\n extract_data_urls return a object that contains url, data, found_urls, and all_urls\n url is a url that we crawled\n data is Html content of the url\n found_urls are new urls that we have to crawl that\n all_urls are all links in the html page\n \"\"\"\n urls = await self.extract_data_urls(fetch_urls[0:self.max_async_call])\n del fetch_urls[0:self.max_async_call]\n for url, data, found_urls, all_urls in urls:\n fetch_urls.extend(found_urls)\n result = self.parse_html_content(data)\n result['urls'] = all_urls\n results.append((url, result))\n return results","def daily_task():\n global CATEGORIES_PAGES\n global BROWSER\n global DATE\n global OBSERVATION\n log.info('Scraper started')\n # Refresh date\n DATE = str(datetime.date.today())\n OBSERVATION = 0\n # Initiate headless web browser\n log.info('Initializing browser')\n BROWSER = webdriver.Chrome(executable_path=PROJECT_PATH + \"/bin/chromedriver\",\n options=OPTIONS)\n # Download topsite and get categories directories\n base_file_name = \"All_cat_\" + DATE + \".html\"\n fetch_html(BASE_URL, base_file_name, PATH_HTML, attempts_limit=1000)\n html_file = open(PATH_HTML + base_file_name).read()\n CATEGORIES_PAGES = get_category_list(html_file)\n log.info('Found ' + str(len(CATEGORIES_PAGES)) + ' categories')\n # Read each categories pages and scrape for data\n for cat in track(CATEGORIES_PAGES,\n description = \"[green]Scraping...\",\n total = len(CATEGORIES_PAGES)):\n cat_file = \"cat_\" + cat['name'] + \"_\" + DATE + \".html\"\n download = fetch_html(cat['directlink'], cat_file, PATH_HTML)\n if download:\n scrap_data(cat)\n # Close browser\n BROWSER.close()\n BROWSER.service.process.send_signal(signal.SIGTERM)\n BROWSER.quit()","def schedule(args):\n job_args = [(x[0], x[1]) for x in (y.split(\"=\", 1) for y in args.arg)]\n _projects = lib.get_projects(\n args.target, args.project, username=args.username, password=args.password\n )\n for project in _projects:\n _spiders = lib.get_spiders(\n args.target,\n project,\n args.spider,\n username=args.username,\n password=args.password,\n )\n for spider in _spiders:\n job_id = lib.schedule(\n args.target,\n project,\n spider,\n job_args,\n username=args.username,\n password=args.password,\n )\n print(f\"{project} / {spider} => {job_id}\")"],"string":"[\n \"def runSpider(spiderClass):\\n\\n\\tprocess = CrawlerProcess({\\n\\t\\t# 'USER_AGENT': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'\\n\\t})\\n\\n\\tprocess.crawl(spiderClass)\\n\\tprocess.start() # the script will block here until the crawling is finished\",\n \"def crawl(spider: str, book_id: int):\\n proc = CrawlerProcess(get_project_settings())\\n\\n proc.crawl(spider, book_id=book_id)\\n\\n proc.start()\",\n \"def crawl(spiders_classes, connector, debug=False, spider_error_callback=stdout_error_callback):\\n if debug:\\n dispatcher.connect(spider_error_callback, signals.spider_error)\\n\\n process = CrawlerProcess({\\n 'ITEM_PIPELINES': {\\n 'pyjobs_crawlers.pipelines.RecordJobPipeline': 1,\\n },\\n 'connector': connector,\\n 'LOG_ENABLED': False\\n })\\n\\n for spider_class in spiders_classes:\\n process.crawl(spider_class)\\n\\n spiders = []\\n for crawler in list(process.crawlers):\\n spiders.append(crawler.spider)\\n process.start()\\n\\n return spiders\",\n \"def spidercls_for_request(spider_loader, request, default_spidercls: Optional[Any] = ..., log_none: bool = ..., log_multiple: bool = ...):\\n ...\",\n \"def runSpider(spider, searchterm = None, fullink = None, spiderbotid = -1):\\n sclogic.runSpider(spider, searchterm, fullink, spiderbotid)\",\n \"def main():\\n\\n from scrapy.crawler import CrawlerProcess\\n from scrapy.utils.project import get_project_settings\\n\\n process = CrawlerProcess(get_project_settings())\\n process.crawl(NCBIGeoSpider)\\n process.start()\",\n \"def run_spider_on_zyte(spider_name):\\n print(f'Running spider {spider_name}...')\\n data = dict(project=project_id, spider=spider_name)\\n response = requests.post('https://app.scrapinghub.com/api/run.json', data=data, auth=(api_key, ''))\\n return response.json()['jobid']\",\n \"def runCrawler(crawlerid):\\n sclogic.runCrawler(crawlerid)\",\n \"def crawl(self):\\n try:\\n self.crawl_pages()\\n self.crawl_posts()\\n self.crawl_comments()\\n except Exception as exception:\\n self.handle_request_limit(exception)\",\n \"def main():\\n # get input params\\n args = parm_parser.get_args()\\n # init log config\\n log.init_log('./log/mini_spider')\\n if args:\\n # read config file spider.conf\\n conf_params = parm_parser.set_config_by_file(args.conf)\\n # use config set up spider initial params\\n spider = SpiderWorker(conf_params)\\n # init result_path, make it complete\\n spider.set_path()\\n # init url queue\\n spider.set_url_queue()\\n # start to crawl url\\n spider.start_crawl_work()\\n\\n return\",\n \"def start_crawling(crawler_instance: Crawler):\\n print('start crawling!')\\n logger.info('started a new crawl!')\\n crawler_instance.crawl()\\n threading.Timer(Config.CRAWL_TIMEOUT, start_crawling,\\n [crawler_instance]).start()\",\n \"def crawl(self):\\n\\n # create helper process and setup IPC\\n self.socket.listen(1)\\n help_out_fd = open(self.helper_outfile, \\\"w\\\")\\n with subprocess.Popen(\\\"./crawl_helper.py\\\", stdout=help_out_fd, stderr=subprocess.STDOUT) as proc:\\n self.helper_pid = proc.pid\\n try:\\n conn, _ = self.socket.accept()\\n # create initial params for crawler helper and send them\\n new_urls = set()\\n setup_params = {\\\"start_urls\\\": self.start_urls, \\\"allowed_domains\\\": [self.domain],\\n \\\"cookies\\\": self.cookies, \\\"user_agent\\\": self.config[\\\"user_agent\\\"]}\\n ipc_operations.send_object(conn, setup_params)\\n\\n # loop: receive a response object, then send new URLs to crawl. Catch & handle problems.\\n while True:\\n try:\\n proc.wait(timeout=0.001)\\n break\\n except subprocess.TimeoutExpired:\\n response = ipc_operations.receive_object(conn)\\n if not response: # socket is dead / closed\\n break\\n new_urls = self.process_response(response)\\n ipc_operations.send_object(conn, new_urls)\\n except socket.timeout:\\n util.printit(\\\"Unix socket connection to scrapy crawler unexpectedly broke. \\\" +\\n \\\"Quitting crawling of %s\\\" % self.base_url, color=util.RED)\\n break\\n finally:\\n # ensure connection is closed and helper process killed in any case\\n conn.close()\\n proc.kill()\\n\\n # after the actual crawling, extract all the gathered cookies from Selenium\\n if self.config[\\\"use_selenium\\\"].lower() == \\\"true\\\":\\n selenium_cookies = self.driver.get_cookies()\\n for cookie in selenium_cookies:\\n if not any(cookie[\\\"name\\\"] == c[\\\"name\\\"] and cookie[\\\"path\\\"] == c[\\\"path\\\"] and\\n cookie[\\\"domain\\\"] == c[\\\"domain\\\"] for c in self.found_cookies):\\n parsed_cookie = {}\\n for key in (\\\"name\\\", \\\"path\\\", \\\"domain\\\", \\\"httpOnly\\\", \\\"secure\\\"):\\n parsed_cookie[key] = cookie[key]\\n self.found_cookies.append(parsed_cookie)\\n\\n help_out_fd.close()\\n return self.create_results()\",\n \"def WebscraperTask(job_id):\\n logger.debug(\\\"Entering dispatch_wordscraper with job ID: %s\\\" % str(job_id))\\n\\n # Obtain all required crawler arguments\\n job = Job.objects.get(pk=job_id)\\n word_list = [(term.term_id, term.term)\\n for term in Term.objects.filter(job=job)]\\n site_list = [(site.site_id, site.url, job.max_depth, 'English')\\n for site in Site.objects.filter(job=job)]\\n\\n # Initialize the crawling process\\n logger.debug(\\\"Configuring crawl controller with job_id: \\\" +\\n \\\"%d, terms: %s, sites: %s\\\" % (job_id, str(word_list),\\n str(site_list),))\\n controller = init_controller()\\n controller.crawl(job_id, site_list, word_list)\\n logger.debug(\\\"Crawl complete for job: %d\\\" % job_id)\\n\\n # Cache the results in the database so the results are dated as close to the\\n # crawl date as possible.\\n results = controller.query(site_list, word_list)\\n result_cache = Result()\\n result_cache.job = job\\n result_cache.output = results\\n result_cache.save()\",\n \"def run_crawl(self, args):\\n\\n # Crawler process declaration\\n process = CrawlerProcess({\\n 'USER_AGENT': 'David Avs Crawler',\\n 'FEED_FORMAT': 'json',\\n 'FEED_URI': 'stdout:',\\n 'LOG_ENABLED': args.verbose,\\n })\\n kwargs = dict(\\n start_urls=[args.url],\\n allowed_domains=[urlparse.urlparse(args.url).netloc.lower()],\\n )\\n\\n # Run crawling\\n old_stdout = sys.stdout\\n sys.stdout = args.file\\n try:\\n process.crawl(DavidAvsSpider, **kwargs)\\n process.start()\\n finally:\\n sys.stdout = old_stdout\",\n \"def start_crawlers(spider_name: str, rules: List[Rule]) -> None:\\n runner = CrawlerRunner(settings)\\n crawlers = runner.spider_loader.list()\\n crawlers = [c for c in crawlers if c.__contains__(spider_name)]\\n if crawlers:\\n for rule in rules:\\n runner.crawl(crawlers[0], rule=rule)\\n d = runner.join()\\n d.addBoth(lambda _: reactor.stop())\\n reactor.run()\\n launch_logger.debug('all finished.')\\n else:\\n launch_logger.warning('provide the right spider name.')\",\n \"def start(self):\\n self.start_spider()\\n self.start_ranker()\\n\\n concurrent.futures.wait(self.spider_thread_futures) # wait for spiders to finish\\n self.logger.info(\\\"Done crawling\\\")\\n self.ranker.done_crawling.set()\\n\\n self.ranker.print_ranks()\",\n \"def open_spider(self,Spider):\\n pass\",\n \"def crawl_start(crawl_obj):\\n \\n res = None\\n\\n if crawl_obj.type in ['user', 'song'] :\\n res = eval('crawl_' + crawl_obj.type)(crawl_obj)\\n elif crawl_obj.type in ['artist', 'album'] :\\n web_data = requests.get(crawl_obj.url, headers = cheat_headers)\\n soup = bs4.BeautifulSoup(web_data.text, 'lxml')\\n\\n res = eval('crawl_' + crawl_obj.type)(crawl_obj.type, soup)\\n else:\\n print(\\\"Object type UNKNOWN!\\\")\\n \\n return res\",\n \"def from_crawler(cls, crawler, *args, **kwargs):\\n\\n spider = super(autos_detran_terceiros_sp_spider, cls).from_crawler(\\n crawler, *args, **kwargs)\\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\\n return spider\",\n \"def run_spiders():\\n hour_limit = 3600 # in seconds\\n\\n settings = get_project_settings()\\n\\n # Uncomment the following block of code if you want to test the manager on\\n # the \\\"onepagetest\\\" to make sure the manager is working.\\n \\\"\\\"\\\"\\n settings[\\\"HTTPCACHE_ENABLED\\\"] = 1\\n settings[\\\"HTTPCACHE_EXPIRATION_SECS\\\"] = 0\\n settings[\\\"HTTPCACHE_STORAGE\\\"] = \\\"scrapy.extensions.httpcache.FilesystemCacheStorage\\\"\\n settings[\\\"HTTPCACHE_IGNORE_MISSING\\\"] = 1\\n settings[\\\"HTTPCACHE_DIR\\\"] = \\\"onepagetest\\\"\\n \\\"\\\"\\\"\\n\\n runner = CrawlerRunner(settings)\\n begin_time = datetime.now()\\n\\n d = runner.crawl(\\\"sb_spider\\\")\\n d.addBoth(lambda _: continue_crawl(d, runner, begin_time, hour_limit))\\n reactor.run()\",\n \"def run_generic_spider( user_id\\t\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\tspider_id\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\tdatamodel\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\trun_spider_config\\t= None,\\n\\t\\t\\t\\t\\t\\ttest_limit\\t\\t\\t= None\\n\\t\\t\\t\\t\\t\\t):\\n\\n\\tprint ()\\n\\tlog_scrap.info(\\\"--- run_generic_spider / spider_id : %s \\\", spider_id )\\n\\n\\t### WARNING !!! --> TEMPORARY SOLUTION\\n\\t### remove spider folder for spider_id in JOBDIR\\n\\tlog_scrap.debug(u\\\"--- run_generic_spider / cwd : %s\\\", os.getcwd() )\\n\\ttry :\\n\\t\\tshutil.rmtree( os.getcwd() + \\\"/\\\" + JOBDIR_FOLDER + \\\"/\\\" + spider_id )\\n\\texcept:\\n\\t\\tpass\\n\\tlog_scrap.debug(u\\\"--- run_generic_spider / removed folder : {}/{}\\\".format(JOBDIR_FOLDER, spider_id) )\\n\\n\\t# !!! spider is launched from main.py level !!!\\n\\t# all relative routes referring to this...\\n\\tlog_scrap.info(\\\"--- run_generic_spider / os.getcwd() : %s \\\", os.getcwd() )\\n\\n\\t### flattening run_spider_config : from nested to flat dict\\n\\tlog_scrap.info(\\\"--- run_generic_spider / 'flattenSpiderConfig()' on 'run_spider_config' --> 'spider_config_flat' ...\\\" )\\n\\tspider_config_flat = flattenSpiderConfig( run_spider_config )\\n\\n\\n\\t### settings for crawler\\n\\t# cf : https://hackernoon.com/how-to-crawl-the-web-politely-with-scrapy-15fbe489573d\\n\\n\\t### global settings for scrapy processes (see upper)\\n\\tlog_scrap.info(\\\"--- run_generic_spider / BOT_NAME : %s \\\", settings.get('BOT_NAME') )\\n\\tlog_scrap.info(\\\"--- run_generic_spider / USER_AGENT : %s \\\", settings.get('USER_AGENT') )\\n\\tlog_scrap.info(\\\"--- run_generic_spider / ITEM_PIPELINES : %s \\\", settings.get('ITEM_PIPELINES').__dict__ )\\n\\n\\n\\t# specific settings for this scrapy process\\n\\n\\t# settings.set( \\\"RETRY_TIMES\\\"\\t\\t\\t\\t\\t\\t, RETRY_TIMES )\\n\\t# settings.set( \\\"CONCURRENT_ITEMS\\\"\\t\\t\\t\\t, CONCURRENT_ITEMS )\\n\\t# settings.set( \\\"CONCURRENT_REQUESTS\\\"\\t\\t\\t\\t, CONCURRENT_REQUESTS )\\n\\t# settings.set( \\\"CONCURRENT_REQUESTS_PER_DOMAIN\\\"\\t, CONCURRENT_REQUESTS_PER_DOMAIN )\\n\\t# settings.set( \\\"REDIRECT_MAX_TIMES\\\"\\t\\t\\t\\t, REDIRECT_MAX_TIMES )\\n\\t# settings.set( \\\"DOWNLOAD_MAXSIZE\\\" \\t\\t\\t\\t, DOWNLOAD_MAXSIZE )\\n\\t# settings.set( \\\"DEPTH_PRIORITY\\\"\\t\\t\\t\\t\\t, DEPTH_PRIORITY )\\n\\t# settings.set( \\\"SCHEDULER_DISK_QUEUE\\\"\\t\\t\\t, SCHEDULER_DISK_QUEUE )\\n\\t# settings.set( \\\"DEPTH_PRIORITY\\\"\\t\\t\\t\\t\\t, SCHEDULER_MEMORY_QUEUE )\\n\\n\\t# settings.set( \\\"RANDOMIZE_DOWNLOAD_DELAY\\\"\\t\\t, RANDOMIZE_DOWNLOAD_DELAY )\\n\\t# cf : https://doc.scrapy.org/en/latest/topics/jobs.html#job-directory\\n\\tsettings.set( \\\"JOBDIR\\\"\\t\\t\\t\\t\\t\\t\\t, JOBDIR_FOLDER + \\\"/\\\" + spider_id )\\n\\n\\t## https://scrapy.readthedocs.io/en/0.12/topics/extensions.html#module-scrapy.contrib.closespider\\n\\n\\tsettings.set( \\\"CURRENT_SPIDER_ID\\\" \\t\\t\\t, spider_id )\\n\\tsettings.set( \\\"RETRY_TIMES\\\"\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"RETRY_TIMES\\\"] )\\n\\tsettings.set( \\\"CLOSESPIDER_ITEMCOUNT\\\"\\t\\t, spider_config_flat[\\\"LIMIT_ITEMS\\\"] )\\n\\t# settings.set( \\\"CLOSESPIDER_PAGECOUNT\\\"\\t\\t, spider_config_flat[\\\"LIMIT_PAGES\\\"] )\\n\\tsettings.set( \\\"DOWNLOAD_DELAY\\\" \\t\\t\\t\\t\\t, spider_config_flat[\\\"download_delay\\\"] )\\n\\tsettings.set( \\\"CONCURRENT_ITEMS\\\"\\t\\t\\t\\t, spider_config_flat[\\\"CONCURRENT_ITEMS\\\"] )\\n\\tsettings.set( \\\"CONCURRENT_REQUESTS\\\"\\t\\t\\t, spider_config_flat[\\\"CONCURRENT_REQUESTS\\\"] )\\n\\t# settings.set( \\\"DOWNLOAD_DELAY\\\" \\t\\t\\t\\t, DOWNLOAD_DELAY )\\n\\n\\tsettings.set( \\\"BOT_NAME\\\"\\t\\t\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"BOT_NAME\\\"] )\\n\\tsettings.set( \\\"USER_AGENT\\\"\\t\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"USER_AGENT\\\"] )\\n\\tsettings.set( \\\"ROBOTSTXT_OBEY\\\"\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"ROBOTSTXT_OBEY\\\"] )\\n\\tsettings.set( \\\"AUTOTHROTTLE_ENABLED\\\"\\t\\t\\t, spider_config_flat[\\\"AUTOTHROTTLE_ENABLED\\\"] )\\n\\tsettings.set( \\\"HTTPCACHE_ENABLED\\\"\\t\\t\\t\\t\\t, spider_config_flat[\\\"HTTPCACHE_ENABLED\\\"] )\\n\\tsettings.set( \\\"RANDOMIZE_DOWNLOAD_DELAY\\\"\\t, spider_config_flat[\\\"RANDOMIZE_DOWNLOAD_DELAY\\\"] )\\n\\n\\t### initiating crawler process\\n\\tlog_scrap.info(\\\"--- run_generic_spider / instanciate process ...\\\" \\t )\\n\\tprocess = CrawlerRunner( settings = settings )\\n\\n\\t### adding CrawlerRunner as deferred\\n\\tdef f(q):\\n\\t\\ttry:\\n\\t\\t\\t### send/create custom spider from run_spider_config\\n\\t\\t\\t### cf : https://stackoverflow.com/questions/35662146/dynamic-spider-generation-with-scrapy-subclass-init-error\\n\\n\\t\\t\\tdeferred = process.crawl( \\tGenericSpider,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tuser_id\\t\\t\\t\\t\\t\\t\\t= user_id,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tdatamodel \\t\\t\\t\\t\\t= datamodel ,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tspider_id \\t\\t\\t\\t\\t= spider_id ,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tspider_config_flat\\t= spider_config_flat,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttest_limit\\t\\t\\t\\t\\t= test_limit\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t)\\n\\t\\t\\tdeferred.addBoth(lambda _: reactor.stop())\\n\\t\\t\\treactor.run()\\n\\t\\t\\tq.put(None)\\n\\t\\texcept Exception as e:\\n\\t\\t\\tq.put(e)\\n\\n\\t### putting task in queue and start\\n\\tq = Queue()\\n\\tp = Process(target=f, args=(q,))\\n\\tp.start()\\n\\tresult = q.get()\\n\\tp.join()\\n\\n\\tif result is not None:\\n\\t\\traise result\\n\\n\\n\\n\\tprint (\\\"\\\\n\\\\n{}\\\\n\\\".format(\\\"> > > \\\"*20))\",\n \"def crawl(self):\\n self.get('http://code.google.com/p/webscraping/')\\n self.get('http://code.google.com/p/sitescraper/')\\n QTimer.singleShot(5000, self.app.quit)\",\n \"def from_crawler(cls, crawler, *args, **kwargs):\\n\\n spider = super(telecom_vivo_movel_spider, cls).from_crawler(\\n crawler, *args, **kwargs)\\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\\n return spider\",\n \"def run(self):\\n \\n try:\\n logging.info('Thread:{} starting'.format(self.thread_id))\\n\\n self.crawl_url()\\n self.parse_html()\\n except IOError as e:\\n self.thread_post_processing()\\n logging.error('CrawlUrlError url:{} msg:{}'.format(self.url, e))\\n\\n self.thread_post_processing()\",\n \"def run_crawler(self) -> List[JobEventSchema]:\\n print(f\\\"Ready for scraping, current task: {self.tasks}\\\")\\n\\n crawling_result = []\\n for task in self.tasks:\\n result = task.run()\\n crawling_result.extend(result)\\n return crawling_result\",\n \"def open_spider(self, spider):\\n pass\",\n \"def _scrape(self):\",\n \"def crawl(self):\\n if os.path.exists(self.__work_path):\\n shutil.rmtree(self.__work_path)\\n print '\\\\nOld Data Was Found And Removed.\\\\n'\\n\\n initial_first_run = True\\n initial_recursion_depth = 0\\n initial_prev_link_size = 0\\n for url in self.__urls:\\n self.__start_recursion(url, initial_first_run,\\n initial_recursion_depth, initial_prev_link_size)\\n\\n Crawler.mission_report(self.__work_path)\",\n \"def parse(self, response):\\n page_jobs=[]\\n\\n # Calling abstarct method get_jobs_list() and iterating...\\n jobs_div_list=self.get_jobs_list(response)\\n for div in jobs_div_list:\\n \\n # Calling abstarct method get_job_dict()\\n job_dict=self.get_job_dict(div)\\n\\n if not job_dict['url'] or not job_dict['title'] :\\n # At least url, title data is loaded from the list of job posting ...\\n raise ValueError( \\\"Could not find valid job information ('url' and 'title') in data:\\\\n\\\" + \\n str(div.get()) + \\\"\\\\nScraped infos:\\\\n\\\" + str(job_dict) + \\\"\\\\nReport this issue on github!\\\" )\\n \\n # Store source as the name of the spider aka website\\n job_dict['source']=self.name\\n page_jobs.append(job_dict)\\n \\n \\\"\\\"\\\"\\n Load full job page only if:\\n - it's a new job (not in database)\\n - load_full_jobs=Yes\\n - the method parse_full_job_page() has been re-wrote by the Scraper subclass\\n \\\"\\\"\\\"\\n if ( (not self.db or self.db.find_job(job_dict)==None)\\n and self.load_full_jobs ):\\n if type(self).parse_full_job_page != Scraper.parse_full_job_page:\\n # load_full_jobs=Yes and it's supported by scraper\\n # Call parse_full_job_page() with job URL\\n\\n # Handle SeleniumRequest if use_selenium=True\\n if self.use_selenium:\\n yield SeleniumRequest(url=job_dict['url'], \\n callback=self.parse_full_job_page,\\n cb_kwargs=dict(job_dict=job_dict),\\n wait_time=self.selenium_wait_time, script=SCROLL_DOWN)\\n else:\\n yield response.follow(url=job_dict['url'], \\n callback=self.parse_full_job_page,\\n cb_kwargs=dict(job_dict=job_dict))\\n else:\\n yield Job(job_dict)\\n else:\\n yield Job(job_dict)\\n\\n \\\"\\\"\\\" Just printing in one line \\\"\\\"\\\"\\n if self.load_full_jobs:\\n if type(self).parse_full_job_page == Scraper.parse_full_job_page:\\n if self.load_all_new_pages==False:\\n self.log.info(\\\"Scraped {} jobs from {}. Scraper {} does not support load_full_jobs=True and load_all_new_pages=False, some new job postings and job informations might be missing\\\".format(len(page_jobs), response.url, self.name))\\n else:\\n self.log.info(\\\"Scraped {} jobs from {}. Scraper {} does not support load_full_jobs=True, some informations might be missing\\\".format(len(page_jobs), response.url, self.name))\\n else:\\n self.log.info(\\\"Scraping {} jobs from {}...\\\".format(len(page_jobs), response.url))\\n else:\\n if self.load_all_new_pages==False:\\n self.log.info(\\\"Scraped {} jobs from {}. load_all_new_pages=False and load_full_jobs=False, some new job postings and job informations might be missing\\\".format(len(page_jobs), response.url))\\n else:\\n self.log.info(\\\"Scraped {} jobs from {}. load_full_jobs=False, some informations might be missing\\\".format(len(page_jobs), response.url))\\n \\n \\\"\\\"\\\"\\n If all page jobs are new and \\n The method get_next_page_url() has been re-wrote by the Scraper subclass\\n Scrape next page\\n \\\"\\\"\\\"\\n if self.load_all_new_pages==True:\\n if self.db and any( [self.db.find_job(job_dict)!=None for job_dict in page_jobs] ):\\n # All new job postings loaded\\n pass\\n else:\\n if self.get_next_page_url(response)!=None :\\n # Loading next page...\\n if self.use_selenium:\\n yield SeleniumRequest(\\n url=self.get_next_page_url(response),\\n callback=self.parse,\\n wait_time=self.selenium_wait_time, script=SCROLL_DOWN)\\n else:\\n yield response.follow(\\n url=self.get_next_page_url(response),\\n callback=self.parse)\\n else:\\n if type(self).get_next_page_url != Scraper.get_next_page_url:\\n # Last page loaded\\n pass\\n else:\\n self.log.info(\\\"Scraper {} does not support load_all_new_pages=True, some new job postings might be missing\\\".format(self.name))\",\n \"def crawl(self, url):\\n return None\",\n \"def addCrawler(name):\\n global allCrawlerNames\\n if name == 'scihub':\\n allCrawlers.append(ScihubCrawler())\\n allCrawlerNames = [ c.name for c in allCrawlers ]\",\n \"def spider_and_save_thread(\\n self, source_url, crawl_timeout, target_url_patten, max_depth, output_directory):\\n url_result = self.crawl(\\n source_url,\\n crawl_timeout,\\n target_url_patten,\\n max_depth)\\n self.save_url(url_result, crawl_timeout, output_directory)\",\n \"def scrape(self):\\n\\n self.jobs_load()\\n self.new_jobs = []\\n\\n for bot in self.bot_squad:\\n self.new_jobs += bot.scrape_all_pages()\\n\\n self.statistics(self.new_jobs)\\n print('SCRAPE COMPLETE. NOTE: Resulting job list still in RAM')\\n print('We observed %d new jobs' % len(self.new_jobs))\",\n \"def crawl(self, keyword, since=None, to=None):\\n no_of_pages = self.get_no_of_pages(keyword, since, to)\\n print('pages: ' + str(no_of_pages))\\n self.keyword = keyword\\n self.since = since\\n self.to = to\\n p = Pool()\\n p.map(self.distribute, range(1, no_of_pages+1))\",\n \"def __init__(self):\\n self.SPIDER = \\\"spider\\\"\",\n \"def parse(self, response):\\n\\n\\t\\t### close spider if exception\\n\\t\\tif 'Bandwidth exceeded' in response.body:\\n\\t\\t\\traise CloseSpider('bandwidth_exceeded')\\n\\n\\t\\tlog_scrap.debug(u\\\"\\\\n>>> NEW PARSING >>>\\\\n\\\" )\\n\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse ...\\\" )\\n\\n\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse /response : \\\\n%s\\\" , response)\\n\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse /response : \\\\n%s \\\\n\\\" , response.__dict__.keys() )\\n\\n\\t\\t# for k, v in response.__dict__.iteritems() :\\n\\t\\t# \\tlog_scrap.info(\\\"\\\\n--- [k] {} : [v] {} : \\\".format(k,v))\\n\\t\\t# print response._body\\n\\t\\tstart_url = response.meta[\\\"start_url\\\"]\\n\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / start_url : %s\\\", start_url )\\n\\n\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t### start request with API crawler\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t# if self.spider_config_flat[\\\"parse_api\\\"] == True :\\n\\t\\tif self.parse_api == True :\\n\\n\\t\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse / starting request on API endpoint... \\\" )\\n\\t\\t\\tjsonresponse = json.loads(response.body_as_unicode())\\n\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider.parse / jsonresponse : \\\\n%s\\\", jsonresponse )\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / jsonresponse received...\\\" )\\n\\n\\t\\t\\traw_items_list = get_dictvalue_from_xpath(jsonresponse, self.item_xpath)\\n\\t\\t\\t# raw_items_list = jsonresponse[self.item_xpath]\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / raw_items_list[0] : \\\\n%s\\\\n...\\\", pformat(raw_items_list[0]) )\\n\\n\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t### PARSING PAGE - API\\n\\t\\t\\t### start parsing page : loop through data items in page in response\\n\\t\\t\\tif len(raw_items_list) != 0 :\\n\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / START LOOPING raw_items_list WITH API ...\\\" )\\n\\n\\t\\t\\t\\t# while self.there_is_more_items_to_scrap_dict[start_url] :\\n\\n\\t\\t\\t\\tfor raw_data in raw_items_list :\\n\\n\\t\\t\\t\\t\\tself.item_count += 1\\n\\n\\t\\t\\t\\t\\t### check if can continue depending on item_count\\n\\t\\t\\t\\t\\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\\n\\n\\t\\t\\t\\t\\t\\tprint()\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - API - item n°{} >>> \\\\n\\\".format(self.item_count) )\\n\\n\\t\\t\\t\\t\\t\\t### instantiate Item to fill from datamodel --> cf items.py\\n\\t\\t\\t\\t\\t\\titemclass \\t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\\n\\t\\t\\t\\t\\t\\titem \\t\\t= itemclass()\\n\\n\\t\\t\\t\\t\\t\\t### add global info to item : i.e. core fields in dm_core_item_related list\\n\\t\\t\\t\\t\\t\\titem[ 'spider_id' ]\\t= self.spider_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_by' ]\\t= self.user_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_at' ]\\t= time.time()\\t\\t# timestamp\\n\\t\\t\\t\\t\\t\\titem[ 'link_src' ]\\t= response._url\\n\\n\\t\\t\\t\\t\\t\\titem[ 'page_n' ]\\t\\t= self.page_count\\n\\t\\t\\t\\t\\t\\titem[ 'item_n' ]\\t\\t= self.item_count\\n\\n\\t\\t\\t\\t\\t\\t### extract data and feed it to the Item instance based on spider_config_flat\\n\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, is_api_rest=True, item_n=self.item_count)\\n\\n\\n\\t\\t\\t\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t\\t### FOLLOW LINK - API\\n\\t\\t\\t\\t\\t\\t### if need to follow to extract all data\\n\\t\\t\\t\\t\\t\\tif self.spider_config_flat[\\\"parse_follow\\\"] == True :\\n\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> FOLLOW LINK - API - item n°{} / page n°{} >>>>>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_xpath : %s\\\", self.follow_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t# follow_link_raw = raw_data[ self.follow_xpath ]\\n\\t\\t\\t\\t\\t\\t\\tfollow_link_raw = get_dictvalue_from_xpath(raw_data, self.follow_xpath)\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link RAW ({}) : {} \\\".format(type(follow_link_raw),follow_link_raw) )\\n\\n\\t\\t\\t\\t\\t\\t\\turl_follow = \\\"\\\"\\n\\t\\t\\t\\t\\t\\t\\tif self.api_follow_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.api_follow_root\\n\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.page_url\\n\\n\\t\\t\\t\\t\\t\\t\\t# complete follow link if needed\\n\\t\\t\\t\\t\\t\\t\\tfollow_link = self.clean_link(follow_link_raw, url_root=url_follow)\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link CLEAN : %s \\\", follow_link )\\n\\n\\t\\t\\t\\t\\t\\t\\t# store follow_link\\n\\t\\t\\t\\t\\t\\t\\titem[ 'link_data' ]\\t= follow_link\\n\\t\\t\\t\\t\\t\\t\\turl \\t\\t\\t\\t= item['link_data']\\n\\n\\t\\t\\t\\t\\t\\t\\tfollow_is_api = self.follow_is_api\\n\\n\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url, 'item_n' : self.item_count , 'parse_api' : follow_is_api })\\n\\n\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t### if no follow link\\n\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\\n\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> item : \\\\n %s \\\\n\\\", pformat(item) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\" --> item ...\\\" )\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\t# log_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\\n\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF ITEMS')\\n\\n\\t\\t\\t### - - - - - - - - - - - - ###\\n\\t\\t\\t### NEXT PAGE - API\\n\\t\\t\\tif self.test_limit == None or self.page_count < self.test_limit :\\n\\n\\t\\t\\t\\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\\n\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse (API) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\\\n\\\".format(self.page_count) )\\n\\n\\t\\t\\t\\t\\t### get and go to next page\\n\\t\\t\\t\\t\\tself.page_count += 1\\n\\n\\t\\t\\t\\t\\turl_next = \\\"\\\"\\n\\t\\t\\t\\t\\tif self.api_pagination_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\turl_next = self.api_pagination_root\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\turl_next = self.page_url\\n\\n\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\tnext_page = url_next + str(self.page_count)\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse >>> NEXT PAGE II : %s\\\", next_page )\\n\\n\\t\\t\\t\\t\\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\\n\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} \\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\t\\t\\telse :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} \\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t### start requests with pure Scrapy requests\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\telif self.spider_config_flat[\\\"parse_reactive\\\"] == False :\\n\\t\\t# elif self.parse_reactive == False :\\n \\n\\t\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse / starting requests with Scrapy... \\\" )\\n\\t\\t\\t# self.parse_scrapy(response)\\n\\n\\t\\t\\t### find items list\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / self.item_xpath : %s\\\", self.item_xpath )\\n\\t\\t\\traw_items_list = response.xpath(self.item_xpath)\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / len(raw_items_list) : %d \\\", len(raw_items_list) )\\n\\n\\n\\t\\t\\t### - - - - - - - - - - - ###\\n\\t\\t\\t### PARSING PAGE - SCRAPY\\n\\t\\t\\t### start parsing page : loop through data items in page in response\\n\\t\\t\\tif len(raw_items_list) != 0 :\\n\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / START LOOPING raw_items_list WITH SCRAPY ...\\\" )\\n\\n\\t\\t\\t\\tfor raw_data in raw_items_list :\\n\\n\\t\\t\\t\\t\\tself.item_count += 1\\n\\n\\t\\t\\t\\t\\t### check if can continue depending on item_count\\n\\t\\t\\t\\t\\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\\n\\n\\t\\t\\t\\t\\t\\tprint()\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - Scrapy - item n°{} / page n°{} >>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\n\\t\\t\\t\\t\\t\\t# print \\\">>> raw_data : \\\\n\\\", raw_data.extract()\\n\\n\\t\\t\\t\\t\\t\\t### instantiate Item to fill from datamodel --> cf items.py\\n\\t\\t\\t\\t\\t\\titemclass \\t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\\n\\t\\t\\t\\t\\t\\titem \\t\\t= itemclass()\\n\\n\\t\\t\\t\\t\\t\\t### add global info to item : i.e. core fields in dm_core_item_related list\\n\\t\\t\\t\\t\\t\\titem[ 'spider_id' ]\\t\\t= self.spider_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_by' ]\\t\\t= self.user_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_at' ]\\t\\t= time.time()\\t\\t# timestamp\\n\\t\\t\\t\\t\\t\\titem[ 'link_src' ]\\t\\t= response._url\\n\\n\\t\\t\\t\\t\\t\\titem[ 'page_n' ]\\t\\t= self.page_count\\n\\t\\t\\t\\t\\t\\titem[ 'item_n' ]\\t\\t= self.item_count\\n\\n\\t\\t\\t\\t\\t\\t### extract data and feed it to the Item instance based on spider_config_flat\\n\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, item_n=self.item_count)\\n\\n\\n\\t\\t\\t\\t\\t\\t### - - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t\\t### FOLLOW LINK - SCRAPY\\n\\t\\t\\t\\t\\t\\t### if need to follow to extract all data\\n\\t\\t\\t\\t\\t\\tif self.spider_config_flat[\\\"parse_follow\\\"] == True :\\n\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> FOLLOW LINK - SCRAPY - item n°{} / page n°{} >>>>>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_xpath : %s\\\", self.follow_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\tfollow_link \\t= raw_data.xpath( self.follow_xpath ).extract_first()\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link RAW ({}) : {} \\\".format(type(follow_link),follow_link) )\\n\\n\\t\\t\\t\\t\\t\\t\\turl_follow = \\\"\\\"\\n\\t\\t\\t\\t\\t\\t\\tif self.api_follow_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.api_follow_root\\n\\n\\t\\t\\t\\t\\t\\t\\t# complete follow link if needed\\n\\t\\t\\t\\t\\t\\t\\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> follow_link CLEAN : %s \\\", follow_link )\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link CLEAN ({}) : {} \\\".format(type(follow_link),follow_link) )\\n\\n\\t\\t\\t\\t\\t\\t\\t# store follow_link\\n\\t\\t\\t\\t\\t\\t\\titem[ 'link_data' ]\\t= follow_link\\n\\t\\t\\t\\t\\t\\t\\turl \\t\\t\\t\\t= item['link_data']\\n\\n\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOWING LINK --> url : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\t# yield Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url } )\\n\\t\\t\\t\\t\\t\\t\\t\\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False} )\\n\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.warning(u\\\">>> FOLLOWING LINK --> url : {} / WORKED !!! \\\".format(url) )\\n\\n\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOW LINK - NOT WORKING : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t### if no follow link\\n\\t\\t\\t\\t\\t\\telse :\\n\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> NO FOLLOW LINK ... \\\" )\\n\\t\\t\\t\\t\\t\\t\\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\">>> GenericSpider.parse - item.items() : \\\\n %s\\\", item.items() )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\">>> GenericSpider.parse - item.keys() : \\\\n %s\\\", item.items() )\\n\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t# print (\\\"\\\\n>>> NEXT ITEM \\\" + \\\">>> >>> \\\"*10, \\\"\\\\n\\\")\\n\\n\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> item : \\\\n %s \\\\n\\\", pformat(item) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\" --> item ...\\\" )\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\\n\\n\\t\\t\\telse :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t# raise CloseSpider('OUT OF ITEMS')\\n\\n\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t### NEXT PAGE - SCRAPY\\n\\t\\t\\t### check if there is a test_limit\\n\\t\\t\\tif self.test_limit == None or self.page_count < self.test_limit :\\n\\n\\t\\t\\t\\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\\n\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse (Scrapy) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\\\n\\\".format(self.page_count) )\\n\\n\\t\\t\\t\\t\\t### get and go to next page\\n\\t\\t\\t\\t\\tis_next_page, next_page = self.get_next_page(response, start_url)\\n\\n\\t\\t\\t\\t\\tif is_next_page :\\n\\n\\t\\t\\t\\t\\t\\tself.page_count += 1\\n\\n\\t\\t\\t\\t\\t\\turl_next = \\\"\\\"\\n\\t\\t\\t\\t\\t\\tif self.api_pagination_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\turl_next = self.api_pagination_root\\n\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse >>> NEXT PAGE I : %s\\\", next_page )\\n\\t\\t\\t\\t\\t\\tnext_page = self.clean_link(next_page, url_root=url_next)\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse >>> NEXT PAGE II : %s\\\", next_page )\\n\\n\\t\\t\\t\\t\\t\\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / NO MORE PAGE TO SCRAP - pages count : {} \\\".format(self.page_count) )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('NO MORE PAGE TO SCRAP')\\n\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\t\\t\\telse :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t### start requests with Selenium\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\telse :\\n\\t\\t\\t### initiate selenium browser\\n\\t\\t\\t### cf : https://github.com/voliveirajr/seleniumcrawler/blob/master/seleniumcrawler/spiders/seleniumcrawler_spider.py\\n\\t\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse / starting Selenium driver... \\\" )\\n\\n\\t\\t\\t# retrieve exec path for chromedriver from settings_scrapy.py\\n\\t\\t\\t### GET APP MODE FROM ENV VARS\\n\\t\\t\\tapp_mode \\t\\t\\t\\t\\t\\t= os.environ.get('APP_MODE', 'default')\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider.parse / APP_MODE : %s\\\", app_mode)\\n\\t\\t\\tchromedriver_path \\t= CHROMEDRIVER_PATH_LIST[ app_mode ]\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider.parse / chromedriver_path : %s\\\", chromedriver_path)\\n\\n\\t\\t\\t### specify executable path to launch webdriver-->\\n\\t\\t\\t# cf : where chromedriver was installed when `brew install chromedriver`\\n\\t\\t\\tself.driver = webdriver.Chrome(executable_path=chromedriver_path, chrome_options=options_selenium)\\n\\t\\t\\t# self.driver = webdriver.Chrome(chrome_options=options_selenium)\\n\\t\\t\\t# self.driver = webdriver.Firefox()\\n\\t\\t\\t# self.driver = webdriver.Chrome()\\n\\t\\t\\t# self.driver = webdriver.PhantomJS() ### deprecated\\n\\n\\t\\t\\t### setup waiting times\\n\\t\\t\\t# self.driver.set_page_load_timeout(60)\\n\\t\\t\\tself.wait_driver\\t= WebDriverWait(self.driver, self.delay_driver)\\n\\t\\t\\tself.wait_page \\t\\t= WebDriverWait(self.driver, self.delay_new_page)\\n\\t\\t\\tself.driver.implicitly_wait(self.delay_implicit)\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / self.delay_driver : %s\\\", self.delay_driver )\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / self.delay_new_page : %s\\\", self.delay_new_page )\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / self.delay_implicit : %s\\\", self.delay_implicit )\\n\\n\\n\\t\\t\\t### start parsing with selenium\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / response._url : %s\\\", response._url )\\n\\t\\t\\ttry :\\n\\t\\t\\t\\tself.driver.get(response._url)\\n\\n\\t\\t\\t\\t### try scroll_down if needed in config\\n\\t\\t\\t\\tif self.spider_config_flat['scroll_down'] : \\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / scroll_down is TRUE ... \\\" )\\n\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericsSpider. / scroll_down - self.spider_config_flat : \\\\n%s\\\", pformat(self.spider_config_flat) )\\n\\n\\t\\t\\t\\t\\tscroll_pause_time = self.spider_config_flat[\\\"scroll_pause_time\\\"]\\n\\t\\t\\t\\t\\tmax_loops \\t\\t\\t\\t= self.spider_config_flat[\\\"scroll_loops\\\"]\\n\\t\\t\\t\\t\\tself.driver = scroll_down(self.driver, scroll_pause_time, max_loops)\\n\\t\\t\\t\\t\\t# scroll_down(self.driver, scroll_pause_time, max_loops)\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / url '{}' is loaded ... \\\".format( response._url ))\\n\\t\\t\\t\\n\\t\\t\\texcept :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\traise CloseSpider('DRIVER NOT RESPONDING')\\n\\n\\n\\t\\t\\t### clean original xpath from strings\\n\\t\\t\\tstrings_to_clean = [\\n\\t\\t\\t\\t'/@src',\\n\\t\\t\\t\\t'/@href',\\n\\t\\t\\t\\t'/text()',\\n\\t\\t\\t\\t'/@*[name()=\\\"xlink:href\\\"]',\\n\\t\\t\\t\\t'/@datetime'\\n\\t\\t\\t]\\n\\n\\t\\t\\t# while self.there_is_more_items_to_scrap :\\n\\t\\t\\twhile self.there_is_more_items_to_scrap_dict[start_url] :\\n\\n\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / while loop continues : %s\\\", self.there_is_more_items_to_scrap )\\n\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / while loop continues : %s\\\", self.there_is_more_items_to_scrap_dict[start_url] )\\n\\n\\t\\t\\t\\ttry :\\n\\n\\t\\t\\t\\t\\t### wait / debug page content\\n\\t\\t\\t\\t\\tpage_source_code = self.driver.page_source.encode(\\\"utf-8\\\")\\n\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / page_source_code : \\\\n %s \\\", page_source_code )\\n\\t\\t\\t\\t\\ttime.sleep(self.delay_new_page)\\n\\n\\t\\t\\t\\t\\t### start parsing page :\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.item_xpath : %s\\\", self.item_xpath )\\n\\t\\t\\t\\t\\traw_items_list \\t= self.driver.find_elements_by_xpath(self.item_xpath)\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / raw_items_list length : %s\\\", len(raw_items_list) )\\n\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / raw_items_list[0].text : \\\\n%s\\\", raw_items_list[0].text )\\n\\n\\t\\t\\t\\t\\t# current_item_index = 0\\n\\n\\t\\t\\t\\t\\t### - - - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t### PARSING PAGE - SELENIUM\\n\\t\\t\\t\\t\\t# loop through data items in page in response\\n\\t\\t\\t\\t\\tif len(raw_items_list) != 0 :\\n\\n\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / START PARSING WITH SELENIUM ...\\\\n\\\" )\\n\\n\\t\\t\\t\\t\\t\\tfor raw_data in raw_items_list :\\n\\n\\t\\t\\t\\t\\t\\t\\tprint()\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / START LOOPING raw_items_list WITH SELENIUM ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\t### add +1 to items count\\n\\t\\t\\t\\t\\t\\t\\tself.item_count += 1\\n\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} - there_is_more_items_to_scrap_dict[start_url] : {} \\\".format(str(self.spider_name), self.item_count, self.there_is_more_items_to_scrap_dict[start_url]) )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} \\\".format(self.spider_name, self.item_count) )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - item n°{} \\\".format(self.item_count) )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - spider_name : '%s' - item n°%s \\\" %(self.spider_name, self.item_count) )\\n\\n\\t\\t\\t\\t\\t\\t\\t### check if can continue depending on item_count\\n\\t\\t\\t\\t\\t\\t\\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - Selenium - item n°{} / page n°{} >>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### instantiate Item to fill from datamodel --> cf items.py\\n\\t\\t\\t\\t\\t\\t\\t\\titemclass \\t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\\n\\t\\t\\t\\t\\t\\t\\t\\titem \\t\\t= itemclass()\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### add global info to item : i.e. core fields in dm_core_item_related list\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'spider_id' ]\\t\\t= self.spider_id\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'added_by' ]\\t\\t= self.user_id\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'added_at' ]\\t\\t= time.time()\\t\\t# timestamp\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'link_src' ]\\t\\t= response._url\\n\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'page_n' ]\\t\\t= self.page_count\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'item_n' ]\\t\\t= self.item_count\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### extract data and feed it to the Item instance based on spider_config_flat\\n\\t\\t\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t\\t\\t\\t### FOLLOW LINK - SELENIUM\\n\\t\\t\\t\\t\\t\\t\\t\\t### find follow link to open detailled item view\\n\\t\\t\\t\\t\\t\\t\\t\\tif self.spider_config_flat[\\\"parse_follow\\\"] == True :\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> FOLLOW LINK - SELENIUM - item n°{} / page n°{} >>>>>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_xpath : %s\\\", self.follow_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t### follow link with Scrapy\\n\\t\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / follow link with Scrapy ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / get href of follow_link ...\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link_xpath \\t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link_xpath : %s \\\", follow_link_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link\\t\\t\\t= raw_data.find_element_by_xpath( follow_link_xpath ).get_attribute('href')\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link RAW : %s \\\", follow_link )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\turl_follow = \\\"\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tif self.api_follow_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.api_follow_root\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# complete follow link if needed\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link CLEAN ({}) : {}\\\".format(type(follow_link), follow_link ) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# store follow_link\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\titem[ 'link_data' ]\\t= follow_link\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\turl\\t\\t\\t= item['link_data']\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOWING LINK --> url : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False})\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOW LINK - NOT WORKING : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t### follow link with Selenium\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t### FIND A WEBSITE TEST FOR REACTIVE DETAILLED PAGES\\n\\t\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / follow link with Selenium ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link_xpath \\t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_link_xpath : %s\\\", self.follow_link_xpath )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link \\t\\t= raw_data.find_element_by_xpath( follow_link_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### open link in new tab ?\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link.click()\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### get data and save data\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / get data and save data ...\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### back to previous page and scrap from where it left\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### cf : https://selenium-python.readthedocs.io/navigating.html#navigation-history-and-location\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tself.driver.back()\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### if no follow link\\n\\t\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> item : \\\\n %s \\\\n\\\", pformat(item) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\" --> item ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\traise CloseSpider('OUT OF LIMIT_ITEMS')\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF ITEMS - page n°{} - limit : {} - test_limit : {} / except -> break\\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\t### - - - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t### NEXT PAGE - SELENIUM\\n\\t\\t\\t\\t\\tif self.test_limit == None or self.page_count < self.test_limit :\\n\\n\\t\\t\\t\\t\\t\\tif self.there_is_more_items_to_scrap_dict[start_url] :\\n\\n\\t\\t\\t\\t\\t\\t\\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tprint ()\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --- GenericSpider.parse (Selenium) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\\\n\\\".format(self.page_count) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### add +1 to parsed pages\\n\\t\\t\\t\\t\\t\\t\\t\\tself.page_count += 1\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - current start_url : {} >>>\\\".format(start_url) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### find next page btn in current view\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.next_page : %s\\\", self.next_page )\\n\\t\\t\\t\\t\\t\\t\\t\\tnext_page_xpath = clean_xpath_for_reactive(self.next_page, strings_to_clean)\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page_xpath : %s\\\", next_page_xpath )\\n\\t\\t\\t\\t\\t\\t\\t\\t# next_page \\t= re.sub(\\\"|\\\".join(strings_to_clean), \\\"\\\", next_page )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# try :\\n\\t\\t\\t\\t\\t\\t\\t\\t# element_present = EC.presence_of_element_located((By.XPATH, next_page_xpath ))\\n\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / next_page present : %s\\\", element_present )\\n\\t\\t\\t\\t\\t\\t\\t\\t# self.wait.until(element_present)\\n\\t\\t\\t\\t\\t\\t\\t\\t# next_page = self.wait.until( EC.element_to_be_clickable(element_present) )\\n\\t\\t\\t\\t\\t\\t\\t\\t# next_page \\t\\t= self.driver.find_element_by_xpath( next_page_xpath )\\n\\t\\t\\t\\t\\t\\t\\t\\tnext_page \\t\\t= self.driver.find_element(By.XPATH, next_page_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page : %s\\\", next_page )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page.text : %s\\\", next_page.text )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# except TimeoutException:\\n\\t\\t\\t\\t\\t\\t\\t\\t# except :\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\tlog_scrap.error(\\\"--- GenericSpider. / Timed out waiting for page to load\\\")\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### click next button and wait for ajax calls to complete (post and get)\\n\\t\\t\\t\\t\\t\\t\\t\\t### cf : http://www.obeythetestinggoat.com/how-to-get-selenium-to-wait-for-page-load-after-a-click.html\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# def wait_for(condition_function):\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\tstart_time = time.time()\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\twhile time.time() < start_time + 3:\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\tif condition_function():\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\t\\treturn True\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\t\\ttime.sleep(0.1)\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\traise Exception ('Timeout waiting for {}'.format(condition_function.__name__) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# def link_has_gone_stale():\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\ttry:\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\t# poll the link with an arbitrary call\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\tnext_page.find_elements_by_xpath(self.item_xpath)\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\treturn False\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\texcept StaleElementReferenceException :\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\treturn True\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- ... ---\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page.click() \\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnext_page.click()\\n\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / next_page.send_keys( \\\\ n )\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# next_page.send_keys(\\\"\\\\n\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# added this step for compatibility of scrolling to the view\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.error(\\\"--- GenericSpider. / ALTERNATIVE next_page.click() \\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# self.driver.execute_script(\\\"return arguments[0].scrollIntoView();\\\", next_page)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# next_page.click()\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.driver.execute_script(\\\"arguments[0].click();\\\", next_page)\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### wait after click\\n\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / wait for ajax to finish... \\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# wait_for(link_has_gone_stale)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.wait_page.until(lambda driver: self.driver.execute_script('return jQuery.active') == 0)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.wait_page.until(lambda driver: self.driver.execute_script('return document.readyState') == 'complete')\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# time.sleep(self.delay_implicit)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\ttime.sleep(self.delay_new_page)\\n\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.error(\\\"--- GenericSpider. / !!! FAIL / wait for ajax to finish... \\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF PAGES TO SCRAP - page n°{} / except -> break\\\".format(self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\t\\t\\traise CloseSpider('OUT OF PAGES TO SCRAP')\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / NO MORE ITEMS TO SCRAP - item_count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\traise CloseSpider('NO MORE ITEMS TO SCRAP')\\n\\t\\t\\t\\t\\tbreak\",\n \"def parse_item(self, response):\\n NewhouseSpider.crawled_urls.append(response.url)\\n item = FocusedScrapyCrawlerItem()\\n item['url'] = response.url\\n item['link_text'] = response.meta.get('link_text', '') if response.meta else ''\\n soup = BeautifulSoup(response.body, 'html.parser')\\n\\n item['body_p_tags'] = self._getBodyText(soup)\\n item['head_title'] = self._getHeadTitle(soup)\\n item['last_crawled'] = time.time()\\n links = self._getLinks(response, soup)\\n\\n # get score of the page based upon classifier\\n if self.classifier:\\n score = self.classifier.score(item['link_text'], item['head_title'], item['body_p_tags'])\\n else:\\n score = 0.0\\n\\n item['score'] = score\\n yield item\\n if score <= 0:\\n self.log(\\\"item={} does not belong to new home so stop crawling\\\".format(item),\\n logging.INFO)\\n else:\\n for link in links:\\n req = Request(link, priority=int(score * 1000000), # after the request is done, run parse_item to train the apprentice\\n callback=self.parse_item)\\n yield req\",\n \"def generate_crawler(self):\\n \\n targets = ['https://community.upwork.com/t5/Announcements/bd-p/news', \\\\\\n 'https://community.upwork.com/t5/Freelancers/bd-p/freelancers', \\\\\\n 'https://community.upwork.com/t5/Clients/bd-p/clients', \\\\\\n 'https://community.upwork.com/t5/Agencies/bd-p/Agencies']\\n target = None\\n for tar in targets:\\n if tar in sys.argv:\\n target = tar\\n\\n #Regenerate crawler object depending on params\\n if target is None:\\n if '-d' in sys.argv:\\n crawler = Crawler(self.webdriver, self.db, debug=True)\\n else:\\n crawler = Crawler(self.webdriver, self.db)\\n else:\\n if '-d' in sys.argv:\\n crawler = Crawler(self.webdriver, self.db, debug=True, link=target)\\n else:\\n crawler = Crawler(self.webdriver, self.db, link=target)\\n\\n return crawler\",\n \"def scrap_keywords():\\n ParScr = ParallelScraper()\\n ParScr.create_and_run_threads()\\n return\",\n \"def scrap_site(link):\\n pass # Scrapy or BeautifulSoup\",\n \"def parse(self, response):\\n content = response.body\\n if not content:\\n return\\n sel = Selector(response)\\n #print sel.xpath('//table[@class=\\\"board-list tiz\\\"]/tr').extract()\\n for job in sel.xpath('//ul[@class=\\\"sojob-list\\\"]/li'):\\n #print 'd',job\\n info = job.xpath('div[@class=\\\"sojob-item-main clearfix\\\"]/div[@class=\\\"job-info\\\"]')\\n com_info = job.xpath('div[@class=\\\"sojob-item-main clearfix\\\"]/div[@class=\\\"company-info nohover\\\"]')\\n title = info.xpath('h3/a/text()').extract_first().lower()\\n if title.find('python') != -1:\\n url = info.xpath('h3/a/@href').extract_first()\\n request = scrapy.Request(url=url,\\n callback=self.parse_items,\\n headers=self.spider.headers,\\n cookies=self.cookies)\\n company_item, job_item = CompanyItem(), JobItem()\\n company_item['name'] = com_info.xpath('p[@class=\\\"company-name\\\"]/a/text()').extract_first()\\n company_item['homepage'] = com_info.xpath('p[@class=\\\"company-name\\\"]/a/@href').extract_first()\\n job_item['pub_time'] = info.xpath('p[@class=\\\"time-info clearfix\\\"]/time/text()').extract_first()\\n year = str(date.today().year)\\n if str(year) not in job_item['pub_time']:\\n if job_item['pub_time'] == u'昨天':\\n job_item['pub_time'] = (date.today()-timedelta(days=1)).strftime(\\\"%Y-%m-%d\\\")\\n elif job_item['pub_time'] == u'前天':\\n job_item['pub_time'] = (date.today() - timedelta(days=2)).strftime(\\\"%Y-%m-%d\\\")\\n else:\\n job_item['pub_time'] = date.today().strftime(\\\"%Y-%m-%d\\\")\\n job_item['title'] = title\\n job_item['welfare'] = ' '.join(com_info.xpath('p[@class=\\\"temptation clearfix\\\"]/span/text()').extract())\\n job_item['salary'] = info.xpath('p[@class=\\\"condition clearfix\\\"]/span[@class=\\\"text-warning\\\"]/text()').extract_first()\\n request.meta['company_item'] = company_item\\n request.meta['job_item'] = job_item\\n yield request\",\n \"def scrape(location='', *args, **kwargs):\\n if not location:\\n location = Courses.location\\n\\n logger = setup_logging()\\n\\n logger.info('Starting Courses scrape')\\n queue = Queue()\\n\\n for _ in Courses.LETTERS:\\n course_worker = CourseWorker(queue, location)\\n course_worker.daemon = True\\n course_worker.start()\\n\\n for letter in Courses.LETTERS:\\n queue.put(letter)\\n\\n queue.join()\\n logger.info('Completed Courses scrape')\",\n \"def scrape(self):\\n pass\",\n \"def crawlSite(siteUrl, siteName):\\n\\n\\t#add the site to crawl & resources list. Also get the site name\\n\\tvariables.crawlFrontier = [siteUrl]\\n\\tvariables.resources = [siteUrl]\\n\\n\\t#scan the site's home page\\n\\tscanPage(siteUrl, siteName)\\n\\n\\t#repeatedly scan all the pages in crawlFrontier\\n\\tposLink = 1\\t\\t#at 0th index is the site's home page\\n\\n\\twhile posLink < len(variables.crawlFrontier):\\n\\t\\tprint('url=',variables.crawlFrontier[posLink])\\n\\n\\t\\turl = variables.crawlFrontier[posLink]\\n\\t\\tscanPage(url, siteName)\\n\\n\\t\\tposLink += 1\",\n \"def run(self):\\n print(\\\"INFO: start crawling comic, \\\" + self.comicSource.getComicName())\\n\\n if not self.onlyGetCurVol:\\n pageNotFoundCounter = 0\\n while self.comicSource.isCrawlAtEnd() == False:\\n print(\\\"INFO: crawling volume \\\" + str(self.volumeNum) + \\\"...\\\")\\n\\n if self.comicSource.crawler(self.volumeNum, self.downloadDir) == False:\\n pageNotFoundCounter += 1\\n else:\\n pageNotFoundCounter = 0\\n\\n if pageNotFoundCounter >= 400:\\n print(\\\"ERROR: comic \\\" + self.comicSource.getComicName() + \\\" not found, exit\\\")\\n break\\n\\n self.volumeNum += 1\\n else:\\n print(\\\"INFO: crawling volume \\\" + str(self.volumeNum) + \\\"...\\\")\\n self.comicSource.crawl(self.volumeNum)\\n\\n print(\\\"INFO: retrieve comic\\\" + self.comicSource.getComicName() + \\\" end!\\\")\\n self.comicSource.quit()\",\n \"def __init__(self, urls_file_, file_spider_='no', target_format_='', ignored_links_file_='',\\n allow_clean_url_='no', time_out_=60, work_path_='./',\\n max_recursion_depth_=0, one_bite_='no', white_list_path_=\\\"\\\"):\\n self.__urls = Crawler.__read_file(urls_file_)\\n self.__file_spider = file_spider_\\n self.__target_format = target_format_\\n self.__allow_clean_url = allow_clean_url_\\n self.__one_bite = one_bite_\\n self.__white_list_path = white_list_path_\\n self.__white_list = []\\n\\n # loads white list in beginning in case an argument was passed for it\\n if self.__file_spider == 'yes' and self.__white_list_path != '':\\n self.__white_list = Crawler.__read_white_list(self.__white_list_path)\\n\\n # link titles that should be ignored during recursions\\n self.__ignored_links = Crawler.__read_file(ignored_links_file_)\\n\\n self.__time_out = time_out_\\n self.__work_path = os.path.join(work_path_.rstrip('/')+'/', 'DATA')\\n self.__recursion_max_depth = max_recursion_depth_\\n self.__extensions = ['txt', 'html', 'csv', 'tsv', 'tar', 'raw']\\n\\n logging.info('''Crawler Has been Initialized With The Below Configurations:\\n-------------------------------------------------------------------\\n-urls: %s\\n-file_spider: %s\\n-target_format: %s\\n-ignored_links_file: %s\\n-allow_clean_url: %s\\n-time_out: %s\\n-work_path: %s\\n-max_recursion_depth: %s\\n-one_bite: %s\\n-white_list_path: %s\\n''', self.__urls, self.__file_spider, self.__target_format, self.__ignored_links,\\n self.__allow_clean_url, self.__time_out, self.__work_path,\\n self.__recursion_max_depth, self.__one_bite, self.__white_list_path)\",\n \"def setup_crawler(self, crawlers: List[BaseCrawler]) -> None:\\n self.tasks.extend(crawlers)\",\n \"def threaded_crawler(seed_url, delay=5, cache=None, scrape_callback=None, proxies=None, num_retries=1, max_threads=10):\\n crawl_queue = MongoQueue(timeout=30)\\n crawl_queue.clear()\\n crawl_queue.push(seed_url)\\n D = Downloader(\\n cache=cache,\\n delay=delay,\\n proxies=proxies,\\n num_retries=num_retries\\n )\\n\\n def process_queue():\\n while True:\\n try:\\n url = crawl_queue.pop()\\n # print(url)\\n except KeyError:\\n # crawl queue is empty\\n break\\n else:\\n html = D(url)\\n if scrape_callback:\\n try:\\n links = scrape_callback(url, html) or []\\n crawl_queue.complete(url)\\n except Exception as e:\\n print('Error in callback for: {}: {}'.format(url, e))\\n\\n # wait for all download threads to finish\\n threads = []\\n while threads or crawl_queue:\\n # the crawl is still active\\n for thread in threads:\\n if not thread.is_alive():\\n # remove the stopped threads\\n threads.remove(thread)\\n while len(threads) < max_threads and crawl_queue:\\n # can start some more threads\\n thread = threading.Thread(target=process_queue)\\n thread.setDaemon(True) # set daemon so main thread can exit when receives ctrl-c\\n thread.start()\\n threads.append(thread)\\n # all threads have been processed\\n # sleep temporarily so CPU can focus execution on other threads\\n time.sleep(SLEEP_TIME)\",\n \"def crawl_page(self, keyword, since=None, to=None, page=None):\\n data = self.get_news(keyword, since, to, page)\\n print(current_process())\\n print('crawling page no.: ' + str(page))\\n urls = self.get_urls(data)\\n p = Process()\\n p.start(urls)\",\n \"def genspider(ctx, name, agency_name, start_urls):\\n start_urls = start_urls.split(',')\\n domains = _get_domains(start_urls)\\n _gen_spider(name, agency_name, domains, start_urls)\\n _gen_tests(name)\\n _gen_html(name, start_urls)\",\n \"def parse(self, response):\\n page_source = self.upwork_controller.get_source_home()\\n\\n # Hand-off between Selenium and Scrapy happens here\\n sel = Selector(text=page_source)\\n # Extract data\\n sections = sel.xpath(\\\"//section/div\\\")\\n\\n for section in sections:\\n selector = Selector(text=section.get())\\n jobtitle = selector.xpath(\\\"//div/div/div/h4/a/text()\\\")\\n jobdescription = selector.xpath(\\\"//div/div/div/div/div/div/div/span/span/text()\\\")\\n hourlypay = selector.xpath(\\\"//div/div/div/div/small/span/strong/text()\\\")\\n proposals = selector.xpath(\\\"//div/div/div/div/div/span/small/strong/text()\\\")\\n country = selector.xpath(\\\"//div/div/div/div/small/span/span/span/span/strong[@class='text-muted client-location ng-binding']/text()\\\")\\n\\n job = Job(jobtitle=jobtitle.get(),\\n jobdescription=jobdescription.get(),\\n hourlypay=hourlypay.get(),\\n proposals=proposals.get(),\\n country=country.get())\\n job.serialize()\\n yield job.dict()\",\n \"def parse_inner_urls(self, response):\\n s = Selector(response)\\n\\n jobs_per_site = s.xpath('//div[@class=\\\"col-lg-12 col-md-12 col-sm-12 aggelia-view-title\\\"]//a/@href').extract()\\n print(jobs_per_site)\\n\\n for inner_site in jobs_per_site:\\n url = urljoin(\\\"https://www.skywalker.gr/\\\", inner_site)\\n yield scrapy.Request(url, callback=self.parse_items)\",\n \"def scrape(site=''):\\n scraper.scrape(get_site_config(site))\",\n \"def continue_crawl(d, runner, begin_time, hour_limit):\\n end_time = datetime.now()\\n\\n # Convert elapsed time to seconds\\n elapsed_time = end_time - begin_time\\n elapsed_time_seconds = elapsed_time.days * 86400\\n elapsed_time_seconds += elapsed_time.seconds\\n\\n if elapsed_time_seconds < hour_limit:\\n wait_time = hour_limit - elapsed_time_seconds\\n # print(\\\"Waiting for {0} seconds\\\".format(wait_time))\\n time.sleep(wait_time)\\n\\n d = runner.crawl(\\\"sb_spider\\\")\\n\\n # end_time is the new \\\"start\\\" time for this iteration of the spider.\\n # Pass it in as the 3rd argument.\\n d.addBoth(lambda _: continue_crawl(d, runner, end_time, hour_limit))\",\n \"def crawler():\\n job_entries = []\\n for job in job_info(URL):\\n labels = \\\"\\\"\\n if job[\\\"labels\\\"]:\\n for label in job[\\\"labels\\\"]:\\n labels += label[\\\"name\\\"]\\n if job[\\\"labels\\\"].index(label) != len(job[\\\"labels\\\"]) - 1:\\n labels += \\\",\\\"\\n job_entries.append((job[\\\"number\\\"], job[\\\"id\\\"],\\n job[\\\"title\\\"], job[\\\"html_url\\\"], labels))\\n\\n conn = sqlite3.connect('jobber/jobber.db')\\n c = conn.cursor()\\n c.executemany(('INSERT OR IGNORE INTO job_entries '\\n 'VALUES (?,?,?,?,?)'), job_entries)\\n conn.commit()\\n conn.close()\",\n \"def __init__(self, *args, **kwargs):\\n super(AlibabaCompanySpider, self).__init__(*args, **kwargs)\",\n \"def run(self):\\n\\n # The url is too deep, skip the url.. Work is done!\\n if self.depth_ > self.depth:\\n return\\n\\n # Get doc id corresponds to the url. Add a new entry into doc index if there is no entry.\\n doc_id = self.crawler.document_id(self.curr_url)\\n\\n # Check if the doc_id has been visited/processed by any of crawler_threads. Add doc_id to seen if not so.\\n if self.crawler.checkDocVisitedAndUpdate(doc_id):\\n return\\n\\n # Process the document corresponds to the url\\n socket = None\\n try:\\n socket = urllib2.urlopen(self.curr_url, timeout=self.timeout)\\n soup = BeautifulSoup(socket.read())\\n self._curr_depth = self.depth_ + 1\\n self._curr_doc_id = doc_id\\n # Traverse the document as deep as possible and add those newly discovered urls into url queue\\n self._index_document(soup)\\n # Store (wordId, docId) and (word, url) into inverted_index and resolved_inverted_index respectively.\\n self.crawler._add_words_to_document(self._curr_words, self._curr_doc_id)\\n except:\\n pass\\n finally:\\n if socket:\\n socket.close()\",\n \"def single_crawl(self, urlitem: str):\\n # print(\\\"Item: \\\", urlitem)\\n try:\\n hdr = {\\n \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36 \\\",\\n \\\"Accept\\\": \\\"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\\\",\\n \\\"Accept-Charset\\\": \\\"ISO-8859-1,utf-8;q=0.7,*;q=0.3\\\",\\n \\\"Accept-Encoding\\\": \\\"none\\\",\\n \\\"Accept-Language\\\": \\\"en-US,en;q=0.8\\\",\\n \\\"Connection\\\": \\\"keep-alive\\\",\\n }\\n try:\\n req = Request(urlitem, headers=hdr)\\n html_page = urlopen(req)\\n soup = BeautifulSoup(html_page, \\\"lxml\\\")\\n links = [\\n requests.compat.urljoin(urlitem, link.get(\\\"href\\\"))\\n for link in soup.findAll(\\\"a\\\")\\n ]\\n links = [x for x in links if \\\"#\\\" not in x]\\n except Exception as e:\\n # print(e)\\n pass\\n return links\\n\\n except:\\n pass\",\n \"def crawl(self, query, start_date, end_date, *args, **kwargs):\\n pass\",\n \"def __init__(self, board='Gossiping', pages=1, file='tmp.json', title_lim=[], jsonf=None, copy_data=[], simple_mode=True):\\n if copy_data:\\n self.extend(copy_data)\\n return\\n os.chdir(os.path.split(os.path.realpath(__file__))[0])\\n print(os.getcwd())\\n com = 'scrapy crawl ptt ' if not simple_mode else 'scrapy crawl ptt_url '\\n # output json file name\\n com += '-o %s ' % (file)\\n # page\\n com += '-a pages=%d ' % (pages)\\n # board\\n com += '-a board=%s ' % (board)\\n\\n # title limit\\n if title_lim:\\n com += '-a title_lim=\\\"'\\n for lim in title_lim:\\n com += \\\"%s,\\\" % (str(lim))\\n com += '\\\" '\\n # not opened by json_file\\n if not jsonf:\\n # start crawl\\n print('Command: ' + com)\\n os.system('rm -f {}'.format(file))\\n os.system('{}'.format(com))\\n # opened by json file\\n else:\\n file = jsonf\\n\\n # all data save in self\\n self.load_json(file)\\n self.com = com\\n self.file = file\",\n \"def scrape_pipeline(args):\\n kickoff = args.kickoff\\n fname = args.fname\\n d = DbHelper()\\n s = Scraper()\\n c = Crawler(20)\\n if fname is not None:\\n app_names = pd.read_csv(fname)['packageName'].tolist()\\n apps = [list(a) for a in zip(app_names, d.app_names_to_uuids(app_names))]\\n else:\\n apps = None\\n\\n # start by updating top apps\\n if not args.skip_top:\\n logger.info(\\\"getting top apps...\\\")\\n new_top_list = c.get_top_apps_list()\\n logger.info(\\\"scraping top apps not in DB...\\\")\\n s.scrape_missing(new_top_list, compare_top=True)\\n logger.info(\\\"updating top apps...\\\")\\n d.update_top_apps(new_top_list)\\n\\n if kickoff == True:\\n s = None\\n if fname is None:\\n # use crawler to get list of package names\\n logger.error(\\\"Crawler for package names not implemented yet\\\")\\n return\\n else:\\n # use specified file of package names\\n s = Scraper(input_file=fname)\\n\\n # use scraper\\n logger.info(\\\"Starting efficient scrape...\\\")\\n s.efficient_scrape()\\n logger.info(\\\"...efficient scrape done\\\")\\n else:\\n # use updater\\n logger.info(\\\"Starting updater...\\\")\\n if fname is None:\\n u = Updater()\\n else:\\n u = Updater(input_file=fname)\\n u.update_apps()\\n logger.info(\\\"...update done\\\")\\n\\n # crawl privacy policies\\n c.crawl_app_privacy_policies(app_list=apps)\\n\\n if args.no_decompile:\\n # download only\\n logger.info(\\\"Starting download...\\\")\\n downloader = Downloader()\\n if apps is None:\\n downloader.download_all_from_db(top=True)\\n else:\\n downloader.download(apps)\\n logger.info(\\\"...done\\\")\\n else:\\n # download/decompile\\n logger.info(\\\"Starting download and decompile...\\\")\\n download_decompile_all()\\n logger.info(\\\"...download and decompile done\\\")\\n logger.info(\\\"run analysis pipeline now\\\")\",\n \"def parse(self, response):\\n content_type = self.get_content_type(response.headers)\\n\\n sitescan = response.meta.get('sitescan')\\n\\n if 'text/html' not in self.get_content_type(response.headers):\\n\\n # For linked content, find the urlscan it linked from\\n urlscan = model.URLScan.objects.get(\\n site_scan=sitescan,\\n page_url_hash=sha256(response.meta['referrer']).hexdigest())\\n else:\\n # Only create urlscans for text/html\\n urlscan, us_created = model.URLScan.objects.get_or_create(\\n\\n site_scan=sitescan,\\n page_url_hash=sha256(response.url).hexdigest(),\\n defaults={'page_url': response.url,\\n 'timestamp': self.get_now_time()})\\n\\n # Continue crawling\\n # Parse stylesheet links, scripts, and hyperlinks\\n hxs = HtmlXPathSelector(response)\\n\\n # Extract other target links\\n try:\\n css_links = hxs.select('//link/@href').extract()\\n except TypeError:\\n css_links = []\\n\\n try:\\n js_links = hxs.select('//script/@src').extract()\\n except TypeError:\\n js_links = []\\n\\n try:\\n hyperlinks = hxs.select('//a/@href').extract()\\n except TypeError:\\n hyperlinks = []\\n\\n # Using a set removes duplicate links.\\n all_links = set(hyperlinks + js_links + css_links)\\n\\n # Examine links, yield requests if they are valid\\n for url in all_links:\\n\\n if not url.startswith('http://'):\\n # ensure that links are to real sites\\n if url.startswith('javascript:'):\\n continue\\n else:\\n url = urljoin(response.url, url)\\n\\n ua = response.meta['user_agent']\\n\\n request = Request(url)\\n request.headers.setdefault('User-Agent', ua.ua_string)\\n request.meta['referrer'] = response.url\\n request.meta['sitescan'] = sitescan\\n request.meta['user_agent'] = ua\\n request.meta['content_type'] = None\\n\\n yield request\\n\\n # The response contains a user agent, we should yield an item\\n item = MarkupItem()\\n item['content_type'] = self.get_content_type(response.headers)\\n item['filename'] = os.path.basename(urlparse(response.url).path)\\n item['headers'] = unicode(response.headers)\\n item['meta'] = response.meta\\n item['raw_content'] = response.body\\n item['sitescan'] = sitescan\\n item['urlscan'] = urlscan\\n item['url'] = response.url\\n item['user_agent'] = response.meta.get('user_agent')\\n item['redirected_from'] = response.meta.get('redirected_from',\\n u'')\\n yield item\",\n \"def kickoff(self):\\n settings = Settings()\\n\\n # settings.set(\\\"USER_AGENT\\\", \\\"Test\\\")\\n settings.set('JOBDIR', self.args.data_dir)\\n self.spider = MavenDataSpider()\\n\\n # Wrap with crawler, configure\\n crawler = Crawler(self.spider, settings)\\n crawler.signals.connect(spider_closing, signal=signals.spider_closed)\\n\\n logger.info('Starting crawler')\\n crawler.crawl(self.spider, app=self, dbsess=self.session)\\n\\n self.spider = crawler.spider\\n self.spider.link_queue_mode = False\\n if self.args.debug:\\n coloredlogs.install(level=logging.DEBUG)\\n\\n # Keeping thread working\\n reactor.run()\",\n \"def start_requests(self):\\n url = self.start_urls[0]\\n yield scrapy.Request(url=url, callback=self.parse)\",\n \"def run(self):\\n print \\\"CAlled run in querythread\\\"\\n #global config.mqchannel\\n self.qstatus = \\\"Running\\\"\\n start = time.clock()\\n \\n self.crawl_async_result = crawl.apply_async(args=[self.start_url, self.max_depth, self.parser], serializer=\\\"json\\\")\\n while not self.crawl_async_result.ready():\\n time.sleep(0)\\n \\n # self.crawl_async_result is a list of { URLs, links, htmls } to be parsed\\n \\n self.crawlstatus = \\\"Done\\\"\\n self.elapsed = (time.clock() - start)\\n print \\\"Crawl Done\\\"\\n print json.dumps(self.crawl_async_result.result, indent=4)\\n \\n self.__insert_into_db(self.crawl_async_result.result)\\n content = json.dumps({\\\"query_id\\\":self.qid, \\\"message\\\":\\\"done\\\", \\\"dbkey\\\":str(self.dbkey), \\\"time\\\":self.elapsed});\\n config.mqchannel.basic_publish(exchange=config.get(\\\"MQEXCHANGE\\\"), routing_key='', body=content)\",\n \"def __init__(self, config, processors):\\n source = HackernewsStories()\\n source.configure(config)\\n\\n super(HackernewsCrawlJob, self).__init__(source, processors)\",\n \"def from_crawler(cls, crawler, *args, **kwargs):\\n pipeline = cls()\\n crawler.signals.connect(pipeline.handle_list_of_items, signal=signals.spider_idle)\\n return pipeline\",\n \"def start_requests(self):\\n\\n with open(os.path.join(os.path.dirname(__file__), \\\"../resources/mapemall_categories.csv\\\")) as categories:\\n for category in csv.DictReader(categories):\\n category_text=category[\\\"category\\\"]\\n url=str(MapemallCrawlerSpider.start_urls[0])+category_text\\n # The meta is used to send our search text into the parser as metadata\\n yield scrapy.Request(url, callback = self.parse, meta = {\\\"category_text\\\": category_text})\",\n \"def iter_spider_classes(module):\\n ...\",\n \"def main(call_args):\\n\\n args = parse_args(call_args)\\n init_logging(args.loglevel)\\n\\n _log.info(\\\"'scrape-jobs' called with args: %s\\\", args)\\n runner.run_with_config_file(args.site, args.config_file)\",\n \"def next_spider(self, spider):\\n for spidercls, urls, isdata in self.nextnodes:\\n if self.spider_name(spider) == self.spider_name(spidercls):\\n if isinstance(spidercls, (str, unicode,)):\\n if '.' in spidercls:\\n modulestr, classtr = spidercls.rsplit('.', 1)\\n else:\\n modulestr, classtr = self.__class__.__module__, spidercls\\n spidercls = getattr(__import__(modulestr),classtr)\\n return spidercls, urls, isdata\\n \\n raise ValueError(\\\"The spider of {0} not in nextnodes of spidernode {1}\\\".format(\\n self.spider_name(spider), self.__class__.__name__))\",\n \"def __init__(self):\\n self.gdc = GdocsCrawler()\",\n \"def crawler(self):\\n\\n\\t\\tfor page in range(self.first_page, self.last_page+1):\\n\\t\\t\\tprint(\\\"\\\\nCrawling Page \\\" + str(page))\\n\\t\\t\\tpage_url = self.site_url + \\\"?page=\\\" + str(page) +\\\\\\n\\t\\t\\t \\\"&index=prod_all_products_term_optimization\\\"\\n\\t\\t\\t\\n\\t\\t\\tself.scrape_features(page_url)\",\n \"def _genspider(self, module, name, domain, template_name, template_file):\\n tvars = {\\n 'project_name': settings.get('BOT_NAME'),\\n 'ProjectName': string_camelcase(settings.get('BOT_NAME')),\\n 'module': module,\\n 'name': name,\\n 'domain': domain,\\n 'classname': '%sSpider' % ''.join([s.capitalize() \\\\\\n for s in module.split('_')])\\n }\\n\\n spiders_module = __import__(settings['NEWSPIDER_MODULE'], {}, {}, [''])\\n spiders_dir = abspath(dirname(spiders_module.__file__))\\n spider_file = \\\"%s.py\\\" % join(spiders_dir, module)\\n\\n shutil.copyfile(template_file, spider_file)\\n render_templatefile(spider_file, **tvars)\\n print \\\"Created spider %r using template %r in module:\\\" % (name, \\\\\\n template_name)\\n print \\\" %s.%s\\\" % (spiders_module.__name__, module)\",\n \"def genspider(ctx, name, domain):\\n spider_filename = _gen_spider(name, domain)\\n print('Created {0}'.format(spider_filename))\\n\\n test_filename = _gen_tests(name, domain)\\n print('Created {0}'.format(test_filename))\",\n \"def run(self):\\n if self.is_full():\\n return\\n for crawler in self.crawlers:\\n logger.info(f'crawler {crawler} to get proxy')\\n proxies = crawler.run()\\n if proxies:\\n for proxy in proxies:\\n self.redis.add(proxy)\\n logger.info(f'crawled {len(proxies)} proxies from {crawler}')\\n else:\\n logger.info(f'cannot crawl proxies from {crawler}')\",\n \"def open_spider(self, spider):\\n now = spider.get_now_time()\\n\\n # Create initial batch\\n spider.batch = model.Batch.objects.create(\\n kickoff_time=now, finish_time=now)\\n spider.batch.save()\\n\\n # save initial site list\\n file_content = ContentFile('\\\\n'.join(spider.start_urls))\\n filename = str(spider.batch).replace(' ', '')\\n spider.batch.sitelist.save(filename, file_content)\\n spider.batch.sitelist.close()\\n spider.batch.save()\\n\\n spider.batch_user_agents = []\\n\\n # Give the spider a set of batch user agents, which preserve historical\\n # user agent data\\n for ua in list(model.UserAgent.objects.all()):\\n batch_user_agent = model.BatchUserAgent.objects.create(\\n batch=spider.batch,\\n ua_string=ua.ua_string,\\n primary_ua=ua.primary_ua,\\n ua_type=ua.ua_type,\\n ua_human_name=ua.ua_human_name\\n )\\n spider.batch_user_agents.append(batch_user_agent)\\n\\n if not spider.batch_user_agents:\\n raise ValueError(\\n \\\"No user agents; add some with 'manage.py useragents --add'\\\")\",\n \"def distribute(self, page):\\n self.crawl_page(self.keyword, self.since, self.to, page)\",\n \"def __init__(self, thread_id, depth, spider_config, url, pattern):\\n\\n super(CrawlUrl, self).__init__()\\n\\n self.thread_id = thread_id\\n self.depth = depth\\n self.spider_config = spider_config\\n self.url = url\\n self.pattern = pattern\\n self.page = ''\",\n \"def crawler(self):\\n\\n def decorator(f: Callable) -> Callable:\\n self.register_crawler(f)\\n return f\\n\\n return decorator\",\n \"def start_requests(self):\\n for url in self.start_urls:\\n yield scrapy.Request(url, callback=self.parse)\",\n \"def start_requests(self):\\n self.spider = Base_Spider(LpCfg)\\n self.first_url = 'https://www.liepin.com/zhaopin/' \\\\\\n '?industries=&dqs=010&salary=15%2440' \\\\\\n '&jobKind=2&pubTime=3&compkind=&compscale=' \\\\\\n '&industryType=&searchType=1&clean_condition=' \\\\\\n '&isAnalysis=&init=1&sortFlag=15&flushckid=1' \\\\\\n '&fromSearchBtn=2&headckid=0b5a9690a5cb1d82&key=Python'\\n urls = []\\n s = self.spider.get_content(self.first_url)\\n self.cookies = self.spider.session.cookies.get_dict()\\n del s\\n self.spider.headers.update({'Cookie': self.cookies})\\n for page in range(1,5):\\n url = self.first_url + '&curPage=%d'%page\\n urls.append(url)\\n for url in urls:\\n print url\\n yield scrapy.Request(url=url,\\n callback=self.parse,\\n headers=self.spider.headers,\\n cookies=self.cookies\\n )\",\n \"def scrape_main() -> None:\\n\\n logger.info(\\\"Starting scrape\\\")\\n search_info = construct_scrape_regex_patterns(grab_scrape_info())\\n links = run_scrape(\\n url=search_info['url'],\\n seasons_regex=search_info['seasons'],\\n episodes_regex=search_info['episodes']\\n )\\n if links:\\n logger.debug(\\\"Writing urls to file\\\")\\n with open('urls.txt', 'w') as f:\\n for link in links:\\n f.write(link + '\\\\n')\\n else:\\n logger.warning(\\\"No links available\\\")\",\n \"def run(self):\\n\\n for url in self.urls:\\n try:\\n # Use requests to retrieve web page data\\n print(url)\\n response = session.get(url, ) # allow_redirects=True)\\n\\n if response.status_code != 200:\\n print('Failed to retrieve page, URL: {0}, error: {1}\\\\n'.format(url, response.status_code))\\n return\\n\\n # Get web page data from HTML response\\n content = get_json_data(response.text)\\n\\n # Compile data into dictionary to be used for reporting\\n summary_data = generate_report(content)\\n\\n # Generate/print report\\n print_report(summary_data)\\n\\n except Exception as error:\\n print('Scraper failed to run for URL {0}, error: {1}, {2}\\\\n'.format(\\n url, type(error).__name__, error\\n ))\\n\\n # time.sleep(1) # for load concerns\",\n \"def parse(self, response):\\n for cate_selector in response.css(\\\"div.sub-nav-cont ul li a\\\"):\\n link = cate_selector.css(\\\"::attr(href)\\\").extract_first()\\n if response.urljoin(link) in self.start_urls:\\n continue\\n cate_name = cate_selector.css(\\\"::attr(c-bname)\\\").extract_first()\\n meta = {\\\"cate_name\\\": cate_name, \\\"page_num\\\": 1,\\n \\\"base_url\\\": link.rsplit(\\\".\\\", 1)[0]}\\n yield response.follow(link, callback=self.parse_category, meta=meta)\",\n \"def start_requests(self):\\r\\n try:\\r\\n\\r\\n for url in self.start_urls:\\r\\n yield scrapy.Request(url,\\r\\n callback=self.navigate_to)\\r\\n except Exception as err:\\r\\n logger.error(f'TekDefenceScraper : start_requests : {err}')\\r\\n raise err\",\n \"def start_requests(self):\\n # Load sitemap JSON - generate queues\\n if self.args.sitemap_json is None:\\n yield Request('https://repo1.maven.org/maven2/', callback=self.spider.parse_page, meta=dict())\\n return\\n\\n for req in self.gen_links(self.args.sitemap_json):\\n yield req\",\n \"def crawlerAdd(name):\\n sclogic.crawlerAdd(name)\",\n \"def __init__(self):\\n self.redis = RedisClient()\\n self.crawlers = [crawler_cls() for crawler_cls in crawlers_cls]\",\n \"def test_with_progress_start_requests_all_visited(mock_spider_state_cls, mock_site_pager_cls, _):\\n data = CategoryBasedSpiderData(\\\"some-progress-file-dir\\\", \\\"some-spider-name\\\", \\\"http://some-recipes.com\\\")\\n mock_request_factory = Mock()\\n\\n mock_current_category_parent = Mock()\\n mock_current_category_parent.parent = None\\n mock_current_category_parent.children = [Mock(), Mock()]\\n mock_current_category_parent.children[0].visit_state = VisitState.VISITED\\n mock_current_category_parent.children[1].visit_state = VisitState.VISITED\\n mock_current_category_node = Mock()\\n mock_current_category_node.parent = mock_current_category_parent\\n\\n mock_spider_state_instance = __prepare_mock_spider_instance(True)\\n mock_spider_state_instance.site_structure.get_node_at_path.return_value = mock_current_category_node\\n mock_spider_state_cls.return_value = mock_spider_state_instance\\n\\n mock_site_pager_cls_instance = Mock()\\n mock_site_pager_cls.return_value = mock_site_pager_cls_instance\\n\\n spider = CategoryBasedSpider(Mock(), Mock(), data)\\n spider.request_factory = mock_request_factory\\n list(spider.start_requests())\\n mock_site_pager_cls_instance.start.assert_called()\\n\\n site_page_callbacks = mock_site_pager_cls.call_args[0][3]\\n site_page_callbacks.on_page_finished(\\\"http://some-recipes.com/next-page\\\")\\n site_page_callbacks.on_paging_finished()\\n mock_spider_state_instance.save.assert_called()\\n mock_current_category_parent.set_visit_state.assert_called()\",\n \"def main(state=None, overwrite=False):\\n \\n # Initialize process\\n process = initialize_process()\\n\\n if overwrite:\\n # TODO: delete all (and only) files to be regenerated\\n pass\\n\\n # Add a spider instance for each state to be run\\n if state:\\n add_state_to_process(state, process=process)\\n else:\\n for s in list(CONFIG.keys()):\\n add_state_to_process(s, process=process)\\n\\n # Run scrape\\n process.start()\",\n \"def crawl(self):\\n retrievedSubs = []\\n reddit = praw.Reddit(\\n client_id='QRl_4bwjckcg9A',\\n client_secret='dsavqFoOk5NgWEOWtMf9NknwxRIoIw',\\n password='P@ssword123',\\n user_agent='cluelessv1',\\n username='theclueless1009'\\n )\\n submissions = reddit.subreddit('all').search(self.keyword, sort='relevance', limit=50, time_filter='week')\\n\\n for sub in submissions:\\n self.data = [sub.selftext, sub.upvote_ratio, sub.score,\\n sub.title, sub.id, sub.total_awards_received, sub.created_utc]\\n self.data = tuple(self.data)\\n retrievedSubs.append(self.data)\\n\\n return retrievedSubs\",\n \"def add_crawler(self, crawler: BaseCrawler) -> None:\\n self.tasks.append(crawler)\",\n \"def crawl(url):\\n\\n if not url in visited_urls:\\n try:\\n r = sess.get(url, headers={'User-Agent': user_agent}, stream=True)\\n visited_urls.add(url)\\n # Don't download non html files\\n if r.headers['content-type'].startswith(\\\"text/html\\\"):\\n # TODO: Use console logger\\n print url, datetime.datetime.now()\\n links = extract_links(r.text.encode(\\\"utf-8\\\"))\\n update_queue(url, links)\\n return r.text.encode('utf-8', 'ignore')\\n # what if url is email address\\n except requests.exceptions.MissingSchema, e:\\n print(e)\\n return \\\"\\\"\\n except requests.ConnectionError, e:\\n # Any requests exception, log and don't quit.\\n print(e)\\n logger.error(e)\",\n \"def scrape_pdfs(db):\\n process = CrawlerProcess()\\n process.crawl(PdfSpider, db=db)\\n process.start()\",\n \"def work(self):\\n while True:\\n url, depth = self.crawl_queue.get(timeout=self.crawl_queue_time_out)\\n self.crawl_queue.task_done()\\n try:\\n if depth <= self.depth_limit:\\n with Spider.seen_urls_lock:\\n seen_already = url in self.seen_urls\\n if not seen_already:\\n page, links = self.crawl_page(url, depth, self.domain_name)\\n self._add_links_to_crawl_queue(links, depth)\\n self._add_page_to_rank_queue(page)\\n self._add_page_to_storage(page)\\n with Spider.seen_urls_lock:\\n self.seen_urls.add(url)\\n except Exception as e:\\n self.logger.debug(e)\",\n \"def main(args):\\n parser = create_parser()\\n\\n if not args:\\n parser.print_usage()\\n sys.exit(1)\\n\\n parsed_args = parser.parse_args(args)\\n scrape_url(parsed_args.url)\",\n \"async def crawl(self):\\n fetch_urls = [self.start_url]\\n results = []\\n while len(fetch_urls):\\n \\\"\\\"\\\"\\n slicing array urls with max_async_call arg and then run extract_data_urls\\n extract_data_urls return a object that contains url, data, found_urls, and all_urls\\n url is a url that we crawled\\n data is Html content of the url\\n found_urls are new urls that we have to crawl that\\n all_urls are all links in the html page\\n \\\"\\\"\\\"\\n urls = await self.extract_data_urls(fetch_urls[0:self.max_async_call])\\n del fetch_urls[0:self.max_async_call]\\n for url, data, found_urls, all_urls in urls:\\n fetch_urls.extend(found_urls)\\n result = self.parse_html_content(data)\\n result['urls'] = all_urls\\n results.append((url, result))\\n return results\",\n \"def daily_task():\\n global CATEGORIES_PAGES\\n global BROWSER\\n global DATE\\n global OBSERVATION\\n log.info('Scraper started')\\n # Refresh date\\n DATE = str(datetime.date.today())\\n OBSERVATION = 0\\n # Initiate headless web browser\\n log.info('Initializing browser')\\n BROWSER = webdriver.Chrome(executable_path=PROJECT_PATH + \\\"/bin/chromedriver\\\",\\n options=OPTIONS)\\n # Download topsite and get categories directories\\n base_file_name = \\\"All_cat_\\\" + DATE + \\\".html\\\"\\n fetch_html(BASE_URL, base_file_name, PATH_HTML, attempts_limit=1000)\\n html_file = open(PATH_HTML + base_file_name).read()\\n CATEGORIES_PAGES = get_category_list(html_file)\\n log.info('Found ' + str(len(CATEGORIES_PAGES)) + ' categories')\\n # Read each categories pages and scrape for data\\n for cat in track(CATEGORIES_PAGES,\\n description = \\\"[green]Scraping...\\\",\\n total = len(CATEGORIES_PAGES)):\\n cat_file = \\\"cat_\\\" + cat['name'] + \\\"_\\\" + DATE + \\\".html\\\"\\n download = fetch_html(cat['directlink'], cat_file, PATH_HTML)\\n if download:\\n scrap_data(cat)\\n # Close browser\\n BROWSER.close()\\n BROWSER.service.process.send_signal(signal.SIGTERM)\\n BROWSER.quit()\",\n \"def schedule(args):\\n job_args = [(x[0], x[1]) for x in (y.split(\\\"=\\\", 1) for y in args.arg)]\\n _projects = lib.get_projects(\\n args.target, args.project, username=args.username, password=args.password\\n )\\n for project in _projects:\\n _spiders = lib.get_spiders(\\n args.target,\\n project,\\n args.spider,\\n username=args.username,\\n password=args.password,\\n )\\n for spider in _spiders:\\n job_id = lib.schedule(\\n args.target,\\n project,\\n spider,\\n job_args,\\n username=args.username,\\n password=args.password,\\n )\\n print(f\\\"{project} / {spider} => {job_id}\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73961866","0.6965943","0.6719651","0.6231977","0.6110582","0.60992587","0.6060535","0.6008926","0.5995375","0.5984809","0.5936894","0.59176165","0.59090364","0.5877148","0.58751583","0.5838686","0.5806472","0.57944125","0.57699037","0.57601506","0.5735935","0.57135326","0.57116354","0.5597671","0.5583405","0.5578234","0.5562777","0.5553221","0.55443513","0.5541015","0.55283964","0.55125195","0.5489356","0.54739016","0.5466806","0.5466082","0.54315734","0.54226536","0.5407359","0.540429","0.5357472","0.53524363","0.5339555","0.5333631","0.531721","0.5316352","0.52996457","0.528219","0.527444","0.5250569","0.52137125","0.52099156","0.520455","0.5203667","0.51851654","0.5180572","0.517663","0.51686335","0.515485","0.51335174","0.51299375","0.51291525","0.5125681","0.5117038","0.509505","0.50915104","0.50797415","0.5079427","0.5056364","0.50474745","0.503386","0.5026094","0.50149435","0.49695602","0.49643198","0.49618998","0.49577165","0.49514976","0.4933116","0.49280772","0.4924991","0.49241325","0.491499","0.4904311","0.48882332","0.48845848","0.48770577","0.4876546","0.4869455","0.48608375","0.48413327","0.48407328","0.48400724","0.48324504","0.48315194","0.4824769","0.48243928","0.48222598","0.4819525","0.48167318"],"string":"[\n \"0.73961866\",\n \"0.6965943\",\n \"0.6719651\",\n \"0.6231977\",\n \"0.6110582\",\n \"0.60992587\",\n \"0.6060535\",\n \"0.6008926\",\n \"0.5995375\",\n \"0.5984809\",\n \"0.5936894\",\n \"0.59176165\",\n \"0.59090364\",\n \"0.5877148\",\n \"0.58751583\",\n \"0.5838686\",\n \"0.5806472\",\n \"0.57944125\",\n \"0.57699037\",\n \"0.57601506\",\n \"0.5735935\",\n \"0.57135326\",\n \"0.57116354\",\n \"0.5597671\",\n \"0.5583405\",\n \"0.5578234\",\n \"0.5562777\",\n \"0.5553221\",\n \"0.55443513\",\n \"0.5541015\",\n \"0.55283964\",\n \"0.55125195\",\n \"0.5489356\",\n \"0.54739016\",\n \"0.5466806\",\n \"0.5466082\",\n \"0.54315734\",\n \"0.54226536\",\n \"0.5407359\",\n \"0.540429\",\n \"0.5357472\",\n \"0.53524363\",\n \"0.5339555\",\n \"0.5333631\",\n \"0.531721\",\n \"0.5316352\",\n \"0.52996457\",\n \"0.528219\",\n \"0.527444\",\n \"0.5250569\",\n \"0.52137125\",\n \"0.52099156\",\n \"0.520455\",\n \"0.5203667\",\n \"0.51851654\",\n \"0.5180572\",\n \"0.517663\",\n \"0.51686335\",\n \"0.515485\",\n \"0.51335174\",\n \"0.51299375\",\n \"0.51291525\",\n \"0.5125681\",\n \"0.5117038\",\n \"0.509505\",\n \"0.50915104\",\n \"0.50797415\",\n \"0.5079427\",\n \"0.5056364\",\n \"0.50474745\",\n \"0.503386\",\n \"0.5026094\",\n \"0.50149435\",\n \"0.49695602\",\n \"0.49643198\",\n \"0.49618998\",\n \"0.49577165\",\n \"0.49514976\",\n \"0.4933116\",\n \"0.49280772\",\n \"0.4924991\",\n \"0.49241325\",\n \"0.491499\",\n \"0.4904311\",\n \"0.48882332\",\n \"0.48845848\",\n \"0.48770577\",\n \"0.4876546\",\n \"0.4869455\",\n \"0.48608375\",\n \"0.48413327\",\n \"0.48407328\",\n \"0.48400724\",\n \"0.48324504\",\n \"0.48315194\",\n \"0.4824769\",\n \"0.48243928\",\n \"0.48222598\",\n \"0.4819525\",\n \"0.48167318\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70772463"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":94289,"cells":{"query":{"kind":"string","value":"Launch crawl job for JobSpider class"},"document":{"kind":"string","value":"def crawl(spiders_classes, connector, debug=False, spider_error_callback=stdout_error_callback):\n if debug:\n dispatcher.connect(spider_error_callback, signals.spider_error)\n\n process = CrawlerProcess({\n 'ITEM_PIPELINES': {\n 'pyjobs_crawlers.pipelines.RecordJobPipeline': 1,\n },\n 'connector': connector,\n 'LOG_ENABLED': False\n })\n\n for spider_class in spiders_classes:\n process.crawl(spider_class)\n\n spiders = []\n for crawler in list(process.crawlers):\n spiders.append(crawler.spider)\n process.start()\n\n return spiders"},"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 # get input params\n args = parm_parser.get_args()\n # init log config\n log.init_log('./log/mini_spider')\n if args:\n # read config file spider.conf\n conf_params = parm_parser.set_config_by_file(args.conf)\n # use config set up spider initial params\n spider = SpiderWorker(conf_params)\n # init result_path, make it complete\n spider.set_path()\n # init url queue\n spider.set_url_queue()\n # start to crawl url\n spider.start_crawl_work()\n\n return","def crawl(spider: str, book_id: int):\n proc = CrawlerProcess(get_project_settings())\n\n proc.crawl(spider, book_id=book_id)\n\n proc.start()","def runSpider(spiderClass):\n\n\tprocess = CrawlerProcess({\n\t\t# 'USER_AGENT': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'\n\t})\n\n\tprocess.crawl(spiderClass)\n\tprocess.start() # the script will block here until the crawling is finished","def main():\n\n from scrapy.crawler import CrawlerProcess\n from scrapy.utils.project import get_project_settings\n\n process = CrawlerProcess(get_project_settings())\n process.crawl(NCBIGeoSpider)\n process.start()","def parse(self, response):\n page_jobs=[]\n\n # Calling abstarct method get_jobs_list() and iterating...\n jobs_div_list=self.get_jobs_list(response)\n for div in jobs_div_list:\n \n # Calling abstarct method get_job_dict()\n job_dict=self.get_job_dict(div)\n\n if not job_dict['url'] or not job_dict['title'] :\n # At least url, title data is loaded from the list of job posting ...\n raise ValueError( \"Could not find valid job information ('url' and 'title') in data:\\n\" + \n str(div.get()) + \"\\nScraped infos:\\n\" + str(job_dict) + \"\\nReport this issue on github!\" )\n \n # Store source as the name of the spider aka website\n job_dict['source']=self.name\n page_jobs.append(job_dict)\n \n \"\"\"\n Load full job page only if:\n - it's a new job (not in database)\n - load_full_jobs=Yes\n - the method parse_full_job_page() has been re-wrote by the Scraper subclass\n \"\"\"\n if ( (not self.db or self.db.find_job(job_dict)==None)\n and self.load_full_jobs ):\n if type(self).parse_full_job_page != Scraper.parse_full_job_page:\n # load_full_jobs=Yes and it's supported by scraper\n # Call parse_full_job_page() with job URL\n\n # Handle SeleniumRequest if use_selenium=True\n if self.use_selenium:\n yield SeleniumRequest(url=job_dict['url'], \n callback=self.parse_full_job_page,\n cb_kwargs=dict(job_dict=job_dict),\n wait_time=self.selenium_wait_time, script=SCROLL_DOWN)\n else:\n yield response.follow(url=job_dict['url'], \n callback=self.parse_full_job_page,\n cb_kwargs=dict(job_dict=job_dict))\n else:\n yield Job(job_dict)\n else:\n yield Job(job_dict)\n\n \"\"\" Just printing in one line \"\"\"\n if self.load_full_jobs:\n if type(self).parse_full_job_page == Scraper.parse_full_job_page:\n if self.load_all_new_pages==False:\n self.log.info(\"Scraped {} jobs from {}. Scraper {} does not support load_full_jobs=True and load_all_new_pages=False, some new job postings and job informations might be missing\".format(len(page_jobs), response.url, self.name))\n else:\n self.log.info(\"Scraped {} jobs from {}. Scraper {} does not support load_full_jobs=True, some informations might be missing\".format(len(page_jobs), response.url, self.name))\n else:\n self.log.info(\"Scraping {} jobs from {}...\".format(len(page_jobs), response.url))\n else:\n if self.load_all_new_pages==False:\n self.log.info(\"Scraped {} jobs from {}. load_all_new_pages=False and load_full_jobs=False, some new job postings and job informations might be missing\".format(len(page_jobs), response.url))\n else:\n self.log.info(\"Scraped {} jobs from {}. load_full_jobs=False, some informations might be missing\".format(len(page_jobs), response.url))\n \n \"\"\"\n If all page jobs are new and \n The method get_next_page_url() has been re-wrote by the Scraper subclass\n Scrape next page\n \"\"\"\n if self.load_all_new_pages==True:\n if self.db and any( [self.db.find_job(job_dict)!=None for job_dict in page_jobs] ):\n # All new job postings loaded\n pass\n else:\n if self.get_next_page_url(response)!=None :\n # Loading next page...\n if self.use_selenium:\n yield SeleniumRequest(\n url=self.get_next_page_url(response),\n callback=self.parse,\n wait_time=self.selenium_wait_time, script=SCROLL_DOWN)\n else:\n yield response.follow(\n url=self.get_next_page_url(response),\n callback=self.parse)\n else:\n if type(self).get_next_page_url != Scraper.get_next_page_url:\n # Last page loaded\n pass\n else:\n self.log.info(\"Scraper {} does not support load_all_new_pages=True, some new job postings might be missing\".format(self.name))","def start(self):\n self.start_spider()\n self.start_ranker()\n\n concurrent.futures.wait(self.spider_thread_futures) # wait for spiders to finish\n self.logger.info(\"Done crawling\")\n self.ranker.done_crawling.set()\n\n self.ranker.print_ranks()","def WebscraperTask(job_id):\n logger.debug(\"Entering dispatch_wordscraper with job ID: %s\" % str(job_id))\n\n # Obtain all required crawler arguments\n job = Job.objects.get(pk=job_id)\n word_list = [(term.term_id, term.term)\n for term in Term.objects.filter(job=job)]\n site_list = [(site.site_id, site.url, job.max_depth, 'English')\n for site in Site.objects.filter(job=job)]\n\n # Initialize the crawling process\n logger.debug(\"Configuring crawl controller with job_id: \" +\n \"%d, terms: %s, sites: %s\" % (job_id, str(word_list),\n str(site_list),))\n controller = init_controller()\n controller.crawl(job_id, site_list, word_list)\n logger.debug(\"Crawl complete for job: %d\" % job_id)\n\n # Cache the results in the database so the results are dated as close to the\n # crawl date as possible.\n results = controller.query(site_list, word_list)\n result_cache = Result()\n result_cache.job = job\n result_cache.output = results\n result_cache.save()","def __init__(self, config, processors):\n source = HackernewsStories()\n source.configure(config)\n\n super(HackernewsCrawlJob, self).__init__(source, processors)","def crawler():\n job_entries = []\n for job in job_info(URL):\n labels = \"\"\n if job[\"labels\"]:\n for label in job[\"labels\"]:\n labels += label[\"name\"]\n if job[\"labels\"].index(label) != len(job[\"labels\"]) - 1:\n labels += \",\"\n job_entries.append((job[\"number\"], job[\"id\"],\n job[\"title\"], job[\"html_url\"], labels))\n\n conn = sqlite3.connect('jobber/jobber.db')\n c = conn.cursor()\n c.executemany(('INSERT OR IGNORE INTO job_entries '\n 'VALUES (?,?,?,?,?)'), job_entries)\n conn.commit()\n conn.close()","def main(call_args):\n\n args = parse_args(call_args)\n init_logging(args.loglevel)\n\n _log.info(\"'scrape-jobs' called with args: %s\", args)\n runner.run_with_config_file(args.site, args.config_file)","def kickoff(self):\n settings = Settings()\n\n # settings.set(\"USER_AGENT\", \"Test\")\n settings.set('JOBDIR', self.args.data_dir)\n self.spider = MavenDataSpider()\n\n # Wrap with crawler, configure\n crawler = Crawler(self.spider, settings)\n crawler.signals.connect(spider_closing, signal=signals.spider_closed)\n\n logger.info('Starting crawler')\n crawler.crawl(self.spider, app=self, dbsess=self.session)\n\n self.spider = crawler.spider\n self.spider.link_queue_mode = False\n if self.args.debug:\n coloredlogs.install(level=logging.DEBUG)\n\n # Keeping thread working\n reactor.run()","def run_crawl(self, args):\n\n # Crawler process declaration\n process = CrawlerProcess({\n 'USER_AGENT': 'David Avs Crawler',\n 'FEED_FORMAT': 'json',\n 'FEED_URI': 'stdout:',\n 'LOG_ENABLED': args.verbose,\n })\n kwargs = dict(\n start_urls=[args.url],\n allowed_domains=[urlparse.urlparse(args.url).netloc.lower()],\n )\n\n # Run crawling\n old_stdout = sys.stdout\n sys.stdout = args.file\n try:\n process.crawl(DavidAvsSpider, **kwargs)\n process.start()\n finally:\n sys.stdout = old_stdout","def run_crawler(self) -> List[JobEventSchema]:\n print(f\"Ready for scraping, current task: {self.tasks}\")\n\n crawling_result = []\n for task in self.tasks:\n result = task.run()\n crawling_result.extend(result)\n return crawling_result","def run_spider_on_zyte(spider_name):\n print(f'Running spider {spider_name}...')\n data = dict(project=project_id, spider=spider_name)\n response = requests.post('https://app.scrapinghub.com/api/run.json', data=data, auth=(api_key, ''))\n return response.json()['jobid']","def open_spider(self,Spider):\n pass","def runSpider(spider, searchterm = None, fullink = None, spiderbotid = -1):\n sclogic.runSpider(spider, searchterm, fullink, spiderbotid)","def parse(self, response):\n content = response.body\n if not content:\n return\n sel = Selector(response)\n #print sel.xpath('//table[@class=\"board-list tiz\"]/tr').extract()\n for job in sel.xpath('//ul[@class=\"sojob-list\"]/li'):\n #print 'd',job\n info = job.xpath('div[@class=\"sojob-item-main clearfix\"]/div[@class=\"job-info\"]')\n com_info = job.xpath('div[@class=\"sojob-item-main clearfix\"]/div[@class=\"company-info nohover\"]')\n title = info.xpath('h3/a/text()').extract_first().lower()\n if title.find('python') != -1:\n url = info.xpath('h3/a/@href').extract_first()\n request = scrapy.Request(url=url,\n callback=self.parse_items,\n headers=self.spider.headers,\n cookies=self.cookies)\n company_item, job_item = CompanyItem(), JobItem()\n company_item['name'] = com_info.xpath('p[@class=\"company-name\"]/a/text()').extract_first()\n company_item['homepage'] = com_info.xpath('p[@class=\"company-name\"]/a/@href').extract_first()\n job_item['pub_time'] = info.xpath('p[@class=\"time-info clearfix\"]/time/text()').extract_first()\n year = str(date.today().year)\n if str(year) not in job_item['pub_time']:\n if job_item['pub_time'] == u'昨天':\n job_item['pub_time'] = (date.today()-timedelta(days=1)).strftime(\"%Y-%m-%d\")\n elif job_item['pub_time'] == u'前天':\n job_item['pub_time'] = (date.today() - timedelta(days=2)).strftime(\"%Y-%m-%d\")\n else:\n job_item['pub_time'] = date.today().strftime(\"%Y-%m-%d\")\n job_item['title'] = title\n job_item['welfare'] = ' '.join(com_info.xpath('p[@class=\"temptation clearfix\"]/span/text()').extract())\n job_item['salary'] = info.xpath('p[@class=\"condition clearfix\"]/span[@class=\"text-warning\"]/text()').extract_first()\n request.meta['company_item'] = company_item\n request.meta['job_item'] = job_item\n yield request","def crawl(self):\n\n # create helper process and setup IPC\n self.socket.listen(1)\n help_out_fd = open(self.helper_outfile, \"w\")\n with subprocess.Popen(\"./crawl_helper.py\", stdout=help_out_fd, stderr=subprocess.STDOUT) as proc:\n self.helper_pid = proc.pid\n try:\n conn, _ = self.socket.accept()\n # create initial params for crawler helper and send them\n new_urls = set()\n setup_params = {\"start_urls\": self.start_urls, \"allowed_domains\": [self.domain],\n \"cookies\": self.cookies, \"user_agent\": self.config[\"user_agent\"]}\n ipc_operations.send_object(conn, setup_params)\n\n # loop: receive a response object, then send new URLs to crawl. Catch & handle problems.\n while True:\n try:\n proc.wait(timeout=0.001)\n break\n except subprocess.TimeoutExpired:\n response = ipc_operations.receive_object(conn)\n if not response: # socket is dead / closed\n break\n new_urls = self.process_response(response)\n ipc_operations.send_object(conn, new_urls)\n except socket.timeout:\n util.printit(\"Unix socket connection to scrapy crawler unexpectedly broke. \" +\n \"Quitting crawling of %s\" % self.base_url, color=util.RED)\n break\n finally:\n # ensure connection is closed and helper process killed in any case\n conn.close()\n proc.kill()\n\n # after the actual crawling, extract all the gathered cookies from Selenium\n if self.config[\"use_selenium\"].lower() == \"true\":\n selenium_cookies = self.driver.get_cookies()\n for cookie in selenium_cookies:\n if not any(cookie[\"name\"] == c[\"name\"] and cookie[\"path\"] == c[\"path\"] and\n cookie[\"domain\"] == c[\"domain\"] for c in self.found_cookies):\n parsed_cookie = {}\n for key in (\"name\", \"path\", \"domain\", \"httpOnly\", \"secure\"):\n parsed_cookie[key] = cookie[key]\n self.found_cookies.append(parsed_cookie)\n\n help_out_fd.close()\n return self.create_results()","def scrape(self):\n\n self.jobs_load()\n self.new_jobs = []\n\n for bot in self.bot_squad:\n self.new_jobs += bot.scrape_all_pages()\n\n self.statistics(self.new_jobs)\n print('SCRAPE COMPLETE. NOTE: Resulting job list still in RAM')\n print('We observed %d new jobs' % len(self.new_jobs))","def run(self):\n \n try:\n logging.info('Thread:{} starting'.format(self.thread_id))\n\n self.crawl_url()\n self.parse_html()\n except IOError as e:\n self.thread_post_processing()\n logging.error('CrawlUrlError url:{} msg:{}'.format(self.url, e))\n\n self.thread_post_processing()","def run_generic_spider( user_id\t\t\t\t= None,\n\t\t\t\t\t\tspider_id\t\t\t= None,\n\t\t\t\t\t\tdatamodel\t\t\t= None,\n\t\t\t\t\t\trun_spider_config\t= None,\n\t\t\t\t\t\ttest_limit\t\t\t= None\n\t\t\t\t\t\t):\n\n\tprint ()\n\tlog_scrap.info(\"--- run_generic_spider / spider_id : %s \", spider_id )\n\n\t### WARNING !!! --> TEMPORARY SOLUTION\n\t### remove spider folder for spider_id in JOBDIR\n\tlog_scrap.debug(u\"--- run_generic_spider / cwd : %s\", os.getcwd() )\n\ttry :\n\t\tshutil.rmtree( os.getcwd() + \"/\" + JOBDIR_FOLDER + \"/\" + spider_id )\n\texcept:\n\t\tpass\n\tlog_scrap.debug(u\"--- run_generic_spider / removed folder : {}/{}\".format(JOBDIR_FOLDER, spider_id) )\n\n\t# !!! spider is launched from main.py level !!!\n\t# all relative routes referring to this...\n\tlog_scrap.info(\"--- run_generic_spider / os.getcwd() : %s \", os.getcwd() )\n\n\t### flattening run_spider_config : from nested to flat dict\n\tlog_scrap.info(\"--- run_generic_spider / 'flattenSpiderConfig()' on 'run_spider_config' --> 'spider_config_flat' ...\" )\n\tspider_config_flat = flattenSpiderConfig( run_spider_config )\n\n\n\t### settings for crawler\n\t# cf : https://hackernoon.com/how-to-crawl-the-web-politely-with-scrapy-15fbe489573d\n\n\t### global settings for scrapy processes (see upper)\n\tlog_scrap.info(\"--- run_generic_spider / BOT_NAME : %s \", settings.get('BOT_NAME') )\n\tlog_scrap.info(\"--- run_generic_spider / USER_AGENT : %s \", settings.get('USER_AGENT') )\n\tlog_scrap.info(\"--- run_generic_spider / ITEM_PIPELINES : %s \", settings.get('ITEM_PIPELINES').__dict__ )\n\n\n\t# specific settings for this scrapy process\n\n\t# settings.set( \"RETRY_TIMES\"\t\t\t\t\t\t, RETRY_TIMES )\n\t# settings.set( \"CONCURRENT_ITEMS\"\t\t\t\t, CONCURRENT_ITEMS )\n\t# settings.set( \"CONCURRENT_REQUESTS\"\t\t\t\t, CONCURRENT_REQUESTS )\n\t# settings.set( \"CONCURRENT_REQUESTS_PER_DOMAIN\"\t, CONCURRENT_REQUESTS_PER_DOMAIN )\n\t# settings.set( \"REDIRECT_MAX_TIMES\"\t\t\t\t, REDIRECT_MAX_TIMES )\n\t# settings.set( \"DOWNLOAD_MAXSIZE\" \t\t\t\t, DOWNLOAD_MAXSIZE )\n\t# settings.set( \"DEPTH_PRIORITY\"\t\t\t\t\t, DEPTH_PRIORITY )\n\t# settings.set( \"SCHEDULER_DISK_QUEUE\"\t\t\t, SCHEDULER_DISK_QUEUE )\n\t# settings.set( \"DEPTH_PRIORITY\"\t\t\t\t\t, SCHEDULER_MEMORY_QUEUE )\n\n\t# settings.set( \"RANDOMIZE_DOWNLOAD_DELAY\"\t\t, RANDOMIZE_DOWNLOAD_DELAY )\n\t# cf : https://doc.scrapy.org/en/latest/topics/jobs.html#job-directory\n\tsettings.set( \"JOBDIR\"\t\t\t\t\t\t\t, JOBDIR_FOLDER + \"/\" + spider_id )\n\n\t## https://scrapy.readthedocs.io/en/0.12/topics/extensions.html#module-scrapy.contrib.closespider\n\n\tsettings.set( \"CURRENT_SPIDER_ID\" \t\t\t, spider_id )\n\tsettings.set( \"RETRY_TIMES\"\t\t\t\t\t\t\t, spider_config_flat[\"RETRY_TIMES\"] )\n\tsettings.set( \"CLOSESPIDER_ITEMCOUNT\"\t\t, spider_config_flat[\"LIMIT_ITEMS\"] )\n\t# settings.set( \"CLOSESPIDER_PAGECOUNT\"\t\t, spider_config_flat[\"LIMIT_PAGES\"] )\n\tsettings.set( \"DOWNLOAD_DELAY\" \t\t\t\t\t, spider_config_flat[\"download_delay\"] )\n\tsettings.set( \"CONCURRENT_ITEMS\"\t\t\t\t, spider_config_flat[\"CONCURRENT_ITEMS\"] )\n\tsettings.set( \"CONCURRENT_REQUESTS\"\t\t\t, spider_config_flat[\"CONCURRENT_REQUESTS\"] )\n\t# settings.set( \"DOWNLOAD_DELAY\" \t\t\t\t, DOWNLOAD_DELAY )\n\n\tsettings.set( \"BOT_NAME\"\t\t\t\t\t\t\t\t\t, spider_config_flat[\"BOT_NAME\"] )\n\tsettings.set( \"USER_AGENT\"\t\t\t\t\t\t\t\t, spider_config_flat[\"USER_AGENT\"] )\n\tsettings.set( \"ROBOTSTXT_OBEY\"\t\t\t\t\t\t, spider_config_flat[\"ROBOTSTXT_OBEY\"] )\n\tsettings.set( \"AUTOTHROTTLE_ENABLED\"\t\t\t, spider_config_flat[\"AUTOTHROTTLE_ENABLED\"] )\n\tsettings.set( \"HTTPCACHE_ENABLED\"\t\t\t\t\t, spider_config_flat[\"HTTPCACHE_ENABLED\"] )\n\tsettings.set( \"RANDOMIZE_DOWNLOAD_DELAY\"\t, spider_config_flat[\"RANDOMIZE_DOWNLOAD_DELAY\"] )\n\n\t### initiating crawler process\n\tlog_scrap.info(\"--- run_generic_spider / instanciate process ...\" \t )\n\tprocess = CrawlerRunner( settings = settings )\n\n\t### adding CrawlerRunner as deferred\n\tdef f(q):\n\t\ttry:\n\t\t\t### send/create custom spider from run_spider_config\n\t\t\t### cf : https://stackoverflow.com/questions/35662146/dynamic-spider-generation-with-scrapy-subclass-init-error\n\n\t\t\tdeferred = process.crawl( \tGenericSpider,\n\t\t\t\t\t\t\t\t\t\t\tuser_id\t\t\t\t\t\t\t= user_id,\n\t\t\t\t\t\t\t\t\t\t\tdatamodel \t\t\t\t\t= datamodel ,\n\t\t\t\t\t\t\t\t\t\t\tspider_id \t\t\t\t\t= spider_id ,\n\t\t\t\t\t\t\t\t\t\t\tspider_config_flat\t= spider_config_flat,\n\t\t\t\t\t\t\t\t\t\t\ttest_limit\t\t\t\t\t= test_limit\n\t\t\t\t\t\t\t\t\t)\n\t\t\tdeferred.addBoth(lambda _: reactor.stop())\n\t\t\treactor.run()\n\t\t\tq.put(None)\n\t\texcept Exception as e:\n\t\t\tq.put(e)\n\n\t### putting task in queue and start\n\tq = Queue()\n\tp = Process(target=f, args=(q,))\n\tp.start()\n\tresult = q.get()\n\tp.join()\n\n\tif result is not None:\n\t\traise result\n\n\n\n\tprint (\"\\n\\n{}\\n\".format(\"> > > \"*20))","def start_requests(self):\n url = self.start_urls[0]\n yield scrapy.Request(url=url, callback=self.parse)","def run_spiders():\n hour_limit = 3600 # in seconds\n\n settings = get_project_settings()\n\n # Uncomment the following block of code if you want to test the manager on\n # the \"onepagetest\" to make sure the manager is working.\n \"\"\"\n settings[\"HTTPCACHE_ENABLED\"] = 1\n settings[\"HTTPCACHE_EXPIRATION_SECS\"] = 0\n settings[\"HTTPCACHE_STORAGE\"] = \"scrapy.extensions.httpcache.FilesystemCacheStorage\"\n settings[\"HTTPCACHE_IGNORE_MISSING\"] = 1\n settings[\"HTTPCACHE_DIR\"] = \"onepagetest\"\n \"\"\"\n\n runner = CrawlerRunner(settings)\n begin_time = datetime.now()\n\n d = runner.crawl(\"sb_spider\")\n d.addBoth(lambda _: continue_crawl(d, runner, begin_time, hour_limit))\n reactor.run()","def runCrawler(crawlerid):\n sclogic.runCrawler(crawlerid)","def start_crawling(crawler_instance: Crawler):\n print('start crawling!')\n logger.info('started a new crawl!')\n crawler_instance.crawl()\n threading.Timer(Config.CRAWL_TIMEOUT, start_crawling,\n [crawler_instance]).start()","def parse(self, response):\n page_source = self.upwork_controller.get_source_home()\n\n # Hand-off between Selenium and Scrapy happens here\n sel = Selector(text=page_source)\n # Extract data\n sections = sel.xpath(\"//section/div\")\n\n for section in sections:\n selector = Selector(text=section.get())\n jobtitle = selector.xpath(\"//div/div/div/h4/a/text()\")\n jobdescription = selector.xpath(\"//div/div/div/div/div/div/div/span/span/text()\")\n hourlypay = selector.xpath(\"//div/div/div/div/small/span/strong/text()\")\n proposals = selector.xpath(\"//div/div/div/div/div/span/small/strong/text()\")\n country = selector.xpath(\"//div/div/div/div/small/span/span/span/span/strong[@class='text-muted client-location ng-binding']/text()\")\n\n job = Job(jobtitle=jobtitle.get(),\n jobdescription=jobdescription.get(),\n hourlypay=hourlypay.get(),\n proposals=proposals.get(),\n country=country.get())\n job.serialize()\n yield job.dict()","def __init__(self,\n config,\n cache_manager=None,\n jobs=None,\n scraper_search=None,\n session=None,\n db_lock=None,\n cache_lock=None,\n start_page_pos=1,\n search_engine=None,\n search_type=None,\n proxy=None,\n progress_queue=None):\n\n self.config = config\n self.cache_manager = cache_manager\n\n jobs = jobs or {}\n self.search_engine_name = search_engine['engine'].lower()\n self.search_instance = search_engine\n\n assert self.search_engine_name, 'You need to specify an search_engine'\n\n if not search_type:\n self.search_type = self.config.get('search_type', 'normal')\n else:\n self.search_type = search_type\n\n self.jobs = jobs\n\n # the keywords that couldn't be scraped by this worker\n self.missed_keywords = set()\n # the number of keywords\n self.num_keywords = len(self.jobs)\n # The actual keyword that is to be scraped next\n self.query = ''\n # The default pages per keywords\n self.pages_per_keyword = [1, ]\n # The number that shows how many searches have been done by the worker\n self.search_number = 1\n # The parser that should be used to parse the search engine results\n self.parser = Parsing().get_parser_by_search_engine(\n self.search_engine_name\n )(config=self.config)\n # The number of results per page\n self.num_results_per_page = int(self.config.get('num_results_per_page', 10))\n\n # The page where to start scraping. By default the starting page is 1.\n if start_page_pos:\n self.start_page_pos = 1 if start_page_pos < 1 else start_page_pos\n else:\n self.start_page_pos = int(self.config.get('search_offset', 1))\n\n # The page where we are right now\n self.page_number = self.start_page_pos\n\n # Install the proxy if one was provided\n self.proxy = proxy\n if isinstance(proxy, Proxies().Proxy):\n self.set_proxy()\n self.requested_by = self.proxy.host + ':' + self.proxy.port\n else:\n self.requested_by = 'localhost'\n\n # the scraper_search object\n self.scraper_search = scraper_search\n # the scrape mode\n # to be set by subclasses\n self.scrape_method = ''\n # Whether the instance is ready to run\n self.startable = True\n # set the database lock\n self.db_lock = db_lock\n # init the cache lock\n self.cache_lock = cache_lock\n # a queue to put an element in whenever a new keyword is scraped.\n # to visualize the progress\n self.progress_queue = progress_queue\n # set the session\n self.session = session\n # the current request time\n self.requested_at = None\n # The name of the scraper\n self.name = '[{}]'.format(self.search_engine_name) + self.__class__.__name__\n\n # How long to sleep (in seconds) after every request\n self.sleeping_min = self.config.get('sleeping_min')\n self.sleeping_max = self.config.get('sleeping_max')\n\n # the default timeout\n self.timeout = 5\n # the status of the thread after finishing or failing\n self.status = 'successful'\n self.html = ''","def open_spider(self, spider):\n pass","def start_requests(self):\n # Load sitemap JSON - generate queues\n if self.args.sitemap_json is None:\n yield Request('https://repo1.maven.org/maven2/', callback=self.spider.parse_page, meta=dict())\n return\n\n for req in self.gen_links(self.args.sitemap_json):\n yield req","def start_requests(self):\n for url in self.start_urls:\n yield scrapy.Request(url, callback=self.parse)","def schedule(args):\n job_args = [(x[0], x[1]) for x in (y.split(\"=\", 1) for y in args.arg)]\n _projects = lib.get_projects(\n args.target, args.project, username=args.username, password=args.password\n )\n for project in _projects:\n _spiders = lib.get_spiders(\n args.target,\n project,\n args.spider,\n username=args.username,\n password=args.password,\n )\n for spider in _spiders:\n job_id = lib.schedule(\n args.target,\n project,\n spider,\n job_args,\n username=args.username,\n password=args.password,\n )\n print(f\"{project} / {spider} => {job_id}\")","def run(self):\n print \"CAlled run in querythread\"\n #global config.mqchannel\n self.qstatus = \"Running\"\n start = time.clock()\n \n self.crawl_async_result = crawl.apply_async(args=[self.start_url, self.max_depth, self.parser], serializer=\"json\")\n while not self.crawl_async_result.ready():\n time.sleep(0)\n \n # self.crawl_async_result is a list of { URLs, links, htmls } to be parsed\n \n self.crawlstatus = \"Done\"\n self.elapsed = (time.clock() - start)\n print \"Crawl Done\"\n print json.dumps(self.crawl_async_result.result, indent=4)\n \n self.__insert_into_db(self.crawl_async_result.result)\n content = json.dumps({\"query_id\":self.qid, \"message\":\"done\", \"dbkey\":str(self.dbkey), \"time\":self.elapsed});\n config.mqchannel.basic_publish(exchange=config.get(\"MQEXCHANGE\"), routing_key='', body=content)","def start_job(self):\n # POST /jobs/{job_id}/results\n pass","def start_crawlers(spider_name: str, rules: List[Rule]) -> None:\n runner = CrawlerRunner(settings)\n crawlers = runner.spider_loader.list()\n crawlers = [c for c in crawlers if c.__contains__(spider_name)]\n if crawlers:\n for rule in rules:\n runner.crawl(crawlers[0], rule=rule)\n d = runner.join()\n d.addBoth(lambda _: reactor.stop())\n reactor.run()\n launch_logger.debug('all finished.')\n else:\n launch_logger.warning('provide the right spider name.')","def start_screenshot_job_if_needed(self):\n url2scrape = None\n if self.task_data.get('product_url', self.task_data.get('url', None)):\n url2scrape = self.task_data.get('product_url', self.task_data.get('url', None))\n # TODO: searchterm jobs? checkout scrapers?\n if url2scrape:\n # scrapy_path = \"/home/spiders/virtual_environment/bin/scrapy\"\n # python_path = \"/home/spiders/virtual_environment/bin/python\"\n output_path = self.get_output_path()\n cmd = ('cd {repo_base_path}/product-ranking'\n ' && scrapy crawl url2screenshot_products'\n ' -a product_url=\"{url2scrape}\" '\n ' -a width=1280 -a height=1024 -a timeout=90 '\n ' -s LOG_FILE=\"{log_file}\"'\n ' -o \"{output_file}\" &').format(\n repo_base_path=REPO_BASE_PATH,\n log_file=output_path+'.screenshot.log', url2scrape=url2scrape,\n output_file=output_path+'.screenshot.jl')\n logger.info('Starting a new parallel screenshot job: %s' % cmd)\n os.system(cmd) # use Popen instead?","def crawl(self, url):\n return None","def start_requests(self):\r\n try:\r\n\r\n for url in self.start_urls:\r\n yield scrapy.Request(url,\r\n callback=self.navigate_to)\r\n except Exception as err:\r\n logger.error(f'TekDefenceScraper : start_requests : {err}')\r\n raise err","def start(self, job: PandaJob) -> None:\n raise NotImplementedError(\"Base method not implemented\")","def crawl(self):\n try:\n self.crawl_pages()\n self.crawl_posts()\n self.crawl_comments()\n except Exception as exception:\n self.handle_request_limit(exception)","def open_spider(self, spider):\n now = spider.get_now_time()\n\n # Create initial batch\n spider.batch = model.Batch.objects.create(\n kickoff_time=now, finish_time=now)\n spider.batch.save()\n\n # save initial site list\n file_content = ContentFile('\\n'.join(spider.start_urls))\n filename = str(spider.batch).replace(' ', '')\n spider.batch.sitelist.save(filename, file_content)\n spider.batch.sitelist.close()\n spider.batch.save()\n\n spider.batch_user_agents = []\n\n # Give the spider a set of batch user agents, which preserve historical\n # user agent data\n for ua in list(model.UserAgent.objects.all()):\n batch_user_agent = model.BatchUserAgent.objects.create(\n batch=spider.batch,\n ua_string=ua.ua_string,\n primary_ua=ua.primary_ua,\n ua_type=ua.ua_type,\n ua_human_name=ua.ua_human_name\n )\n spider.batch_user_agents.append(batch_user_agent)\n\n if not spider.batch_user_agents:\n raise ValueError(\n \"No user agents; add some with 'manage.py useragents --add'\")","def scrape_pipeline(args):\n kickoff = args.kickoff\n fname = args.fname\n d = DbHelper()\n s = Scraper()\n c = Crawler(20)\n if fname is not None:\n app_names = pd.read_csv(fname)['packageName'].tolist()\n apps = [list(a) for a in zip(app_names, d.app_names_to_uuids(app_names))]\n else:\n apps = None\n\n # start by updating top apps\n if not args.skip_top:\n logger.info(\"getting top apps...\")\n new_top_list = c.get_top_apps_list()\n logger.info(\"scraping top apps not in DB...\")\n s.scrape_missing(new_top_list, compare_top=True)\n logger.info(\"updating top apps...\")\n d.update_top_apps(new_top_list)\n\n if kickoff == True:\n s = None\n if fname is None:\n # use crawler to get list of package names\n logger.error(\"Crawler for package names not implemented yet\")\n return\n else:\n # use specified file of package names\n s = Scraper(input_file=fname)\n\n # use scraper\n logger.info(\"Starting efficient scrape...\")\n s.efficient_scrape()\n logger.info(\"...efficient scrape done\")\n else:\n # use updater\n logger.info(\"Starting updater...\")\n if fname is None:\n u = Updater()\n else:\n u = Updater(input_file=fname)\n u.update_apps()\n logger.info(\"...update done\")\n\n # crawl privacy policies\n c.crawl_app_privacy_policies(app_list=apps)\n\n if args.no_decompile:\n # download only\n logger.info(\"Starting download...\")\n downloader = Downloader()\n if apps is None:\n downloader.download_all_from_db(top=True)\n else:\n downloader.download(apps)\n logger.info(\"...done\")\n else:\n # download/decompile\n logger.info(\"Starting download and decompile...\")\n download_decompile_all()\n logger.info(\"...download and decompile done\")\n logger.info(\"run analysis pipeline now\")","def job(name):\n current_app.logger.info(\"Running custom job: {}\".format(name))","def start_requests(self):\n self.spider = Base_Spider(LpCfg)\n self.first_url = 'https://www.liepin.com/zhaopin/' \\\n '?industries=&dqs=010&salary=15%2440' \\\n '&jobKind=2&pubTime=3&compkind=&compscale=' \\\n '&industryType=&searchType=1&clean_condition=' \\\n '&isAnalysis=&init=1&sortFlag=15&flushckid=1' \\\n '&fromSearchBtn=2&headckid=0b5a9690a5cb1d82&key=Python'\n urls = []\n s = self.spider.get_content(self.first_url)\n self.cookies = self.spider.session.cookies.get_dict()\n del s\n self.spider.headers.update({'Cookie': self.cookies})\n for page in range(1,5):\n url = self.first_url + '&curPage=%d'%page\n urls.append(url)\n for url in urls:\n print url\n yield scrapy.Request(url=url,\n callback=self.parse,\n headers=self.spider.headers,\n cookies=self.cookies\n )","def process_job():\n r = redis.StrictRedis()\n while True:\n curr_job = r.blpop('job_queue', 0)[1]\n r.hset('status', curr_job, 'processing')\n print('current job ID:', curr_job)\n # convert byte to string\n url = r.hget('urls', curr_job).decode(\"utf-8\")\n print('Current URL:', url)\n\n # if this url has not been requested before/is not in the db\n if Site.query.filter_by(url=url).first():\n r.hset('status', curr_job, 'complete')\n print('Job', curr_job, 'Completed')\n else:\n # fetches url page source\n try:\n html = str(get_html(url))\n print('Successfully retrieved HTML')\n # add results to database\n db.session.add(Site(url=url, html=html))\n db.session.commit()\n print('Added to database')\n r.hset('status', curr_job, 'complete')\n print('Job', curr_job, 'Completed')\n except ValueError:\n r.hset('status', curr_job, 'abort')\n print('Job', curr_job, 'Aborted')\n except TimeoutError:\n r.hset('status', curr_job, 'timeout')\n print('Job', curr_job, 'Timed Out')\n return","def __process_job(self, job):\r\n\r\n job_a_tag = job.find_element_by_tag_name('a')\r\n job_href = job_a_tag.get_attribute('href')\r\n # Removing all extraneous indeed url query string parameters\r\n job_href = job_href.split('&from')[0] \r\n self.nav(job_href)","def crawl(self, keyword, since=None, to=None):\n no_of_pages = self.get_no_of_pages(keyword, since, to)\n print('pages: ' + str(no_of_pages))\n self.keyword = keyword\n self.since = since\n self.to = to\n p = Pool()\n p.map(self.distribute, range(1, no_of_pages+1))","def crawl(self):\n self.get('http://code.google.com/p/webscraping/')\n self.get('http://code.google.com/p/sitescraper/')\n QTimer.singleShot(5000, self.app.quit)","def crawl(self):\n if os.path.exists(self.__work_path):\n shutil.rmtree(self.__work_path)\n print '\\nOld Data Was Found And Removed.\\n'\n\n initial_first_run = True\n initial_recursion_depth = 0\n initial_prev_link_size = 0\n for url in self.__urls:\n self.__start_recursion(url, initial_first_run,\n initial_recursion_depth, initial_prev_link_size)\n\n Crawler.mission_report(self.__work_path)","def _start_scrapy_process(self):\n cmd = self._parse_task_and_get_cmd()\n self.process = Popen(cmd, shell=True, stdout=PIPE,\n stderr=PIPE, preexec_fn=os.setsid)\n if self.task_data.get('with_best_seller_ranking', False):\n logger.info('With best seller ranking')\n cmd = self._parse_task_and_get_cmd(True)\n self.process_bsr = Popen(cmd, shell=True, stdout=PIPE,\n stderr=PIPE, preexec_fn=os.setsid)\n else:\n logger.info('Skipping best seller')\n logger.info('Scrapy process started for task #%s',\n self.task_data.get('task_id', 0))","def parse(self, response):\n\n\t\t### close spider if exception\n\t\tif 'Bandwidth exceeded' in response.body:\n\t\t\traise CloseSpider('bandwidth_exceeded')\n\n\t\tlog_scrap.debug(u\"\\n>>> NEW PARSING >>>\\n\" )\n\t\tlog_scrap.info(\"--- GenericSpider.parse ...\" )\n\n\t\tlog_scrap.info(\"\\n--- GenericSpider.parse /response : \\n%s\" , response)\n\t\tlog_scrap.info(\"\\n--- GenericSpider.parse /response : \\n%s \\n\" , response.__dict__.keys() )\n\n\t\t# for k, v in response.__dict__.iteritems() :\n\t\t# \tlog_scrap.info(\"\\n--- [k] {} : [v] {} : \".format(k,v))\n\t\t# print response._body\n\t\tstart_url = response.meta[\"start_url\"]\n\t\tlog_scrap.info(\"--- GenericSpider.parse / start_url : %s\", start_url )\n\n\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t### start request with API crawler\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t# if self.spider_config_flat[\"parse_api\"] == True :\n\t\tif self.parse_api == True :\n\n\t\t\tlog_scrap.info(\"\\n--- GenericSpider.parse / starting request on API endpoint... \" )\n\t\t\tjsonresponse = json.loads(response.body_as_unicode())\n\t\t\t# log_scrap.info(\"--- GenericSpider.parse / jsonresponse : \\n%s\", jsonresponse )\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / jsonresponse received...\" )\n\n\t\t\traw_items_list = get_dictvalue_from_xpath(jsonresponse, self.item_xpath)\n\t\t\t# raw_items_list = jsonresponse[self.item_xpath]\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / raw_items_list[0] : \\n%s\\n...\", pformat(raw_items_list[0]) )\n\n\t\t\t### - - - - - - - - - - ###\n\t\t\t### PARSING PAGE - API\n\t\t\t### start parsing page : loop through data items in page in response\n\t\t\tif len(raw_items_list) != 0 :\n\n\t\t\t\tlog_scrap.info(\"--- GenericSpider. / START LOOPING raw_items_list WITH API ...\" )\n\n\t\t\t\t# while self.there_is_more_items_to_scrap_dict[start_url] :\n\n\t\t\t\tfor raw_data in raw_items_list :\n\n\t\t\t\t\tself.item_count += 1\n\n\t\t\t\t\t### check if can continue depending on item_count\n\t\t\t\t\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\n\n\t\t\t\t\t\tprint()\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - API - item n°{} >>> \\n\".format(self.item_count) )\n\n\t\t\t\t\t\t### instantiate Item to fill from datamodel --> cf items.py\n\t\t\t\t\t\titemclass \t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\n\t\t\t\t\t\titem \t\t= itemclass()\n\n\t\t\t\t\t\t### add global info to item : i.e. core fields in dm_core_item_related list\n\t\t\t\t\t\titem[ 'spider_id' ]\t= self.spider_id\n\t\t\t\t\t\titem[ 'added_by' ]\t= self.user_id\n\t\t\t\t\t\titem[ 'added_at' ]\t= time.time()\t\t# timestamp\n\t\t\t\t\t\titem[ 'link_src' ]\t= response._url\n\n\t\t\t\t\t\titem[ 'page_n' ]\t\t= self.page_count\n\t\t\t\t\t\titem[ 'item_n' ]\t\t= self.item_count\n\n\t\t\t\t\t\t### extract data and feed it to the Item instance based on spider_config_flat\n\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, is_api_rest=True, item_n=self.item_count)\n\n\n\t\t\t\t\t\t### - - - - - - - - - - ###\n\t\t\t\t\t\t### FOLLOW LINK - API\n\t\t\t\t\t\t### if need to follow to extract all data\n\t\t\t\t\t\tif self.spider_config_flat[\"parse_follow\"] == True :\n\n\t\t\t\t\t\t\tlog_scrap.debug(u\">>> FOLLOW LINK - API - item n°{} / page n°{} >>>>>> \\n\".format(self.item_count, self.page_count) )\n\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_xpath : %s\", self.follow_xpath )\n\n\t\t\t\t\t\t\t# follow_link_raw = raw_data[ self.follow_xpath ]\n\t\t\t\t\t\t\tfollow_link_raw = get_dictvalue_from_xpath(raw_data, self.follow_xpath)\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link RAW ({}) : {} \".format(type(follow_link_raw),follow_link_raw) )\n\n\t\t\t\t\t\t\turl_follow = \"\"\n\t\t\t\t\t\t\tif self.api_follow_root != \"\" :\n\t\t\t\t\t\t\t\t\turl_follow = self.api_follow_root\n\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\turl_follow = self.page_url\n\n\t\t\t\t\t\t\t# complete follow link if needed\n\t\t\t\t\t\t\tfollow_link = self.clean_link(follow_link_raw, url_root=url_follow)\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link CLEAN : %s \", follow_link )\n\n\t\t\t\t\t\t\t# store follow_link\n\t\t\t\t\t\t\titem[ 'link_data' ]\t= follow_link\n\t\t\t\t\t\t\turl \t\t\t\t= item['link_data']\n\n\t\t\t\t\t\t\tfollow_is_api = self.follow_is_api\n\n\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url, 'item_n' : self.item_count , 'parse_api' : follow_is_api })\n\n\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t### if no follow link\n\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\n\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t# log_scrap.info(\" --> item : \\n %s \\n\", pformat(item) )\n\t\t\t\t\t\tlog_scrap.debug(u\" --> item ...\" )\n\n\t\t\t\t\telse :\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\t# log_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\n\n\t\t\t\telse :\n\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t# raise CloseSpider('OUT OF ITEMS')\n\n\t\t\t### - - - - - - - - - - - - ###\n\t\t\t### NEXT PAGE - API\n\t\t\tif self.test_limit == None or self.page_count < self.test_limit :\n\n\t\t\t\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\n\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse (API) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\n\".format(self.page_count) )\n\n\t\t\t\t\t### get and go to next page\n\t\t\t\t\tself.page_count += 1\n\n\t\t\t\t\turl_next = \"\"\n\t\t\t\t\tif self.api_pagination_root != \"\" :\n\t\t\t\t\t\turl_next = self.api_pagination_root\n\t\t\t\t\telse :\n\t\t\t\t\t\turl_next = self.page_url\n\n\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\tnext_page = url_next + str(self.page_count)\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse >>> NEXT PAGE II : %s\", next_page )\n\n\t\t\t\t\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\n\n\t\t\t\telse :\n\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} \".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\t\t\telse :\n\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} \".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t### start requests with pure Scrapy requests\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\telif self.spider_config_flat[\"parse_reactive\"] == False :\n\t\t# elif self.parse_reactive == False :\n \n\t\t\tlog_scrap.info(\"\\n--- GenericSpider.parse / starting requests with Scrapy... \" )\n\t\t\t# self.parse_scrapy(response)\n\n\t\t\t### find items list\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / self.item_xpath : %s\", self.item_xpath )\n\t\t\traw_items_list = response.xpath(self.item_xpath)\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / len(raw_items_list) : %d \", len(raw_items_list) )\n\n\n\t\t\t### - - - - - - - - - - - ###\n\t\t\t### PARSING PAGE - SCRAPY\n\t\t\t### start parsing page : loop through data items in page in response\n\t\t\tif len(raw_items_list) != 0 :\n\n\t\t\t\tlog_scrap.info(\"--- GenericSpider. / START LOOPING raw_items_list WITH SCRAPY ...\" )\n\n\t\t\t\tfor raw_data in raw_items_list :\n\n\t\t\t\t\tself.item_count += 1\n\n\t\t\t\t\t### check if can continue depending on item_count\n\t\t\t\t\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\n\n\t\t\t\t\t\tprint()\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - Scrapy - item n°{} / page n°{} >>> \\n\".format(self.item_count, self.page_count) )\n\n\t\t\t\t\t\t# print \">>> raw_data : \\n\", raw_data.extract()\n\n\t\t\t\t\t\t### instantiate Item to fill from datamodel --> cf items.py\n\t\t\t\t\t\titemclass \t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\n\t\t\t\t\t\titem \t\t= itemclass()\n\n\t\t\t\t\t\t### add global info to item : i.e. core fields in dm_core_item_related list\n\t\t\t\t\t\titem[ 'spider_id' ]\t\t= self.spider_id\n\t\t\t\t\t\titem[ 'added_by' ]\t\t= self.user_id\n\t\t\t\t\t\titem[ 'added_at' ]\t\t= time.time()\t\t# timestamp\n\t\t\t\t\t\titem[ 'link_src' ]\t\t= response._url\n\n\t\t\t\t\t\titem[ 'page_n' ]\t\t= self.page_count\n\t\t\t\t\t\titem[ 'item_n' ]\t\t= self.item_count\n\n\t\t\t\t\t\t### extract data and feed it to the Item instance based on spider_config_flat\n\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, item_n=self.item_count)\n\n\n\t\t\t\t\t\t### - - - - - - - - - - - ###\n\t\t\t\t\t\t### FOLLOW LINK - SCRAPY\n\t\t\t\t\t\t### if need to follow to extract all data\n\t\t\t\t\t\tif self.spider_config_flat[\"parse_follow\"] == True :\n\n\t\t\t\t\t\t\tlog_scrap.debug(u\">>> FOLLOW LINK - SCRAPY - item n°{} / page n°{} >>>>>> \\n\".format(self.item_count, self.page_count) )\n\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_xpath : %s\", self.follow_xpath )\n\n\t\t\t\t\t\t\tfollow_link \t= raw_data.xpath( self.follow_xpath ).extract_first()\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link RAW ({}) : {} \".format(type(follow_link),follow_link) )\n\n\t\t\t\t\t\t\turl_follow = \"\"\n\t\t\t\t\t\t\tif self.api_follow_root != \"\" :\n\t\t\t\t\t\t\t\turl_follow = self.api_follow_root\n\n\t\t\t\t\t\t\t# complete follow link if needed\n\t\t\t\t\t\t\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\n\t\t\t\t\t\t\t# log_scrap.info(\" --> follow_link CLEAN : %s \", follow_link )\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link CLEAN ({}) : {} \".format(type(follow_link),follow_link) )\n\n\t\t\t\t\t\t\t# store follow_link\n\t\t\t\t\t\t\titem[ 'link_data' ]\t= follow_link\n\t\t\t\t\t\t\turl \t\t\t\t= item['link_data']\n\n\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOWING LINK --> url : {} \".format(url) )\n\t\t\t\t\t\t\t\t# yield Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url } )\n\t\t\t\t\t\t\t\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False} )\n\t\t\t\t\t\t\t\t# log_scrap.warning(u\">>> FOLLOWING LINK --> url : {} / WORKED !!! \".format(url) )\n\n\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOW LINK - NOT WORKING : {} \".format(url) )\n\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t### if no follow link\n\t\t\t\t\t\telse :\n\n\t\t\t\t\t\t\tlog_scrap.warning(u\">>> NO FOLLOW LINK ... \" )\n\t\t\t\t\t\t\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\n\t\t\t\t\t\t\t# log_scrap.info(\">>> GenericSpider.parse - item.items() : \\n %s\", item.items() )\n\t\t\t\t\t\t\t# log_scrap.info(\">>> GenericSpider.parse - item.keys() : \\n %s\", item.items() )\n\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t# print (\"\\n>>> NEXT ITEM \" + \">>> >>> \"*10, \"\\n\")\n\n\t\t\t\t\t\t# log_scrap.info(\" --> item : \\n %s \\n\", pformat(item) )\n\t\t\t\t\t\tlog_scrap.debug(u\" --> item ...\" )\n\n\t\t\t\t\telse :\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\n\n\t\t\telse :\n\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t# raise CloseSpider('OUT OF ITEMS')\n\n\t\t\t### - - - - - - - - - - ###\n\t\t\t### NEXT PAGE - SCRAPY\n\t\t\t### check if there is a test_limit\n\t\t\tif self.test_limit == None or self.page_count < self.test_limit :\n\n\t\t\t\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\n\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse (Scrapy) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\n\".format(self.page_count) )\n\n\t\t\t\t\t### get and go to next page\n\t\t\t\t\tis_next_page, next_page = self.get_next_page(response, start_url)\n\n\t\t\t\t\tif is_next_page :\n\n\t\t\t\t\t\tself.page_count += 1\n\n\t\t\t\t\t\turl_next = \"\"\n\t\t\t\t\t\tif self.api_pagination_root != \"\" :\n\t\t\t\t\t\t\turl_next = self.api_pagination_root\n\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse >>> NEXT PAGE I : %s\", next_page )\n\t\t\t\t\t\tnext_page = self.clean_link(next_page, url_root=url_next)\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse >>> NEXT PAGE II : %s\", next_page )\n\n\t\t\t\t\t\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\n\n\t\t\t\t\telse :\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / NO MORE PAGE TO SCRAP - pages count : {} \".format(self.page_count) )\n\t\t\t\t\t\t# raise CloseSpider('NO MORE PAGE TO SCRAP')\n\n\t\t\t\telse :\n\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\t\t\telse :\n\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t### start requests with Selenium\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\telse :\n\t\t\t### initiate selenium browser\n\t\t\t### cf : https://github.com/voliveirajr/seleniumcrawler/blob/master/seleniumcrawler/spiders/seleniumcrawler_spider.py\n\t\t\tlog_scrap.info(\"\\n--- GenericSpider.parse / starting Selenium driver... \" )\n\n\t\t\t# retrieve exec path for chromedriver from settings_scrapy.py\n\t\t\t### GET APP MODE FROM ENV VARS\n\t\t\tapp_mode \t\t\t\t\t\t= os.environ.get('APP_MODE', 'default')\n\t\t\tlog_scrap.debug(u\"--- GenericSpider.parse / APP_MODE : %s\", app_mode)\n\t\t\tchromedriver_path \t= CHROMEDRIVER_PATH_LIST[ app_mode ]\n\t\t\tlog_scrap.debug(u\"--- GenericSpider.parse / chromedriver_path : %s\", chromedriver_path)\n\n\t\t\t### specify executable path to launch webdriver-->\n\t\t\t# cf : where chromedriver was installed when `brew install chromedriver`\n\t\t\tself.driver = webdriver.Chrome(executable_path=chromedriver_path, chrome_options=options_selenium)\n\t\t\t# self.driver = webdriver.Chrome(chrome_options=options_selenium)\n\t\t\t# self.driver = webdriver.Firefox()\n\t\t\t# self.driver = webdriver.Chrome()\n\t\t\t# self.driver = webdriver.PhantomJS() ### deprecated\n\n\t\t\t### setup waiting times\n\t\t\t# self.driver.set_page_load_timeout(60)\n\t\t\tself.wait_driver\t= WebDriverWait(self.driver, self.delay_driver)\n\t\t\tself.wait_page \t\t= WebDriverWait(self.driver, self.delay_new_page)\n\t\t\tself.driver.implicitly_wait(self.delay_implicit)\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / self.delay_driver : %s\", self.delay_driver )\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / self.delay_new_page : %s\", self.delay_new_page )\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / self.delay_implicit : %s\", self.delay_implicit )\n\n\n\t\t\t### start parsing with selenium\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / response._url : %s\", response._url )\n\t\t\ttry :\n\t\t\t\tself.driver.get(response._url)\n\n\t\t\t\t### try scroll_down if needed in config\n\t\t\t\tif self.spider_config_flat['scroll_down'] : \n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / scroll_down is TRUE ... \" )\n\t\t\t\t\t# log_scrap.debug(u\"--- GenericsSpider. / scroll_down - self.spider_config_flat : \\n%s\", pformat(self.spider_config_flat) )\n\n\t\t\t\t\tscroll_pause_time = self.spider_config_flat[\"scroll_pause_time\"]\n\t\t\t\t\tmax_loops \t\t\t\t= self.spider_config_flat[\"scroll_loops\"]\n\t\t\t\t\tself.driver = scroll_down(self.driver, scroll_pause_time, max_loops)\n\t\t\t\t\t# scroll_down(self.driver, scroll_pause_time, max_loops)\n\t\t\t\tlog_scrap.info(\"--- GenericSpider. / url '{}' is loaded ... \".format( response._url ))\n\t\t\t\n\t\t\texcept :\n\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tself.driver.close()\n\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\traise CloseSpider('DRIVER NOT RESPONDING')\n\n\n\t\t\t### clean original xpath from strings\n\t\t\tstrings_to_clean = [\n\t\t\t\t'/@src',\n\t\t\t\t'/@href',\n\t\t\t\t'/text()',\n\t\t\t\t'/@*[name()=\"xlink:href\"]',\n\t\t\t\t'/@datetime'\n\t\t\t]\n\n\t\t\t# while self.there_is_more_items_to_scrap :\n\t\t\twhile self.there_is_more_items_to_scrap_dict[start_url] :\n\n\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / while loop continues : %s\", self.there_is_more_items_to_scrap )\n\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / while loop continues : %s\", self.there_is_more_items_to_scrap_dict[start_url] )\n\n\t\t\t\ttry :\n\n\t\t\t\t\t### wait / debug page content\n\t\t\t\t\tpage_source_code = self.driver.page_source.encode(\"utf-8\")\n\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / page_source_code : \\n %s \", page_source_code )\n\t\t\t\t\ttime.sleep(self.delay_new_page)\n\n\t\t\t\t\t### start parsing page :\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.item_xpath : %s\", self.item_xpath )\n\t\t\t\t\traw_items_list \t= self.driver.find_elements_by_xpath(self.item_xpath)\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / raw_items_list length : %s\", len(raw_items_list) )\n\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / raw_items_list[0].text : \\n%s\", raw_items_list[0].text )\n\n\t\t\t\t\t# current_item_index = 0\n\n\t\t\t\t\t### - - - - - - - - - - - - ###\n\t\t\t\t\t### PARSING PAGE - SELENIUM\n\t\t\t\t\t# loop through data items in page in response\n\t\t\t\t\tif len(raw_items_list) != 0 :\n\n\t\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / START PARSING WITH SELENIUM ...\\n\" )\n\n\t\t\t\t\t\tfor raw_data in raw_items_list :\n\n\t\t\t\t\t\t\tprint()\n\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / START LOOPING raw_items_list WITH SELENIUM ...\" )\n\n\t\t\t\t\t\t\t### add +1 to items count\n\t\t\t\t\t\t\tself.item_count += 1\n\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} - there_is_more_items_to_scrap_dict[start_url] : {} \".format(str(self.spider_name), self.item_count, self.there_is_more_items_to_scrap_dict[start_url]) )\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} \".format(self.spider_name, self.item_count) )\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - item n°{} \".format(self.item_count) )\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - spider_name : '%s' - item n°%s \" %(self.spider_name, self.item_count) )\n\n\t\t\t\t\t\t\t### check if can continue depending on item_count\n\t\t\t\t\t\t\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\n\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - Selenium - item n°{} / page n°{} >>> \\n\".format(self.item_count, self.page_count) )\n\n\t\t\t\t\t\t\t\t### instantiate Item to fill from datamodel --> cf items.py\n\t\t\t\t\t\t\t\titemclass \t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\n\t\t\t\t\t\t\t\titem \t\t= itemclass()\n\n\t\t\t\t\t\t\t\t### add global info to item : i.e. core fields in dm_core_item_related list\n\t\t\t\t\t\t\t\titem[ 'spider_id' ]\t\t= self.spider_id\n\t\t\t\t\t\t\t\titem[ 'added_by' ]\t\t= self.user_id\n\t\t\t\t\t\t\t\titem[ 'added_at' ]\t\t= time.time()\t\t# timestamp\n\t\t\t\t\t\t\t\titem[ 'link_src' ]\t\t= response._url\n\n\t\t\t\t\t\t\t\titem[ 'page_n' ]\t\t= self.page_count\n\t\t\t\t\t\t\t\titem[ 'item_n' ]\t\t= self.item_count\n\n\t\t\t\t\t\t\t\t### extract data and feed it to the Item instance based on spider_config_flat\n\t\t\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\n\n\t\t\t\t\t\t\t\t### - - - - - - - - - - ###\n\t\t\t\t\t\t\t\t### FOLLOW LINK - SELENIUM\n\t\t\t\t\t\t\t\t### find follow link to open detailled item view\n\t\t\t\t\t\t\t\tif self.spider_config_flat[\"parse_follow\"] == True :\n\n\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> FOLLOW LINK - SELENIUM - item n°{} / page n°{} >>>>>> \\n\".format(self.item_count, self.page_count) )\n\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_xpath : %s\", self.follow_xpath )\n\n\t\t\t\t\t\t\t\t\t### follow link with Scrapy\n\t\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / follow link with Scrapy ...\" )\n\n\t\t\t\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / get href of follow_link ...\" )\n\t\t\t\t\t\t\t\t\t\tfollow_link_xpath \t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link_xpath : %s \", follow_link_xpath )\n\n\t\t\t\t\t\t\t\t\t\tfollow_link\t\t\t= raw_data.find_element_by_xpath( follow_link_xpath ).get_attribute('href')\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link RAW : %s \", follow_link )\n\n\t\t\t\t\t\t\t\t\t\turl_follow = \"\"\n\t\t\t\t\t\t\t\t\t\tif self.api_follow_root != \"\" :\n\t\t\t\t\t\t\t\t\t\t\t\turl_follow = self.api_follow_root\n\n\t\t\t\t\t\t\t\t\t\t# complete follow link if needed\n\t\t\t\t\t\t\t\t\t\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link CLEAN ({}) : {}\".format(type(follow_link), follow_link ) )\n\n\t\t\t\t\t\t\t\t\t\t# store follow_link\n\t\t\t\t\t\t\t\t\t\titem[ 'link_data' ]\t= follow_link\n\t\t\t\t\t\t\t\t\t\turl\t\t\t= item['link_data']\n\n\t\t\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOWING LINK --> url : {} \".format(url) )\n\t\t\t\t\t\t\t\t\t\t\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False})\n\n\t\t\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOW LINK - NOT WORKING : {} \".format(url) )\n\t\t\t\t\t\t\t\t\t\t\tyield item\n\n\n\t\t\t\t\t\t\t\t\t### follow link with Selenium\n\t\t\t\t\t\t\t\t\t### FIND A WEBSITE TEST FOR REACTIVE DETAILLED PAGES\n\t\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / follow link with Selenium ...\" )\n\n\t\t\t\t\t\t\t\t\t\tfollow_link_xpath \t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_link_xpath : %s\", self.follow_link_xpath )\n\t\t\t\t\t\t\t\t\t\tfollow_link \t\t= raw_data.find_element_by_xpath( follow_link_xpath )\n\n\t\t\t\t\t\t\t\t\t\t### open link in new tab ?\n\t\t\t\t\t\t\t\t\t\tfollow_link.click()\n\n\t\t\t\t\t\t\t\t\t\t### get data and save data\n\t\t\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / get data and save data ...\" )\n\t\t\t\t\t\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\n\n\t\t\t\t\t\t\t\t\t\t\t### back to previous page and scrap from where it left\n\t\t\t\t\t\t\t\t\t\t\t### cf : https://selenium-python.readthedocs.io/navigating.html#navigation-history-and-location\n\t\t\t\t\t\t\t\t\t\t\tself.driver.back()\n\n\t\t\t\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t\t### if no follow link\n\t\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t\t# log_scrap.info(\" --> item : \\n %s \\n\", pformat(item) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\" --> item ...\" )\n\n\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\t\t\t\traise CloseSpider('OUT OF LIMIT_ITEMS')\n\t\t\t\t\t\t\t\tbreak\n\n\t\t\t\t\telse :\n\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF ITEMS - page n°{} - limit : {} - test_limit : {} / except -> break\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\t\t\t\t\t\tbreak\n\n\t\t\t\t\t### - - - - - - - - - - - - ###\n\t\t\t\t\t### NEXT PAGE - SELENIUM\n\t\t\t\t\tif self.test_limit == None or self.page_count < self.test_limit :\n\n\t\t\t\t\t\tif self.there_is_more_items_to_scrap_dict[start_url] :\n\n\t\t\t\t\t\t\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\n\n\t\t\t\t\t\t\t\tprint ()\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\t\t\t\tlog_scrap.info(\" --- GenericSpider.parse (Selenium) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\n\".format(self.page_count) )\n\n\t\t\t\t\t\t\t\t### add +1 to parsed pages\n\t\t\t\t\t\t\t\tself.page_count += 1\n\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - current start_url : {} >>>\".format(start_url) )\n\n\t\t\t\t\t\t\t\t### find next page btn in current view\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.next_page : %s\", self.next_page )\n\t\t\t\t\t\t\t\tnext_page_xpath = clean_xpath_for_reactive(self.next_page, strings_to_clean)\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page_xpath : %s\", next_page_xpath )\n\t\t\t\t\t\t\t\t# next_page \t= re.sub(\"|\".join(strings_to_clean), \"\", next_page )\n\n\t\t\t\t\t\t\t\t# try :\n\t\t\t\t\t\t\t\t# element_present = EC.presence_of_element_located((By.XPATH, next_page_xpath ))\n\t\t\t\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / next_page present : %s\", element_present )\n\t\t\t\t\t\t\t\t# self.wait.until(element_present)\n\t\t\t\t\t\t\t\t# next_page = self.wait.until( EC.element_to_be_clickable(element_present) )\n\t\t\t\t\t\t\t\t# next_page \t\t= self.driver.find_element_by_xpath( next_page_xpath )\n\t\t\t\t\t\t\t\tnext_page \t\t= self.driver.find_element(By.XPATH, next_page_xpath )\n\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page : %s\", next_page )\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page.text : %s\", next_page.text )\n\n\t\t\t\t\t\t\t\t# except TimeoutException:\n\t\t\t\t\t\t\t\t# except :\n\t\t\t\t\t\t\t\t# \tlog_scrap.error(\"--- GenericSpider. / Timed out waiting for page to load\")\n\n\t\t\t\t\t\t\t\t### click next button and wait for ajax calls to complete (post and get)\n\t\t\t\t\t\t\t\t### cf : http://www.obeythetestinggoat.com/how-to-get-selenium-to-wait-for-page-load-after-a-click.html\n\n\t\t\t\t\t\t\t\t# def wait_for(condition_function):\n\t\t\t\t\t\t\t\t# \t\tstart_time = time.time()\n\t\t\t\t\t\t\t\t# \twhile time.time() < start_time + 3:\n\t\t\t\t\t\t\t\t# \t\tif condition_function():\n\t\t\t\t\t\t\t\t# \t\t\treturn True\n\t\t\t\t\t\t\t\t# \t\telse:\n\t\t\t\t\t\t\t\t# \t\t\ttime.sleep(0.1)\n\t\t\t\t\t\t\t\t# \traise Exception ('Timeout waiting for {}'.format(condition_function.__name__) )\n\n\t\t\t\t\t\t\t\t# def link_has_gone_stale():\n\t\t\t\t\t\t\t\t# \t\ttry:\n\t\t\t\t\t\t\t\t# \t\t# poll the link with an arbitrary call\n\t\t\t\t\t\t\t\t# \t\tnext_page.find_elements_by_xpath(self.item_xpath)\n\t\t\t\t\t\t\t\t# \t\treturn False\n\t\t\t\t\t\t\t\t# \texcept StaleElementReferenceException :\n\t\t\t\t\t\t\t\t# \t\treturn True\n\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- ... ---\")\n\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page.click() \" )\n\t\t\t\t\t\t\t\t\tnext_page.click()\n\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / next_page.send_keys( \\ n )\" )\n\t\t\t\t\t\t\t\t\t# next_page.send_keys(\"\\n\")\n\t\t\t\t\t\t\t\t\t# added this step for compatibility of scrolling to the view\n\t\t\t\t\t\t\t\t\tlog_scrap.error(\"--- GenericSpider. / ALTERNATIVE next_page.click() \" )\n\t\t\t\t\t\t\t\t\t# self.driver.execute_script(\"return arguments[0].scrollIntoView();\", next_page)\n\t\t\t\t\t\t\t\t\t# next_page.click()\n\t\t\t\t\t\t\t\t\tself.driver.execute_script(\"arguments[0].click();\", next_page)\n\n\t\t\t\t\t\t\t\t### wait after click\n\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / wait for ajax to finish... \" )\n\t\t\t\t\t\t\t\t\t# wait_for(link_has_gone_stale)\n\t\t\t\t\t\t\t\t\tself.wait_page.until(lambda driver: self.driver.execute_script('return jQuery.active') == 0)\n\t\t\t\t\t\t\t\t\tself.wait_page.until(lambda driver: self.driver.execute_script('return document.readyState') == 'complete')\n\t\t\t\t\t\t\t\t\t# time.sleep(self.delay_implicit)\n\t\t\t\t\t\t\t\t\ttime.sleep(self.delay_new_page)\n\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\tlog_scrap.error(\"--- GenericSpider. / !!! FAIL / wait for ajax to finish... \" )\n\n\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF PAGES TO SCRAP - page n°{} / except -> break\".format(self.page_count) )\n\t\t\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\t\t\traise CloseSpider('OUT OF PAGES TO SCRAP')\n\t\t\t\t\t\t\t\tbreak\n\n\t\t\t\t\telse :\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\t\t\t\t\t\tbreak\n\n\t\t\t\texcept :\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / NO MORE ITEMS TO SCRAP - item_count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\tself.driver.close()\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\traise CloseSpider('NO MORE ITEMS TO SCRAP')\n\t\t\t\t\tbreak","def spider_and_save_thread(\n self, source_url, crawl_timeout, target_url_patten, max_depth, output_directory):\n url_result = self.crawl(\n source_url,\n crawl_timeout,\n target_url_patten,\n max_depth)\n self.save_url(url_result, crawl_timeout, output_directory)","def start_requests(self):\n yield scrapy.Request(url=self.start_urls[0])","def executor(self, job):\n job.connect(self)\n job.trigger(wait=True, **job.trigger_args) # Wait until job is ready\n job.start() # Notify star of job\n # Run specific action for this job\n job.action(**job.action_args)","def work(self, job):\n pass","def daemon_job(interval):\n time.sleep(3) # Wait for api server to start first\n while True:\n try:\n crawl()\n process_notification()\n except Exception:\n traceback.print_exc()\n time.sleep(interval)","def run(self) -> None:\n\n # These are set here, because user may\n # change settings (i.e. app.config['LOG_LEVEL] = 'DEBUG')\n # after instantiation\n self.logger = create_logger(self.config[\"LOG_LEVEL\"], self.config[\"LOG_FILE\"])\n\n self._check_valid_config()\n self.exporter = Exporter(self.config[\"OUT_FILE\"], self.config[\"OUT_FORMAT\"])\n self.crawler = Crawler(\n self.logger,\n self.exporter,\n wait=self.config[\"WAIT\"],\n timeout=self.config[\"TIMEOUT\"],\n concurrency=self.config[\"CONCURRENCY\"],\n max_retries=self.config[\"MAX_RETRIES\"],\n )\n\n self.logger.info(\"Starting crawler\")\n indent = \" \" * 4\n for key, val in self.config.items():\n self.logger.info(f\"{indent}{key}: {val}\")\n\n # Create a new event loop for each execution\n # Allows run() to be called multiple times\n try:\n loop = asyncio.new_event_loop()\n asyncio.set_event_loop(loop)\n rc = loop.run_until_complete(self.crawler.crawl(self._starting_requests))\n finally:\n loop.close()\n self.end()\n\n if rc == ReturnCode.SUCCESS:\n self.logger.info(\"Crawler ended successfully\")\n else:\n self.logger.critical(\"Crawler ended with error\")","def start_requests(self):\n yield Request(self.base_url, \n callback=self.parse_urls)","def scrap_keywords():\n ParScr = ParallelScraper()\n ParScr.create_and_run_threads()\n return","def _run_express_job(self, class_name, options=\"\"):\n cmd = \"source {bento_home}/bin/kiji-env.sh; express job {jar} {myclass} --kiji {kiji_uri}\"\n cmd = cmd.format(\n bento_home=self.bento_home,\n jar=os.path.join(self.movie_advisor_home, self.express_jar),\n myclass=class_name,\n kiji_uri=self.kiji_uri,\n ) + \" \" + options\n print(run(cmd))","def parse_inner_urls(self, response):\n s = Selector(response)\n\n jobs_per_site = s.xpath('//div[@class=\"col-lg-12 col-md-12 col-sm-12 aggelia-view-title\"]//a/@href').extract()\n print(jobs_per_site)\n\n for inner_site in jobs_per_site:\n url = urljoin(\"https://www.skywalker.gr/\", inner_site)\n yield scrapy.Request(url, callback=self.parse_items)","def launch_job(self,\n job_id: Text,\n parent: Text,\n training_input: Dict[Text, Any],\n job_labels: Optional[Dict[Text, Text]] = None) -> None:\n pass","def scrape_job_page(driver, job_title, job_location):\n \n current_date = str(datetime.datetime.now(pytz.timezone('US/Mountain')))\n json_dct = {'search_title': job_title, \\\n 'search_location': job_location, \\\n 'search_date': current_date, 'job_site': 'glassdoor'}\n\n jobs = driver.find_elements_by_class_name('jobListing')\n\n mongo_update_lst = [query_for_data(driver, json_dct, job, idx) for \n idx, job in enumerate(jobs[:-1])]\n\n store_in_mongo(mongo_update_lst, 'job_postings', 'glassdoor')","def t_run_process(self, *args, **kwargs):\n\n str_cmd = \"\"\n d_request = {}\n d_meta = {}\n\n for k,v in kwargs.items():\n if k == 'request': d_request = v\n\n d_meta = d_request['meta']\n\n if d_meta:\n self.jid = d_meta['jid']\n self.auid = d_meta['auid']\n str_cmd = d_meta['cmd']\n\n if isinstance(self.jid, int):\n self.jid = str(self.jid)\n\n self.dp.qprint(\"spawing and starting poller thread\")\n\n # Start the 'poller' worker\n self.poller = Poller(cmd = str_cmd,\n debugToFile = self.b_debugToFile,\n debugFile = self.str_debugFile)\n self.poller.start()\n\n str_timeStamp = datetime.datetime.today().strftime('%Y%m%d%H%M%S.%f')\n str_uuid = uuid.uuid4()\n str_dir = '%s_%s' % (str_timeStamp, str_uuid)\n self.str_jobRootDir = str_dir\n\n b_jobsAllDone = False\n\n p = self._ptree\n\n p.cd('/')\n p.mkcd(str_dir)\n p.touch('d_meta', json.dumps(d_meta))\n p.touch('cmd', str_cmd)\n if len(self.auid):\n p.touch('auid', self.auid)\n if len(self.jid):\n p.touch('jid', self.jid)\n\n p.mkdir('start')\n p.mkdir('end')\n\n jobCount = 0\n p.touch('jobCount', jobCount)\n\n while not b_jobsAllDone:\n try:\n b_jobsAllDone = self.poller.queueAllDone.get_nowait()\n except queue.Empty:\n self.dp.qprint('Waiting on start job info')\n d_startInfo = self.poller.queueStart.get()\n str_startDir = '/%s/start/%d' % (self.str_jobRootDir, jobCount)\n p.mkdir(str_startDir)\n p.cd(str_startDir)\n p.touch('startInfo', d_startInfo.copy())\n p.touch('/%s/startInfo' % str_dir, d_startInfo.copy())\n\n self.dp.qprint('Waiting on end job info')\n d_endInfo = self.poller.queueEnd.get()\n str_endDir = '/%s/end/%d' % (self.str_jobRootDir, jobCount)\n p.mkdir(str_endDir)\n p.cd(str_endDir)\n p.touch('endInfo', d_endInfo.copy())\n p.touch('/%s/endInfo' % str_dir, d_endInfo.copy())\n\n p.touch('/%s/jobCount' % str_dir, jobCount)\n jobCount += 1\n self.dp.qprint('All jobs processed.')","def start_requests(self):\n for url in self.start_urls:\n yield SplashRequest(\n url=url,\n callback=self.parse,\n method=\"GET\",\n endpoint=\"execute\",\n args={\"wait\": 15.0, \"lua_source\": self.lua_script},\n )","def __init__(self, urls_file_, file_spider_='no', target_format_='', ignored_links_file_='',\n allow_clean_url_='no', time_out_=60, work_path_='./',\n max_recursion_depth_=0, one_bite_='no', white_list_path_=\"\"):\n self.__urls = Crawler.__read_file(urls_file_)\n self.__file_spider = file_spider_\n self.__target_format = target_format_\n self.__allow_clean_url = allow_clean_url_\n self.__one_bite = one_bite_\n self.__white_list_path = white_list_path_\n self.__white_list = []\n\n # loads white list in beginning in case an argument was passed for it\n if self.__file_spider == 'yes' and self.__white_list_path != '':\n self.__white_list = Crawler.__read_white_list(self.__white_list_path)\n\n # link titles that should be ignored during recursions\n self.__ignored_links = Crawler.__read_file(ignored_links_file_)\n\n self.__time_out = time_out_\n self.__work_path = os.path.join(work_path_.rstrip('/')+'/', 'DATA')\n self.__recursion_max_depth = max_recursion_depth_\n self.__extensions = ['txt', 'html', 'csv', 'tsv', 'tar', 'raw']\n\n logging.info('''Crawler Has been Initialized With The Below Configurations:\n-------------------------------------------------------------------\n-urls: %s\n-file_spider: %s\n-target_format: %s\n-ignored_links_file: %s\n-allow_clean_url: %s\n-time_out: %s\n-work_path: %s\n-max_recursion_depth: %s\n-one_bite: %s\n-white_list_path: %s\n''', self.__urls, self.__file_spider, self.__target_format, self.__ignored_links,\n self.__allow_clean_url, self.__time_out, self.__work_path,\n self.__recursion_max_depth, self.__one_bite, self.__white_list_path)","def start_requests(self):\r\n yield Request(url=MooreSpider.start_url,\r\n callback=self.parse_directory_list,\r\n method=\"GET\")","def start(self):\n\t\tself.app.printflush('Sitemap: ' + self.sitemap_url)\n\t\tself.getUrlsList()\n\t\tself.app.printflush('Fetched: ' + str(self.fetched_count))\n\t\tself.app.printflush('Processes: ' + str(self.processes))\n\t\tself.CheckURLs()\n\t\tself.printReport()","def crawl_job_detail(positionId, positionName):\n request_url = 'https://m.lagou.com/jobs/' + str(positionId) + '.html'\n\n headers = {\n 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',\n 'Accept-Encoding': 'gzip, deflate, sdch',\n 'Accept-Language': 'zh-CN,zh;q=0.8',\n 'Host': 'm.lagou.com',\n 'Upgrade-Insecure-Requests': '1',\n 'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/600.1.3 (KHTML, like Gecko) Version/8.0 Mobile/12A4345d Safari/600.1.4'\n }\n\n response = requests.get(request_url, headers=headers, timeout=10, cookies=init_cookies(), proxies=PROXIES)\n\n if response.status_code == 200:\n soup = BeautifulSoup(response.text, 'html5lib')\n items = soup.find('div', class_='items')\n jobnature = items.find('span', class_='item jobnature').span.text.strip()\n workyear = items.find('span', class_='item workyear').span.text.strip()\n education = items.find('span', class_='item education').span.text.strip()\n jd = soup.find_all('div', class_='content')[0].get_text().strip().replace('\\n', '').replace('&nbps;', '') # jd\n\n elif response.status_code == 403:\n print('request is forbidden by the server...')\n else:\n print(response.status_code)\n return [positionId, positionName, jobnature, workyear, education, jd]","def parse_item(self, response):\n NewhouseSpider.crawled_urls.append(response.url)\n item = FocusedScrapyCrawlerItem()\n item['url'] = response.url\n item['link_text'] = response.meta.get('link_text', '') if response.meta else ''\n soup = BeautifulSoup(response.body, 'html.parser')\n\n item['body_p_tags'] = self._getBodyText(soup)\n item['head_title'] = self._getHeadTitle(soup)\n item['last_crawled'] = time.time()\n links = self._getLinks(response, soup)\n\n # get score of the page based upon classifier\n if self.classifier:\n score = self.classifier.score(item['link_text'], item['head_title'], item['body_p_tags'])\n else:\n score = 0.0\n\n item['score'] = score\n yield item\n if score <= 0:\n self.log(\"item={} does not belong to new home so stop crawling\".format(item),\n logging.INFO)\n else:\n for link in links:\n req = Request(link, priority=int(score * 1000000), # after the request is done, run parse_item to train the apprentice\n callback=self.parse_item)\n yield req","def crawl_page(self, keyword, since=None, to=None, page=None):\n data = self.get_news(keyword, since, to, page)\n print(current_process())\n print('crawling page no.: ' + str(page))\n urls = self.get_urls(data)\n p = Process()\n p.start(urls)","def submit(self, **kwargs):\n pwd = curdir\n wd = dirname(self.logFile)\n chdir(wd)\n d = OrderedDict()\n #d['universe'] = 'vanilla'\n #d['executable'] = self.command\n\td['job-name'] = self.name\n\td['nodes'] = 1\n\td['partition'] = defaults.get('queue')\n\td['time'] = defaults.get(\"cputime\")\n\td['mem'] = defaults.get(\"memory\")\n d['output'] = op_join(wd,\"output.log\")\n d['error'] = op_join(wd,\"output.err\")\n csi_file = open(\"submit.sh\", \"w\")\n\tcsi_file.write(\"#!/bin/bash\\n\")\n data = [\"#SBATCH --%s=%s\\n\" % (k, v) for k, v in d.iteritems()]\n csi_file.write(\"\".join(data))\n\tcsi_file.write(\"export DAMPE_WORKFLOW_SERVER_URL=%s\\n\"%DAMPE_WORKFLOW_URL)\n csi_file.write(\"bash script\\n\")\n csi_file.close()\n output = self.__run__(\"sbatch submit.sh\")\n chdir(pwd)\n return self.__regexId__(output)","def run(): # pragma: no cover\n\n register_handler(job_configs.config)\n bot = Bot()\n bot.run()","def start_requests(self):\n\n with open(os.path.join(os.path.dirname(__file__), \"../resources/mapemall_categories.csv\")) as categories:\n for category in csv.DictReader(categories):\n category_text=category[\"category\"]\n url=str(MapemallCrawlerSpider.start_urls[0])+category_text\n # The meta is used to send our search text into the parser as metadata\n yield scrapy.Request(url, callback = self.parse, meta = {\"category_text\": category_text})","def __init__(self, *args, **kwargs):\n super(AlibabaCompanySpider, self).__init__(*args, **kwargs)","def parse_items(self, response):\n items = JobcrawlerItem()\n\n current_date = datetime.now()\n current_date_str = current_date.strftime(\"%b %d %Y %H:%M:%S\")\n\n items[\"timestamp\"] = current_date_str\n items[\"site\"] = self.allowed_domains[0]\n items[\"full_html\"] = response.text\n items[\"job_post_url\"] = response.request.url\n items[\"full_text\"] = \" \".join(response.xpath('//div[@id=\"aggelia-text\"]//text()').re('(\\w+)'))\n\n extracted_title = response.xpath('//h3[@id=\"aggelia-title\"]/text()').extract()\n if extracted_title:\n items[\"job_title\"] = extracted_title[0]\n else:\n items[\"job_title\"] = \"\"\n\n job_requirements = response.xpath(self.requirements_xpath).extract()\n requirements_list = list(filter(lambda item: item.strip() != '', job_requirements))\n items[\"job_requirements\"] = \" \".join(requirements_list).replace('\\n', '')\n\n return items","def continue_crawl(d, runner, begin_time, hour_limit):\n end_time = datetime.now()\n\n # Convert elapsed time to seconds\n elapsed_time = end_time - begin_time\n elapsed_time_seconds = elapsed_time.days * 86400\n elapsed_time_seconds += elapsed_time.seconds\n\n if elapsed_time_seconds < hour_limit:\n wait_time = hour_limit - elapsed_time_seconds\n # print(\"Waiting for {0} seconds\".format(wait_time))\n time.sleep(wait_time)\n\n d = runner.crawl(\"sb_spider\")\n\n # end_time is the new \"start\" time for this iteration of the spider.\n # Pass it in as the 3rd argument.\n d.addBoth(lambda _: continue_crawl(d, runner, end_time, hour_limit))","def _initJobs(self):\n super(DigestManager, self)._initJobs()\n conf = self.config.container_manager\n\n job4 = LoopingCall(self.performRequestedScan)\n job4.start(float(conf.activescan_interval))\n self.jobs.append(job4)","def parse(self, response: scrapy.http.Response):\n for job in self.parse_jobs(response):\n yield job\n\n if self.has_next_page(response):\n yield scrapy.Request(self.next_url,\n meta={'cookiejar': response.meta['cookiejar'],\n 'queries': response.meta['queries']},\n dont_filter=True)","def runNewSearch(self):\n self.__searchJob = self.__startSearch()\n\n self.monitorSearchJob()","def main():\n try:\n jobs = {}\n scraped_jobs = []\n\n scraped_jobs = read_from_text_file(\"\", scraped_jobs_filename)\n\n for URL in URLs:\n if \"www.linkedin.com\" in URL:\n (jobs, scraped_jobs) = linkedin_meta_search(URL, jobs, scraped_jobs)\n if \"www.python.org\" in URL:\n (jobs, scraped_jobs) = pythondotorg_meta_search(URL, jobs, scraped_jobs)\n if \"www.ziprecruiter.com\" in URL:\n (jobs, scraped_jobs) = ziprecruiter_meta_search(URL, jobs, scraped_jobs)\n\n write_to_text_file(\"\", \"scraped_jobs.txt\", scraped_jobs)\n\n for id in jobs.keys():\n score, link, title, company, date_posted, location, full_text = jobs[id]\n\n print(f\"\\nEvaluating {title} at {company} ({id}).\")\n\n try:\n if \"yesterday\" in date_posted:\n age_in_days = 1\n elif \"just now\" in date_posted:\n age_in_days = 0\n elif \"hours ago\" in date_posted or \"hour ago\" in date_posted:\n age_in_days = float(date_posted.split()[0]) / 24\n else:\n datetimePosted = parser.parse(date_posted)\n age = datetime.now().timestamp() - datetimePosted.timestamp()\n age_in_days = int(age / 24 / 60 / 60)\n except parser.ParserError as e:\n print(f\"{e}: {date_posted} couldn't be parsed properly from {link}\")\n age_in_days = 0\n age_reduction = int(age_in_days ** 2)\n score -= age_reduction\n if age_reduction > 0:\n print(\n f\"... docking {age_reduction} from the score ({score}) \\\n because the listing is {age_in_days} days old.\"\n )\n\n for search_phrase in search_phrases.keys():\n if search_phrase.lower() in title.lower():\n\n score_adjustment = 2 * search_phrases[search_phrase]\n score += score_adjustment\n if score_adjustment > 0:\n score_adjustment = \"+\" + str(score_adjustment)\n print(\n f\"... {score_adjustment} points ({score}) for \\\n {search_phrase} being in {title}.\"\n )\n if search_phrase.lower() in full_text.lower():\n score_adjustment = search_phrases[search_phrase]\n score += score_adjustment\n if score_adjustment > 0:\n score_adjustment = \"+\" + str(score_adjustment)\n print(\n f\"... {score_adjustment} points ({score}) for {search_phrase} \\\n being in the text of the listing.\"\n )\n jobs[id][0] = score\n\n print(\"\\n\")\n\n send_email(jobs)\n\n except Exception as e:\n send_email(f\"Not working: {e}\") # \".message}, {e.args}\")","def parse_job(content: scrapy.selector.Selector, job: Job):\n\n job['title'] = content.xpath('.//div[@class=\"hidden-xs likeH2\"]/text()').extract_first().strip()\n job['organization'] = content.xpath('.//div[@class=\"hidden-xs likeH3\"]/text()').extract_first().strip()\n column1_elements = content.xpath('.//div[@class=\"jobHitColumn1\"]/p')\n job['regions'] = column1_elements[0].xpath('text()').extract_first().strip()\n job['area'] = ' '.join(column1_elements[1].xpath('text()').extract_first().strip().split())\n job['url'] = 'https://www.mta-dialog.de/' + \\\n content.xpath('.//a[@class=\"detailLinkParent\"]/@href').extract_first().strip()\n return MTADialogSpider.parse_job_details(job)","def _launch_job(self, job):\n details = self.sm.get_job_details(job.jobId)\n handler = self.handlers[details[0]['method']]\n type = details[0]['type']\n resultId = details[0]['resultid']\n job.set_phase('EXECUTING')\n job.set_start_time(datetime.utcnow().isoformat())\n job.add_result(resultId, 'http://localhost:8000/%s/%s/results/details' % (type, job.jobId))\n self.sm.update_job(job = job)\n self.threads.append(Future(handler, job.jobId, job))","def execute(self, job):\n raise NotImplementedError","def execute(self):\r\n\r\n if username and password:\r\n job_name = input('Please enter the name of the job that you would like to apply for: ')\r\n job_location = input('Please enter where you would like to work: ')\r\n self.login_to_linkedin()\r\n self.driver.maximize_window()\r\n time.sleep(5)\r\n self.job_filter(job_name, job_location)\r\n time.sleep(5)\r\n self.get_job_listings()\r\n else:\r\n print('Please provide a username and password')","def initialize_process():\n\n settings = Settings({'BOT_NAME': 'warnnoticebot',\n 'LOG_LEVEL': 'INFO',\n 'ITEM_PIPELINES': {'modules.pipelines.PerStateJsonlinesExportPipeline': 300},\n 'USER_AGENT': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36', # This is my actual user agent when using a browser\n 'COOKIES_ENABLED': False,\n 'ROBOTSTXT_OBEY': True,\n 'DOWNLOAD_DELAY': 5.0,\n 'DEFAULT_REQUEST_HEADERS': {\n 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',\n 'Accept-Language': 'en',\n 'Upgrade-Insecure-Requests': 1}\n })\n \n process = CrawlerProcess(settings) \n\n return process","def get_worker(self):\n worker = self.worker(job_id=self.job_id, spider=self.spider,\n http_session={'url': self.url, 'timeout': self.timeout},\n **self.kwargs)\n return worker","def __init__(self, board='Gossiping', pages=1, file='tmp.json', title_lim=[], jsonf=None, copy_data=[], simple_mode=True):\n if copy_data:\n self.extend(copy_data)\n return\n os.chdir(os.path.split(os.path.realpath(__file__))[0])\n print(os.getcwd())\n com = 'scrapy crawl ptt ' if not simple_mode else 'scrapy crawl ptt_url '\n # output json file name\n com += '-o %s ' % (file)\n # page\n com += '-a pages=%d ' % (pages)\n # board\n com += '-a board=%s ' % (board)\n\n # title limit\n if title_lim:\n com += '-a title_lim=\"'\n for lim in title_lim:\n com += \"%s,\" % (str(lim))\n com += '\" '\n # not opened by json_file\n if not jsonf:\n # start crawl\n print('Command: ' + com)\n os.system('rm -f {}'.format(file))\n os.system('{}'.format(com))\n # opened by json file\n else:\n file = jsonf\n\n # all data save in self\n self.load_json(file)\n self.com = com\n self.file = file","def crawl_start(crawl_obj):\n \n res = None\n\n if crawl_obj.type in ['user', 'song'] :\n res = eval('crawl_' + crawl_obj.type)(crawl_obj)\n elif crawl_obj.type in ['artist', 'album'] :\n web_data = requests.get(crawl_obj.url, headers = cheat_headers)\n soup = bs4.BeautifulSoup(web_data.text, 'lxml')\n\n res = eval('crawl_' + crawl_obj.type)(crawl_obj.type, soup)\n else:\n print(\"Object type UNKNOWN!\")\n \n return res","def from_crawler(cls, crawler, *args, **kwargs):\n\n spider = super(telecom_vivo_movel_spider, cls).from_crawler(\n crawler, *args, **kwargs)\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\n return spider","def scrape_main() -> None:\n\n logger.info(\"Starting scrape\")\n search_info = construct_scrape_regex_patterns(grab_scrape_info())\n links = run_scrape(\n url=search_info['url'],\n seasons_regex=search_info['seasons'],\n episodes_regex=search_info['episodes']\n )\n if links:\n logger.debug(\"Writing urls to file\")\n with open('urls.txt', 'w') as f:\n for link in links:\n f.write(link + '\\n')\n else:\n logger.warning(\"No links available\")","def run(self):\n self.submit()\n self.start()","def setup_crawler(self, crawlers: List[BaseCrawler]) -> None:\n self.tasks.extend(crawlers)","def run(self):\n\n # The url is too deep, skip the url.. Work is done!\n if self.depth_ > self.depth:\n return\n\n # Get doc id corresponds to the url. Add a new entry into doc index if there is no entry.\n doc_id = self.crawler.document_id(self.curr_url)\n\n # Check if the doc_id has been visited/processed by any of crawler_threads. Add doc_id to seen if not so.\n if self.crawler.checkDocVisitedAndUpdate(doc_id):\n return\n\n # Process the document corresponds to the url\n socket = None\n try:\n socket = urllib2.urlopen(self.curr_url, timeout=self.timeout)\n soup = BeautifulSoup(socket.read())\n self._curr_depth = self.depth_ + 1\n self._curr_doc_id = doc_id\n # Traverse the document as deep as possible and add those newly discovered urls into url queue\n self._index_document(soup)\n # Store (wordId, docId) and (word, url) into inverted_index and resolved_inverted_index respectively.\n self.crawler._add_words_to_document(self._curr_words, self._curr_doc_id)\n except:\n pass\n finally:\n if socket:\n socket.close()","def jobs(self):\n raise NotImplementedError()","def parse_jobs(self, response: scrapy.http.Response):\n hits = response.xpath('//div[@class=\"jobHit\"]')\n for hit in hits:\n job = self.default_job()\n job['queries'] = response.meta['queries']\n for i in MTADialogSpider.parse_job(hit, job):\n yield i","def get_job_soup(what = WHAT, where = WHERE, start = 0):\n\tjob_page = rqs.get(get_job_url(what, where, start))\n\treturn BeautifulSoup(job_page.text, 'html.parser')","def crawl(self, query, start_date, end_date, *args, **kwargs):\n pass","def _initJobs(self):\n pass","def startScrape(latest=False):\n print '*** STARTED SCRAPING: DEFAULT: ***' \n cache.set('default_scrape','true')\n cache.set('scrape_mode','default')\n \n for key in ['scrape_friends','scrape_followers','scrape_tweets']:\n cache.set(key,'')\n \n doDefaultScrape.delay(latest=latest)","def from_crawler(cls, crawler, *args, **kwargs):\n\n spider = super(autos_detran_terceiros_sp_spider, cls).from_crawler(\n crawler, *args, **kwargs)\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\n return spider"],"string":"[\n \"def main():\\n # get input params\\n args = parm_parser.get_args()\\n # init log config\\n log.init_log('./log/mini_spider')\\n if args:\\n # read config file spider.conf\\n conf_params = parm_parser.set_config_by_file(args.conf)\\n # use config set up spider initial params\\n spider = SpiderWorker(conf_params)\\n # init result_path, make it complete\\n spider.set_path()\\n # init url queue\\n spider.set_url_queue()\\n # start to crawl url\\n spider.start_crawl_work()\\n\\n return\",\n \"def crawl(spider: str, book_id: int):\\n proc = CrawlerProcess(get_project_settings())\\n\\n proc.crawl(spider, book_id=book_id)\\n\\n proc.start()\",\n \"def runSpider(spiderClass):\\n\\n\\tprocess = CrawlerProcess({\\n\\t\\t# 'USER_AGENT': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'\\n\\t})\\n\\n\\tprocess.crawl(spiderClass)\\n\\tprocess.start() # the script will block here until the crawling is finished\",\n \"def main():\\n\\n from scrapy.crawler import CrawlerProcess\\n from scrapy.utils.project import get_project_settings\\n\\n process = CrawlerProcess(get_project_settings())\\n process.crawl(NCBIGeoSpider)\\n process.start()\",\n \"def parse(self, response):\\n page_jobs=[]\\n\\n # Calling abstarct method get_jobs_list() and iterating...\\n jobs_div_list=self.get_jobs_list(response)\\n for div in jobs_div_list:\\n \\n # Calling abstarct method get_job_dict()\\n job_dict=self.get_job_dict(div)\\n\\n if not job_dict['url'] or not job_dict['title'] :\\n # At least url, title data is loaded from the list of job posting ...\\n raise ValueError( \\\"Could not find valid job information ('url' and 'title') in data:\\\\n\\\" + \\n str(div.get()) + \\\"\\\\nScraped infos:\\\\n\\\" + str(job_dict) + \\\"\\\\nReport this issue on github!\\\" )\\n \\n # Store source as the name of the spider aka website\\n job_dict['source']=self.name\\n page_jobs.append(job_dict)\\n \\n \\\"\\\"\\\"\\n Load full job page only if:\\n - it's a new job (not in database)\\n - load_full_jobs=Yes\\n - the method parse_full_job_page() has been re-wrote by the Scraper subclass\\n \\\"\\\"\\\"\\n if ( (not self.db or self.db.find_job(job_dict)==None)\\n and self.load_full_jobs ):\\n if type(self).parse_full_job_page != Scraper.parse_full_job_page:\\n # load_full_jobs=Yes and it's supported by scraper\\n # Call parse_full_job_page() with job URL\\n\\n # Handle SeleniumRequest if use_selenium=True\\n if self.use_selenium:\\n yield SeleniumRequest(url=job_dict['url'], \\n callback=self.parse_full_job_page,\\n cb_kwargs=dict(job_dict=job_dict),\\n wait_time=self.selenium_wait_time, script=SCROLL_DOWN)\\n else:\\n yield response.follow(url=job_dict['url'], \\n callback=self.parse_full_job_page,\\n cb_kwargs=dict(job_dict=job_dict))\\n else:\\n yield Job(job_dict)\\n else:\\n yield Job(job_dict)\\n\\n \\\"\\\"\\\" Just printing in one line \\\"\\\"\\\"\\n if self.load_full_jobs:\\n if type(self).parse_full_job_page == Scraper.parse_full_job_page:\\n if self.load_all_new_pages==False:\\n self.log.info(\\\"Scraped {} jobs from {}. Scraper {} does not support load_full_jobs=True and load_all_new_pages=False, some new job postings and job informations might be missing\\\".format(len(page_jobs), response.url, self.name))\\n else:\\n self.log.info(\\\"Scraped {} jobs from {}. Scraper {} does not support load_full_jobs=True, some informations might be missing\\\".format(len(page_jobs), response.url, self.name))\\n else:\\n self.log.info(\\\"Scraping {} jobs from {}...\\\".format(len(page_jobs), response.url))\\n else:\\n if self.load_all_new_pages==False:\\n self.log.info(\\\"Scraped {} jobs from {}. load_all_new_pages=False and load_full_jobs=False, some new job postings and job informations might be missing\\\".format(len(page_jobs), response.url))\\n else:\\n self.log.info(\\\"Scraped {} jobs from {}. load_full_jobs=False, some informations might be missing\\\".format(len(page_jobs), response.url))\\n \\n \\\"\\\"\\\"\\n If all page jobs are new and \\n The method get_next_page_url() has been re-wrote by the Scraper subclass\\n Scrape next page\\n \\\"\\\"\\\"\\n if self.load_all_new_pages==True:\\n if self.db and any( [self.db.find_job(job_dict)!=None for job_dict in page_jobs] ):\\n # All new job postings loaded\\n pass\\n else:\\n if self.get_next_page_url(response)!=None :\\n # Loading next page...\\n if self.use_selenium:\\n yield SeleniumRequest(\\n url=self.get_next_page_url(response),\\n callback=self.parse,\\n wait_time=self.selenium_wait_time, script=SCROLL_DOWN)\\n else:\\n yield response.follow(\\n url=self.get_next_page_url(response),\\n callback=self.parse)\\n else:\\n if type(self).get_next_page_url != Scraper.get_next_page_url:\\n # Last page loaded\\n pass\\n else:\\n self.log.info(\\\"Scraper {} does not support load_all_new_pages=True, some new job postings might be missing\\\".format(self.name))\",\n \"def start(self):\\n self.start_spider()\\n self.start_ranker()\\n\\n concurrent.futures.wait(self.spider_thread_futures) # wait for spiders to finish\\n self.logger.info(\\\"Done crawling\\\")\\n self.ranker.done_crawling.set()\\n\\n self.ranker.print_ranks()\",\n \"def WebscraperTask(job_id):\\n logger.debug(\\\"Entering dispatch_wordscraper with job ID: %s\\\" % str(job_id))\\n\\n # Obtain all required crawler arguments\\n job = Job.objects.get(pk=job_id)\\n word_list = [(term.term_id, term.term)\\n for term in Term.objects.filter(job=job)]\\n site_list = [(site.site_id, site.url, job.max_depth, 'English')\\n for site in Site.objects.filter(job=job)]\\n\\n # Initialize the crawling process\\n logger.debug(\\\"Configuring crawl controller with job_id: \\\" +\\n \\\"%d, terms: %s, sites: %s\\\" % (job_id, str(word_list),\\n str(site_list),))\\n controller = init_controller()\\n controller.crawl(job_id, site_list, word_list)\\n logger.debug(\\\"Crawl complete for job: %d\\\" % job_id)\\n\\n # Cache the results in the database so the results are dated as close to the\\n # crawl date as possible.\\n results = controller.query(site_list, word_list)\\n result_cache = Result()\\n result_cache.job = job\\n result_cache.output = results\\n result_cache.save()\",\n \"def __init__(self, config, processors):\\n source = HackernewsStories()\\n source.configure(config)\\n\\n super(HackernewsCrawlJob, self).__init__(source, processors)\",\n \"def crawler():\\n job_entries = []\\n for job in job_info(URL):\\n labels = \\\"\\\"\\n if job[\\\"labels\\\"]:\\n for label in job[\\\"labels\\\"]:\\n labels += label[\\\"name\\\"]\\n if job[\\\"labels\\\"].index(label) != len(job[\\\"labels\\\"]) - 1:\\n labels += \\\",\\\"\\n job_entries.append((job[\\\"number\\\"], job[\\\"id\\\"],\\n job[\\\"title\\\"], job[\\\"html_url\\\"], labels))\\n\\n conn = sqlite3.connect('jobber/jobber.db')\\n c = conn.cursor()\\n c.executemany(('INSERT OR IGNORE INTO job_entries '\\n 'VALUES (?,?,?,?,?)'), job_entries)\\n conn.commit()\\n conn.close()\",\n \"def main(call_args):\\n\\n args = parse_args(call_args)\\n init_logging(args.loglevel)\\n\\n _log.info(\\\"'scrape-jobs' called with args: %s\\\", args)\\n runner.run_with_config_file(args.site, args.config_file)\",\n \"def kickoff(self):\\n settings = Settings()\\n\\n # settings.set(\\\"USER_AGENT\\\", \\\"Test\\\")\\n settings.set('JOBDIR', self.args.data_dir)\\n self.spider = MavenDataSpider()\\n\\n # Wrap with crawler, configure\\n crawler = Crawler(self.spider, settings)\\n crawler.signals.connect(spider_closing, signal=signals.spider_closed)\\n\\n logger.info('Starting crawler')\\n crawler.crawl(self.spider, app=self, dbsess=self.session)\\n\\n self.spider = crawler.spider\\n self.spider.link_queue_mode = False\\n if self.args.debug:\\n coloredlogs.install(level=logging.DEBUG)\\n\\n # Keeping thread working\\n reactor.run()\",\n \"def run_crawl(self, args):\\n\\n # Crawler process declaration\\n process = CrawlerProcess({\\n 'USER_AGENT': 'David Avs Crawler',\\n 'FEED_FORMAT': 'json',\\n 'FEED_URI': 'stdout:',\\n 'LOG_ENABLED': args.verbose,\\n })\\n kwargs = dict(\\n start_urls=[args.url],\\n allowed_domains=[urlparse.urlparse(args.url).netloc.lower()],\\n )\\n\\n # Run crawling\\n old_stdout = sys.stdout\\n sys.stdout = args.file\\n try:\\n process.crawl(DavidAvsSpider, **kwargs)\\n process.start()\\n finally:\\n sys.stdout = old_stdout\",\n \"def run_crawler(self) -> List[JobEventSchema]:\\n print(f\\\"Ready for scraping, current task: {self.tasks}\\\")\\n\\n crawling_result = []\\n for task in self.tasks:\\n result = task.run()\\n crawling_result.extend(result)\\n return crawling_result\",\n \"def run_spider_on_zyte(spider_name):\\n print(f'Running spider {spider_name}...')\\n data = dict(project=project_id, spider=spider_name)\\n response = requests.post('https://app.scrapinghub.com/api/run.json', data=data, auth=(api_key, ''))\\n return response.json()['jobid']\",\n \"def open_spider(self,Spider):\\n pass\",\n \"def runSpider(spider, searchterm = None, fullink = None, spiderbotid = -1):\\n sclogic.runSpider(spider, searchterm, fullink, spiderbotid)\",\n \"def parse(self, response):\\n content = response.body\\n if not content:\\n return\\n sel = Selector(response)\\n #print sel.xpath('//table[@class=\\\"board-list tiz\\\"]/tr').extract()\\n for job in sel.xpath('//ul[@class=\\\"sojob-list\\\"]/li'):\\n #print 'd',job\\n info = job.xpath('div[@class=\\\"sojob-item-main clearfix\\\"]/div[@class=\\\"job-info\\\"]')\\n com_info = job.xpath('div[@class=\\\"sojob-item-main clearfix\\\"]/div[@class=\\\"company-info nohover\\\"]')\\n title = info.xpath('h3/a/text()').extract_first().lower()\\n if title.find('python') != -1:\\n url = info.xpath('h3/a/@href').extract_first()\\n request = scrapy.Request(url=url,\\n callback=self.parse_items,\\n headers=self.spider.headers,\\n cookies=self.cookies)\\n company_item, job_item = CompanyItem(), JobItem()\\n company_item['name'] = com_info.xpath('p[@class=\\\"company-name\\\"]/a/text()').extract_first()\\n company_item['homepage'] = com_info.xpath('p[@class=\\\"company-name\\\"]/a/@href').extract_first()\\n job_item['pub_time'] = info.xpath('p[@class=\\\"time-info clearfix\\\"]/time/text()').extract_first()\\n year = str(date.today().year)\\n if str(year) not in job_item['pub_time']:\\n if job_item['pub_time'] == u'昨天':\\n job_item['pub_time'] = (date.today()-timedelta(days=1)).strftime(\\\"%Y-%m-%d\\\")\\n elif job_item['pub_time'] == u'前天':\\n job_item['pub_time'] = (date.today() - timedelta(days=2)).strftime(\\\"%Y-%m-%d\\\")\\n else:\\n job_item['pub_time'] = date.today().strftime(\\\"%Y-%m-%d\\\")\\n job_item['title'] = title\\n job_item['welfare'] = ' '.join(com_info.xpath('p[@class=\\\"temptation clearfix\\\"]/span/text()').extract())\\n job_item['salary'] = info.xpath('p[@class=\\\"condition clearfix\\\"]/span[@class=\\\"text-warning\\\"]/text()').extract_first()\\n request.meta['company_item'] = company_item\\n request.meta['job_item'] = job_item\\n yield request\",\n \"def crawl(self):\\n\\n # create helper process and setup IPC\\n self.socket.listen(1)\\n help_out_fd = open(self.helper_outfile, \\\"w\\\")\\n with subprocess.Popen(\\\"./crawl_helper.py\\\", stdout=help_out_fd, stderr=subprocess.STDOUT) as proc:\\n self.helper_pid = proc.pid\\n try:\\n conn, _ = self.socket.accept()\\n # create initial params for crawler helper and send them\\n new_urls = set()\\n setup_params = {\\\"start_urls\\\": self.start_urls, \\\"allowed_domains\\\": [self.domain],\\n \\\"cookies\\\": self.cookies, \\\"user_agent\\\": self.config[\\\"user_agent\\\"]}\\n ipc_operations.send_object(conn, setup_params)\\n\\n # loop: receive a response object, then send new URLs to crawl. Catch & handle problems.\\n while True:\\n try:\\n proc.wait(timeout=0.001)\\n break\\n except subprocess.TimeoutExpired:\\n response = ipc_operations.receive_object(conn)\\n if not response: # socket is dead / closed\\n break\\n new_urls = self.process_response(response)\\n ipc_operations.send_object(conn, new_urls)\\n except socket.timeout:\\n util.printit(\\\"Unix socket connection to scrapy crawler unexpectedly broke. \\\" +\\n \\\"Quitting crawling of %s\\\" % self.base_url, color=util.RED)\\n break\\n finally:\\n # ensure connection is closed and helper process killed in any case\\n conn.close()\\n proc.kill()\\n\\n # after the actual crawling, extract all the gathered cookies from Selenium\\n if self.config[\\\"use_selenium\\\"].lower() == \\\"true\\\":\\n selenium_cookies = self.driver.get_cookies()\\n for cookie in selenium_cookies:\\n if not any(cookie[\\\"name\\\"] == c[\\\"name\\\"] and cookie[\\\"path\\\"] == c[\\\"path\\\"] and\\n cookie[\\\"domain\\\"] == c[\\\"domain\\\"] for c in self.found_cookies):\\n parsed_cookie = {}\\n for key in (\\\"name\\\", \\\"path\\\", \\\"domain\\\", \\\"httpOnly\\\", \\\"secure\\\"):\\n parsed_cookie[key] = cookie[key]\\n self.found_cookies.append(parsed_cookie)\\n\\n help_out_fd.close()\\n return self.create_results()\",\n \"def scrape(self):\\n\\n self.jobs_load()\\n self.new_jobs = []\\n\\n for bot in self.bot_squad:\\n self.new_jobs += bot.scrape_all_pages()\\n\\n self.statistics(self.new_jobs)\\n print('SCRAPE COMPLETE. NOTE: Resulting job list still in RAM')\\n print('We observed %d new jobs' % len(self.new_jobs))\",\n \"def run(self):\\n \\n try:\\n logging.info('Thread:{} starting'.format(self.thread_id))\\n\\n self.crawl_url()\\n self.parse_html()\\n except IOError as e:\\n self.thread_post_processing()\\n logging.error('CrawlUrlError url:{} msg:{}'.format(self.url, e))\\n\\n self.thread_post_processing()\",\n \"def run_generic_spider( user_id\\t\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\tspider_id\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\tdatamodel\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\trun_spider_config\\t= None,\\n\\t\\t\\t\\t\\t\\ttest_limit\\t\\t\\t= None\\n\\t\\t\\t\\t\\t\\t):\\n\\n\\tprint ()\\n\\tlog_scrap.info(\\\"--- run_generic_spider / spider_id : %s \\\", spider_id )\\n\\n\\t### WARNING !!! --> TEMPORARY SOLUTION\\n\\t### remove spider folder for spider_id in JOBDIR\\n\\tlog_scrap.debug(u\\\"--- run_generic_spider / cwd : %s\\\", os.getcwd() )\\n\\ttry :\\n\\t\\tshutil.rmtree( os.getcwd() + \\\"/\\\" + JOBDIR_FOLDER + \\\"/\\\" + spider_id )\\n\\texcept:\\n\\t\\tpass\\n\\tlog_scrap.debug(u\\\"--- run_generic_spider / removed folder : {}/{}\\\".format(JOBDIR_FOLDER, spider_id) )\\n\\n\\t# !!! spider is launched from main.py level !!!\\n\\t# all relative routes referring to this...\\n\\tlog_scrap.info(\\\"--- run_generic_spider / os.getcwd() : %s \\\", os.getcwd() )\\n\\n\\t### flattening run_spider_config : from nested to flat dict\\n\\tlog_scrap.info(\\\"--- run_generic_spider / 'flattenSpiderConfig()' on 'run_spider_config' --> 'spider_config_flat' ...\\\" )\\n\\tspider_config_flat = flattenSpiderConfig( run_spider_config )\\n\\n\\n\\t### settings for crawler\\n\\t# cf : https://hackernoon.com/how-to-crawl-the-web-politely-with-scrapy-15fbe489573d\\n\\n\\t### global settings for scrapy processes (see upper)\\n\\tlog_scrap.info(\\\"--- run_generic_spider / BOT_NAME : %s \\\", settings.get('BOT_NAME') )\\n\\tlog_scrap.info(\\\"--- run_generic_spider / USER_AGENT : %s \\\", settings.get('USER_AGENT') )\\n\\tlog_scrap.info(\\\"--- run_generic_spider / ITEM_PIPELINES : %s \\\", settings.get('ITEM_PIPELINES').__dict__ )\\n\\n\\n\\t# specific settings for this scrapy process\\n\\n\\t# settings.set( \\\"RETRY_TIMES\\\"\\t\\t\\t\\t\\t\\t, RETRY_TIMES )\\n\\t# settings.set( \\\"CONCURRENT_ITEMS\\\"\\t\\t\\t\\t, CONCURRENT_ITEMS )\\n\\t# settings.set( \\\"CONCURRENT_REQUESTS\\\"\\t\\t\\t\\t, CONCURRENT_REQUESTS )\\n\\t# settings.set( \\\"CONCURRENT_REQUESTS_PER_DOMAIN\\\"\\t, CONCURRENT_REQUESTS_PER_DOMAIN )\\n\\t# settings.set( \\\"REDIRECT_MAX_TIMES\\\"\\t\\t\\t\\t, REDIRECT_MAX_TIMES )\\n\\t# settings.set( \\\"DOWNLOAD_MAXSIZE\\\" \\t\\t\\t\\t, DOWNLOAD_MAXSIZE )\\n\\t# settings.set( \\\"DEPTH_PRIORITY\\\"\\t\\t\\t\\t\\t, DEPTH_PRIORITY )\\n\\t# settings.set( \\\"SCHEDULER_DISK_QUEUE\\\"\\t\\t\\t, SCHEDULER_DISK_QUEUE )\\n\\t# settings.set( \\\"DEPTH_PRIORITY\\\"\\t\\t\\t\\t\\t, SCHEDULER_MEMORY_QUEUE )\\n\\n\\t# settings.set( \\\"RANDOMIZE_DOWNLOAD_DELAY\\\"\\t\\t, RANDOMIZE_DOWNLOAD_DELAY )\\n\\t# cf : https://doc.scrapy.org/en/latest/topics/jobs.html#job-directory\\n\\tsettings.set( \\\"JOBDIR\\\"\\t\\t\\t\\t\\t\\t\\t, JOBDIR_FOLDER + \\\"/\\\" + spider_id )\\n\\n\\t## https://scrapy.readthedocs.io/en/0.12/topics/extensions.html#module-scrapy.contrib.closespider\\n\\n\\tsettings.set( \\\"CURRENT_SPIDER_ID\\\" \\t\\t\\t, spider_id )\\n\\tsettings.set( \\\"RETRY_TIMES\\\"\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"RETRY_TIMES\\\"] )\\n\\tsettings.set( \\\"CLOSESPIDER_ITEMCOUNT\\\"\\t\\t, spider_config_flat[\\\"LIMIT_ITEMS\\\"] )\\n\\t# settings.set( \\\"CLOSESPIDER_PAGECOUNT\\\"\\t\\t, spider_config_flat[\\\"LIMIT_PAGES\\\"] )\\n\\tsettings.set( \\\"DOWNLOAD_DELAY\\\" \\t\\t\\t\\t\\t, spider_config_flat[\\\"download_delay\\\"] )\\n\\tsettings.set( \\\"CONCURRENT_ITEMS\\\"\\t\\t\\t\\t, spider_config_flat[\\\"CONCURRENT_ITEMS\\\"] )\\n\\tsettings.set( \\\"CONCURRENT_REQUESTS\\\"\\t\\t\\t, spider_config_flat[\\\"CONCURRENT_REQUESTS\\\"] )\\n\\t# settings.set( \\\"DOWNLOAD_DELAY\\\" \\t\\t\\t\\t, DOWNLOAD_DELAY )\\n\\n\\tsettings.set( \\\"BOT_NAME\\\"\\t\\t\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"BOT_NAME\\\"] )\\n\\tsettings.set( \\\"USER_AGENT\\\"\\t\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"USER_AGENT\\\"] )\\n\\tsettings.set( \\\"ROBOTSTXT_OBEY\\\"\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"ROBOTSTXT_OBEY\\\"] )\\n\\tsettings.set( \\\"AUTOTHROTTLE_ENABLED\\\"\\t\\t\\t, spider_config_flat[\\\"AUTOTHROTTLE_ENABLED\\\"] )\\n\\tsettings.set( \\\"HTTPCACHE_ENABLED\\\"\\t\\t\\t\\t\\t, spider_config_flat[\\\"HTTPCACHE_ENABLED\\\"] )\\n\\tsettings.set( \\\"RANDOMIZE_DOWNLOAD_DELAY\\\"\\t, spider_config_flat[\\\"RANDOMIZE_DOWNLOAD_DELAY\\\"] )\\n\\n\\t### initiating crawler process\\n\\tlog_scrap.info(\\\"--- run_generic_spider / instanciate process ...\\\" \\t )\\n\\tprocess = CrawlerRunner( settings = settings )\\n\\n\\t### adding CrawlerRunner as deferred\\n\\tdef f(q):\\n\\t\\ttry:\\n\\t\\t\\t### send/create custom spider from run_spider_config\\n\\t\\t\\t### cf : https://stackoverflow.com/questions/35662146/dynamic-spider-generation-with-scrapy-subclass-init-error\\n\\n\\t\\t\\tdeferred = process.crawl( \\tGenericSpider,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tuser_id\\t\\t\\t\\t\\t\\t\\t= user_id,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tdatamodel \\t\\t\\t\\t\\t= datamodel ,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tspider_id \\t\\t\\t\\t\\t= spider_id ,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tspider_config_flat\\t= spider_config_flat,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttest_limit\\t\\t\\t\\t\\t= test_limit\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t)\\n\\t\\t\\tdeferred.addBoth(lambda _: reactor.stop())\\n\\t\\t\\treactor.run()\\n\\t\\t\\tq.put(None)\\n\\t\\texcept Exception as e:\\n\\t\\t\\tq.put(e)\\n\\n\\t### putting task in queue and start\\n\\tq = Queue()\\n\\tp = Process(target=f, args=(q,))\\n\\tp.start()\\n\\tresult = q.get()\\n\\tp.join()\\n\\n\\tif result is not None:\\n\\t\\traise result\\n\\n\\n\\n\\tprint (\\\"\\\\n\\\\n{}\\\\n\\\".format(\\\"> > > \\\"*20))\",\n \"def start_requests(self):\\n url = self.start_urls[0]\\n yield scrapy.Request(url=url, callback=self.parse)\",\n \"def run_spiders():\\n hour_limit = 3600 # in seconds\\n\\n settings = get_project_settings()\\n\\n # Uncomment the following block of code if you want to test the manager on\\n # the \\\"onepagetest\\\" to make sure the manager is working.\\n \\\"\\\"\\\"\\n settings[\\\"HTTPCACHE_ENABLED\\\"] = 1\\n settings[\\\"HTTPCACHE_EXPIRATION_SECS\\\"] = 0\\n settings[\\\"HTTPCACHE_STORAGE\\\"] = \\\"scrapy.extensions.httpcache.FilesystemCacheStorage\\\"\\n settings[\\\"HTTPCACHE_IGNORE_MISSING\\\"] = 1\\n settings[\\\"HTTPCACHE_DIR\\\"] = \\\"onepagetest\\\"\\n \\\"\\\"\\\"\\n\\n runner = CrawlerRunner(settings)\\n begin_time = datetime.now()\\n\\n d = runner.crawl(\\\"sb_spider\\\")\\n d.addBoth(lambda _: continue_crawl(d, runner, begin_time, hour_limit))\\n reactor.run()\",\n \"def runCrawler(crawlerid):\\n sclogic.runCrawler(crawlerid)\",\n \"def start_crawling(crawler_instance: Crawler):\\n print('start crawling!')\\n logger.info('started a new crawl!')\\n crawler_instance.crawl()\\n threading.Timer(Config.CRAWL_TIMEOUT, start_crawling,\\n [crawler_instance]).start()\",\n \"def parse(self, response):\\n page_source = self.upwork_controller.get_source_home()\\n\\n # Hand-off between Selenium and Scrapy happens here\\n sel = Selector(text=page_source)\\n # Extract data\\n sections = sel.xpath(\\\"//section/div\\\")\\n\\n for section in sections:\\n selector = Selector(text=section.get())\\n jobtitle = selector.xpath(\\\"//div/div/div/h4/a/text()\\\")\\n jobdescription = selector.xpath(\\\"//div/div/div/div/div/div/div/span/span/text()\\\")\\n hourlypay = selector.xpath(\\\"//div/div/div/div/small/span/strong/text()\\\")\\n proposals = selector.xpath(\\\"//div/div/div/div/div/span/small/strong/text()\\\")\\n country = selector.xpath(\\\"//div/div/div/div/small/span/span/span/span/strong[@class='text-muted client-location ng-binding']/text()\\\")\\n\\n job = Job(jobtitle=jobtitle.get(),\\n jobdescription=jobdescription.get(),\\n hourlypay=hourlypay.get(),\\n proposals=proposals.get(),\\n country=country.get())\\n job.serialize()\\n yield job.dict()\",\n \"def __init__(self,\\n config,\\n cache_manager=None,\\n jobs=None,\\n scraper_search=None,\\n session=None,\\n db_lock=None,\\n cache_lock=None,\\n start_page_pos=1,\\n search_engine=None,\\n search_type=None,\\n proxy=None,\\n progress_queue=None):\\n\\n self.config = config\\n self.cache_manager = cache_manager\\n\\n jobs = jobs or {}\\n self.search_engine_name = search_engine['engine'].lower()\\n self.search_instance = search_engine\\n\\n assert self.search_engine_name, 'You need to specify an search_engine'\\n\\n if not search_type:\\n self.search_type = self.config.get('search_type', 'normal')\\n else:\\n self.search_type = search_type\\n\\n self.jobs = jobs\\n\\n # the keywords that couldn't be scraped by this worker\\n self.missed_keywords = set()\\n # the number of keywords\\n self.num_keywords = len(self.jobs)\\n # The actual keyword that is to be scraped next\\n self.query = ''\\n # The default pages per keywords\\n self.pages_per_keyword = [1, ]\\n # The number that shows how many searches have been done by the worker\\n self.search_number = 1\\n # The parser that should be used to parse the search engine results\\n self.parser = Parsing().get_parser_by_search_engine(\\n self.search_engine_name\\n )(config=self.config)\\n # The number of results per page\\n self.num_results_per_page = int(self.config.get('num_results_per_page', 10))\\n\\n # The page where to start scraping. By default the starting page is 1.\\n if start_page_pos:\\n self.start_page_pos = 1 if start_page_pos < 1 else start_page_pos\\n else:\\n self.start_page_pos = int(self.config.get('search_offset', 1))\\n\\n # The page where we are right now\\n self.page_number = self.start_page_pos\\n\\n # Install the proxy if one was provided\\n self.proxy = proxy\\n if isinstance(proxy, Proxies().Proxy):\\n self.set_proxy()\\n self.requested_by = self.proxy.host + ':' + self.proxy.port\\n else:\\n self.requested_by = 'localhost'\\n\\n # the scraper_search object\\n self.scraper_search = scraper_search\\n # the scrape mode\\n # to be set by subclasses\\n self.scrape_method = ''\\n # Whether the instance is ready to run\\n self.startable = True\\n # set the database lock\\n self.db_lock = db_lock\\n # init the cache lock\\n self.cache_lock = cache_lock\\n # a queue to put an element in whenever a new keyword is scraped.\\n # to visualize the progress\\n self.progress_queue = progress_queue\\n # set the session\\n self.session = session\\n # the current request time\\n self.requested_at = None\\n # The name of the scraper\\n self.name = '[{}]'.format(self.search_engine_name) + self.__class__.__name__\\n\\n # How long to sleep (in seconds) after every request\\n self.sleeping_min = self.config.get('sleeping_min')\\n self.sleeping_max = self.config.get('sleeping_max')\\n\\n # the default timeout\\n self.timeout = 5\\n # the status of the thread after finishing or failing\\n self.status = 'successful'\\n self.html = ''\",\n \"def open_spider(self, spider):\\n pass\",\n \"def start_requests(self):\\n # Load sitemap JSON - generate queues\\n if self.args.sitemap_json is None:\\n yield Request('https://repo1.maven.org/maven2/', callback=self.spider.parse_page, meta=dict())\\n return\\n\\n for req in self.gen_links(self.args.sitemap_json):\\n yield req\",\n \"def start_requests(self):\\n for url in self.start_urls:\\n yield scrapy.Request(url, callback=self.parse)\",\n \"def schedule(args):\\n job_args = [(x[0], x[1]) for x in (y.split(\\\"=\\\", 1) for y in args.arg)]\\n _projects = lib.get_projects(\\n args.target, args.project, username=args.username, password=args.password\\n )\\n for project in _projects:\\n _spiders = lib.get_spiders(\\n args.target,\\n project,\\n args.spider,\\n username=args.username,\\n password=args.password,\\n )\\n for spider in _spiders:\\n job_id = lib.schedule(\\n args.target,\\n project,\\n spider,\\n job_args,\\n username=args.username,\\n password=args.password,\\n )\\n print(f\\\"{project} / {spider} => {job_id}\\\")\",\n \"def run(self):\\n print \\\"CAlled run in querythread\\\"\\n #global config.mqchannel\\n self.qstatus = \\\"Running\\\"\\n start = time.clock()\\n \\n self.crawl_async_result = crawl.apply_async(args=[self.start_url, self.max_depth, self.parser], serializer=\\\"json\\\")\\n while not self.crawl_async_result.ready():\\n time.sleep(0)\\n \\n # self.crawl_async_result is a list of { URLs, links, htmls } to be parsed\\n \\n self.crawlstatus = \\\"Done\\\"\\n self.elapsed = (time.clock() - start)\\n print \\\"Crawl Done\\\"\\n print json.dumps(self.crawl_async_result.result, indent=4)\\n \\n self.__insert_into_db(self.crawl_async_result.result)\\n content = json.dumps({\\\"query_id\\\":self.qid, \\\"message\\\":\\\"done\\\", \\\"dbkey\\\":str(self.dbkey), \\\"time\\\":self.elapsed});\\n config.mqchannel.basic_publish(exchange=config.get(\\\"MQEXCHANGE\\\"), routing_key='', body=content)\",\n \"def start_job(self):\\n # POST /jobs/{job_id}/results\\n pass\",\n \"def start_crawlers(spider_name: str, rules: List[Rule]) -> None:\\n runner = CrawlerRunner(settings)\\n crawlers = runner.spider_loader.list()\\n crawlers = [c for c in crawlers if c.__contains__(spider_name)]\\n if crawlers:\\n for rule in rules:\\n runner.crawl(crawlers[0], rule=rule)\\n d = runner.join()\\n d.addBoth(lambda _: reactor.stop())\\n reactor.run()\\n launch_logger.debug('all finished.')\\n else:\\n launch_logger.warning('provide the right spider name.')\",\n \"def start_screenshot_job_if_needed(self):\\n url2scrape = None\\n if self.task_data.get('product_url', self.task_data.get('url', None)):\\n url2scrape = self.task_data.get('product_url', self.task_data.get('url', None))\\n # TODO: searchterm jobs? checkout scrapers?\\n if url2scrape:\\n # scrapy_path = \\\"/home/spiders/virtual_environment/bin/scrapy\\\"\\n # python_path = \\\"/home/spiders/virtual_environment/bin/python\\\"\\n output_path = self.get_output_path()\\n cmd = ('cd {repo_base_path}/product-ranking'\\n ' && scrapy crawl url2screenshot_products'\\n ' -a product_url=\\\"{url2scrape}\\\" '\\n ' -a width=1280 -a height=1024 -a timeout=90 '\\n ' -s LOG_FILE=\\\"{log_file}\\\"'\\n ' -o \\\"{output_file}\\\" &').format(\\n repo_base_path=REPO_BASE_PATH,\\n log_file=output_path+'.screenshot.log', url2scrape=url2scrape,\\n output_file=output_path+'.screenshot.jl')\\n logger.info('Starting a new parallel screenshot job: %s' % cmd)\\n os.system(cmd) # use Popen instead?\",\n \"def crawl(self, url):\\n return None\",\n \"def start_requests(self):\\r\\n try:\\r\\n\\r\\n for url in self.start_urls:\\r\\n yield scrapy.Request(url,\\r\\n callback=self.navigate_to)\\r\\n except Exception as err:\\r\\n logger.error(f'TekDefenceScraper : start_requests : {err}')\\r\\n raise err\",\n \"def start(self, job: PandaJob) -> None:\\n raise NotImplementedError(\\\"Base method not implemented\\\")\",\n \"def crawl(self):\\n try:\\n self.crawl_pages()\\n self.crawl_posts()\\n self.crawl_comments()\\n except Exception as exception:\\n self.handle_request_limit(exception)\",\n \"def open_spider(self, spider):\\n now = spider.get_now_time()\\n\\n # Create initial batch\\n spider.batch = model.Batch.objects.create(\\n kickoff_time=now, finish_time=now)\\n spider.batch.save()\\n\\n # save initial site list\\n file_content = ContentFile('\\\\n'.join(spider.start_urls))\\n filename = str(spider.batch).replace(' ', '')\\n spider.batch.sitelist.save(filename, file_content)\\n spider.batch.sitelist.close()\\n spider.batch.save()\\n\\n spider.batch_user_agents = []\\n\\n # Give the spider a set of batch user agents, which preserve historical\\n # user agent data\\n for ua in list(model.UserAgent.objects.all()):\\n batch_user_agent = model.BatchUserAgent.objects.create(\\n batch=spider.batch,\\n ua_string=ua.ua_string,\\n primary_ua=ua.primary_ua,\\n ua_type=ua.ua_type,\\n ua_human_name=ua.ua_human_name\\n )\\n spider.batch_user_agents.append(batch_user_agent)\\n\\n if not spider.batch_user_agents:\\n raise ValueError(\\n \\\"No user agents; add some with 'manage.py useragents --add'\\\")\",\n \"def scrape_pipeline(args):\\n kickoff = args.kickoff\\n fname = args.fname\\n d = DbHelper()\\n s = Scraper()\\n c = Crawler(20)\\n if fname is not None:\\n app_names = pd.read_csv(fname)['packageName'].tolist()\\n apps = [list(a) for a in zip(app_names, d.app_names_to_uuids(app_names))]\\n else:\\n apps = None\\n\\n # start by updating top apps\\n if not args.skip_top:\\n logger.info(\\\"getting top apps...\\\")\\n new_top_list = c.get_top_apps_list()\\n logger.info(\\\"scraping top apps not in DB...\\\")\\n s.scrape_missing(new_top_list, compare_top=True)\\n logger.info(\\\"updating top apps...\\\")\\n d.update_top_apps(new_top_list)\\n\\n if kickoff == True:\\n s = None\\n if fname is None:\\n # use crawler to get list of package names\\n logger.error(\\\"Crawler for package names not implemented yet\\\")\\n return\\n else:\\n # use specified file of package names\\n s = Scraper(input_file=fname)\\n\\n # use scraper\\n logger.info(\\\"Starting efficient scrape...\\\")\\n s.efficient_scrape()\\n logger.info(\\\"...efficient scrape done\\\")\\n else:\\n # use updater\\n logger.info(\\\"Starting updater...\\\")\\n if fname is None:\\n u = Updater()\\n else:\\n u = Updater(input_file=fname)\\n u.update_apps()\\n logger.info(\\\"...update done\\\")\\n\\n # crawl privacy policies\\n c.crawl_app_privacy_policies(app_list=apps)\\n\\n if args.no_decompile:\\n # download only\\n logger.info(\\\"Starting download...\\\")\\n downloader = Downloader()\\n if apps is None:\\n downloader.download_all_from_db(top=True)\\n else:\\n downloader.download(apps)\\n logger.info(\\\"...done\\\")\\n else:\\n # download/decompile\\n logger.info(\\\"Starting download and decompile...\\\")\\n download_decompile_all()\\n logger.info(\\\"...download and decompile done\\\")\\n logger.info(\\\"run analysis pipeline now\\\")\",\n \"def job(name):\\n current_app.logger.info(\\\"Running custom job: {}\\\".format(name))\",\n \"def start_requests(self):\\n self.spider = Base_Spider(LpCfg)\\n self.first_url = 'https://www.liepin.com/zhaopin/' \\\\\\n '?industries=&dqs=010&salary=15%2440' \\\\\\n '&jobKind=2&pubTime=3&compkind=&compscale=' \\\\\\n '&industryType=&searchType=1&clean_condition=' \\\\\\n '&isAnalysis=&init=1&sortFlag=15&flushckid=1' \\\\\\n '&fromSearchBtn=2&headckid=0b5a9690a5cb1d82&key=Python'\\n urls = []\\n s = self.spider.get_content(self.first_url)\\n self.cookies = self.spider.session.cookies.get_dict()\\n del s\\n self.spider.headers.update({'Cookie': self.cookies})\\n for page in range(1,5):\\n url = self.first_url + '&curPage=%d'%page\\n urls.append(url)\\n for url in urls:\\n print url\\n yield scrapy.Request(url=url,\\n callback=self.parse,\\n headers=self.spider.headers,\\n cookies=self.cookies\\n )\",\n \"def process_job():\\n r = redis.StrictRedis()\\n while True:\\n curr_job = r.blpop('job_queue', 0)[1]\\n r.hset('status', curr_job, 'processing')\\n print('current job ID:', curr_job)\\n # convert byte to string\\n url = r.hget('urls', curr_job).decode(\\\"utf-8\\\")\\n print('Current URL:', url)\\n\\n # if this url has not been requested before/is not in the db\\n if Site.query.filter_by(url=url).first():\\n r.hset('status', curr_job, 'complete')\\n print('Job', curr_job, 'Completed')\\n else:\\n # fetches url page source\\n try:\\n html = str(get_html(url))\\n print('Successfully retrieved HTML')\\n # add results to database\\n db.session.add(Site(url=url, html=html))\\n db.session.commit()\\n print('Added to database')\\n r.hset('status', curr_job, 'complete')\\n print('Job', curr_job, 'Completed')\\n except ValueError:\\n r.hset('status', curr_job, 'abort')\\n print('Job', curr_job, 'Aborted')\\n except TimeoutError:\\n r.hset('status', curr_job, 'timeout')\\n print('Job', curr_job, 'Timed Out')\\n return\",\n \"def __process_job(self, job):\\r\\n\\r\\n job_a_tag = job.find_element_by_tag_name('a')\\r\\n job_href = job_a_tag.get_attribute('href')\\r\\n # Removing all extraneous indeed url query string parameters\\r\\n job_href = job_href.split('&from')[0] \\r\\n self.nav(job_href)\",\n \"def crawl(self, keyword, since=None, to=None):\\n no_of_pages = self.get_no_of_pages(keyword, since, to)\\n print('pages: ' + str(no_of_pages))\\n self.keyword = keyword\\n self.since = since\\n self.to = to\\n p = Pool()\\n p.map(self.distribute, range(1, no_of_pages+1))\",\n \"def crawl(self):\\n self.get('http://code.google.com/p/webscraping/')\\n self.get('http://code.google.com/p/sitescraper/')\\n QTimer.singleShot(5000, self.app.quit)\",\n \"def crawl(self):\\n if os.path.exists(self.__work_path):\\n shutil.rmtree(self.__work_path)\\n print '\\\\nOld Data Was Found And Removed.\\\\n'\\n\\n initial_first_run = True\\n initial_recursion_depth = 0\\n initial_prev_link_size = 0\\n for url in self.__urls:\\n self.__start_recursion(url, initial_first_run,\\n initial_recursion_depth, initial_prev_link_size)\\n\\n Crawler.mission_report(self.__work_path)\",\n \"def _start_scrapy_process(self):\\n cmd = self._parse_task_and_get_cmd()\\n self.process = Popen(cmd, shell=True, stdout=PIPE,\\n stderr=PIPE, preexec_fn=os.setsid)\\n if self.task_data.get('with_best_seller_ranking', False):\\n logger.info('With best seller ranking')\\n cmd = self._parse_task_and_get_cmd(True)\\n self.process_bsr = Popen(cmd, shell=True, stdout=PIPE,\\n stderr=PIPE, preexec_fn=os.setsid)\\n else:\\n logger.info('Skipping best seller')\\n logger.info('Scrapy process started for task #%s',\\n self.task_data.get('task_id', 0))\",\n \"def parse(self, response):\\n\\n\\t\\t### close spider if exception\\n\\t\\tif 'Bandwidth exceeded' in response.body:\\n\\t\\t\\traise CloseSpider('bandwidth_exceeded')\\n\\n\\t\\tlog_scrap.debug(u\\\"\\\\n>>> NEW PARSING >>>\\\\n\\\" )\\n\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse ...\\\" )\\n\\n\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse /response : \\\\n%s\\\" , response)\\n\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse /response : \\\\n%s \\\\n\\\" , response.__dict__.keys() )\\n\\n\\t\\t# for k, v in response.__dict__.iteritems() :\\n\\t\\t# \\tlog_scrap.info(\\\"\\\\n--- [k] {} : [v] {} : \\\".format(k,v))\\n\\t\\t# print response._body\\n\\t\\tstart_url = response.meta[\\\"start_url\\\"]\\n\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / start_url : %s\\\", start_url )\\n\\n\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t### start request with API crawler\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t# if self.spider_config_flat[\\\"parse_api\\\"] == True :\\n\\t\\tif self.parse_api == True :\\n\\n\\t\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse / starting request on API endpoint... \\\" )\\n\\t\\t\\tjsonresponse = json.loads(response.body_as_unicode())\\n\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider.parse / jsonresponse : \\\\n%s\\\", jsonresponse )\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / jsonresponse received...\\\" )\\n\\n\\t\\t\\traw_items_list = get_dictvalue_from_xpath(jsonresponse, self.item_xpath)\\n\\t\\t\\t# raw_items_list = jsonresponse[self.item_xpath]\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / raw_items_list[0] : \\\\n%s\\\\n...\\\", pformat(raw_items_list[0]) )\\n\\n\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t### PARSING PAGE - API\\n\\t\\t\\t### start parsing page : loop through data items in page in response\\n\\t\\t\\tif len(raw_items_list) != 0 :\\n\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / START LOOPING raw_items_list WITH API ...\\\" )\\n\\n\\t\\t\\t\\t# while self.there_is_more_items_to_scrap_dict[start_url] :\\n\\n\\t\\t\\t\\tfor raw_data in raw_items_list :\\n\\n\\t\\t\\t\\t\\tself.item_count += 1\\n\\n\\t\\t\\t\\t\\t### check if can continue depending on item_count\\n\\t\\t\\t\\t\\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\\n\\n\\t\\t\\t\\t\\t\\tprint()\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - API - item n°{} >>> \\\\n\\\".format(self.item_count) )\\n\\n\\t\\t\\t\\t\\t\\t### instantiate Item to fill from datamodel --> cf items.py\\n\\t\\t\\t\\t\\t\\titemclass \\t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\\n\\t\\t\\t\\t\\t\\titem \\t\\t= itemclass()\\n\\n\\t\\t\\t\\t\\t\\t### add global info to item : i.e. core fields in dm_core_item_related list\\n\\t\\t\\t\\t\\t\\titem[ 'spider_id' ]\\t= self.spider_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_by' ]\\t= self.user_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_at' ]\\t= time.time()\\t\\t# timestamp\\n\\t\\t\\t\\t\\t\\titem[ 'link_src' ]\\t= response._url\\n\\n\\t\\t\\t\\t\\t\\titem[ 'page_n' ]\\t\\t= self.page_count\\n\\t\\t\\t\\t\\t\\titem[ 'item_n' ]\\t\\t= self.item_count\\n\\n\\t\\t\\t\\t\\t\\t### extract data and feed it to the Item instance based on spider_config_flat\\n\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, is_api_rest=True, item_n=self.item_count)\\n\\n\\n\\t\\t\\t\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t\\t### FOLLOW LINK - API\\n\\t\\t\\t\\t\\t\\t### if need to follow to extract all data\\n\\t\\t\\t\\t\\t\\tif self.spider_config_flat[\\\"parse_follow\\\"] == True :\\n\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> FOLLOW LINK - API - item n°{} / page n°{} >>>>>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_xpath : %s\\\", self.follow_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t# follow_link_raw = raw_data[ self.follow_xpath ]\\n\\t\\t\\t\\t\\t\\t\\tfollow_link_raw = get_dictvalue_from_xpath(raw_data, self.follow_xpath)\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link RAW ({}) : {} \\\".format(type(follow_link_raw),follow_link_raw) )\\n\\n\\t\\t\\t\\t\\t\\t\\turl_follow = \\\"\\\"\\n\\t\\t\\t\\t\\t\\t\\tif self.api_follow_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.api_follow_root\\n\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.page_url\\n\\n\\t\\t\\t\\t\\t\\t\\t# complete follow link if needed\\n\\t\\t\\t\\t\\t\\t\\tfollow_link = self.clean_link(follow_link_raw, url_root=url_follow)\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link CLEAN : %s \\\", follow_link )\\n\\n\\t\\t\\t\\t\\t\\t\\t# store follow_link\\n\\t\\t\\t\\t\\t\\t\\titem[ 'link_data' ]\\t= follow_link\\n\\t\\t\\t\\t\\t\\t\\turl \\t\\t\\t\\t= item['link_data']\\n\\n\\t\\t\\t\\t\\t\\t\\tfollow_is_api = self.follow_is_api\\n\\n\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url, 'item_n' : self.item_count , 'parse_api' : follow_is_api })\\n\\n\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t### if no follow link\\n\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\\n\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> item : \\\\n %s \\\\n\\\", pformat(item) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\" --> item ...\\\" )\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\t# log_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\\n\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF ITEMS')\\n\\n\\t\\t\\t### - - - - - - - - - - - - ###\\n\\t\\t\\t### NEXT PAGE - API\\n\\t\\t\\tif self.test_limit == None or self.page_count < self.test_limit :\\n\\n\\t\\t\\t\\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\\n\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse (API) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\\\n\\\".format(self.page_count) )\\n\\n\\t\\t\\t\\t\\t### get and go to next page\\n\\t\\t\\t\\t\\tself.page_count += 1\\n\\n\\t\\t\\t\\t\\turl_next = \\\"\\\"\\n\\t\\t\\t\\t\\tif self.api_pagination_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\turl_next = self.api_pagination_root\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\turl_next = self.page_url\\n\\n\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\tnext_page = url_next + str(self.page_count)\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse >>> NEXT PAGE II : %s\\\", next_page )\\n\\n\\t\\t\\t\\t\\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\\n\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} \\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\t\\t\\telse :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} \\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t### start requests with pure Scrapy requests\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\telif self.spider_config_flat[\\\"parse_reactive\\\"] == False :\\n\\t\\t# elif self.parse_reactive == False :\\n \\n\\t\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse / starting requests with Scrapy... \\\" )\\n\\t\\t\\t# self.parse_scrapy(response)\\n\\n\\t\\t\\t### find items list\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / self.item_xpath : %s\\\", self.item_xpath )\\n\\t\\t\\traw_items_list = response.xpath(self.item_xpath)\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / len(raw_items_list) : %d \\\", len(raw_items_list) )\\n\\n\\n\\t\\t\\t### - - - - - - - - - - - ###\\n\\t\\t\\t### PARSING PAGE - SCRAPY\\n\\t\\t\\t### start parsing page : loop through data items in page in response\\n\\t\\t\\tif len(raw_items_list) != 0 :\\n\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / START LOOPING raw_items_list WITH SCRAPY ...\\\" )\\n\\n\\t\\t\\t\\tfor raw_data in raw_items_list :\\n\\n\\t\\t\\t\\t\\tself.item_count += 1\\n\\n\\t\\t\\t\\t\\t### check if can continue depending on item_count\\n\\t\\t\\t\\t\\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\\n\\n\\t\\t\\t\\t\\t\\tprint()\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - Scrapy - item n°{} / page n°{} >>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\n\\t\\t\\t\\t\\t\\t# print \\\">>> raw_data : \\\\n\\\", raw_data.extract()\\n\\n\\t\\t\\t\\t\\t\\t### instantiate Item to fill from datamodel --> cf items.py\\n\\t\\t\\t\\t\\t\\titemclass \\t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\\n\\t\\t\\t\\t\\t\\titem \\t\\t= itemclass()\\n\\n\\t\\t\\t\\t\\t\\t### add global info to item : i.e. core fields in dm_core_item_related list\\n\\t\\t\\t\\t\\t\\titem[ 'spider_id' ]\\t\\t= self.spider_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_by' ]\\t\\t= self.user_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_at' ]\\t\\t= time.time()\\t\\t# timestamp\\n\\t\\t\\t\\t\\t\\titem[ 'link_src' ]\\t\\t= response._url\\n\\n\\t\\t\\t\\t\\t\\titem[ 'page_n' ]\\t\\t= self.page_count\\n\\t\\t\\t\\t\\t\\titem[ 'item_n' ]\\t\\t= self.item_count\\n\\n\\t\\t\\t\\t\\t\\t### extract data and feed it to the Item instance based on spider_config_flat\\n\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, item_n=self.item_count)\\n\\n\\n\\t\\t\\t\\t\\t\\t### - - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t\\t### FOLLOW LINK - SCRAPY\\n\\t\\t\\t\\t\\t\\t### if need to follow to extract all data\\n\\t\\t\\t\\t\\t\\tif self.spider_config_flat[\\\"parse_follow\\\"] == True :\\n\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> FOLLOW LINK - SCRAPY - item n°{} / page n°{} >>>>>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_xpath : %s\\\", self.follow_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\tfollow_link \\t= raw_data.xpath( self.follow_xpath ).extract_first()\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link RAW ({}) : {} \\\".format(type(follow_link),follow_link) )\\n\\n\\t\\t\\t\\t\\t\\t\\turl_follow = \\\"\\\"\\n\\t\\t\\t\\t\\t\\t\\tif self.api_follow_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.api_follow_root\\n\\n\\t\\t\\t\\t\\t\\t\\t# complete follow link if needed\\n\\t\\t\\t\\t\\t\\t\\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> follow_link CLEAN : %s \\\", follow_link )\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link CLEAN ({}) : {} \\\".format(type(follow_link),follow_link) )\\n\\n\\t\\t\\t\\t\\t\\t\\t# store follow_link\\n\\t\\t\\t\\t\\t\\t\\titem[ 'link_data' ]\\t= follow_link\\n\\t\\t\\t\\t\\t\\t\\turl \\t\\t\\t\\t= item['link_data']\\n\\n\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOWING LINK --> url : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\t# yield Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url } )\\n\\t\\t\\t\\t\\t\\t\\t\\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False} )\\n\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.warning(u\\\">>> FOLLOWING LINK --> url : {} / WORKED !!! \\\".format(url) )\\n\\n\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOW LINK - NOT WORKING : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t### if no follow link\\n\\t\\t\\t\\t\\t\\telse :\\n\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> NO FOLLOW LINK ... \\\" )\\n\\t\\t\\t\\t\\t\\t\\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\">>> GenericSpider.parse - item.items() : \\\\n %s\\\", item.items() )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\">>> GenericSpider.parse - item.keys() : \\\\n %s\\\", item.items() )\\n\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t# print (\\\"\\\\n>>> NEXT ITEM \\\" + \\\">>> >>> \\\"*10, \\\"\\\\n\\\")\\n\\n\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> item : \\\\n %s \\\\n\\\", pformat(item) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\" --> item ...\\\" )\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\\n\\n\\t\\t\\telse :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t# raise CloseSpider('OUT OF ITEMS')\\n\\n\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t### NEXT PAGE - SCRAPY\\n\\t\\t\\t### check if there is a test_limit\\n\\t\\t\\tif self.test_limit == None or self.page_count < self.test_limit :\\n\\n\\t\\t\\t\\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\\n\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse (Scrapy) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\\\n\\\".format(self.page_count) )\\n\\n\\t\\t\\t\\t\\t### get and go to next page\\n\\t\\t\\t\\t\\tis_next_page, next_page = self.get_next_page(response, start_url)\\n\\n\\t\\t\\t\\t\\tif is_next_page :\\n\\n\\t\\t\\t\\t\\t\\tself.page_count += 1\\n\\n\\t\\t\\t\\t\\t\\turl_next = \\\"\\\"\\n\\t\\t\\t\\t\\t\\tif self.api_pagination_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\turl_next = self.api_pagination_root\\n\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse >>> NEXT PAGE I : %s\\\", next_page )\\n\\t\\t\\t\\t\\t\\tnext_page = self.clean_link(next_page, url_root=url_next)\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse >>> NEXT PAGE II : %s\\\", next_page )\\n\\n\\t\\t\\t\\t\\t\\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / NO MORE PAGE TO SCRAP - pages count : {} \\\".format(self.page_count) )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('NO MORE PAGE TO SCRAP')\\n\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\t\\t\\telse :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t### start requests with Selenium\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\telse :\\n\\t\\t\\t### initiate selenium browser\\n\\t\\t\\t### cf : https://github.com/voliveirajr/seleniumcrawler/blob/master/seleniumcrawler/spiders/seleniumcrawler_spider.py\\n\\t\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse / starting Selenium driver... \\\" )\\n\\n\\t\\t\\t# retrieve exec path for chromedriver from settings_scrapy.py\\n\\t\\t\\t### GET APP MODE FROM ENV VARS\\n\\t\\t\\tapp_mode \\t\\t\\t\\t\\t\\t= os.environ.get('APP_MODE', 'default')\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider.parse / APP_MODE : %s\\\", app_mode)\\n\\t\\t\\tchromedriver_path \\t= CHROMEDRIVER_PATH_LIST[ app_mode ]\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider.parse / chromedriver_path : %s\\\", chromedriver_path)\\n\\n\\t\\t\\t### specify executable path to launch webdriver-->\\n\\t\\t\\t# cf : where chromedriver was installed when `brew install chromedriver`\\n\\t\\t\\tself.driver = webdriver.Chrome(executable_path=chromedriver_path, chrome_options=options_selenium)\\n\\t\\t\\t# self.driver = webdriver.Chrome(chrome_options=options_selenium)\\n\\t\\t\\t# self.driver = webdriver.Firefox()\\n\\t\\t\\t# self.driver = webdriver.Chrome()\\n\\t\\t\\t# self.driver = webdriver.PhantomJS() ### deprecated\\n\\n\\t\\t\\t### setup waiting times\\n\\t\\t\\t# self.driver.set_page_load_timeout(60)\\n\\t\\t\\tself.wait_driver\\t= WebDriverWait(self.driver, self.delay_driver)\\n\\t\\t\\tself.wait_page \\t\\t= WebDriverWait(self.driver, self.delay_new_page)\\n\\t\\t\\tself.driver.implicitly_wait(self.delay_implicit)\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / self.delay_driver : %s\\\", self.delay_driver )\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / self.delay_new_page : %s\\\", self.delay_new_page )\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / self.delay_implicit : %s\\\", self.delay_implicit )\\n\\n\\n\\t\\t\\t### start parsing with selenium\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / response._url : %s\\\", response._url )\\n\\t\\t\\ttry :\\n\\t\\t\\t\\tself.driver.get(response._url)\\n\\n\\t\\t\\t\\t### try scroll_down if needed in config\\n\\t\\t\\t\\tif self.spider_config_flat['scroll_down'] : \\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / scroll_down is TRUE ... \\\" )\\n\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericsSpider. / scroll_down - self.spider_config_flat : \\\\n%s\\\", pformat(self.spider_config_flat) )\\n\\n\\t\\t\\t\\t\\tscroll_pause_time = self.spider_config_flat[\\\"scroll_pause_time\\\"]\\n\\t\\t\\t\\t\\tmax_loops \\t\\t\\t\\t= self.spider_config_flat[\\\"scroll_loops\\\"]\\n\\t\\t\\t\\t\\tself.driver = scroll_down(self.driver, scroll_pause_time, max_loops)\\n\\t\\t\\t\\t\\t# scroll_down(self.driver, scroll_pause_time, max_loops)\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / url '{}' is loaded ... \\\".format( response._url ))\\n\\t\\t\\t\\n\\t\\t\\texcept :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\traise CloseSpider('DRIVER NOT RESPONDING')\\n\\n\\n\\t\\t\\t### clean original xpath from strings\\n\\t\\t\\tstrings_to_clean = [\\n\\t\\t\\t\\t'/@src',\\n\\t\\t\\t\\t'/@href',\\n\\t\\t\\t\\t'/text()',\\n\\t\\t\\t\\t'/@*[name()=\\\"xlink:href\\\"]',\\n\\t\\t\\t\\t'/@datetime'\\n\\t\\t\\t]\\n\\n\\t\\t\\t# while self.there_is_more_items_to_scrap :\\n\\t\\t\\twhile self.there_is_more_items_to_scrap_dict[start_url] :\\n\\n\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / while loop continues : %s\\\", self.there_is_more_items_to_scrap )\\n\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / while loop continues : %s\\\", self.there_is_more_items_to_scrap_dict[start_url] )\\n\\n\\t\\t\\t\\ttry :\\n\\n\\t\\t\\t\\t\\t### wait / debug page content\\n\\t\\t\\t\\t\\tpage_source_code = self.driver.page_source.encode(\\\"utf-8\\\")\\n\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / page_source_code : \\\\n %s \\\", page_source_code )\\n\\t\\t\\t\\t\\ttime.sleep(self.delay_new_page)\\n\\n\\t\\t\\t\\t\\t### start parsing page :\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.item_xpath : %s\\\", self.item_xpath )\\n\\t\\t\\t\\t\\traw_items_list \\t= self.driver.find_elements_by_xpath(self.item_xpath)\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / raw_items_list length : %s\\\", len(raw_items_list) )\\n\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / raw_items_list[0].text : \\\\n%s\\\", raw_items_list[0].text )\\n\\n\\t\\t\\t\\t\\t# current_item_index = 0\\n\\n\\t\\t\\t\\t\\t### - - - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t### PARSING PAGE - SELENIUM\\n\\t\\t\\t\\t\\t# loop through data items in page in response\\n\\t\\t\\t\\t\\tif len(raw_items_list) != 0 :\\n\\n\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / START PARSING WITH SELENIUM ...\\\\n\\\" )\\n\\n\\t\\t\\t\\t\\t\\tfor raw_data in raw_items_list :\\n\\n\\t\\t\\t\\t\\t\\t\\tprint()\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / START LOOPING raw_items_list WITH SELENIUM ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\t### add +1 to items count\\n\\t\\t\\t\\t\\t\\t\\tself.item_count += 1\\n\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} - there_is_more_items_to_scrap_dict[start_url] : {} \\\".format(str(self.spider_name), self.item_count, self.there_is_more_items_to_scrap_dict[start_url]) )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} \\\".format(self.spider_name, self.item_count) )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - item n°{} \\\".format(self.item_count) )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - spider_name : '%s' - item n°%s \\\" %(self.spider_name, self.item_count) )\\n\\n\\t\\t\\t\\t\\t\\t\\t### check if can continue depending on item_count\\n\\t\\t\\t\\t\\t\\t\\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - Selenium - item n°{} / page n°{} >>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### instantiate Item to fill from datamodel --> cf items.py\\n\\t\\t\\t\\t\\t\\t\\t\\titemclass \\t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\\n\\t\\t\\t\\t\\t\\t\\t\\titem \\t\\t= itemclass()\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### add global info to item : i.e. core fields in dm_core_item_related list\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'spider_id' ]\\t\\t= self.spider_id\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'added_by' ]\\t\\t= self.user_id\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'added_at' ]\\t\\t= time.time()\\t\\t# timestamp\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'link_src' ]\\t\\t= response._url\\n\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'page_n' ]\\t\\t= self.page_count\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'item_n' ]\\t\\t= self.item_count\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### extract data and feed it to the Item instance based on spider_config_flat\\n\\t\\t\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t\\t\\t\\t### FOLLOW LINK - SELENIUM\\n\\t\\t\\t\\t\\t\\t\\t\\t### find follow link to open detailled item view\\n\\t\\t\\t\\t\\t\\t\\t\\tif self.spider_config_flat[\\\"parse_follow\\\"] == True :\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> FOLLOW LINK - SELENIUM - item n°{} / page n°{} >>>>>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_xpath : %s\\\", self.follow_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t### follow link with Scrapy\\n\\t\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / follow link with Scrapy ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / get href of follow_link ...\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link_xpath \\t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link_xpath : %s \\\", follow_link_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link\\t\\t\\t= raw_data.find_element_by_xpath( follow_link_xpath ).get_attribute('href')\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link RAW : %s \\\", follow_link )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\turl_follow = \\\"\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tif self.api_follow_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.api_follow_root\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# complete follow link if needed\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link CLEAN ({}) : {}\\\".format(type(follow_link), follow_link ) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# store follow_link\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\titem[ 'link_data' ]\\t= follow_link\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\turl\\t\\t\\t= item['link_data']\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOWING LINK --> url : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False})\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOW LINK - NOT WORKING : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t### follow link with Selenium\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t### FIND A WEBSITE TEST FOR REACTIVE DETAILLED PAGES\\n\\t\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / follow link with Selenium ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link_xpath \\t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_link_xpath : %s\\\", self.follow_link_xpath )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link \\t\\t= raw_data.find_element_by_xpath( follow_link_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### open link in new tab ?\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link.click()\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### get data and save data\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / get data and save data ...\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### back to previous page and scrap from where it left\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### cf : https://selenium-python.readthedocs.io/navigating.html#navigation-history-and-location\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tself.driver.back()\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### if no follow link\\n\\t\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> item : \\\\n %s \\\\n\\\", pformat(item) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\" --> item ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\traise CloseSpider('OUT OF LIMIT_ITEMS')\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF ITEMS - page n°{} - limit : {} - test_limit : {} / except -> break\\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\t### - - - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t### NEXT PAGE - SELENIUM\\n\\t\\t\\t\\t\\tif self.test_limit == None or self.page_count < self.test_limit :\\n\\n\\t\\t\\t\\t\\t\\tif self.there_is_more_items_to_scrap_dict[start_url] :\\n\\n\\t\\t\\t\\t\\t\\t\\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tprint ()\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --- GenericSpider.parse (Selenium) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\\\n\\\".format(self.page_count) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### add +1 to parsed pages\\n\\t\\t\\t\\t\\t\\t\\t\\tself.page_count += 1\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - current start_url : {} >>>\\\".format(start_url) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### find next page btn in current view\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.next_page : %s\\\", self.next_page )\\n\\t\\t\\t\\t\\t\\t\\t\\tnext_page_xpath = clean_xpath_for_reactive(self.next_page, strings_to_clean)\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page_xpath : %s\\\", next_page_xpath )\\n\\t\\t\\t\\t\\t\\t\\t\\t# next_page \\t= re.sub(\\\"|\\\".join(strings_to_clean), \\\"\\\", next_page )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# try :\\n\\t\\t\\t\\t\\t\\t\\t\\t# element_present = EC.presence_of_element_located((By.XPATH, next_page_xpath ))\\n\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / next_page present : %s\\\", element_present )\\n\\t\\t\\t\\t\\t\\t\\t\\t# self.wait.until(element_present)\\n\\t\\t\\t\\t\\t\\t\\t\\t# next_page = self.wait.until( EC.element_to_be_clickable(element_present) )\\n\\t\\t\\t\\t\\t\\t\\t\\t# next_page \\t\\t= self.driver.find_element_by_xpath( next_page_xpath )\\n\\t\\t\\t\\t\\t\\t\\t\\tnext_page \\t\\t= self.driver.find_element(By.XPATH, next_page_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page : %s\\\", next_page )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page.text : %s\\\", next_page.text )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# except TimeoutException:\\n\\t\\t\\t\\t\\t\\t\\t\\t# except :\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\tlog_scrap.error(\\\"--- GenericSpider. / Timed out waiting for page to load\\\")\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### click next button and wait for ajax calls to complete (post and get)\\n\\t\\t\\t\\t\\t\\t\\t\\t### cf : http://www.obeythetestinggoat.com/how-to-get-selenium-to-wait-for-page-load-after-a-click.html\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# def wait_for(condition_function):\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\tstart_time = time.time()\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\twhile time.time() < start_time + 3:\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\tif condition_function():\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\t\\treturn True\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\t\\ttime.sleep(0.1)\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\traise Exception ('Timeout waiting for {}'.format(condition_function.__name__) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# def link_has_gone_stale():\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\ttry:\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\t# poll the link with an arbitrary call\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\tnext_page.find_elements_by_xpath(self.item_xpath)\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\treturn False\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\texcept StaleElementReferenceException :\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\treturn True\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- ... ---\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page.click() \\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnext_page.click()\\n\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / next_page.send_keys( \\\\ n )\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# next_page.send_keys(\\\"\\\\n\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# added this step for compatibility of scrolling to the view\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.error(\\\"--- GenericSpider. / ALTERNATIVE next_page.click() \\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# self.driver.execute_script(\\\"return arguments[0].scrollIntoView();\\\", next_page)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# next_page.click()\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.driver.execute_script(\\\"arguments[0].click();\\\", next_page)\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### wait after click\\n\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / wait for ajax to finish... \\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# wait_for(link_has_gone_stale)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.wait_page.until(lambda driver: self.driver.execute_script('return jQuery.active') == 0)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.wait_page.until(lambda driver: self.driver.execute_script('return document.readyState') == 'complete')\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# time.sleep(self.delay_implicit)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\ttime.sleep(self.delay_new_page)\\n\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.error(\\\"--- GenericSpider. / !!! FAIL / wait for ajax to finish... \\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF PAGES TO SCRAP - page n°{} / except -> break\\\".format(self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\t\\t\\traise CloseSpider('OUT OF PAGES TO SCRAP')\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / NO MORE ITEMS TO SCRAP - item_count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\traise CloseSpider('NO MORE ITEMS TO SCRAP')\\n\\t\\t\\t\\t\\tbreak\",\n \"def spider_and_save_thread(\\n self, source_url, crawl_timeout, target_url_patten, max_depth, output_directory):\\n url_result = self.crawl(\\n source_url,\\n crawl_timeout,\\n target_url_patten,\\n max_depth)\\n self.save_url(url_result, crawl_timeout, output_directory)\",\n \"def start_requests(self):\\n yield scrapy.Request(url=self.start_urls[0])\",\n \"def executor(self, job):\\n job.connect(self)\\n job.trigger(wait=True, **job.trigger_args) # Wait until job is ready\\n job.start() # Notify star of job\\n # Run specific action for this job\\n job.action(**job.action_args)\",\n \"def work(self, job):\\n pass\",\n \"def daemon_job(interval):\\n time.sleep(3) # Wait for api server to start first\\n while True:\\n try:\\n crawl()\\n process_notification()\\n except Exception:\\n traceback.print_exc()\\n time.sleep(interval)\",\n \"def run(self) -> None:\\n\\n # These are set here, because user may\\n # change settings (i.e. app.config['LOG_LEVEL] = 'DEBUG')\\n # after instantiation\\n self.logger = create_logger(self.config[\\\"LOG_LEVEL\\\"], self.config[\\\"LOG_FILE\\\"])\\n\\n self._check_valid_config()\\n self.exporter = Exporter(self.config[\\\"OUT_FILE\\\"], self.config[\\\"OUT_FORMAT\\\"])\\n self.crawler = Crawler(\\n self.logger,\\n self.exporter,\\n wait=self.config[\\\"WAIT\\\"],\\n timeout=self.config[\\\"TIMEOUT\\\"],\\n concurrency=self.config[\\\"CONCURRENCY\\\"],\\n max_retries=self.config[\\\"MAX_RETRIES\\\"],\\n )\\n\\n self.logger.info(\\\"Starting crawler\\\")\\n indent = \\\" \\\" * 4\\n for key, val in self.config.items():\\n self.logger.info(f\\\"{indent}{key}: {val}\\\")\\n\\n # Create a new event loop for each execution\\n # Allows run() to be called multiple times\\n try:\\n loop = asyncio.new_event_loop()\\n asyncio.set_event_loop(loop)\\n rc = loop.run_until_complete(self.crawler.crawl(self._starting_requests))\\n finally:\\n loop.close()\\n self.end()\\n\\n if rc == ReturnCode.SUCCESS:\\n self.logger.info(\\\"Crawler ended successfully\\\")\\n else:\\n self.logger.critical(\\\"Crawler ended with error\\\")\",\n \"def start_requests(self):\\n yield Request(self.base_url, \\n callback=self.parse_urls)\",\n \"def scrap_keywords():\\n ParScr = ParallelScraper()\\n ParScr.create_and_run_threads()\\n return\",\n \"def _run_express_job(self, class_name, options=\\\"\\\"):\\n cmd = \\\"source {bento_home}/bin/kiji-env.sh; express job {jar} {myclass} --kiji {kiji_uri}\\\"\\n cmd = cmd.format(\\n bento_home=self.bento_home,\\n jar=os.path.join(self.movie_advisor_home, self.express_jar),\\n myclass=class_name,\\n kiji_uri=self.kiji_uri,\\n ) + \\\" \\\" + options\\n print(run(cmd))\",\n \"def parse_inner_urls(self, response):\\n s = Selector(response)\\n\\n jobs_per_site = s.xpath('//div[@class=\\\"col-lg-12 col-md-12 col-sm-12 aggelia-view-title\\\"]//a/@href').extract()\\n print(jobs_per_site)\\n\\n for inner_site in jobs_per_site:\\n url = urljoin(\\\"https://www.skywalker.gr/\\\", inner_site)\\n yield scrapy.Request(url, callback=self.parse_items)\",\n \"def launch_job(self,\\n job_id: Text,\\n parent: Text,\\n training_input: Dict[Text, Any],\\n job_labels: Optional[Dict[Text, Text]] = None) -> None:\\n pass\",\n \"def scrape_job_page(driver, job_title, job_location):\\n \\n current_date = str(datetime.datetime.now(pytz.timezone('US/Mountain')))\\n json_dct = {'search_title': job_title, \\\\\\n 'search_location': job_location, \\\\\\n 'search_date': current_date, 'job_site': 'glassdoor'}\\n\\n jobs = driver.find_elements_by_class_name('jobListing')\\n\\n mongo_update_lst = [query_for_data(driver, json_dct, job, idx) for \\n idx, job in enumerate(jobs[:-1])]\\n\\n store_in_mongo(mongo_update_lst, 'job_postings', 'glassdoor')\",\n \"def t_run_process(self, *args, **kwargs):\\n\\n str_cmd = \\\"\\\"\\n d_request = {}\\n d_meta = {}\\n\\n for k,v in kwargs.items():\\n if k == 'request': d_request = v\\n\\n d_meta = d_request['meta']\\n\\n if d_meta:\\n self.jid = d_meta['jid']\\n self.auid = d_meta['auid']\\n str_cmd = d_meta['cmd']\\n\\n if isinstance(self.jid, int):\\n self.jid = str(self.jid)\\n\\n self.dp.qprint(\\\"spawing and starting poller thread\\\")\\n\\n # Start the 'poller' worker\\n self.poller = Poller(cmd = str_cmd,\\n debugToFile = self.b_debugToFile,\\n debugFile = self.str_debugFile)\\n self.poller.start()\\n\\n str_timeStamp = datetime.datetime.today().strftime('%Y%m%d%H%M%S.%f')\\n str_uuid = uuid.uuid4()\\n str_dir = '%s_%s' % (str_timeStamp, str_uuid)\\n self.str_jobRootDir = str_dir\\n\\n b_jobsAllDone = False\\n\\n p = self._ptree\\n\\n p.cd('/')\\n p.mkcd(str_dir)\\n p.touch('d_meta', json.dumps(d_meta))\\n p.touch('cmd', str_cmd)\\n if len(self.auid):\\n p.touch('auid', self.auid)\\n if len(self.jid):\\n p.touch('jid', self.jid)\\n\\n p.mkdir('start')\\n p.mkdir('end')\\n\\n jobCount = 0\\n p.touch('jobCount', jobCount)\\n\\n while not b_jobsAllDone:\\n try:\\n b_jobsAllDone = self.poller.queueAllDone.get_nowait()\\n except queue.Empty:\\n self.dp.qprint('Waiting on start job info')\\n d_startInfo = self.poller.queueStart.get()\\n str_startDir = '/%s/start/%d' % (self.str_jobRootDir, jobCount)\\n p.mkdir(str_startDir)\\n p.cd(str_startDir)\\n p.touch('startInfo', d_startInfo.copy())\\n p.touch('/%s/startInfo' % str_dir, d_startInfo.copy())\\n\\n self.dp.qprint('Waiting on end job info')\\n d_endInfo = self.poller.queueEnd.get()\\n str_endDir = '/%s/end/%d' % (self.str_jobRootDir, jobCount)\\n p.mkdir(str_endDir)\\n p.cd(str_endDir)\\n p.touch('endInfo', d_endInfo.copy())\\n p.touch('/%s/endInfo' % str_dir, d_endInfo.copy())\\n\\n p.touch('/%s/jobCount' % str_dir, jobCount)\\n jobCount += 1\\n self.dp.qprint('All jobs processed.')\",\n \"def start_requests(self):\\n for url in self.start_urls:\\n yield SplashRequest(\\n url=url,\\n callback=self.parse,\\n method=\\\"GET\\\",\\n endpoint=\\\"execute\\\",\\n args={\\\"wait\\\": 15.0, \\\"lua_source\\\": self.lua_script},\\n )\",\n \"def __init__(self, urls_file_, file_spider_='no', target_format_='', ignored_links_file_='',\\n allow_clean_url_='no', time_out_=60, work_path_='./',\\n max_recursion_depth_=0, one_bite_='no', white_list_path_=\\\"\\\"):\\n self.__urls = Crawler.__read_file(urls_file_)\\n self.__file_spider = file_spider_\\n self.__target_format = target_format_\\n self.__allow_clean_url = allow_clean_url_\\n self.__one_bite = one_bite_\\n self.__white_list_path = white_list_path_\\n self.__white_list = []\\n\\n # loads white list in beginning in case an argument was passed for it\\n if self.__file_spider == 'yes' and self.__white_list_path != '':\\n self.__white_list = Crawler.__read_white_list(self.__white_list_path)\\n\\n # link titles that should be ignored during recursions\\n self.__ignored_links = Crawler.__read_file(ignored_links_file_)\\n\\n self.__time_out = time_out_\\n self.__work_path = os.path.join(work_path_.rstrip('/')+'/', 'DATA')\\n self.__recursion_max_depth = max_recursion_depth_\\n self.__extensions = ['txt', 'html', 'csv', 'tsv', 'tar', 'raw']\\n\\n logging.info('''Crawler Has been Initialized With The Below Configurations:\\n-------------------------------------------------------------------\\n-urls: %s\\n-file_spider: %s\\n-target_format: %s\\n-ignored_links_file: %s\\n-allow_clean_url: %s\\n-time_out: %s\\n-work_path: %s\\n-max_recursion_depth: %s\\n-one_bite: %s\\n-white_list_path: %s\\n''', self.__urls, self.__file_spider, self.__target_format, self.__ignored_links,\\n self.__allow_clean_url, self.__time_out, self.__work_path,\\n self.__recursion_max_depth, self.__one_bite, self.__white_list_path)\",\n \"def start_requests(self):\\r\\n yield Request(url=MooreSpider.start_url,\\r\\n callback=self.parse_directory_list,\\r\\n method=\\\"GET\\\")\",\n \"def start(self):\\n\\t\\tself.app.printflush('Sitemap: ' + self.sitemap_url)\\n\\t\\tself.getUrlsList()\\n\\t\\tself.app.printflush('Fetched: ' + str(self.fetched_count))\\n\\t\\tself.app.printflush('Processes: ' + str(self.processes))\\n\\t\\tself.CheckURLs()\\n\\t\\tself.printReport()\",\n \"def crawl_job_detail(positionId, positionName):\\n request_url = 'https://m.lagou.com/jobs/' + str(positionId) + '.html'\\n\\n headers = {\\n 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',\\n 'Accept-Encoding': 'gzip, deflate, sdch',\\n 'Accept-Language': 'zh-CN,zh;q=0.8',\\n 'Host': 'm.lagou.com',\\n 'Upgrade-Insecure-Requests': '1',\\n 'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/600.1.3 (KHTML, like Gecko) Version/8.0 Mobile/12A4345d Safari/600.1.4'\\n }\\n\\n response = requests.get(request_url, headers=headers, timeout=10, cookies=init_cookies(), proxies=PROXIES)\\n\\n if response.status_code == 200:\\n soup = BeautifulSoup(response.text, 'html5lib')\\n items = soup.find('div', class_='items')\\n jobnature = items.find('span', class_='item jobnature').span.text.strip()\\n workyear = items.find('span', class_='item workyear').span.text.strip()\\n education = items.find('span', class_='item education').span.text.strip()\\n jd = soup.find_all('div', class_='content')[0].get_text().strip().replace('\\\\n', '').replace('&nbps;', '') # jd\\n\\n elif response.status_code == 403:\\n print('request is forbidden by the server...')\\n else:\\n print(response.status_code)\\n return [positionId, positionName, jobnature, workyear, education, jd]\",\n \"def parse_item(self, response):\\n NewhouseSpider.crawled_urls.append(response.url)\\n item = FocusedScrapyCrawlerItem()\\n item['url'] = response.url\\n item['link_text'] = response.meta.get('link_text', '') if response.meta else ''\\n soup = BeautifulSoup(response.body, 'html.parser')\\n\\n item['body_p_tags'] = self._getBodyText(soup)\\n item['head_title'] = self._getHeadTitle(soup)\\n item['last_crawled'] = time.time()\\n links = self._getLinks(response, soup)\\n\\n # get score of the page based upon classifier\\n if self.classifier:\\n score = self.classifier.score(item['link_text'], item['head_title'], item['body_p_tags'])\\n else:\\n score = 0.0\\n\\n item['score'] = score\\n yield item\\n if score <= 0:\\n self.log(\\\"item={} does not belong to new home so stop crawling\\\".format(item),\\n logging.INFO)\\n else:\\n for link in links:\\n req = Request(link, priority=int(score * 1000000), # after the request is done, run parse_item to train the apprentice\\n callback=self.parse_item)\\n yield req\",\n \"def crawl_page(self, keyword, since=None, to=None, page=None):\\n data = self.get_news(keyword, since, to, page)\\n print(current_process())\\n print('crawling page no.: ' + str(page))\\n urls = self.get_urls(data)\\n p = Process()\\n p.start(urls)\",\n \"def submit(self, **kwargs):\\n pwd = curdir\\n wd = dirname(self.logFile)\\n chdir(wd)\\n d = OrderedDict()\\n #d['universe'] = 'vanilla'\\n #d['executable'] = self.command\\n\\td['job-name'] = self.name\\n\\td['nodes'] = 1\\n\\td['partition'] = defaults.get('queue')\\n\\td['time'] = defaults.get(\\\"cputime\\\")\\n\\td['mem'] = defaults.get(\\\"memory\\\")\\n d['output'] = op_join(wd,\\\"output.log\\\")\\n d['error'] = op_join(wd,\\\"output.err\\\")\\n csi_file = open(\\\"submit.sh\\\", \\\"w\\\")\\n\\tcsi_file.write(\\\"#!/bin/bash\\\\n\\\")\\n data = [\\\"#SBATCH --%s=%s\\\\n\\\" % (k, v) for k, v in d.iteritems()]\\n csi_file.write(\\\"\\\".join(data))\\n\\tcsi_file.write(\\\"export DAMPE_WORKFLOW_SERVER_URL=%s\\\\n\\\"%DAMPE_WORKFLOW_URL)\\n csi_file.write(\\\"bash script\\\\n\\\")\\n csi_file.close()\\n output = self.__run__(\\\"sbatch submit.sh\\\")\\n chdir(pwd)\\n return self.__regexId__(output)\",\n \"def run(): # pragma: no cover\\n\\n register_handler(job_configs.config)\\n bot = Bot()\\n bot.run()\",\n \"def start_requests(self):\\n\\n with open(os.path.join(os.path.dirname(__file__), \\\"../resources/mapemall_categories.csv\\\")) as categories:\\n for category in csv.DictReader(categories):\\n category_text=category[\\\"category\\\"]\\n url=str(MapemallCrawlerSpider.start_urls[0])+category_text\\n # The meta is used to send our search text into the parser as metadata\\n yield scrapy.Request(url, callback = self.parse, meta = {\\\"category_text\\\": category_text})\",\n \"def __init__(self, *args, **kwargs):\\n super(AlibabaCompanySpider, self).__init__(*args, **kwargs)\",\n \"def parse_items(self, response):\\n items = JobcrawlerItem()\\n\\n current_date = datetime.now()\\n current_date_str = current_date.strftime(\\\"%b %d %Y %H:%M:%S\\\")\\n\\n items[\\\"timestamp\\\"] = current_date_str\\n items[\\\"site\\\"] = self.allowed_domains[0]\\n items[\\\"full_html\\\"] = response.text\\n items[\\\"job_post_url\\\"] = response.request.url\\n items[\\\"full_text\\\"] = \\\" \\\".join(response.xpath('//div[@id=\\\"aggelia-text\\\"]//text()').re('(\\\\w+)'))\\n\\n extracted_title = response.xpath('//h3[@id=\\\"aggelia-title\\\"]/text()').extract()\\n if extracted_title:\\n items[\\\"job_title\\\"] = extracted_title[0]\\n else:\\n items[\\\"job_title\\\"] = \\\"\\\"\\n\\n job_requirements = response.xpath(self.requirements_xpath).extract()\\n requirements_list = list(filter(lambda item: item.strip() != '', job_requirements))\\n items[\\\"job_requirements\\\"] = \\\" \\\".join(requirements_list).replace('\\\\n', '')\\n\\n return items\",\n \"def continue_crawl(d, runner, begin_time, hour_limit):\\n end_time = datetime.now()\\n\\n # Convert elapsed time to seconds\\n elapsed_time = end_time - begin_time\\n elapsed_time_seconds = elapsed_time.days * 86400\\n elapsed_time_seconds += elapsed_time.seconds\\n\\n if elapsed_time_seconds < hour_limit:\\n wait_time = hour_limit - elapsed_time_seconds\\n # print(\\\"Waiting for {0} seconds\\\".format(wait_time))\\n time.sleep(wait_time)\\n\\n d = runner.crawl(\\\"sb_spider\\\")\\n\\n # end_time is the new \\\"start\\\" time for this iteration of the spider.\\n # Pass it in as the 3rd argument.\\n d.addBoth(lambda _: continue_crawl(d, runner, end_time, hour_limit))\",\n \"def _initJobs(self):\\n super(DigestManager, self)._initJobs()\\n conf = self.config.container_manager\\n\\n job4 = LoopingCall(self.performRequestedScan)\\n job4.start(float(conf.activescan_interval))\\n self.jobs.append(job4)\",\n \"def parse(self, response: scrapy.http.Response):\\n for job in self.parse_jobs(response):\\n yield job\\n\\n if self.has_next_page(response):\\n yield scrapy.Request(self.next_url,\\n meta={'cookiejar': response.meta['cookiejar'],\\n 'queries': response.meta['queries']},\\n dont_filter=True)\",\n \"def runNewSearch(self):\\n self.__searchJob = self.__startSearch()\\n\\n self.monitorSearchJob()\",\n \"def main():\\n try:\\n jobs = {}\\n scraped_jobs = []\\n\\n scraped_jobs = read_from_text_file(\\\"\\\", scraped_jobs_filename)\\n\\n for URL in URLs:\\n if \\\"www.linkedin.com\\\" in URL:\\n (jobs, scraped_jobs) = linkedin_meta_search(URL, jobs, scraped_jobs)\\n if \\\"www.python.org\\\" in URL:\\n (jobs, scraped_jobs) = pythondotorg_meta_search(URL, jobs, scraped_jobs)\\n if \\\"www.ziprecruiter.com\\\" in URL:\\n (jobs, scraped_jobs) = ziprecruiter_meta_search(URL, jobs, scraped_jobs)\\n\\n write_to_text_file(\\\"\\\", \\\"scraped_jobs.txt\\\", scraped_jobs)\\n\\n for id in jobs.keys():\\n score, link, title, company, date_posted, location, full_text = jobs[id]\\n\\n print(f\\\"\\\\nEvaluating {title} at {company} ({id}).\\\")\\n\\n try:\\n if \\\"yesterday\\\" in date_posted:\\n age_in_days = 1\\n elif \\\"just now\\\" in date_posted:\\n age_in_days = 0\\n elif \\\"hours ago\\\" in date_posted or \\\"hour ago\\\" in date_posted:\\n age_in_days = float(date_posted.split()[0]) / 24\\n else:\\n datetimePosted = parser.parse(date_posted)\\n age = datetime.now().timestamp() - datetimePosted.timestamp()\\n age_in_days = int(age / 24 / 60 / 60)\\n except parser.ParserError as e:\\n print(f\\\"{e}: {date_posted} couldn't be parsed properly from {link}\\\")\\n age_in_days = 0\\n age_reduction = int(age_in_days ** 2)\\n score -= age_reduction\\n if age_reduction > 0:\\n print(\\n f\\\"... docking {age_reduction} from the score ({score}) \\\\\\n because the listing is {age_in_days} days old.\\\"\\n )\\n\\n for search_phrase in search_phrases.keys():\\n if search_phrase.lower() in title.lower():\\n\\n score_adjustment = 2 * search_phrases[search_phrase]\\n score += score_adjustment\\n if score_adjustment > 0:\\n score_adjustment = \\\"+\\\" + str(score_adjustment)\\n print(\\n f\\\"... {score_adjustment} points ({score}) for \\\\\\n {search_phrase} being in {title}.\\\"\\n )\\n if search_phrase.lower() in full_text.lower():\\n score_adjustment = search_phrases[search_phrase]\\n score += score_adjustment\\n if score_adjustment > 0:\\n score_adjustment = \\\"+\\\" + str(score_adjustment)\\n print(\\n f\\\"... {score_adjustment} points ({score}) for {search_phrase} \\\\\\n being in the text of the listing.\\\"\\n )\\n jobs[id][0] = score\\n\\n print(\\\"\\\\n\\\")\\n\\n send_email(jobs)\\n\\n except Exception as e:\\n send_email(f\\\"Not working: {e}\\\") # \\\".message}, {e.args}\\\")\",\n \"def parse_job(content: scrapy.selector.Selector, job: Job):\\n\\n job['title'] = content.xpath('.//div[@class=\\\"hidden-xs likeH2\\\"]/text()').extract_first().strip()\\n job['organization'] = content.xpath('.//div[@class=\\\"hidden-xs likeH3\\\"]/text()').extract_first().strip()\\n column1_elements = content.xpath('.//div[@class=\\\"jobHitColumn1\\\"]/p')\\n job['regions'] = column1_elements[0].xpath('text()').extract_first().strip()\\n job['area'] = ' '.join(column1_elements[1].xpath('text()').extract_first().strip().split())\\n job['url'] = 'https://www.mta-dialog.de/' + \\\\\\n content.xpath('.//a[@class=\\\"detailLinkParent\\\"]/@href').extract_first().strip()\\n return MTADialogSpider.parse_job_details(job)\",\n \"def _launch_job(self, job):\\n details = self.sm.get_job_details(job.jobId)\\n handler = self.handlers[details[0]['method']]\\n type = details[0]['type']\\n resultId = details[0]['resultid']\\n job.set_phase('EXECUTING')\\n job.set_start_time(datetime.utcnow().isoformat())\\n job.add_result(resultId, 'http://localhost:8000/%s/%s/results/details' % (type, job.jobId))\\n self.sm.update_job(job = job)\\n self.threads.append(Future(handler, job.jobId, job))\",\n \"def execute(self, job):\\n raise NotImplementedError\",\n \"def execute(self):\\r\\n\\r\\n if username and password:\\r\\n job_name = input('Please enter the name of the job that you would like to apply for: ')\\r\\n job_location = input('Please enter where you would like to work: ')\\r\\n self.login_to_linkedin()\\r\\n self.driver.maximize_window()\\r\\n time.sleep(5)\\r\\n self.job_filter(job_name, job_location)\\r\\n time.sleep(5)\\r\\n self.get_job_listings()\\r\\n else:\\r\\n print('Please provide a username and password')\",\n \"def initialize_process():\\n\\n settings = Settings({'BOT_NAME': 'warnnoticebot',\\n 'LOG_LEVEL': 'INFO',\\n 'ITEM_PIPELINES': {'modules.pipelines.PerStateJsonlinesExportPipeline': 300},\\n 'USER_AGENT': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36', # This is my actual user agent when using a browser\\n 'COOKIES_ENABLED': False,\\n 'ROBOTSTXT_OBEY': True,\\n 'DOWNLOAD_DELAY': 5.0,\\n 'DEFAULT_REQUEST_HEADERS': {\\n 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',\\n 'Accept-Language': 'en',\\n 'Upgrade-Insecure-Requests': 1}\\n })\\n \\n process = CrawlerProcess(settings) \\n\\n return process\",\n \"def get_worker(self):\\n worker = self.worker(job_id=self.job_id, spider=self.spider,\\n http_session={'url': self.url, 'timeout': self.timeout},\\n **self.kwargs)\\n return worker\",\n \"def __init__(self, board='Gossiping', pages=1, file='tmp.json', title_lim=[], jsonf=None, copy_data=[], simple_mode=True):\\n if copy_data:\\n self.extend(copy_data)\\n return\\n os.chdir(os.path.split(os.path.realpath(__file__))[0])\\n print(os.getcwd())\\n com = 'scrapy crawl ptt ' if not simple_mode else 'scrapy crawl ptt_url '\\n # output json file name\\n com += '-o %s ' % (file)\\n # page\\n com += '-a pages=%d ' % (pages)\\n # board\\n com += '-a board=%s ' % (board)\\n\\n # title limit\\n if title_lim:\\n com += '-a title_lim=\\\"'\\n for lim in title_lim:\\n com += \\\"%s,\\\" % (str(lim))\\n com += '\\\" '\\n # not opened by json_file\\n if not jsonf:\\n # start crawl\\n print('Command: ' + com)\\n os.system('rm -f {}'.format(file))\\n os.system('{}'.format(com))\\n # opened by json file\\n else:\\n file = jsonf\\n\\n # all data save in self\\n self.load_json(file)\\n self.com = com\\n self.file = file\",\n \"def crawl_start(crawl_obj):\\n \\n res = None\\n\\n if crawl_obj.type in ['user', 'song'] :\\n res = eval('crawl_' + crawl_obj.type)(crawl_obj)\\n elif crawl_obj.type in ['artist', 'album'] :\\n web_data = requests.get(crawl_obj.url, headers = cheat_headers)\\n soup = bs4.BeautifulSoup(web_data.text, 'lxml')\\n\\n res = eval('crawl_' + crawl_obj.type)(crawl_obj.type, soup)\\n else:\\n print(\\\"Object type UNKNOWN!\\\")\\n \\n return res\",\n \"def from_crawler(cls, crawler, *args, **kwargs):\\n\\n spider = super(telecom_vivo_movel_spider, cls).from_crawler(\\n crawler, *args, **kwargs)\\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\\n return spider\",\n \"def scrape_main() -> None:\\n\\n logger.info(\\\"Starting scrape\\\")\\n search_info = construct_scrape_regex_patterns(grab_scrape_info())\\n links = run_scrape(\\n url=search_info['url'],\\n seasons_regex=search_info['seasons'],\\n episodes_regex=search_info['episodes']\\n )\\n if links:\\n logger.debug(\\\"Writing urls to file\\\")\\n with open('urls.txt', 'w') as f:\\n for link in links:\\n f.write(link + '\\\\n')\\n else:\\n logger.warning(\\\"No links available\\\")\",\n \"def run(self):\\n self.submit()\\n self.start()\",\n \"def setup_crawler(self, crawlers: List[BaseCrawler]) -> None:\\n self.tasks.extend(crawlers)\",\n \"def run(self):\\n\\n # The url is too deep, skip the url.. Work is done!\\n if self.depth_ > self.depth:\\n return\\n\\n # Get doc id corresponds to the url. Add a new entry into doc index if there is no entry.\\n doc_id = self.crawler.document_id(self.curr_url)\\n\\n # Check if the doc_id has been visited/processed by any of crawler_threads. Add doc_id to seen if not so.\\n if self.crawler.checkDocVisitedAndUpdate(doc_id):\\n return\\n\\n # Process the document corresponds to the url\\n socket = None\\n try:\\n socket = urllib2.urlopen(self.curr_url, timeout=self.timeout)\\n soup = BeautifulSoup(socket.read())\\n self._curr_depth = self.depth_ + 1\\n self._curr_doc_id = doc_id\\n # Traverse the document as deep as possible and add those newly discovered urls into url queue\\n self._index_document(soup)\\n # Store (wordId, docId) and (word, url) into inverted_index and resolved_inverted_index respectively.\\n self.crawler._add_words_to_document(self._curr_words, self._curr_doc_id)\\n except:\\n pass\\n finally:\\n if socket:\\n socket.close()\",\n \"def jobs(self):\\n raise NotImplementedError()\",\n \"def parse_jobs(self, response: scrapy.http.Response):\\n hits = response.xpath('//div[@class=\\\"jobHit\\\"]')\\n for hit in hits:\\n job = self.default_job()\\n job['queries'] = response.meta['queries']\\n for i in MTADialogSpider.parse_job(hit, job):\\n yield i\",\n \"def get_job_soup(what = WHAT, where = WHERE, start = 0):\\n\\tjob_page = rqs.get(get_job_url(what, where, start))\\n\\treturn BeautifulSoup(job_page.text, 'html.parser')\",\n \"def crawl(self, query, start_date, end_date, *args, **kwargs):\\n pass\",\n \"def _initJobs(self):\\n pass\",\n \"def startScrape(latest=False):\\n print '*** STARTED SCRAPING: DEFAULT: ***' \\n cache.set('default_scrape','true')\\n cache.set('scrape_mode','default')\\n \\n for key in ['scrape_friends','scrape_followers','scrape_tweets']:\\n cache.set(key,'')\\n \\n doDefaultScrape.delay(latest=latest)\",\n \"def from_crawler(cls, crawler, *args, **kwargs):\\n\\n spider = super(autos_detran_terceiros_sp_spider, cls).from_crawler(\\n crawler, *args, **kwargs)\\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\\n return spider\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68515605","0.68069863","0.6725972","0.65931946","0.6564873","0.6453477","0.6431938","0.6309634","0.62984973","0.62603843","0.62601477","0.62413216","0.61893225","0.6176784","0.6167868","0.6138753","0.61035246","0.6056674","0.60286516","0.6023728","0.6009284","0.600814","0.6007173","0.5971846","0.5928023","0.58617646","0.5830549","0.5825821","0.5824449","0.5806738","0.5753789","0.5743707","0.57295007","0.5709358","0.5700973","0.5678749","0.56782776","0.5673895","0.56604576","0.56124383","0.5605982","0.56001574","0.55969274","0.5587366","0.5568115","0.55632335","0.55599356","0.5553495","0.55489844","0.55464584","0.55376637","0.55355144","0.55269945","0.55084133","0.54970974","0.54842186","0.5477556","0.54768616","0.546674","0.54664046","0.54637283","0.54476255","0.54456925","0.5433455","0.54218805","0.5419778","0.5414361","0.54134494","0.5405959","0.54038984","0.5389293","0.53880864","0.53877354","0.53747374","0.53727424","0.5358302","0.535826","0.5346432","0.53455037","0.5338231","0.53070855","0.5305761","0.5305291","0.5303153","0.5302508","0.5295953","0.5294991","0.52945274","0.52826613","0.52767074","0.52729386","0.52504766","0.52498454","0.5247935","0.52472043","0.52397066","0.5239149","0.52236176","0.5217961","0.5217588"],"string":"[\n \"0.68515605\",\n \"0.68069863\",\n \"0.6725972\",\n \"0.65931946\",\n \"0.6564873\",\n \"0.6453477\",\n \"0.6431938\",\n \"0.6309634\",\n \"0.62984973\",\n \"0.62603843\",\n \"0.62601477\",\n \"0.62413216\",\n \"0.61893225\",\n \"0.6176784\",\n \"0.6167868\",\n \"0.6138753\",\n \"0.61035246\",\n \"0.6056674\",\n \"0.60286516\",\n \"0.6023728\",\n \"0.6009284\",\n \"0.600814\",\n \"0.6007173\",\n \"0.5971846\",\n \"0.5928023\",\n \"0.58617646\",\n \"0.5830549\",\n \"0.5825821\",\n \"0.5824449\",\n \"0.5806738\",\n \"0.5753789\",\n \"0.5743707\",\n \"0.57295007\",\n \"0.5709358\",\n \"0.5700973\",\n \"0.5678749\",\n \"0.56782776\",\n \"0.5673895\",\n \"0.56604576\",\n \"0.56124383\",\n \"0.5605982\",\n \"0.56001574\",\n \"0.55969274\",\n \"0.5587366\",\n \"0.5568115\",\n \"0.55632335\",\n \"0.55599356\",\n \"0.5553495\",\n \"0.55489844\",\n \"0.55464584\",\n \"0.55376637\",\n \"0.55355144\",\n \"0.55269945\",\n \"0.55084133\",\n \"0.54970974\",\n \"0.54842186\",\n \"0.5477556\",\n \"0.54768616\",\n \"0.546674\",\n \"0.54664046\",\n \"0.54637283\",\n \"0.54476255\",\n \"0.54456925\",\n \"0.5433455\",\n \"0.54218805\",\n \"0.5419778\",\n \"0.5414361\",\n \"0.54134494\",\n \"0.5405959\",\n \"0.54038984\",\n \"0.5389293\",\n \"0.53880864\",\n \"0.53877354\",\n \"0.53747374\",\n \"0.53727424\",\n \"0.5358302\",\n \"0.535826\",\n \"0.5346432\",\n \"0.53455037\",\n \"0.5338231\",\n \"0.53070855\",\n \"0.5305761\",\n \"0.5305291\",\n \"0.5303153\",\n \"0.5302508\",\n \"0.5295953\",\n \"0.5294991\",\n \"0.52945274\",\n \"0.52826613\",\n \"0.52767074\",\n \"0.52729386\",\n \"0.52504766\",\n \"0.52498454\",\n \"0.5247935\",\n \"0.52472043\",\n \"0.52397066\",\n \"0.5239149\",\n \"0.52236176\",\n \"0.5217961\",\n \"0.5217588\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58343834"},"document_rank":{"kind":"string","value":"26"}}},{"rowIdx":94290,"cells":{"query":{"kind":"string","value":"Return a parsed BIOM table."},"document":{"kind":"string","value":"def load_biom_table(table_f):\n return parse_biom_table(table_f)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _parse_table(text):\n\n text = str(text)\n try:\n text = text.split(\"<pre>\")[1]\n text = text.split(\"</pre>\")[0]\n text = text.split(\"To save this output\")[0]\n lines = text.split(\"\\n\")\n except Exception as exc:\n raise NNDCRequestError(f\"Unable to parse text:\\n{exc}\\n{text}\")\n table = {}\n headers = None\n for line in lines:\n tokens = line.split(\"\\t\")\n tokens = [t.strip() for t in tokens]\n if len(tokens) <= 1:\n continue\n if headers is None:\n headers = tokens\n headers = _parse_headers(headers)\n for header in headers:\n table[header] = []\n else:\n if len(tokens) != len(headers):\n raise NNDCRequestError(\n \"Too few data in table row\\n\"\n + f' Headers: \"{headers}\"\\n'\n + f' Row: \"{tokens}\"'\n )\n for header, token in zip(headers, tokens):\n table[header].append(token)\n return table","def load_biom_table_with_file_contents(biom_f):\n table = parse_biom_table(biom_f)\n if hasattr(biom_f, 'seek'):\n biom_f.seek(0)\n return table, biom_f","def getBiomData(self, data):\r\n try:\r\n if isfile(data):\r\n otu_table = parse_biom_table(qiime_open(data, 'U'))\r\n return otu_table\r\n except TypeError:\r\n if any([type(data) in\r\n [DenseFunctionTable,\r\n DenseGeneTable,\r\n DenseMetaboliteTable,\r\n DenseOTUTable,\r\n DenseOrthologTable,\r\n DensePathwayTable,\r\n DenseTable,\r\n DenseTaxonTable,\r\n FunctionTable,\r\n GeneTable,\r\n MetaboliteTable,\r\n OTUTable,\r\n OrthologTable,\r\n PathwayTable,\r\n SparseFunctionTable,\r\n SparseGeneTable,\r\n SparseMetaboliteTable,\r\n SparseOTUTable,\r\n SparseOrthologTable,\r\n SparsePathwayTable,\r\n SparseTable,\r\n SparseTaxonTable]]):\r\n otu_table = data\r\n return otu_table\r\n else:\r\n raise TypeError('Data is neither a path to a biom table or a' +\r\n ' biom table object.')","def parse_table(table):\n rows = table.find_all('tr')\n if not rows:\n raise ValueError(\"No rows for table\")\n pages = []\n table_tag = \"<table>\"\n tbl_headers = get_tbl_headers(rows)\n table_tag += \"<tr>\"\n for header in tbl_headers.keys():\n table_tag += conf.ADD_TH_TAG(header)\n table_tag += \"</tr>\"\n for row in rows:\n cols = row.find_all('td')\n if not cols:\n continue\n for page_name in cols[0].find_all('a'):\n if not page_name:\n continue\n pages.append(page_name.text)\n table_tag += '<tr>'\n for header, col in tbl_headers.items():\n try:\n table_tag += f\"<td>{preprocess_data(f'{header} : {cols[col].text}')} \\t</td>\"\n except IndexError:\n pass\n table_tag += '</tr>'\n table_tag += '</table>'\n if conf.DOWNLOAD_IMAGES:\n download_images(pages)\n return table_tag","def get_mist_eep_table():\n fp = Path(DATA_PATH, \"mist_eep_table.csv\")\n return pd.read_csv(fp, comment=\"#\")","def wmo_code_table():\n import pandas as pd\n from ..fun import get_data\n\n return pd.read_csv(get_data('Common_C02_20181107_en.txt'))","def parse(self):\r\n hdr = {'User-Agent': 'Mozilla/5.0'}\r\n url = CostOfLiving.URL.format(self.city)\r\n req = Request(url, headers=hdr)\r\n page = urlopen(req)\r\n soup = BeautifulSoup(page, \"html.parser\")\r\n self.table = soup.find(\"table\", attrs={\"class\": \"data_wide_table\"})","def parse_sp500_wiki_page(html_page):\n soup = BeautifulSoup(html_page, 'html.parser')\n table = soup.find(\"table\", {\"id\": \"constituents\"})\n \n data = []\n column_names = [col_name.text.strip() for col_name in table.find_all('th')]\n for row in table.find_all('tr'):\n data_row = [col_name.text.strip() for col_name in row.find_all('td')]\n if data_row:\n data.append(data_row)\n return data, column_names","def get_main(self) -> 'table[category: str][label: str][date: date]':\n\n raw_table = self.get_raw_table(\"M\")\n categories = raw_table[0]\n labels = raw_table[1]\n dates = self.get_dates(raw_table)\n\n def next_cat_col(i):\n n = 1\n while True:\n if i+n > len(categories)-1:\n return i\n if categories[i+n]:\n return i+n\n n += 1\n\n def get_category_labels(i):\n end_col = next_cat_col(i)\n return zip(range(i, end_col), labels[i:end_col])\n\n def get_label_cells(category, label):\n ci = categories.index(category)\n i = labels.index(label, ci)\n cells = {}\n for j, d in enumerate(dates):\n cell = raw_table[j+2][i]\n if cell and cell != \"#VALUE!\":\n cells[d] = cell\n return cells\n\n table = {}\n for i, cat in enumerate(categories):\n if not cat:\n continue\n table[cat] = {}\n for i, label in get_category_labels(i):\n table[cat][label] = get_label_cells(cat, label)\n\n return table","def matrix2Table(self, matrix): \n M = TableModel()\n M.addColumn('Mutations')\n\n fields = matrix.columnHeaders()\n for f in fields:\n M.addColumn(f)\n i = matrix.indexOfColumnWithHeader('Mutations')\n for row in matrix:\n mutationSet = Core.Data.MutationSet(row[i])\n code = '+'.join(mutationSet.mutationCodes(reduced=True))\n M.addRow(code)\n for f in fields:\n j = matrix.indexOfColumnWithHeader(f)\n if f == 'Mutations':\n M.data[code]['Mutations'] = code\n else: \n M.data[code][f] = str(row[j])\n return M","def format_biom_table(biom_table):\r\n generated_by_str = \"QIIME \" + get_qiime_library_version()\r\n return biom_table.getBiomFormatJsonString(generated_by_str)","def get_table_from_file():\n with open(\"story.csv\", \"r\") as file:\n lines = file.readlines()\n table = [element.replace(\"\\n\", \"\").split(\";\") for element in lines]\n return table","def test_parse_classic_otu_table_consensus_lineage(self):\r\n data = \"\"\"#Full OTU Counts\r\n#OTU ID\tFing\tKey\tNA\tconsensusLineage\r\n0\t19111\t44536\t42\tBacteria; Actinobacteria; Actinobacteridae; Propionibacterineae; Propionibacterium\r\n1\t1216\t3500\t6\tBacteria; Firmicutes; Alicyclobacillaceae; Bacilli; Lactobacillales; Lactobacillales; Streptococcaceae; Streptococcus\r\n2\t1803\t1184\t2\tBacteria; Actinobacteria; Actinobacteridae; Gordoniaceae; Corynebacteriaceae\r\n3\t1722\t4903\t17\tBacteria; Firmicutes; Alicyclobacillaceae; Bacilli; Staphylococcaceae\r\n4\t589\t2074\t34\tBacteria; Cyanobacteria; Chloroplasts; vectors\"\"\"\r\n data_f = StringIO(data)\r\n obs = parse_classic_otu_table(data_f)\r\n exp = (['Fing', 'Key', 'NA'],\r\n ['0', '1', '2', '3', '4'],\r\n array([[19111, 44536, 42], [1216, 3500, 6], [1803, 1184, 2],\r\n [1722, 4903, 17], [589, 2074, 34]]),\r\n [['Bacteria', 'Actinobacteria', 'Actinobacteridae', 'Propionibacterineae', 'Propionibacterium'],\r\n ['Bacteria',\r\n 'Firmicutes',\r\n 'Alicyclobacillaceae',\r\n 'Bacilli',\r\n 'Lactobacillales',\r\n 'Lactobacillales',\r\n 'Streptococcaceae',\r\n 'Streptococcus'],\r\n ['Bacteria',\r\n 'Actinobacteria',\r\n 'Actinobacteridae',\r\n 'Gordoniaceae',\r\n 'Corynebacteriaceae'],\r\n ['Bacteria',\r\n 'Firmicutes',\r\n 'Alicyclobacillaceae',\r\n 'Bacilli',\r\n 'Staphylococcaceae'],\r\n ['Bacteria', 'Cyanobacteria', 'Chloroplasts', 'vectors']])\r\n self.assertEqual(obs[0], exp[0])\r\n self.assertEqual(obs[1], exp[1])\r\n assert_almost_equal(obs[2], exp[2])\r\n self.assertEqual(obs[3], exp[3])","def parse_table(soup, start_gen, end_gen):\n pokes = []\n for cell in soup.find_all(\"td\", attrs={'style': None}):\n for name in cell.find_all(\"a\"):\n pokes.append(name.string)\n\n start_index = pokes.index(GEN_STARTS_WITH[start_gen])\n end_index = pokes.index(GEN_ENDS_WITH[end_gen]) + 1\n\n # Doesn't have to be ordered, just personal preference.\n unique_list = OrderedSet(pokes[start_index:end_index])\n\n if start_gen != end_gen:\n print(f\"{len(unique_list)} Pokémon from gen {start_gen} to {end_gen} were fetched.\")\n else:\n print(f\"{len(unique_list)} Pokémon from gen {start_gen} were fetched.\")\n\n pkmn_string = ', '.join(unique_list)\n\n for key, value in NIDORAN_CASE.items():\n # Handling of Nidoran male/female symbols.\n pkmn_string = pkmn_string.replace(key, value)\n\n return pkmn_string","def get_biGramTable(self):\n\t\treturn self._state.biGramTable","def table_from_pmids(pmid):\n soup = try_or(lambda: get_soup(pmid)) \n jsoup = get_soup(pmid,retmode=\"json\")\n #print(pmid)\n cit_count, scopus_json = get_cit_by_pmid(pmid)\n print(f\"scopus_json: {scopus_json}\")\n result = {\n \"pmid\": pmid,\n \"publ_date\": try_or(lambda: get_pub_date(soup)),\n \"pi_name\": try_or(lambda: get_PI(soup)),\n \"full_affil\": try_or(lambda: get_aff_countries(pmid,PI=False)), # !!! change the function to retrieve PI and othe affiliations simultaneously\n \"pi_affil\": try_or(lambda: get_aff_countries(pmid,PI=True)), # !!! change the function to retrieve PI and othe affiliations simultaneously\n \"pi_publ_count\": try_or(lambda: count_results(f\"{get_PI(soup)}[Author - Last]\")),\n \"journal\": try_or(lambda: get_journal(soup)),\n \"journal_publ_count\": try_or(lambda: count_results(f\"{get_journal(soup)}[Journal]\")),\n \"authors_count\": try_or(lambda: get_n_authors(soup)),\n \"cit_count\": cit_count,\n \"summary\": try_or(lambda: json.loads(jsoup.text)),\n \"scopus_json\": scopus_json,\n }\n\n print(pmid)\n return(result)","def extract_main_table_from_html(html):\n soup = bs(html, 'html.parser')\n table = soup.find('table')\n return(table)","def _parse_table(value):\n lines = value.split('\\n')\n header = None\n rows = []\n\n for l in lines:\n if l.startswith('+-'):\n pass\n elif l.startswith('|'):\n columns = [c.strip() for c in l.split('|')[1:-1]]\n if header is None:\n header = columns\n else:\n row = {}\n for i, c in enumerate(columns):\n if len(header)-1 <= i:\n row[i] = c\n else:\n row[header[i]] = c\n rows.append(row)\n return rows","def return_astropy_table(self):\n table = Table()\n for name in self.hdfile.root.Data.Fibers.colnames:\n if hasattr(self, name):\n table[name] = getattr(self, name)\n\n return table","def return_astropy_table(self):\n table = Table()\n for name in self.hdfile.root.Data.Fibers.colnames:\n if hasattr(self, name):\n table[name] = getattr(self, name)\n\n return table","def table(self):\n return self.generator.table","def build_table(self):\n if len(self._abslines) == 0:\n return\n comp_tbl = QTable()\n comp_tbl.add_column(Column([iline.wrest.to(u.AA).value for iline in self._abslines]*u.AA,name='wrest'))\n for attrib in ['z', 'flagN', 'N', 'Nsig']:\n comp_tbl.add_column(Column([iline.attrib[attrib] for iline in self._abslines], name=attrib))\n # Return\n return comp_tbl","def parse_html_tables(html_filename):\n\n with open(html_filename) as f:\n p = SimpleHTMLTableParser()\n p.feed(f.read())\n return p.tables","def parse_biom(filename, keep_otus=True, internal_levels=False):\n from biom import load_table # avoid to ask for the BIOM library if there is no biom file\n\n biom_table = load_table(filename)\n strs = biom_table.delimited_self(header_value='TAXA', header_key='taxonomy')\n lst1 = [str(s) for s in strs.split('\\n')[1:]] # skip the \"# Constructed from biom file\" entry\n biom_file = []\n out = [lst1[0]] # save the header\n pre_taxa = compile(\".__\")\n classs = compile(\"\\(class\\)\")\n\n # consistency check\n i = 0\n while i < (len(lst1)-1):\n if len([s for s in lst1[i].split('\\t')]) != len([s for s in lst1[i+1].split('\\t')]):\n raise Exception('[parse_biom()] It seems that taxonomic metadata are missing, maybe is the wrong biom file?')\n\n i += 1\n\n for l in lst1[1:]:\n otu = None\n lst = [float(s.strip()) for s in l.split('\\t')[1:-1]]\n\n if keep_otus:\n otu = l.split('\\t')[0]\n\n # Clean and move taxa in first place\n taxa = '.'.join([s.strip().replace('[', '').replace('u\\'', '').replace(']', '').replace(' ', '').replace('\\'', '')\n for s in l.split('\\t')[-1].split(',')])\n taxa = pre_taxa.sub('', taxa) # remove '{k|p|o|g|s}__'\n taxa = classs.sub('', taxa) # remove '(class)'\n taxa = taxa.rstrip('.') # remove trailing dots\n\n if otu:\n taxa = taxa + '.' + otu\n\n biom_file.append([taxa] + lst)\n\n # merge such rows that have the same taxa\n i = 1\n dic = {}\n\n for l in biom_file[i:]:\n if l[0] not in dic:\n dic[l[0]] = l[1:]\n\n for k in biom_file[i+1:]:\n if l[0] == k[0]:\n lst = []\n lstdic = dic[l[0]]\n j = 1\n while j < len(lstdic):\n lst.append(float(lstdic[j]) + float(k[j]))\n j += 1\n\n dic[l[0]] = lst\n i += 1\n\n feats = dict(dic)\n\n if internal_levels:\n feats = add_missing_levels(feats)\n\n for k in feats:\n out.append('\\t'.join([str(s) for s in [k] + feats[k]]))\n\n return '\\n'.join(out)","def convert_quick_table(result):\n headline = result.split('\\n',1)[0]\n names, converters = MastCasJobs.get_converters(headline, delimiter=',')\n tab = ascii.read(MastCasJobs.replacenull(result,delimiter=','),\n guess=False,fast_reader=False,format='csv',\n names=names,converters=converters)\n return tab","def read_table(lines):\n # header line 1: (100*Z+A), mass in [m_neutron]\n # [MAT, 3, MT/ ZA, AWR, 0, 0, 0, 0] HEAD\n\n # header line 2: Q-value and some counts\n # [MAT, 3, MT/ QM, QI, 0, LR, NR, NP/ EINT/ S(E)] TAB1\n f = read_line(lines[1])\n nS = int(f[4]) # number of interpolation sections\n nP = int(f[5]) # number of data points\n\n # header line 3: interpolation information\n # [MAT, 3, 0/ 0.0, 0.0, 0, 0, 0, 0] SEND\n # 1 y is constant in x (constant, histogram)\n # 2 y is linear in x (linear-linear)\n # 3 y is linear in ln(x) (linear-log)\n # 4 ln(y) is linear in x (log-linear)\n # 5 ln(y) is linear in ln(x) (log-log)\n # 6 y obeys a Gamow charged-particle penetrability law\n\n # data lines\n x = []\n y = []\n for l in lines[3:]:\n f = read_line(l)\n x.append(f[0])\n y.append(f[1])\n x.append(f[2])\n y.append(f[3])\n x.append(f[4])\n y.append(f[5])\n return np.array(x[:nP]), np.array(y[:nP])","def parse(self):\n if self.filename.endswith('.gz'):\n compression = 'gzip'\n elif self.filename.endswith('.bz2'):\n compression = 'bz2'\n else:\n compression = None\n df = pd.read_table(self.filename, compression=compression)\n\n # drop empty column from extra tab\n df.dropna(axis=1, how='all', inplace=True)\n return df","def parse_bid_table(table):\r\n columns = table.find_all('td')\r\n player_id = int(re.findall('\\d+', columns[0].a['href'])[0])\r\n player = columns[0].text\r\n owner = columns[1].text\r\n team_id = int(re.findall('\\d+', columns[2].img['src'])[0])\r\n team = table.img['alt']\r\n price = int(columns[3].text.replace(\".\", \"\"))\r\n bid_date = columns[4].text\r\n trans_date = columns[5].text\r\n status = columns[6].text\r\n return player_id, player, owner, team_id, team, price, bid_date, trans_date, status","def parse_emission_matrix(emissions_matrix_path):\r\n f = open(emissions_matrix_path)\r\n f.readline() # remove first line\r\n lines = f.readlines()\r\n k_counter = len(lines)\r\n emissions_mat = np.zeros([k_counter + NOT_MOTIF_STATES, ALPHABET_LEN])\r\n # B start\r\n emissions_mat[0, 0] = 1\r\n # B end\r\n emissions_mat[-1, -1] = 1\r\n # B_1\r\n emissions_mat[1, 1:-1] = UNIFORM_PROB\r\n # B_2\r\n emissions_mat[-2, 1:-1] = UNIFORM_PROB\r\n for k, line in enumerate(lines, 2): # go over every line\r\n emissions = line.split('\t')\r\n for letter in range(len(alphabet)): # create emissions for every S_i\r\n emissions_mat[k, letter + 1] = float(emissions[letter])\r\n return wrap_log(emissions_mat), k_counter","def tables(cls):\n if not hasattr(cls, '_tables'):\n cls.parse_attributes()\n return cls._tables","def get_table(new_arr, types, titles):\n try:\n table = agate.Table(new_arr, titles, types)\n return table\n except Exception as e:\n print e","def read_table_data(self, table):\n data = []\n index = 0\n for row in table.rows:\n data.append([])\n for cell in row.cells:\n text_data = ''\n for para in cell.paragraphs:\n text_data += para.text.strip(' ')\n data[index].append(text_data)\n index += 1\n\n # trim unneeded rows in old & new reports\n if all('CAPA' in x for x in data[0]):\n self.table_data = data[2:]\n else:\n self.table_data = data[1:]\n # trim end of list\n self.table_data = [row[:5] for row in self.table_data]","def read_bc_table(fname=datapath+\"/bolometric_corrections/bc_p04_ugriz.data\"):\n with open(fname,'r') as fp:\n lines = fp.readlines()\n s = lines[1].split()\n NTeff, Nlogg, NMH, Nfilt = int(s[0]), int(s[2]), int(s[5]), int(s[7])\n allBCs = {}\n\n Teffs = list(map(float, \"\".join(lines[2:5]).replace(\"\\n\",\" \").split()))\n loggs = list(map(float, lines[5].split()))\n Nlist = list(map(int, lines[6].split()))\n iline = 7\n allBCs = {}\n for ifilt in range(Nfilt):\n BCtable = np.zeros((np.sum(Nlist)*NMH,4))\n itable = 0\n for iMH in range(NMH):\n s = lines[iline].split()\n FeH = float(s[2]); aFe = float(s[5]); filter = s[9]\n iline += 1\n for ilogg,logg in enumerate(loggs):\n BCrow = []\n while len(BCrow) < Nlist[ilogg]:\n line = lines[iline]\n iline += 1\n BCrow += list(map(float, line.split()))\n for iTeff,Teff in enumerate(Teffs[0:Nlist[ilogg]]):\n BCtable[itable,0] = Teff\n BCtable[itable,1] = logg\n BCtable[itable,2] = FeH\n BCtable[itable,3] = BCrow[iTeff]\n itable += 1\n allBCs[filter] = BCtable\n return allBCs","def parse_table(s, allow_wrap=False):\n r = []\n columns = []\n for l in s.splitlines():\n if not l.strip():\n columns = []\n continue\n if rx_header_start.match(l):\n # Column delimiters found. try to determine column's width\n columns = []\n x = 0\n while l:\n match = rx_col.match(l)\n if not match:\n break\n columns.append((x + len(match.group(1)),\n x + len(match.group(1)) + len(\n match.group(2))))\n x += match.end()\n l = l[match.end():]\n elif columns: # Fetch cells\n if allow_wrap:\n row = [l[f:t] for f, t in columns]\n if row[0].startswith(\" \") and r:\n for i, x in enumerate(row):\n r[-1][i] += x\n else:\n r += [row]\n else:\n r += [[l[f:t].strip() for f, t in columns]]\n if allow_wrap:\n return [[x.strip() for x in row] for row in r]\n else:\n return r","def test_format_biom_table(self):\r\n generated_by = \"QIIME \" + get_qiime_library_version()\r\n self.assertTrue(generated_by in format_biom_table(self.biom1))","def testLR0ParseTable(self):\r\n from pydsl.Parser.LR0 import _slr_build_parser_table, build_states_sets\r\n state_sets = build_states_sets(productionset0)\r\n self.assertEqual(len(state_sets), 5)\r\n #0 . EI: : . exp $ , \r\n # exp : .SR\r\n # transitions: S -> 2,\r\n # goto: exp -> 1\r\n #1 EI: exp . $ ,\r\n # transitions: $ -> 3\r\n #2 exp: S . R,\r\n # transitions: R -> 4\r\n #3 EI: exp $ .\r\n #4 exp: S R .\r\n # reduce\r\n\r\n parsetable = _slr_build_parser_table(productionset0)\r\n self.assertEqual(len(parsetable), 4)","def test_parse_classic_otu_table_file(self):\r\n data = \"\"\"#Full OTU Counts\r\n#OTU ID\tFing\tKey\tNA\tConsensus Lineage\r\n0\t19111\t44536\t42\tBacteria; Actinobacteria; Actinobacteridae; Propionibacterineae; Propionibacterium\r\n1\t1216\t3500\t6\tBacteria; Firmicutes; Alicyclobacillaceae; Bacilli; Lactobacillales; Lactobacillales; Streptococcaceae; Streptococcus\r\n2\t1803\t1184\t2\tBacteria; Actinobacteria; Actinobacteridae; Gordoniaceae; Corynebacteriaceae\r\n3\t1722\t4903\t17\tBacteria; Firmicutes; Alicyclobacillaceae; Bacilli; Staphylococcaceae\r\n4\t589\t2074\t34\tBacteria; Cyanobacteria; Chloroplasts; vectors\"\"\"\r\n data_f = StringIO(data)\r\n obs = parse_classic_otu_table(data_f)\r\n exp = (['Fing', 'Key', 'NA'],\r\n ['0', '1', '2', '3', '4'],\r\n array([[19111, 44536, 42], [1216, 3500, 6], [1803, 1184, 2],\r\n [1722, 4903, 17], [589, 2074, 34]]),\r\n [['Bacteria', 'Actinobacteria', 'Actinobacteridae', 'Propionibacterineae', 'Propionibacterium'],\r\n ['Bacteria',\r\n 'Firmicutes',\r\n 'Alicyclobacillaceae',\r\n 'Bacilli',\r\n 'Lactobacillales',\r\n 'Lactobacillales',\r\n 'Streptococcaceae',\r\n 'Streptococcus'],\r\n ['Bacteria',\r\n 'Actinobacteria',\r\n 'Actinobacteridae',\r\n 'Gordoniaceae',\r\n 'Corynebacteriaceae'],\r\n ['Bacteria',\r\n 'Firmicutes',\r\n 'Alicyclobacillaceae',\r\n 'Bacilli',\r\n 'Staphylococcaceae'],\r\n ['Bacteria', 'Cyanobacteria', 'Chloroplasts', 'vectors']])\r\n self.assertEqual(obs[0], exp[0])\r\n self.assertEqual(obs[1], exp[1])\r\n assert_almost_equal(obs[2], exp[2])\r\n self.assertEqual(obs[3], exp[3])","def parse(self):\n mp = {}\n cells = self.row.find_all(\"td\")\n\n for cell in cells:\n if \"visible-mobile\" in cell.attrs[\"class\"]:\n continue\n title = self._get_cell_title(cell)\n content = cell.find(\"span\", class_=\"table-responsive__inner\")\n\n if title == \"name\":\n mp.update(self._parse_name(cell, content))\n elif title == \"fraktion\":\n fraktion, klub = self._parse_abbreviation(content)\n mp[\"political_affiliation\"] = klub + \" (\" + fraktion + \")\"\n elif title == \"wahlkreis\":\n mp[\"wahlkreis\"] = content.text.strip()\n elif title == \"bundesland\":\n mp[\"state\"] = self._parse_abbreviation(content)[1]\n\n return mp","def construct_table(self):\n table_str = self.header_row\n row_lbls, col_lbls = self.get_idxvals()\n for r,rlbl in enumerate(row_lbls):\n row_data = [self.data[rlbl,clbl] for clbl in col_lbls]\n table_str += self.construct_row(r, row_data)\n \n return table_str","def mono_table():\n return Table(\n {\n \"obs_id\": [1, 1, 1, 1, 1, 2],\n \"event_id\": [1, 1, 1, 2, 2, 1],\n \"tel_id\": [1, 2, 3, 5, 7, 1],\n \"hillas_intensity\": [1, 2, 0, 1, 5, 9],\n \"hillas_width\": [0.1, 0.2, 0.1, 0.1, 0.2, 0.1] * u.deg,\n \"hillas_length\": 3 * ([0.1, 0.2, 0.1, 0.1, 0.2, 0.1] * u.deg),\n \"dummy_tel_energy\": [1, 10, 4, 0.5, 0.7, 1] * u.TeV,\n \"dummy_tel_is_valid\": [\n True,\n True,\n True,\n True,\n False,\n False,\n ],\n \"classifier_tel_prediction\": [1, 0, 0.5, 0, 0.6, 1],\n \"classifier_tel_is_valid\": [\n True,\n True,\n False,\n True,\n True,\n True,\n ],\n \"disp_tel_alt\": [58.5, 58, 62.5, 72, 74.5, 81] * u.deg,\n \"disp_tel_az\": [12.5, 15, 13, 21, 20, 14.5] * u.deg,\n \"disp_tel_is_valid\": [\n True,\n False,\n True,\n True,\n True,\n True,\n ],\n }\n )","def _parse_biography(self):\n data = {}\n self.right_column = self.content.find(\"div\", class_=\"rechteSpalte60\")\n heading = self.right_column.find(\"h3\")\n # The page of the second president hides the details information\n # and displays a biography instead. By selecting the second div,\n # we get the hidden div containing the MPs details.\n if not heading:\n self.right_column = self.content.find_all(\"div\", class_=\"rechteSpalte60\")[1]\n data.update(self._parse_dob_job())\n data.update(self._parse_political_mandates())\n data.update(self._parse_political_posts())\n data.update(self._parse_work_history())\n data.update(self._parse_education())\n return data","def parseTable(chart):\n rowelems = chart.find_all('tr')\n rows = [rowelem.find_all('td') for rowelem in rowelems]\n data = [[elem.get_text() for elem in row] for row in rows]\n return(data)","def test_getBiomData(self):\r\n bt_string = '''{\r\n \"id\":null,\r\n \"format\": \"Biological Observation Matrix 0.9.1-dev\",\r\n \"format_url\": \"http://biom-format.org\",\r\n \"type\": \"OTU table\",\r\n \"generated_by\": \"QIIME revision XYZ\",\r\n \"date\": \"2011-12-19T19:00:00\",\r\n \"rows\":[\r\n {\"id\":\"GG_OTU_1\", \"metadata\":null},\r\n {\"id\":\"GG_OTU_2\", \"metadata\":null},\r\n {\"id\":\"GG_OTU_3\", \"metadata\":null},\r\n {\"id\":\"GG_OTU_4\", \"metadata\":null},\r\n {\"id\":\"GG_OTU_5\", \"metadata\":null}\r\n ],\r\n \"columns\": [\r\n {\"id\":\"Sample1\", \"metadata\":null},\r\n {\"id\":\"Sample2\", \"metadata\":null},\r\n {\"id\":\"Sample3\", \"metadata\":null},\r\n {\"id\":\"Sample4\", \"metadata\":null},\r\n {\"id\":\"Sample5\", \"metadata\":null},\r\n {\"id\":\"Sample6\", \"metadata\":null}\r\n ],\r\n \"matrix_type\": \"dense\",\r\n \"matrix_element_type\": \"int\",\r\n \"shape\": [5,6],\r\n \"data\": [[0,0,1,0,0,0],\r\n [5,1,0,2,3,1],\r\n [0,0,1,4,2,0],\r\n [2,1,1,0,0,1],\r\n [0,1,1,0,0,0]]\r\n }'''\r\n biom_data = parse_biom_table_str(bt_string)\r\n F = FunctionWithParams('')\r\n\r\n self.assertEqual(biom_data, F.getBiomData(biom_data))\r\n\r\n # write biom_data to temp location\r\n fd, bt_path = mkstemp(suffix='.biom')\r\n close(fd)\r\n biom_file = open(bt_path, 'w')\r\n biom_file.writelines(bt_string)\r\n biom_file.close()\r\n self.assertEqual(biom_data, F.getBiomData(bt_path))\r\n\r\n # cleanup\r\n remove(bt_path)","def _extract_raw_table(self, expr):\n str_start = \"<table\"\n str_end = \"/table>\"\n\n ind_start = expr.find(str_start)\n assert ind_start >= 0\n\n ind_end = expr.find(str_end)\n assert ind_end >= 0\n\n return expr[ind_start: ind_end + len(str_end)]","def getTableHead():\n return [\"Reporter\", \"Reportee\", \"aln. DKIM\", \"aln. SPF\", \"Disposition\",\n \"DKIM result\", \"SPF result\", \"msg#\", \"IP\", \"Country\",\n \"Report Begin\", \"Report End\", \"Report ID\"]","def parse_table_from_output(output, policy_name):\n\n headers = []\n row = []\n\n separator = \"|\"\n\n for line in output.split(\"\\n\"):\n if not headers and line.startswith(\"Name\"):\n headers = [header.strip() for header in line.split(separator)]\n elif line.startswith(policy_name):\n if row:\n raise Exception(\"Multiple license policies detected - expected 1.\")\n row = [val.strip() for val in line.split(separator)]\n\n if not headers:\n raise Exception(\"Table not found in output!\")\n\n if not row:\n raise Exception(\"No license policies found - expected 1.\")\n\n return dict(zip(headers, row))","def generate_table(self):\n states = self.get_canonical_collection()\n # self.print_canonical_collection(states)\n table = [{} for _ in range(len(states))]\n\n for index in range(len(states)):\n state = states[index]\n first_rule_cnt = 0\n second_rule_cnt = 0\n third_rule_cnt = 0\n beta = []\n for prod in state:\n dot_index = prod[1].index('.')\n alpha = prod[1][:dot_index]\n beta = prod[1][dot_index + 1:]\n if len(beta) != 0:\n first_rule_cnt += 1\n else:\n if prod[0] != 'S1':\n second_rule_cnt += 1\n production_index = self.grammar.P.index((prod[0], alpha))\n elif alpha == [self.grammar.S[0]]:\n third_rule_cnt += 1\n if first_rule_cnt == len(state):\n table[index]['action'] = 'shift'\n\n elif second_rule_cnt == len(state):\n table[index]['action'] = 'reduce ' + str(production_index)\n\n elif third_rule_cnt == len(state):\n table[index]['action'] = 'acc'\n else:\n conflict_msg = 'Conflict! State I' + str(index) + ': ' + str(state) + '\\nSymbol: ' + beta[0]\n raise (Exception(conflict_msg))\n for symbol in self.grammar.N + self.grammar.E: # the goto part of the table\n next_state = self.go_to(state, symbol)\n if next_state in states:\n table[index][symbol] = states.index(next_state)\n # print(\"table\", table)\n return table","def get_structure(self):\n if len(self.headers) == 0:\n self.restore_structure()\n columns = self.parse_declaration()\n result = \"<tablestructure>\\n\"\n result += \"\\t<table id=\\\"%s\\\" name=\\\"%s\\\">\\n\" % (self.id, self.name)\n result += \"\\t<header>\\n\"\n for header in self.headers:\n result += \"\\t\\t%s\\n\" % columns[header].to_xml()\n result += \"\\t</header>\\n\"\n result += \"\\t</table>\\n\"\n result += \"</tablestructure>\"\n return result","def extract_data(self):\r\n self.parse()\r\n lst = []\r\n for i in self.table.text.split(\"\\n\")[3:]:\r\n if i != \"\" and bool(re.search(r'\\d', i)):\r\n lst.append(i.replace(u'\\xa0', ''))\r\n single = lst.pop(-3)\r\n lst = [i + \" \" + j for i, j in zip(lst[::2], lst[1::2])]\r\n lst.append(single)\r\n return lst[0:28]","def get_table(html) -> None:\n\tre_table_class = re.compile('.*2iSP.*') # familiar regex template (str w/ '2iSP')\n\ttable_class = html.find('div', {'class': re_table_class})\n\ttable_lst = re.findall('[А-Я|A-Z][^А-Я|A-Z]*', table_class.text) # regex for capitals\n\n\tfor param in table_lst:\n\t\tif 'Осадки' in param:\n\t\t\tweather_dict['precipation'] = re.search(r'\\d+', param).group()\n\t\telif 'Ветер' in param:\n\t\t\tweather_dict['wind'] = re.search(r'\\d+', param).group()\n\t\telif 'Давление' in param:\n\t\t\tweather_dict['pressure'] = re.search(r'\\d+', param).group()\n\t\telif 'Восход' in param:\n\t\t\tweather_dict['sunrise'] = ':'.join(re.findall(r'\\d+', param))\n\t\telif 'Закат' in param:\n\t\t\tweather_dict['sunset'] = ':'.join(re.findall(r'\\d+', param))","def scrapeTable():\n\tfrom bs4 import BeautifulSoup\n\tfrom urllib2 import urlopen\n\n\turl = \"https://en.wikipedia.org/wiki/List_of_the_largest_libraries_in_the_United_States\"\n\n\t# read the html content\n\thtml = urlopen(url).read()\n\n\t# create BeautifulSoup from html\n\ttable = BeautifulSoup(html)\n\n\t# find all table row elements\n\trows = table.findAll('tr')\n\n\tarr = []\n\tfor tr in rows:\n\n\t\t# find all columns\n\t\tcols = tr.findAll('td')\n\n\t\t# column text\n\t\tx = [c.text for c in cols]\n\n\t\t# filter the content\n\t\tif len(x)!=0:\n\t\t\ttry:\n\t\t\t\tint(x[0])\n\t\t\texcept Exception, e:\n\t\t\t\tbreak\n\n\t\t\tarr.append(x)\n\n\treturn arr","def parse(self):\n for index in range(len(self.columns)):\n if index in self.columns:\n self.parsed_table[self.columns[index].col_name_str] = []\n if not self.table.linked_pages:\n return self.create_empty_table()\n for data_chunk in self.table.linked_pages:\n original_data = data_chunk\n parsed_data = parse_data_page_header(original_data, version=self.version)\n\n last_offset = None\n for rec_offset in parsed_data.record_offsets:\n # Deleted row - Just skip it\n if rec_offset & 0x8000:\n last_offset = rec_offset & 0xfff\n continue\n # Overflow page\n if rec_offset & 0x4000:\n # overflow ptr is 4 bits flags, 12 bits ptr\n rec_ptr_offset = rec_offset & 0xfff\n # update last pointer to pointer without flags\n last_offset = rec_ptr_offset\n # The ptr is the offset in the current data page. we get a 4 byte record_pointer from that\n overflow_rec_ptr = original_data[rec_ptr_offset:rec_ptr_offset + 4]\n overflow_rec_ptr = struct.unpack(\"<I\", overflow_rec_ptr)[0]\n record = self._get_overflow_record(overflow_rec_ptr)\n if record:\n self._parse_row(record)\n continue\n # First record is actually the last one - from offset until the end of the data\n if not last_offset:\n record = original_data[rec_offset:]\n else:\n record = original_data[rec_offset:last_offset]\n last_offset = rec_offset\n if record:\n self._parse_row(record)\n return self.parsed_table","def _populate(self):\n\n # Assume the first word is what we want, and we can find well formed years\n # This sucks, but will work for these ones.\n # Roll on bibtex for citations in the CIM.\n\n citation_detail = self.doc.citation_detail\n author = citation_detail.split(',')[0]\n match = '([^\\w])19|20\\d\\d([^\\w])*?'\n m = re.search(match, citation_detail)\n if m:\n year = m.group(0)\n else:\n year = None\n\n # one error in existing es-doc content to be fixed:\n if 'van Vuuren DP' in author:\n author = 'van Vuuren'\n print 'applying vv fix'\n\n self.year = int(year)\n\n # We assume that this table will have entries which ne\n\n # I use the first three letters of a an authors name, and for\n # three or more authors, EA, and then the year for my bibtex citation string\n self.citeguess = author[0:3] + 'EA' + year[2:]\n # This is what will appear in the table:\n self.citestring = '%s et al. (%s)' % (author, year)\n # Keep this for a reference list for checking against the eventual bibtex reference list.\n self.text = citation_detail","def _process(self, tables=None):\n\n if self._tables:\n return self._tables\n\n tables = tables or {}\n\n for row in self.url.generator.iter_rp:\n\n table_id_key = row['Table ID'].strip().lower()\n\n if not row['Line Number'].strip():\n if 'Universe' not in row['Table Title']:\n if table_id_key not in tables:\n tables[table_id_key] = Table(row['Table ID'], row['Table Title'].strip().title(),\n seq=row['Sequence Number'],\n startpos=int(row['Start Position']))\n else:\n tables[table_id_key].seq = row['Sequence Number']\n tables[table_id_key].startpos = row['Start Position']\n tables[table_id_key].subject = row['Subject Area']\n\n else:\n tables[table_id_key].universe = row['Table Title'].replace('Universe: ', '').strip()\n\n else: # column row\n try:\n\n line_no = int(row['Line Number'])\n\n if not line_no in tables[table_id_key].columns:\n tables[table_id_key].columns[line_no] = Column(row['Table ID'],\n f\"{row['Table ID']}_{line_no:03}\",\n line_no,\n description=row['Table Title'])\n else:\n tables[table_id_key].columns[line_no].description = row['Table Title']\n\n\n except ValueError as e:\n # Headings, which have fractional line numebrs\n # print(row)\n pass\n\n self._tables = tables\n\n return self._tables","def parse_tables_from_html(html, md_file):\n soup = BeautifulSoup(html, features=\"lxml\")\n table_contents = \"\"\n for table in soup.select('table'):\n try:\n table_content = process_table(table)\n table_contents += table_content\n except:\n continue\n\n if not table_contents:\n print(\"NO VALID TABLE\")\n return\n\n # write to the file\n with codecs.open(md_file, mode='w', encoding='utf-8') as file:\n file.write(table_contents)\n print(\"The Table is saved in\" + md_file)","def _html_table(self):\n return '</i>'.join(APtable._repr_html_(self).split('</i>')[1:])","def parse_mbp_data(self, url):\n body = self.get_content(url)\n if body is None:\n return None\n\n doc_body = pq(body)\n content = doc_body('#main-container').html()\n lines = content.splitlines()\n\n record = {\n 'url': url,\n 'price': self.get_price(lines),\n 'year': self.get_year(lines),\n 'bat_count': self.search_int(\n r'循環\\D*(\\d+)',\n content,\n 1\n ),\n 'screen': self.search_int(\n r'(1\\d{1})[吋\"\\']',\n content,\n 1\n ),\n 'cpu': self.search_string(\n r'i5|i7',\n content\n ),\n 'ram': self.search_int(\n r'(8|16)G',\n content,\n 1\n ),\n 'hdd': self.search_int(\n r'(128|256|512)G',\n content,\n 1\n ),\n }\n return record","def test_parse_classic_otu_table(self):\r\n data = self.otu_table1\r\n data_f = (data.split('\\n'))\r\n obs = parse_classic_otu_table(data_f)\r\n exp = (['Fing', 'Key', 'NA'],\r\n ['0', '1', '2', '3', '4'],\r\n array([[19111, 44536, 42], [1216, 3500, 6], [1803, 1184, 2],\r\n [1722, 4903, 17], [589, 2074, 34]]),\r\n self.expected_lineages1)\r\n self.assertEqual(obs[0], exp[0])\r\n self.assertEqual(obs[1], exp[1])\r\n assert_almost_equal(obs[2], exp[2])\r\n self.assertEqual(obs[3], exp[3])\r\n\r\n\r\n # test that the modified parse_classic performs correctly on OTU tables\r\n # without leading comments\r\n data = self.otu_table_without_leading_comment\r\n data_f = (data.split('\\n'))\r\n obs = parse_classic_otu_table(data_f)\r\n sams = ['let-7i', 'miR-7', 'miR-17n', 'miR-18a', 'miR-19a', 'miR-22',\r\n 'miR-25', 'miR-26a']\r\n otus = ['A2M', 'AAAS', 'AACS', 'AADACL1']\r\n vals = array([\r\n [-0.2, 0.03680505, 0.205, 0.23, 0.66, 0.08, -0.373, 0.26],\r\n [-0.09, -0.25, 0.274, 0.15, 0.12, 0.29, 0.029, -0.1148452],\r\n [0.33, 0.19, 0.27, 0.28, 0.19, 0.25, 0.089, 0.14],\r\n [0.49, -0.92, -0.723, -0.23, 0.08, 0.49, -0.386, -0.64]])\r\n exp = (sams, otus, vals, []) # no lineages\r\n # because float comps in arrays always errors\r\n self.assertEqual(obs[0], exp[0])\r\n self.assertEqual(obs[1], exp[1])\r\n self.assertEqual(obs[3], exp[3])\r\n self.assertTrue(all((obs[2] == exp[2]).tolist()))","def create_table_from_table_metric(table_metric: TableMetric) -> Text:\n\n supported_metric = {\n TableMetric.CONTINGENCY_TABLE,\n TableMetric.TABLE_DESCRIPTIVE\n }\n\n assert table_metric.name in supported_metric\n\n table_template = template.TABLE_TEMPLATE\n\n headers = ['​'] + list(table_metric.column_indexes)\n header_string = \"|\".join(headers)\n header_separator = \"|\".join([\":-----:\" for i in range(len(headers))])\n\n table_content = []\n\n for row in table_metric.rows:\n # row header is in BOLD\n row_header = template.BOLD.format(\n content=str(row.row_index).strip())\n row_values = [row_header] + [formatting.numeric_formatting(item.value)\n for item in row.cells]\n table_content.append(\"|\".join(row_values))\n\n table_content_string = \"\\n\".join(table_content)\n\n return table_template.format(\n header=header_string,\n header_separator=header_separator,\n table_content=table_content_string\n )","def read_table(self):\n\n db = self.connection(database=\"imdb\")\n\n try:\n cur = db.cursor()\n sql = \"SELECT title FROM film;\"\n cur.execute(sql)\n return cur.fetchall()\n except:\n print(\"Cannot read from table!\")\n\n db.close()","def read_mumax3_table(filename):\n \n table = pd.read_csv(filename, sep='\\t')\n table.columns = ' '.join(table.columns).split()[1::2]\n \n return table","def load_market_matrix():\n\tfnm = \"../datasets/bbc/bbc.mtx\"\n \tconverters = {\"termid\": toInt, \"docid\": toInt, \"freq\":toFloat}\n \tX = pandas.read_table(fnm, header=None, sep=\" \", skiprows=2, names= [\"termid\", \"docid\", \"freq\"], converters=converters)\n \tX[\"termid\"] = X[\"termid\"] - 1\n\tX[\"docid\"] = X[\"docid\"] - 1\n\treturn X","def read_MCC_results(table):\n f = open(table)\n lines = f.readlines()\n lines = lines[1:] # discard header line\n f.close()\n t = np.zeros(len(lines))\n predicts = np.zeros((len(lines), 3))\n actuals = np.zeros((len(lines), 3))\n line_num = 0\n for line in lines:\n fields = line.split()\n t[line_num] = Time.DateTime(fields[0]).secs\n predicts[line_num, :] = [float(field) for field in fields[1:4]]\n actuals[line_num, :] = [float(field) for field in fields[5:8]]\n line_num = line_num + 1\n return t, predicts, actuals","def message_table(message):\r\n table = Table(['property', 'value'])\r\n table.align['property'] = 'r'\r\n table.align['value'] = 'l'\r\n\r\n table.add_row(['id', message['id']])\r\n table.add_row(['initial_entry_time', message['initial_entry_time']])\r\n table.add_row(['visibility_delay', message['visibility_delay']])\r\n table.add_row(['visibility_interval', message['visibility_interval']])\r\n table.add_row(['fields', message['fields']])\r\n return [table, message['body']]","def parse_populations(\n source, strict=True, encoding=\"utf8\", base64_metadata=True, table=None\n):\n sep = None\n if strict:\n sep = \"\\t\"\n if table is None:\n table = tables.PopulationTable()\n # Read the header and find the indexes of the required fields.\n header = source.readline().rstrip(\"\\n\").split(sep)\n metadata_index = header.index(\"metadata\")\n for line in source:\n tokens = line.rstrip(\"\\n\").split(sep)\n if len(tokens) >= 1:\n metadata = tokens[metadata_index].encode(encoding)\n if base64_metadata:\n metadata = base64.b64decode(metadata)\n table.add_row(metadata=metadata)\n return table","def read_table(self, table):\n return READ_TABLE(table, db=self.db)","def tables():\n return {\n \"MAT24_STD_OCTAD\" : STD_OCTAD,\n }","def parse_table(self, table_name):\n table_offset = self.catalog.get(table_name)\n if not table_offset:\n logging.error(f\"Could not find table {table_name} in DataBase\")\n return\n table_offset = table_offset * self.page_size\n table = self._tables_with_data.get(table_offset)\n if not table:\n table_def = self._table_defs.get(table_offset)\n if table_def:\n table = TableObj(offset=table_offset, val=table_def)\n logging.info(f\"Table {table_name} has no data\")\n else:\n logging.error(f\"Could not find table {table_name} offset {table_offset}\")\n return\n access_table = AccessTable(table, self.version, self.page_size, self._data_pages, self._table_defs)\n return access_table.parse()","def _parse_table(self): # type: (Optional[str]) -> Tuple[Key, Item]\n indent = self.extract()\n self.inc() # Skip opening bracket\n\n is_aot = False\n if self._current == \"[\":\n if not self.inc():\n raise self.parse_error(UnexpectedEofError)\n\n is_aot = True\n\n # Key\n self.mark()\n while self._current != \"]\" and self.inc():\n pass\n\n name = self.extract()\n key = Key(name, sep=\"\")\n\n self.inc() # Skip closing bracket\n if is_aot:\n # TODO: Verify close bracket\n self.inc()\n\n cws, comment, trail = self._parse_comment_trail()\n\n result = Null()\n values = Container()\n\n while not self.end():\n item = self._parse_item()\n if item:\n _key, item = item\n if not self._merge_ws(item, values):\n values.append(_key, item)\n else:\n if self._current == \"[\":\n _, name_next = self._peek_table()\n\n if self._is_child(name, name_next):\n key_next, table_next = self._parse_table()\n key_next = Key(key_next.key[len(name + \".\") :])\n\n values.append(key_next, table_next)\n\n # Picking up any sibling\n while not self.end():\n _, name_next = self._peek_table()\n\n if not self._is_child(name, name_next):\n break\n\n key_next, table_next = self._parse_table()\n key_next = Key(key_next.key[len(name + \".\") :])\n\n values.append(key_next, table_next)\n else:\n table = Table(\n values, Trivia(indent, cws, comment, trail), is_aot\n )\n\n result = table\n if is_aot and (\n not self._aot_stack or name != self._aot_stack[-1]\n ):\n result = self._parse_aot(table, name)\n\n break\n else:\n raise self.parse_error(\n InternalParserError,\n (\"_parse_item() returned None on a non-bracket character.\"),\n )\n\n if isinstance(result, Null):\n result = Table(values, Trivia(indent, cws, comment, trail), is_aot)\n\n return key, result","def _get_table(self):\n\t\treturn self._table","def load_main_table(table_text):\n\n lines = table_text.split('\\n')\n i = 1\n cols = []\n for thing in lines[1].split('\",\"'):\n if thing in ['C ', 'I ', 'K ', 'E ', 'H ']:\n cols.append(thing.strip() + str(i) + ' ')\n if thing == 'H ':\n i += 1\n else:\n cols.append(thing)\n lines[1] = '\",\"'.join(cols)\n text = \"\\n\".join(lines[1:])\n df = pd.read_csv(StringIO(text))\n df.index = df['Student ID']\n\n return df","def build(f, font, tableTag=None):\n lines = Tokenizer(f)\n return parseTable(lines, font, tableTag=tableTag)","def isccp4table(self, text):\n #\n # See e.g. http://www.ccp4.ac.uk/dist/html/loggraphformat.html\n # for format of TABLES\n #\n # Note that this regular expression accommodates slight deviations\n # by making the \"closing\" \":\" of the $TABLE line optional.\n # This is done for consistency with loggraph's behaviour.\n #\n # Set up regular expression for entire table\n # This is the \"strict\" form of the table\n table = self.compile(\n \"isccp4table\",\n r\" *\\$TABLE ?:([^:]*):?[ \\n]+\\$(GRAPHS|SCATTER)[^:]*(:[^\\$]*)\\$\\$([^\\$]*)\\$\\$([^\\$]*)\\$\\$([^\\$]*)\\$\\$\",\n ).search(text)\n result = dict()\n if table:\n result[\"rawtable\"] = table.group(0)\n result[\"title\"] = table.group(1).strip()\n result[\"type\"] = table.group(2).strip()\n result[\"graphs\"] = table.group(3)\n result[\"columns\"] = table.group(4)\n result[\"text\"] = table.group(5)\n result[\"data\"] = table.group(6)\n result[\"nlines\"] = table.group(0).count(\"\\n\")\n return result\n # If there wasn't a match then try a simpler match\n # This relaxes some of the rules in the format definintion\n table = self.compile(\n \"isccp4simplertable\",\n r\" *\\$TABLE ?:([^\\n]*)\\n+\\$(GRAPHS|SCATTER)[^:]*(:[^\\$]*)\\$\\$([^\\$]*)\\$\\$([^\\$]*)\\$\\$([^\\$]*)\\$\\$\",\n ).search(text)\n if table:\n result[\"rawtable\"] = table.group(0)\n result[\"title\"] = table.group(1).strip()\n result[\"type\"] = table.group(2).strip()\n result[\"graphs\"] = table.group(3)\n result[\"columns\"] = table.group(4)\n result[\"text\"] = table.group(5)\n result[\"data\"] = table.group(6)\n result[\"nlines\"] = table.group(0).count(\"\\n\")\n return result\n return result","def __init__(self, tabletext=\"\"):\n\n # Table attributes\n self.__title = \"\"\n self.__type = \"GRAPHS\" # Default to GRAPHS\n self.__graphs = \"\"\n self.__columns = \"\"\n self.__text = \"\"\n self.__data = \"\"\n # Derived data\n self.__graph_list = []\n self.__column_list = []\n # Indicate the the object has been populated\n self.__table_parse_error = False\n self.__nonzero = False\n # The \"raw\" table data from the log file\n self.__rawtable = \"\"\n # Attempt to populate the table\n if tabletext:\n self.__rawtable = tabletext\n if not self.__buildtable(tabletext):\n # Failed to extract table\n # If it could be a title then use this\n # instead\n if str(tabletext).count(\"\\n\") == 0:\n self.settitle(tabletext)","def convert_table(mkd):\n\t\n\tmd_table_codes = re.findall(r\".*\\|.*\\n.*\\-.*(?:\\n.*\\|.*)*\", mkd, re.M)\n\tfor md_code in md_table_codes:\n\t\t\n\t\tmd_rows = re.findall(r\"(.*\\|.*)\", md_code, re.M)\n\t\theader = md_rows.pop(0)\n\t\tcolumn_count = md_rows.pop(0).count(\"-\")\n\n\t\ttex_code = \"\\\\begin{tabular}{|\"+\"l|\"*column_count+\"}\\n\\hline\\n\"\n\t\ttex_code += header.strip(\" |\").replace(\"|\", \"&\")+\" \\\\\\\\\\n\\hline\\n\"\n\t\tfor row in md_rows:\n\t\t\ttex_code += row.strip(\" |\").replace(\"|\", \"&\")+\" \\\\\\\\\\n\"\n\t\ttex_code += \"\\hline\\n\\end{tabular}\"\n\n\t\tmkd = mkd.replace(md_code, tex_code)\n\n\treturn mkd","def WriteBody( self ):\n\n self.ParseHeader( sys.stdin.readline() )\n\n self.CreateTable()\n\n num_lines = 0\n\n total_lines = 0\n sys.stderr.write(\"parsing..\")\n \n while 1:\n line = sys.stdin.readline()\n \n if not line: break\n if line[0] == \"#\": continue\n if line[0:2] == \"//\": break\n \n if not (total_lines % 100) and total_lines > 0:\n sys.stderr.write( \".%i..\" % total_lines)\n print self.table \n self.table.body = []\n\n total_lines = total_lines + 1\n\n (columns) = string.split( line[:-1], \"\\t\" )\n \n if not columns:\n break\n\n if self.mUseIndex:\n col_string = [str(total_lines),] + self.ParseColumns( columns )\n else:\n col_string = self.ParseColumns( columns )\n \n self.table.body.append( col_string ) \n \n print self.table\n \n sys.stderr.write(\"done\\n\")","def make_table(self, content):\n html = '<table class=\"table table-condensed\">'\n\n # Check for list or tuple\n if type(content) is list or type(content) is tuple:\n if len(content) > 0:\n # If first item in list is dictionary continue\n if type(content[0]) is dict:\n # Make table header for every key\n html += '<thead><tr>'\n for key in content[0].keys():\n html += '<th>' + key + '</th>'\n html += '</tr></thead>'\n\n # Make table body\n html += '<tbody>'\n for dictonary in content:\n # New table row for every dict item in list\n html += '<tr>'\n # New column for every value in dictionary\n for value in dictonary.values():\n html += '<td>' + str(value) + '</td>'\n html += '</tr>'\n html += '</tbody>'\n else:\n html += 'No content available'\n\n html += '</table>'\n\n self.table = html\n\n return html","def parse_conll_eval_table(self, fp):\n with open(fp, 'r') as tbl:\n tbl.readline()\n for row in tbl:\n clean_row = re.sub('([\\\\\\\\%]|hline)', '', row)\n cells = [x.strip() for x in clean_row.split('&')]\n self[cells[0]] = {\n 'precision': float(cells[1]),\n 'recall': float(cells[2]),\n 'fscore': float(cells[3])\n }\n assert self.keys(), 'Probably an empty/non-existant file.'\n self[self._total_name] = self['Overall']\n del self['Overall']","def converttable(tablecode):\n table = etree.XML(tablecode)\n rows = iter(table)\n headers = [col.text for col in next(rows)]\n data = []\n for row in rows:\n values = [col.text for col in row]\n debugprint(dict(zip(headers, values)), \"RAW JSON\")\n data.append(dict(zip(headers, values)))\n return data","def get_TABLE_info():\n defalt_width = 300\n defalt_height = 500\n defalt_thickness = 10\n\n message = 'Put width of table. (mm : int) (width >= 210)'\n width = rs.GetInteger(message, defalt_width, None, None)\n\n message = 'Put height of table. (mm : int) (height >= 250)'\n height = rs.GetInteger(message, defalt_height, None, None)\n\n message = 'Put thickness of material (1layer). (mm : int)'\n t_m = rs.GetReal(message, defalt_thickness, None, None)\n\n TABLE_info = [width, height, t_m]\n\n info = [\"width : %s\" % width, \"height : %s\" % height, \"thickness of material : %s\" % t_m]\n print (info)\n\n return TABLE_info","def get_tables():\n page_html = requests.get(conf.PAGE_URL).text\n soup = BeautifulSoup(page_html, 'html.parser')\n tables = soup.find_all(\"table\", {\"class\": conf.TABLE_CLASS_NAME})\n if not tables:\n raise ValueError(\"Table class not found\")\n return tables","def read_table(self, table_type):\n\n if table_type == 'hash':\n entry_class = MPQHashTableEntry\n elif table_type == 'block':\n entry_class = MPQBlockTableEntry\n else:\n raise ValueError(\"Invalid table type.\")\n\n table_offset = self.header['%s_table_offset' % table_type]\n table_entries = self.header['%s_table_entries' % table_type]\n key = self._hash('(%s table)' % table_type, 'TABLE')\n\n self.file.seek(table_offset + self.header['offset'])\n data = self.file.read(table_entries * 16)\n data = self._decrypt(data, key)\n\n def unpack_entry(position):\n entry_data = data[position*16:position*16+16]\n return entry_class._make(\n struct.unpack(entry_class.struct_format, entry_data))\n\n return [unpack_entry(i) for i in range(table_entries)]","def _get_table_info(self):\n highestbet = self.highestBetNotFold(),\n bigb =self.bigBlind() if self._game_state == GAME_STATE_PRE_FLOP and not self.inSmallBlindPosition() else 0\n return [\"blinds: small:%r big:%r\" % (self.small_blind, self.big_blind),\n \"buy_ins: min:%r max:%r\" % (self.min_buy_in, self.max_buy_in),\n \"bs: %r\" % self.betting_structure,\n \"highestbet = %r\" % highestbet,\n \"bigb = %r\" % bigb,]","def split_md_table(string: str) -> Tuple[str, Tuple[str, ...], Tuple[str, ...], str, str]:\n err = 'tabulate returned GFM pipe table with invalid first two lines: {}'\n split = string.split('\\n', 2)\n line_sep = '\\r\\n' if split[0][-1] == '\\r' else '\\n'\n def table_body(pos: int) -> str: return '\\n'.join(split[pos:])\n lines = list(map(lambda s: s.rstrip('\\r'), split[:2]))\n\n md_headers, headers, formats = '', (), None\n for line in reversed(lines):\n if formats:\n match = re.match(r'^\\|.*[^\\\\]\\|$', line)\n headers = tuple(map(\n lambda s: s.strip(' '),\n re.split(r'(?<=[^\\\\])\\|', line[1:-1])\n ))\n if match and len(headers) == len(formats):\n md_headers = line\n else:\n raise TabulateHelperError(err.format(lines))\n elif re.match(r'^\\|:?-+:?(\\|:?-+:?)*\\|$', line):\n formats = tuple(line[1:-1].split('|'))\n if formats:\n return md_headers, headers, formats, table_body(pos=2 if headers else 1), line_sep\n else:\n raise TabulateHelperError(err.format(lines))","def get_table_data(table):\n pattern_body = re.compile(r'(?ims)\\<tbody\\>(.*?)\\</tbody\\>')\n pattern_rows = re.compile(r'(?ims)\\<tr\\>(.*?)\\</tr\\>')\n pattern_cols = re.compile(r'(?ims)\\<td.*?\\>([^<]+?)\\<.*?/td\\>')\n\n body = pattern_body.findall(table)[0]\n return [\n list(map(lambda x: html.unescape(x), pattern_cols.findall(row)[:3]))\n for row in pattern_rows.findall(body)]","def table(self):\r\n return self._table","def parseInput(toParse):\n splitified = toParse.split('--------')\n statesPath = splitified[0].rstrip().strip()\n availableStates = len(splitified[1].rstrip().strip().split())\n probMatrix = splitified[2].rstrip().strip().splitlines()\n\n return(probMatrix, statesPath, availableStates)","def test_parse_taxa_summary_table(self):\r\n actual = parse_taxa_summary_table(self.taxa_summary1.split('\\n'))\r\n self.assertItemsEqual(actual[0], self.taxa_summary1_expected[0])\r\n self.assertItemsEqual(actual[1], self.taxa_summary1_expected[1])\r\n assert_almost_equal(actual[2], self.taxa_summary1_expected[2])","def table(self):\n return self.t","def test_format_otu_table(self):\r\n a = array([[1, 2, 3],\r\n [4, 5, 2718281828459045]])\r\n samples = ['a', 'b', 'c']\r\n otus = [1, 2]\r\n taxa = ['Bacteria', 'Archaea']\r\n res = format_otu_table(samples, otus, a)\r\n # confirm that parsing the res gives us a valid biom file with\r\n # expected observation and sample ids\r\n t = parse_biom_table(res.split('\\n'))\r\n self.assertEqual(t.ObservationIds, ('1', '2'))\r\n self.assertEqual(t.SampleIds, ('a', 'b', 'c'))","def get_table(self, percent=False):\n TABLE_SEPARATOR = '=>'\n\n d = self.data\n headers = self.headers\n group_numbers = self.totals\n\n logging.debug('print_table:')\n logging.debug(d)\n # print header\n csv_header = ['group', 'students'] + [h.label for h in headers] + [h.label+'%' for h in headers]\n\n # print rows and calc totals\n logging.debug(d)\n logging.debug([h.fullname for h in headers])\n\n csv_body = []\n for gr, prep in self.cfg.preps.items():\n csv_body.append( [f'{gr} - {prep}'] + self.data_group(gr, get_student_numbers=True, add_percentes=True))\n\n csv_footer = ['all'] + self.data_group_all(get_student_numbers=True, add_percentes=True)\n\n print(csv_header, csv_body, csv_footer)\n return (csv_header, csv_body, csv_footer)","def get_table(self):\n result_table = [row[:] for row in self.table] # Clone the result table\n\n # Htmlise all columns containing images\n for col_num in self.image_column_nums():\n for row_num in range(1, len(result_table)):\n result_table[row_num][col_num] = self.htmlise(result_table[row_num][col_num])\n\n # Append images\n for ((col,row), image_list) in self.images.items():\n for image in image_list:\n try:\n result_table[row][col] += \"<br>\" + image\n except IndexError:\n pass # Testing must have aborted so discard image\n\n return result_table","def _parse_qstat_tabular(qstat_output):\n def parse_qstat_record(record):\n name, state_code = map(str.strip, record.split('|'))\n return name, Torque._job_states[state_code]\n\n jobs = qstat_output.splitlines()\n parsed = {}\n # @TODO: think of catch-and-log parsing exceptions\n if jobs and (len(jobs) > 1 or jobs[0] != ''):\n parsed = dict(map(parse_qstat_record, jobs))\n\n return parsed","def print_mistakes_table():\n conn = sq.connect(host='localhost', user='root',\n password='student', database='quiz')\n cursor = conn.cursor()\n\n cursor.execute(\"select * from mistakes\")\n data = cursor.fetchall()\n\n table = PrettyTable()\n table.field_names = ['Question', 'Given Answer','User Given Answer']\n for row in data:\n table.add_row(row)\n conn.close()\n\n return table","def parse_ipac_table(table_file):\n file_lines = table_file.readlines()\n if len(file_lines) < 5:\n raise ValueError(\"No images found!\")\n \n columns = file_lines[0].replace(\"|\",\" \").split()\n \n # Each row in the table starting at index 4 is metadata for a new image / observation\n metadatas = []\n for image_data in file_lines[4:]:\n line = image_data.replace(\"|\",\" \").split()\n obsdate_idx = columns.index(\"obsdate\")\n tmp = line[obsdate_idx] + \" \" + line[obsdate_idx+1]\n del line[obsdate_idx+1]\n line[obsdate_idx] = tmp\n metadatas.append(dict(zip(columns, line)))\n \n return metadatas","def rawtable(self):\n return self.__rawtable","def _parse_qstat_tabular(qstat_output):\n def parse_qstat_record(record):\n name, state_code = map(str.strip, record.split('|'))\n return name, Torque._job_states[state_code]\n\n jobs = qstat_output.splitlines()\n parsed = {}\n # @TODO: think of catch-and-log parsing exceptions\n if jobs and (len(jobs) > 1 or jobs[0] is not ''):\n parsed = dict(map(parse_qstat_record, jobs))\n\n return parsed","def _pdread2astrotable(csvgzdir):\n df = pd.read_csv(csvgzdir)\n tb = Table.from_pandas(df)\n return tb","def read_biology(url, header):\n req = requests.get(url)\n values = BeautifulSoup(req.content, 'html.parser').body.text\n\n df = pd.read_csv(StringIO(values), sep=';', header=None,\n index_col=False, names=header)\n res_dic = {}\n for i, row in df.iterrows():\n key = row['Analyse'].replace(' ', '_') # ou analyse?\n value = row['Resultat']\n\n res_dic[key] = value\n\n return res_dic","def setUp(self):\r\n self.bt_str = '{\"id\": \"None\",\"format\": \"Biological Observation Matrix 1.0.0\",\"format_url\": \"http://biom-format.org\",\"type\": \"OTU table\",\"generated_by\": \"BIOM-Format 1.2.0-dev\",\"date\": \"2013-11-28T16:50:27.438635\",\"matrix_type\": \"sparse\",\"matrix_element_type\": \"float\",\"shape\": [10, 10],\"data\": [[0,0,22.0],[0,4,15.0],[0,5,74.0],[0,6,34.0],[0,7,76.0],[0,9,48.0],[1,0,70.0],[1,2,30.0],[1,3,37.0],[1,4,24.0],[1,5,77.0],[1,6,71.0],[1,7,58.0],[1,8,43.0],[2,1,2.0],[2,2,90.0],[2,4,48.0],[2,5,54.0],[2,7,22.0],[2,8,91.0],[3,0,80.0],[3,1,86.0],[3,3,78.0],[3,7,12.0],[4,4,68.0],[4,7,76.0],[4,8,57.0],[5,2,23.0],[5,5,66.0],[5,7,51.0],[5,9,77.0],[6,0,31.0],[6,1,47.0],[6,2,16.0],[6,4,96.0],[6,5,9.0],[7,0,17.0],[7,2,52.0],[7,5,11.0],[7,7,22.0],[8,1,74.0],[8,2,7.0],[8,4,80.0],[8,7,59.0],[9,0,6.0],[9,2,34.0],[9,3,63.0],[9,4,77.0],[9,5,8.0],[9,6,38.0],[9,7,73.0],[9,8,98.0],[9,9,45.0]],\"rows\": [{\"id\": \"o1 \", \"metadata\": {\"taxonomy\": [\"bug1\"]}},{\"id\": \"o2\", \"metadata\": {\"taxonomy\": [\"bug2\"]}},{\"id\": \"o3\", \"metadata\": {\"taxonomy\": [\"bug3\"]}},{\"id\": \"o4\", \"metadata\": {\"taxonomy\": [\"bug4\"]}},{\"id\": \"o5\", \"metadata\": {\"taxonomy\": [\"bug5\"]}},{\"id\": \"o6\", \"metadata\": {\"taxonomy\": [\"bug6\"]}},{\"id\": \"o7\", \"metadata\": {\"taxonomy\": [\"bug7\"]}},{\"id\": \"o8\", \"metadata\": {\"taxonomy\": [\"bug8\"]}},{\"id\": \"o9\", \"metadata\": {\"taxonomy\": [\"bug9\"]}},{\"id\": \"o10\", \"metadata\": {\"taxonomy\": [\"bug10\"]}}],\"columns\": [{\"id\": \"s1\", \"metadata\": null},{\"id\": \"s2\", \"metadata\": null},{\"id\": \"s6\", \"metadata\": null},{\"id\": \"s4\", \"metadata\": null},{\"id\": \"s5\", \"metadata\": null},{\"id\": \"s10\", \"metadata\": null},{\"id\": \"s7\", \"metadata\": null},{\"id\": \"s8\", \"metadata\": null},{\"id\": \"s9\", \"metadata\": null},{\"id\": \"s3\", \"metadata\": null}]}'\r\n self.mf_ordered = ['#SampleIDt\\thsid\\tfield\\tval',\r\n 's1\\t1\\tf1\\t6.1',\r\n 's3\\t1\\tf1\\t0.0',\r\n 's7\\t1\\tf1\\t14.2',\r\n 's9\\t1\\tf2\\t6.5',\r\n 's2\\t1\\tf2\\t21',\r\n 's6\\t2\\tf3\\t0.3',\r\n 's5\\t2\\tf2\\t9.1',\r\n 's4\\t2\\tf3\\t0.8',\r\n 's8\\t2\\tf2\\t5.0',\r\n 's10\\t2\\tf2\\t11.']\r\n self.mf_non_ordered = ['#SampleIDt\\thsid\\tval',\r\n 'Sample9\\t1\\t6.5',\r\n 'Sample8\\t2\\t5.0',\r\n 'Sample1\\t1\\t6.1',\r\n 'Sample2\\t1\\t21',\r\n 'Sample6\\t2\\t0.3',\r\n 'Sample5\\t2\\t9.1',\r\n 'Sample7\\t1\\t14.2',\r\n 'Sample4\\t2\\t0.8',\r\n 'Sample10\\t2\\t11.',\r\n 'Sample3\\t1\\t0.0']\r\n self.cvs1 = ['1', '2']\r\n self.mds1 = [[6.1, 0.0, 14.2, 6.5, 21], [.3, 9.1, .8, 5.0, 11.]]\r\n self.otus1 = [\r\n array([[22., 48., 34., 0., 0.],\r\n [70., 0., 71., 43., 0.],\r\n [0., 0., 0., 91., 2.],\r\n [80., 0., 0., 0., 86.],\r\n [0., 0., 0., 57., 0.],\r\n [0., 77., 0., 0., 0.],\r\n [31., 0., 0., 0., 47.],\r\n [17., 0., 0., 0., 0.],\r\n [0., 0., 0., 0., 74.],\r\n [6., 45., 38., 98., 0.]]),\r\n array([[0., 15., 0., 76., 74.],\r\n [30., 24., 37., 58., 77.],\r\n [90., 48., 0., 22., 54.],\r\n [0., 0., 78., 12., 0.],\r\n [0., 68., 0., 76., 0.],\r\n [23., 0., 0., 51., 66.],\r\n [16., 96., 0., 0., 9.],\r\n [52., 0., 0., 22., 11.],\r\n [7., 80., 0., 59., 0.],\r\n [34., 77., 63., 73., 8.]])]"],"string":"[\n \"def _parse_table(text):\\n\\n text = str(text)\\n try:\\n text = text.split(\\\"<pre>\\\")[1]\\n text = text.split(\\\"</pre>\\\")[0]\\n text = text.split(\\\"To save this output\\\")[0]\\n lines = text.split(\\\"\\\\n\\\")\\n except Exception as exc:\\n raise NNDCRequestError(f\\\"Unable to parse text:\\\\n{exc}\\\\n{text}\\\")\\n table = {}\\n headers = None\\n for line in lines:\\n tokens = line.split(\\\"\\\\t\\\")\\n tokens = [t.strip() for t in tokens]\\n if len(tokens) <= 1:\\n continue\\n if headers is None:\\n headers = tokens\\n headers = _parse_headers(headers)\\n for header in headers:\\n table[header] = []\\n else:\\n if len(tokens) != len(headers):\\n raise NNDCRequestError(\\n \\\"Too few data in table row\\\\n\\\"\\n + f' Headers: \\\"{headers}\\\"\\\\n'\\n + f' Row: \\\"{tokens}\\\"'\\n )\\n for header, token in zip(headers, tokens):\\n table[header].append(token)\\n return table\",\n \"def load_biom_table_with_file_contents(biom_f):\\n table = parse_biom_table(biom_f)\\n if hasattr(biom_f, 'seek'):\\n biom_f.seek(0)\\n return table, biom_f\",\n \"def getBiomData(self, data):\\r\\n try:\\r\\n if isfile(data):\\r\\n otu_table = parse_biom_table(qiime_open(data, 'U'))\\r\\n return otu_table\\r\\n except TypeError:\\r\\n if any([type(data) in\\r\\n [DenseFunctionTable,\\r\\n DenseGeneTable,\\r\\n DenseMetaboliteTable,\\r\\n DenseOTUTable,\\r\\n DenseOrthologTable,\\r\\n DensePathwayTable,\\r\\n DenseTable,\\r\\n DenseTaxonTable,\\r\\n FunctionTable,\\r\\n GeneTable,\\r\\n MetaboliteTable,\\r\\n OTUTable,\\r\\n OrthologTable,\\r\\n PathwayTable,\\r\\n SparseFunctionTable,\\r\\n SparseGeneTable,\\r\\n SparseMetaboliteTable,\\r\\n SparseOTUTable,\\r\\n SparseOrthologTable,\\r\\n SparsePathwayTable,\\r\\n SparseTable,\\r\\n SparseTaxonTable]]):\\r\\n otu_table = data\\r\\n return otu_table\\r\\n else:\\r\\n raise TypeError('Data is neither a path to a biom table or a' +\\r\\n ' biom table object.')\",\n \"def parse_table(table):\\n rows = table.find_all('tr')\\n if not rows:\\n raise ValueError(\\\"No rows for table\\\")\\n pages = []\\n table_tag = \\\"<table>\\\"\\n tbl_headers = get_tbl_headers(rows)\\n table_tag += \\\"<tr>\\\"\\n for header in tbl_headers.keys():\\n table_tag += conf.ADD_TH_TAG(header)\\n table_tag += \\\"</tr>\\\"\\n for row in rows:\\n cols = row.find_all('td')\\n if not cols:\\n continue\\n for page_name in cols[0].find_all('a'):\\n if not page_name:\\n continue\\n pages.append(page_name.text)\\n table_tag += '<tr>'\\n for header, col in tbl_headers.items():\\n try:\\n table_tag += f\\\"<td>{preprocess_data(f'{header} : {cols[col].text}')} \\\\t</td>\\\"\\n except IndexError:\\n pass\\n table_tag += '</tr>'\\n table_tag += '</table>'\\n if conf.DOWNLOAD_IMAGES:\\n download_images(pages)\\n return table_tag\",\n \"def get_mist_eep_table():\\n fp = Path(DATA_PATH, \\\"mist_eep_table.csv\\\")\\n return pd.read_csv(fp, comment=\\\"#\\\")\",\n \"def wmo_code_table():\\n import pandas as pd\\n from ..fun import get_data\\n\\n return pd.read_csv(get_data('Common_C02_20181107_en.txt'))\",\n \"def parse(self):\\r\\n hdr = {'User-Agent': 'Mozilla/5.0'}\\r\\n url = CostOfLiving.URL.format(self.city)\\r\\n req = Request(url, headers=hdr)\\r\\n page = urlopen(req)\\r\\n soup = BeautifulSoup(page, \\\"html.parser\\\")\\r\\n self.table = soup.find(\\\"table\\\", attrs={\\\"class\\\": \\\"data_wide_table\\\"})\",\n \"def parse_sp500_wiki_page(html_page):\\n soup = BeautifulSoup(html_page, 'html.parser')\\n table = soup.find(\\\"table\\\", {\\\"id\\\": \\\"constituents\\\"})\\n \\n data = []\\n column_names = [col_name.text.strip() for col_name in table.find_all('th')]\\n for row in table.find_all('tr'):\\n data_row = [col_name.text.strip() for col_name in row.find_all('td')]\\n if data_row:\\n data.append(data_row)\\n return data, column_names\",\n \"def get_main(self) -> 'table[category: str][label: str][date: date]':\\n\\n raw_table = self.get_raw_table(\\\"M\\\")\\n categories = raw_table[0]\\n labels = raw_table[1]\\n dates = self.get_dates(raw_table)\\n\\n def next_cat_col(i):\\n n = 1\\n while True:\\n if i+n > len(categories)-1:\\n return i\\n if categories[i+n]:\\n return i+n\\n n += 1\\n\\n def get_category_labels(i):\\n end_col = next_cat_col(i)\\n return zip(range(i, end_col), labels[i:end_col])\\n\\n def get_label_cells(category, label):\\n ci = categories.index(category)\\n i = labels.index(label, ci)\\n cells = {}\\n for j, d in enumerate(dates):\\n cell = raw_table[j+2][i]\\n if cell and cell != \\\"#VALUE!\\\":\\n cells[d] = cell\\n return cells\\n\\n table = {}\\n for i, cat in enumerate(categories):\\n if not cat:\\n continue\\n table[cat] = {}\\n for i, label in get_category_labels(i):\\n table[cat][label] = get_label_cells(cat, label)\\n\\n return table\",\n \"def matrix2Table(self, matrix): \\n M = TableModel()\\n M.addColumn('Mutations')\\n\\n fields = matrix.columnHeaders()\\n for f in fields:\\n M.addColumn(f)\\n i = matrix.indexOfColumnWithHeader('Mutations')\\n for row in matrix:\\n mutationSet = Core.Data.MutationSet(row[i])\\n code = '+'.join(mutationSet.mutationCodes(reduced=True))\\n M.addRow(code)\\n for f in fields:\\n j = matrix.indexOfColumnWithHeader(f)\\n if f == 'Mutations':\\n M.data[code]['Mutations'] = code\\n else: \\n M.data[code][f] = str(row[j])\\n return M\",\n \"def format_biom_table(biom_table):\\r\\n generated_by_str = \\\"QIIME \\\" + get_qiime_library_version()\\r\\n return biom_table.getBiomFormatJsonString(generated_by_str)\",\n \"def get_table_from_file():\\n with open(\\\"story.csv\\\", \\\"r\\\") as file:\\n lines = file.readlines()\\n table = [element.replace(\\\"\\\\n\\\", \\\"\\\").split(\\\";\\\") for element in lines]\\n return table\",\n \"def test_parse_classic_otu_table_consensus_lineage(self):\\r\\n data = \\\"\\\"\\\"#Full OTU Counts\\r\\n#OTU ID\\tFing\\tKey\\tNA\\tconsensusLineage\\r\\n0\\t19111\\t44536\\t42\\tBacteria; Actinobacteria; Actinobacteridae; Propionibacterineae; Propionibacterium\\r\\n1\\t1216\\t3500\\t6\\tBacteria; Firmicutes; Alicyclobacillaceae; Bacilli; Lactobacillales; Lactobacillales; Streptococcaceae; Streptococcus\\r\\n2\\t1803\\t1184\\t2\\tBacteria; Actinobacteria; Actinobacteridae; Gordoniaceae; Corynebacteriaceae\\r\\n3\\t1722\\t4903\\t17\\tBacteria; Firmicutes; Alicyclobacillaceae; Bacilli; Staphylococcaceae\\r\\n4\\t589\\t2074\\t34\\tBacteria; Cyanobacteria; Chloroplasts; vectors\\\"\\\"\\\"\\r\\n data_f = StringIO(data)\\r\\n obs = parse_classic_otu_table(data_f)\\r\\n exp = (['Fing', 'Key', 'NA'],\\r\\n ['0', '1', '2', '3', '4'],\\r\\n array([[19111, 44536, 42], [1216, 3500, 6], [1803, 1184, 2],\\r\\n [1722, 4903, 17], [589, 2074, 34]]),\\r\\n [['Bacteria', 'Actinobacteria', 'Actinobacteridae', 'Propionibacterineae', 'Propionibacterium'],\\r\\n ['Bacteria',\\r\\n 'Firmicutes',\\r\\n 'Alicyclobacillaceae',\\r\\n 'Bacilli',\\r\\n 'Lactobacillales',\\r\\n 'Lactobacillales',\\r\\n 'Streptococcaceae',\\r\\n 'Streptococcus'],\\r\\n ['Bacteria',\\r\\n 'Actinobacteria',\\r\\n 'Actinobacteridae',\\r\\n 'Gordoniaceae',\\r\\n 'Corynebacteriaceae'],\\r\\n ['Bacteria',\\r\\n 'Firmicutes',\\r\\n 'Alicyclobacillaceae',\\r\\n 'Bacilli',\\r\\n 'Staphylococcaceae'],\\r\\n ['Bacteria', 'Cyanobacteria', 'Chloroplasts', 'vectors']])\\r\\n self.assertEqual(obs[0], exp[0])\\r\\n self.assertEqual(obs[1], exp[1])\\r\\n assert_almost_equal(obs[2], exp[2])\\r\\n self.assertEqual(obs[3], exp[3])\",\n \"def parse_table(soup, start_gen, end_gen):\\n pokes = []\\n for cell in soup.find_all(\\\"td\\\", attrs={'style': None}):\\n for name in cell.find_all(\\\"a\\\"):\\n pokes.append(name.string)\\n\\n start_index = pokes.index(GEN_STARTS_WITH[start_gen])\\n end_index = pokes.index(GEN_ENDS_WITH[end_gen]) + 1\\n\\n # Doesn't have to be ordered, just personal preference.\\n unique_list = OrderedSet(pokes[start_index:end_index])\\n\\n if start_gen != end_gen:\\n print(f\\\"{len(unique_list)} Pokémon from gen {start_gen} to {end_gen} were fetched.\\\")\\n else:\\n print(f\\\"{len(unique_list)} Pokémon from gen {start_gen} were fetched.\\\")\\n\\n pkmn_string = ', '.join(unique_list)\\n\\n for key, value in NIDORAN_CASE.items():\\n # Handling of Nidoran male/female symbols.\\n pkmn_string = pkmn_string.replace(key, value)\\n\\n return pkmn_string\",\n \"def get_biGramTable(self):\\n\\t\\treturn self._state.biGramTable\",\n \"def table_from_pmids(pmid):\\n soup = try_or(lambda: get_soup(pmid)) \\n jsoup = get_soup(pmid,retmode=\\\"json\\\")\\n #print(pmid)\\n cit_count, scopus_json = get_cit_by_pmid(pmid)\\n print(f\\\"scopus_json: {scopus_json}\\\")\\n result = {\\n \\\"pmid\\\": pmid,\\n \\\"publ_date\\\": try_or(lambda: get_pub_date(soup)),\\n \\\"pi_name\\\": try_or(lambda: get_PI(soup)),\\n \\\"full_affil\\\": try_or(lambda: get_aff_countries(pmid,PI=False)), # !!! change the function to retrieve PI and othe affiliations simultaneously\\n \\\"pi_affil\\\": try_or(lambda: get_aff_countries(pmid,PI=True)), # !!! change the function to retrieve PI and othe affiliations simultaneously\\n \\\"pi_publ_count\\\": try_or(lambda: count_results(f\\\"{get_PI(soup)}[Author - Last]\\\")),\\n \\\"journal\\\": try_or(lambda: get_journal(soup)),\\n \\\"journal_publ_count\\\": try_or(lambda: count_results(f\\\"{get_journal(soup)}[Journal]\\\")),\\n \\\"authors_count\\\": try_or(lambda: get_n_authors(soup)),\\n \\\"cit_count\\\": cit_count,\\n \\\"summary\\\": try_or(lambda: json.loads(jsoup.text)),\\n \\\"scopus_json\\\": scopus_json,\\n }\\n\\n print(pmid)\\n return(result)\",\n \"def extract_main_table_from_html(html):\\n soup = bs(html, 'html.parser')\\n table = soup.find('table')\\n return(table)\",\n \"def _parse_table(value):\\n lines = value.split('\\\\n')\\n header = None\\n rows = []\\n\\n for l in lines:\\n if l.startswith('+-'):\\n pass\\n elif l.startswith('|'):\\n columns = [c.strip() for c in l.split('|')[1:-1]]\\n if header is None:\\n header = columns\\n else:\\n row = {}\\n for i, c in enumerate(columns):\\n if len(header)-1 <= i:\\n row[i] = c\\n else:\\n row[header[i]] = c\\n rows.append(row)\\n return rows\",\n \"def return_astropy_table(self):\\n table = Table()\\n for name in self.hdfile.root.Data.Fibers.colnames:\\n if hasattr(self, name):\\n table[name] = getattr(self, name)\\n\\n return table\",\n \"def return_astropy_table(self):\\n table = Table()\\n for name in self.hdfile.root.Data.Fibers.colnames:\\n if hasattr(self, name):\\n table[name] = getattr(self, name)\\n\\n return table\",\n \"def table(self):\\n return self.generator.table\",\n \"def build_table(self):\\n if len(self._abslines) == 0:\\n return\\n comp_tbl = QTable()\\n comp_tbl.add_column(Column([iline.wrest.to(u.AA).value for iline in self._abslines]*u.AA,name='wrest'))\\n for attrib in ['z', 'flagN', 'N', 'Nsig']:\\n comp_tbl.add_column(Column([iline.attrib[attrib] for iline in self._abslines], name=attrib))\\n # Return\\n return comp_tbl\",\n \"def parse_html_tables(html_filename):\\n\\n with open(html_filename) as f:\\n p = SimpleHTMLTableParser()\\n p.feed(f.read())\\n return p.tables\",\n \"def parse_biom(filename, keep_otus=True, internal_levels=False):\\n from biom import load_table # avoid to ask for the BIOM library if there is no biom file\\n\\n biom_table = load_table(filename)\\n strs = biom_table.delimited_self(header_value='TAXA', header_key='taxonomy')\\n lst1 = [str(s) for s in strs.split('\\\\n')[1:]] # skip the \\\"# Constructed from biom file\\\" entry\\n biom_file = []\\n out = [lst1[0]] # save the header\\n pre_taxa = compile(\\\".__\\\")\\n classs = compile(\\\"\\\\(class\\\\)\\\")\\n\\n # consistency check\\n i = 0\\n while i < (len(lst1)-1):\\n if len([s for s in lst1[i].split('\\\\t')]) != len([s for s in lst1[i+1].split('\\\\t')]):\\n raise Exception('[parse_biom()] It seems that taxonomic metadata are missing, maybe is the wrong biom file?')\\n\\n i += 1\\n\\n for l in lst1[1:]:\\n otu = None\\n lst = [float(s.strip()) for s in l.split('\\\\t')[1:-1]]\\n\\n if keep_otus:\\n otu = l.split('\\\\t')[0]\\n\\n # Clean and move taxa in first place\\n taxa = '.'.join([s.strip().replace('[', '').replace('u\\\\'', '').replace(']', '').replace(' ', '').replace('\\\\'', '')\\n for s in l.split('\\\\t')[-1].split(',')])\\n taxa = pre_taxa.sub('', taxa) # remove '{k|p|o|g|s}__'\\n taxa = classs.sub('', taxa) # remove '(class)'\\n taxa = taxa.rstrip('.') # remove trailing dots\\n\\n if otu:\\n taxa = taxa + '.' + otu\\n\\n biom_file.append([taxa] + lst)\\n\\n # merge such rows that have the same taxa\\n i = 1\\n dic = {}\\n\\n for l in biom_file[i:]:\\n if l[0] not in dic:\\n dic[l[0]] = l[1:]\\n\\n for k in biom_file[i+1:]:\\n if l[0] == k[0]:\\n lst = []\\n lstdic = dic[l[0]]\\n j = 1\\n while j < len(lstdic):\\n lst.append(float(lstdic[j]) + float(k[j]))\\n j += 1\\n\\n dic[l[0]] = lst\\n i += 1\\n\\n feats = dict(dic)\\n\\n if internal_levels:\\n feats = add_missing_levels(feats)\\n\\n for k in feats:\\n out.append('\\\\t'.join([str(s) for s in [k] + feats[k]]))\\n\\n return '\\\\n'.join(out)\",\n \"def convert_quick_table(result):\\n headline = result.split('\\\\n',1)[0]\\n names, converters = MastCasJobs.get_converters(headline, delimiter=',')\\n tab = ascii.read(MastCasJobs.replacenull(result,delimiter=','),\\n guess=False,fast_reader=False,format='csv',\\n names=names,converters=converters)\\n return tab\",\n \"def read_table(lines):\\n # header line 1: (100*Z+A), mass in [m_neutron]\\n # [MAT, 3, MT/ ZA, AWR, 0, 0, 0, 0] HEAD\\n\\n # header line 2: Q-value and some counts\\n # [MAT, 3, MT/ QM, QI, 0, LR, NR, NP/ EINT/ S(E)] TAB1\\n f = read_line(lines[1])\\n nS = int(f[4]) # number of interpolation sections\\n nP = int(f[5]) # number of data points\\n\\n # header line 3: interpolation information\\n # [MAT, 3, 0/ 0.0, 0.0, 0, 0, 0, 0] SEND\\n # 1 y is constant in x (constant, histogram)\\n # 2 y is linear in x (linear-linear)\\n # 3 y is linear in ln(x) (linear-log)\\n # 4 ln(y) is linear in x (log-linear)\\n # 5 ln(y) is linear in ln(x) (log-log)\\n # 6 y obeys a Gamow charged-particle penetrability law\\n\\n # data lines\\n x = []\\n y = []\\n for l in lines[3:]:\\n f = read_line(l)\\n x.append(f[0])\\n y.append(f[1])\\n x.append(f[2])\\n y.append(f[3])\\n x.append(f[4])\\n y.append(f[5])\\n return np.array(x[:nP]), np.array(y[:nP])\",\n \"def parse(self):\\n if self.filename.endswith('.gz'):\\n compression = 'gzip'\\n elif self.filename.endswith('.bz2'):\\n compression = 'bz2'\\n else:\\n compression = None\\n df = pd.read_table(self.filename, compression=compression)\\n\\n # drop empty column from extra tab\\n df.dropna(axis=1, how='all', inplace=True)\\n return df\",\n \"def parse_bid_table(table):\\r\\n columns = table.find_all('td')\\r\\n player_id = int(re.findall('\\\\d+', columns[0].a['href'])[0])\\r\\n player = columns[0].text\\r\\n owner = columns[1].text\\r\\n team_id = int(re.findall('\\\\d+', columns[2].img['src'])[0])\\r\\n team = table.img['alt']\\r\\n price = int(columns[3].text.replace(\\\".\\\", \\\"\\\"))\\r\\n bid_date = columns[4].text\\r\\n trans_date = columns[5].text\\r\\n status = columns[6].text\\r\\n return player_id, player, owner, team_id, team, price, bid_date, trans_date, status\",\n \"def parse_emission_matrix(emissions_matrix_path):\\r\\n f = open(emissions_matrix_path)\\r\\n f.readline() # remove first line\\r\\n lines = f.readlines()\\r\\n k_counter = len(lines)\\r\\n emissions_mat = np.zeros([k_counter + NOT_MOTIF_STATES, ALPHABET_LEN])\\r\\n # B start\\r\\n emissions_mat[0, 0] = 1\\r\\n # B end\\r\\n emissions_mat[-1, -1] = 1\\r\\n # B_1\\r\\n emissions_mat[1, 1:-1] = UNIFORM_PROB\\r\\n # B_2\\r\\n emissions_mat[-2, 1:-1] = UNIFORM_PROB\\r\\n for k, line in enumerate(lines, 2): # go over every line\\r\\n emissions = line.split('\\t')\\r\\n for letter in range(len(alphabet)): # create emissions for every S_i\\r\\n emissions_mat[k, letter + 1] = float(emissions[letter])\\r\\n return wrap_log(emissions_mat), k_counter\",\n \"def tables(cls):\\n if not hasattr(cls, '_tables'):\\n cls.parse_attributes()\\n return cls._tables\",\n \"def get_table(new_arr, types, titles):\\n try:\\n table = agate.Table(new_arr, titles, types)\\n return table\\n except Exception as e:\\n print e\",\n \"def read_table_data(self, table):\\n data = []\\n index = 0\\n for row in table.rows:\\n data.append([])\\n for cell in row.cells:\\n text_data = ''\\n for para in cell.paragraphs:\\n text_data += para.text.strip(' ')\\n data[index].append(text_data)\\n index += 1\\n\\n # trim unneeded rows in old & new reports\\n if all('CAPA' in x for x in data[0]):\\n self.table_data = data[2:]\\n else:\\n self.table_data = data[1:]\\n # trim end of list\\n self.table_data = [row[:5] for row in self.table_data]\",\n \"def read_bc_table(fname=datapath+\\\"/bolometric_corrections/bc_p04_ugriz.data\\\"):\\n with open(fname,'r') as fp:\\n lines = fp.readlines()\\n s = lines[1].split()\\n NTeff, Nlogg, NMH, Nfilt = int(s[0]), int(s[2]), int(s[5]), int(s[7])\\n allBCs = {}\\n\\n Teffs = list(map(float, \\\"\\\".join(lines[2:5]).replace(\\\"\\\\n\\\",\\\" \\\").split()))\\n loggs = list(map(float, lines[5].split()))\\n Nlist = list(map(int, lines[6].split()))\\n iline = 7\\n allBCs = {}\\n for ifilt in range(Nfilt):\\n BCtable = np.zeros((np.sum(Nlist)*NMH,4))\\n itable = 0\\n for iMH in range(NMH):\\n s = lines[iline].split()\\n FeH = float(s[2]); aFe = float(s[5]); filter = s[9]\\n iline += 1\\n for ilogg,logg in enumerate(loggs):\\n BCrow = []\\n while len(BCrow) < Nlist[ilogg]:\\n line = lines[iline]\\n iline += 1\\n BCrow += list(map(float, line.split()))\\n for iTeff,Teff in enumerate(Teffs[0:Nlist[ilogg]]):\\n BCtable[itable,0] = Teff\\n BCtable[itable,1] = logg\\n BCtable[itable,2] = FeH\\n BCtable[itable,3] = BCrow[iTeff]\\n itable += 1\\n allBCs[filter] = BCtable\\n return allBCs\",\n \"def parse_table(s, allow_wrap=False):\\n r = []\\n columns = []\\n for l in s.splitlines():\\n if not l.strip():\\n columns = []\\n continue\\n if rx_header_start.match(l):\\n # Column delimiters found. try to determine column's width\\n columns = []\\n x = 0\\n while l:\\n match = rx_col.match(l)\\n if not match:\\n break\\n columns.append((x + len(match.group(1)),\\n x + len(match.group(1)) + len(\\n match.group(2))))\\n x += match.end()\\n l = l[match.end():]\\n elif columns: # Fetch cells\\n if allow_wrap:\\n row = [l[f:t] for f, t in columns]\\n if row[0].startswith(\\\" \\\") and r:\\n for i, x in enumerate(row):\\n r[-1][i] += x\\n else:\\n r += [row]\\n else:\\n r += [[l[f:t].strip() for f, t in columns]]\\n if allow_wrap:\\n return [[x.strip() for x in row] for row in r]\\n else:\\n return r\",\n \"def test_format_biom_table(self):\\r\\n generated_by = \\\"QIIME \\\" + get_qiime_library_version()\\r\\n self.assertTrue(generated_by in format_biom_table(self.biom1))\",\n \"def testLR0ParseTable(self):\\r\\n from pydsl.Parser.LR0 import _slr_build_parser_table, build_states_sets\\r\\n state_sets = build_states_sets(productionset0)\\r\\n self.assertEqual(len(state_sets), 5)\\r\\n #0 . EI: : . exp $ , \\r\\n # exp : .SR\\r\\n # transitions: S -> 2,\\r\\n # goto: exp -> 1\\r\\n #1 EI: exp . $ ,\\r\\n # transitions: $ -> 3\\r\\n #2 exp: S . R,\\r\\n # transitions: R -> 4\\r\\n #3 EI: exp $ .\\r\\n #4 exp: S R .\\r\\n # reduce\\r\\n\\r\\n parsetable = _slr_build_parser_table(productionset0)\\r\\n self.assertEqual(len(parsetable), 4)\",\n \"def test_parse_classic_otu_table_file(self):\\r\\n data = \\\"\\\"\\\"#Full OTU Counts\\r\\n#OTU ID\\tFing\\tKey\\tNA\\tConsensus Lineage\\r\\n0\\t19111\\t44536\\t42\\tBacteria; Actinobacteria; Actinobacteridae; Propionibacterineae; Propionibacterium\\r\\n1\\t1216\\t3500\\t6\\tBacteria; Firmicutes; Alicyclobacillaceae; Bacilli; Lactobacillales; Lactobacillales; Streptococcaceae; Streptococcus\\r\\n2\\t1803\\t1184\\t2\\tBacteria; Actinobacteria; Actinobacteridae; Gordoniaceae; Corynebacteriaceae\\r\\n3\\t1722\\t4903\\t17\\tBacteria; Firmicutes; Alicyclobacillaceae; Bacilli; Staphylococcaceae\\r\\n4\\t589\\t2074\\t34\\tBacteria; Cyanobacteria; Chloroplasts; vectors\\\"\\\"\\\"\\r\\n data_f = StringIO(data)\\r\\n obs = parse_classic_otu_table(data_f)\\r\\n exp = (['Fing', 'Key', 'NA'],\\r\\n ['0', '1', '2', '3', '4'],\\r\\n array([[19111, 44536, 42], [1216, 3500, 6], [1803, 1184, 2],\\r\\n [1722, 4903, 17], [589, 2074, 34]]),\\r\\n [['Bacteria', 'Actinobacteria', 'Actinobacteridae', 'Propionibacterineae', 'Propionibacterium'],\\r\\n ['Bacteria',\\r\\n 'Firmicutes',\\r\\n 'Alicyclobacillaceae',\\r\\n 'Bacilli',\\r\\n 'Lactobacillales',\\r\\n 'Lactobacillales',\\r\\n 'Streptococcaceae',\\r\\n 'Streptococcus'],\\r\\n ['Bacteria',\\r\\n 'Actinobacteria',\\r\\n 'Actinobacteridae',\\r\\n 'Gordoniaceae',\\r\\n 'Corynebacteriaceae'],\\r\\n ['Bacteria',\\r\\n 'Firmicutes',\\r\\n 'Alicyclobacillaceae',\\r\\n 'Bacilli',\\r\\n 'Staphylococcaceae'],\\r\\n ['Bacteria', 'Cyanobacteria', 'Chloroplasts', 'vectors']])\\r\\n self.assertEqual(obs[0], exp[0])\\r\\n self.assertEqual(obs[1], exp[1])\\r\\n assert_almost_equal(obs[2], exp[2])\\r\\n self.assertEqual(obs[3], exp[3])\",\n \"def parse(self):\\n mp = {}\\n cells = self.row.find_all(\\\"td\\\")\\n\\n for cell in cells:\\n if \\\"visible-mobile\\\" in cell.attrs[\\\"class\\\"]:\\n continue\\n title = self._get_cell_title(cell)\\n content = cell.find(\\\"span\\\", class_=\\\"table-responsive__inner\\\")\\n\\n if title == \\\"name\\\":\\n mp.update(self._parse_name(cell, content))\\n elif title == \\\"fraktion\\\":\\n fraktion, klub = self._parse_abbreviation(content)\\n mp[\\\"political_affiliation\\\"] = klub + \\\" (\\\" + fraktion + \\\")\\\"\\n elif title == \\\"wahlkreis\\\":\\n mp[\\\"wahlkreis\\\"] = content.text.strip()\\n elif title == \\\"bundesland\\\":\\n mp[\\\"state\\\"] = self._parse_abbreviation(content)[1]\\n\\n return mp\",\n \"def construct_table(self):\\n table_str = self.header_row\\n row_lbls, col_lbls = self.get_idxvals()\\n for r,rlbl in enumerate(row_lbls):\\n row_data = [self.data[rlbl,clbl] for clbl in col_lbls]\\n table_str += self.construct_row(r, row_data)\\n \\n return table_str\",\n \"def mono_table():\\n return Table(\\n {\\n \\\"obs_id\\\": [1, 1, 1, 1, 1, 2],\\n \\\"event_id\\\": [1, 1, 1, 2, 2, 1],\\n \\\"tel_id\\\": [1, 2, 3, 5, 7, 1],\\n \\\"hillas_intensity\\\": [1, 2, 0, 1, 5, 9],\\n \\\"hillas_width\\\": [0.1, 0.2, 0.1, 0.1, 0.2, 0.1] * u.deg,\\n \\\"hillas_length\\\": 3 * ([0.1, 0.2, 0.1, 0.1, 0.2, 0.1] * u.deg),\\n \\\"dummy_tel_energy\\\": [1, 10, 4, 0.5, 0.7, 1] * u.TeV,\\n \\\"dummy_tel_is_valid\\\": [\\n True,\\n True,\\n True,\\n True,\\n False,\\n False,\\n ],\\n \\\"classifier_tel_prediction\\\": [1, 0, 0.5, 0, 0.6, 1],\\n \\\"classifier_tel_is_valid\\\": [\\n True,\\n True,\\n False,\\n True,\\n True,\\n True,\\n ],\\n \\\"disp_tel_alt\\\": [58.5, 58, 62.5, 72, 74.5, 81] * u.deg,\\n \\\"disp_tel_az\\\": [12.5, 15, 13, 21, 20, 14.5] * u.deg,\\n \\\"disp_tel_is_valid\\\": [\\n True,\\n False,\\n True,\\n True,\\n True,\\n True,\\n ],\\n }\\n )\",\n \"def _parse_biography(self):\\n data = {}\\n self.right_column = self.content.find(\\\"div\\\", class_=\\\"rechteSpalte60\\\")\\n heading = self.right_column.find(\\\"h3\\\")\\n # The page of the second president hides the details information\\n # and displays a biography instead. By selecting the second div,\\n # we get the hidden div containing the MPs details.\\n if not heading:\\n self.right_column = self.content.find_all(\\\"div\\\", class_=\\\"rechteSpalte60\\\")[1]\\n data.update(self._parse_dob_job())\\n data.update(self._parse_political_mandates())\\n data.update(self._parse_political_posts())\\n data.update(self._parse_work_history())\\n data.update(self._parse_education())\\n return data\",\n \"def parseTable(chart):\\n rowelems = chart.find_all('tr')\\n rows = [rowelem.find_all('td') for rowelem in rowelems]\\n data = [[elem.get_text() for elem in row] for row in rows]\\n return(data)\",\n \"def test_getBiomData(self):\\r\\n bt_string = '''{\\r\\n \\\"id\\\":null,\\r\\n \\\"format\\\": \\\"Biological Observation Matrix 0.9.1-dev\\\",\\r\\n \\\"format_url\\\": \\\"http://biom-format.org\\\",\\r\\n \\\"type\\\": \\\"OTU table\\\",\\r\\n \\\"generated_by\\\": \\\"QIIME revision XYZ\\\",\\r\\n \\\"date\\\": \\\"2011-12-19T19:00:00\\\",\\r\\n \\\"rows\\\":[\\r\\n {\\\"id\\\":\\\"GG_OTU_1\\\", \\\"metadata\\\":null},\\r\\n {\\\"id\\\":\\\"GG_OTU_2\\\", \\\"metadata\\\":null},\\r\\n {\\\"id\\\":\\\"GG_OTU_3\\\", \\\"metadata\\\":null},\\r\\n {\\\"id\\\":\\\"GG_OTU_4\\\", \\\"metadata\\\":null},\\r\\n {\\\"id\\\":\\\"GG_OTU_5\\\", \\\"metadata\\\":null}\\r\\n ],\\r\\n \\\"columns\\\": [\\r\\n {\\\"id\\\":\\\"Sample1\\\", \\\"metadata\\\":null},\\r\\n {\\\"id\\\":\\\"Sample2\\\", \\\"metadata\\\":null},\\r\\n {\\\"id\\\":\\\"Sample3\\\", \\\"metadata\\\":null},\\r\\n {\\\"id\\\":\\\"Sample4\\\", \\\"metadata\\\":null},\\r\\n {\\\"id\\\":\\\"Sample5\\\", \\\"metadata\\\":null},\\r\\n {\\\"id\\\":\\\"Sample6\\\", \\\"metadata\\\":null}\\r\\n ],\\r\\n \\\"matrix_type\\\": \\\"dense\\\",\\r\\n \\\"matrix_element_type\\\": \\\"int\\\",\\r\\n \\\"shape\\\": [5,6],\\r\\n \\\"data\\\": [[0,0,1,0,0,0],\\r\\n [5,1,0,2,3,1],\\r\\n [0,0,1,4,2,0],\\r\\n [2,1,1,0,0,1],\\r\\n [0,1,1,0,0,0]]\\r\\n }'''\\r\\n biom_data = parse_biom_table_str(bt_string)\\r\\n F = FunctionWithParams('')\\r\\n\\r\\n self.assertEqual(biom_data, F.getBiomData(biom_data))\\r\\n\\r\\n # write biom_data to temp location\\r\\n fd, bt_path = mkstemp(suffix='.biom')\\r\\n close(fd)\\r\\n biom_file = open(bt_path, 'w')\\r\\n biom_file.writelines(bt_string)\\r\\n biom_file.close()\\r\\n self.assertEqual(biom_data, F.getBiomData(bt_path))\\r\\n\\r\\n # cleanup\\r\\n remove(bt_path)\",\n \"def _extract_raw_table(self, expr):\\n str_start = \\\"<table\\\"\\n str_end = \\\"/table>\\\"\\n\\n ind_start = expr.find(str_start)\\n assert ind_start >= 0\\n\\n ind_end = expr.find(str_end)\\n assert ind_end >= 0\\n\\n return expr[ind_start: ind_end + len(str_end)]\",\n \"def getTableHead():\\n return [\\\"Reporter\\\", \\\"Reportee\\\", \\\"aln. DKIM\\\", \\\"aln. SPF\\\", \\\"Disposition\\\",\\n \\\"DKIM result\\\", \\\"SPF result\\\", \\\"msg#\\\", \\\"IP\\\", \\\"Country\\\",\\n \\\"Report Begin\\\", \\\"Report End\\\", \\\"Report ID\\\"]\",\n \"def parse_table_from_output(output, policy_name):\\n\\n headers = []\\n row = []\\n\\n separator = \\\"|\\\"\\n\\n for line in output.split(\\\"\\\\n\\\"):\\n if not headers and line.startswith(\\\"Name\\\"):\\n headers = [header.strip() for header in line.split(separator)]\\n elif line.startswith(policy_name):\\n if row:\\n raise Exception(\\\"Multiple license policies detected - expected 1.\\\")\\n row = [val.strip() for val in line.split(separator)]\\n\\n if not headers:\\n raise Exception(\\\"Table not found in output!\\\")\\n\\n if not row:\\n raise Exception(\\\"No license policies found - expected 1.\\\")\\n\\n return dict(zip(headers, row))\",\n \"def generate_table(self):\\n states = self.get_canonical_collection()\\n # self.print_canonical_collection(states)\\n table = [{} for _ in range(len(states))]\\n\\n for index in range(len(states)):\\n state = states[index]\\n first_rule_cnt = 0\\n second_rule_cnt = 0\\n third_rule_cnt = 0\\n beta = []\\n for prod in state:\\n dot_index = prod[1].index('.')\\n alpha = prod[1][:dot_index]\\n beta = prod[1][dot_index + 1:]\\n if len(beta) != 0:\\n first_rule_cnt += 1\\n else:\\n if prod[0] != 'S1':\\n second_rule_cnt += 1\\n production_index = self.grammar.P.index((prod[0], alpha))\\n elif alpha == [self.grammar.S[0]]:\\n third_rule_cnt += 1\\n if first_rule_cnt == len(state):\\n table[index]['action'] = 'shift'\\n\\n elif second_rule_cnt == len(state):\\n table[index]['action'] = 'reduce ' + str(production_index)\\n\\n elif third_rule_cnt == len(state):\\n table[index]['action'] = 'acc'\\n else:\\n conflict_msg = 'Conflict! State I' + str(index) + ': ' + str(state) + '\\\\nSymbol: ' + beta[0]\\n raise (Exception(conflict_msg))\\n for symbol in self.grammar.N + self.grammar.E: # the goto part of the table\\n next_state = self.go_to(state, symbol)\\n if next_state in states:\\n table[index][symbol] = states.index(next_state)\\n # print(\\\"table\\\", table)\\n return table\",\n \"def get_structure(self):\\n if len(self.headers) == 0:\\n self.restore_structure()\\n columns = self.parse_declaration()\\n result = \\\"<tablestructure>\\\\n\\\"\\n result += \\\"\\\\t<table id=\\\\\\\"%s\\\\\\\" name=\\\\\\\"%s\\\\\\\">\\\\n\\\" % (self.id, self.name)\\n result += \\\"\\\\t<header>\\\\n\\\"\\n for header in self.headers:\\n result += \\\"\\\\t\\\\t%s\\\\n\\\" % columns[header].to_xml()\\n result += \\\"\\\\t</header>\\\\n\\\"\\n result += \\\"\\\\t</table>\\\\n\\\"\\n result += \\\"</tablestructure>\\\"\\n return result\",\n \"def extract_data(self):\\r\\n self.parse()\\r\\n lst = []\\r\\n for i in self.table.text.split(\\\"\\\\n\\\")[3:]:\\r\\n if i != \\\"\\\" and bool(re.search(r'\\\\d', i)):\\r\\n lst.append(i.replace(u'\\\\xa0', ''))\\r\\n single = lst.pop(-3)\\r\\n lst = [i + \\\" \\\" + j for i, j in zip(lst[::2], lst[1::2])]\\r\\n lst.append(single)\\r\\n return lst[0:28]\",\n \"def get_table(html) -> None:\\n\\tre_table_class = re.compile('.*2iSP.*') # familiar regex template (str w/ '2iSP')\\n\\ttable_class = html.find('div', {'class': re_table_class})\\n\\ttable_lst = re.findall('[А-Я|A-Z][^А-Я|A-Z]*', table_class.text) # regex for capitals\\n\\n\\tfor param in table_lst:\\n\\t\\tif 'Осадки' in param:\\n\\t\\t\\tweather_dict['precipation'] = re.search(r'\\\\d+', param).group()\\n\\t\\telif 'Ветер' in param:\\n\\t\\t\\tweather_dict['wind'] = re.search(r'\\\\d+', param).group()\\n\\t\\telif 'Давление' in param:\\n\\t\\t\\tweather_dict['pressure'] = re.search(r'\\\\d+', param).group()\\n\\t\\telif 'Восход' in param:\\n\\t\\t\\tweather_dict['sunrise'] = ':'.join(re.findall(r'\\\\d+', param))\\n\\t\\telif 'Закат' in param:\\n\\t\\t\\tweather_dict['sunset'] = ':'.join(re.findall(r'\\\\d+', param))\",\n \"def scrapeTable():\\n\\tfrom bs4 import BeautifulSoup\\n\\tfrom urllib2 import urlopen\\n\\n\\turl = \\\"https://en.wikipedia.org/wiki/List_of_the_largest_libraries_in_the_United_States\\\"\\n\\n\\t# read the html content\\n\\thtml = urlopen(url).read()\\n\\n\\t# create BeautifulSoup from html\\n\\ttable = BeautifulSoup(html)\\n\\n\\t# find all table row elements\\n\\trows = table.findAll('tr')\\n\\n\\tarr = []\\n\\tfor tr in rows:\\n\\n\\t\\t# find all columns\\n\\t\\tcols = tr.findAll('td')\\n\\n\\t\\t# column text\\n\\t\\tx = [c.text for c in cols]\\n\\n\\t\\t# filter the content\\n\\t\\tif len(x)!=0:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tint(x[0])\\n\\t\\t\\texcept Exception, e:\\n\\t\\t\\t\\tbreak\\n\\n\\t\\t\\tarr.append(x)\\n\\n\\treturn arr\",\n \"def parse(self):\\n for index in range(len(self.columns)):\\n if index in self.columns:\\n self.parsed_table[self.columns[index].col_name_str] = []\\n if not self.table.linked_pages:\\n return self.create_empty_table()\\n for data_chunk in self.table.linked_pages:\\n original_data = data_chunk\\n parsed_data = parse_data_page_header(original_data, version=self.version)\\n\\n last_offset = None\\n for rec_offset in parsed_data.record_offsets:\\n # Deleted row - Just skip it\\n if rec_offset & 0x8000:\\n last_offset = rec_offset & 0xfff\\n continue\\n # Overflow page\\n if rec_offset & 0x4000:\\n # overflow ptr is 4 bits flags, 12 bits ptr\\n rec_ptr_offset = rec_offset & 0xfff\\n # update last pointer to pointer without flags\\n last_offset = rec_ptr_offset\\n # The ptr is the offset in the current data page. we get a 4 byte record_pointer from that\\n overflow_rec_ptr = original_data[rec_ptr_offset:rec_ptr_offset + 4]\\n overflow_rec_ptr = struct.unpack(\\\"<I\\\", overflow_rec_ptr)[0]\\n record = self._get_overflow_record(overflow_rec_ptr)\\n if record:\\n self._parse_row(record)\\n continue\\n # First record is actually the last one - from offset until the end of the data\\n if not last_offset:\\n record = original_data[rec_offset:]\\n else:\\n record = original_data[rec_offset:last_offset]\\n last_offset = rec_offset\\n if record:\\n self._parse_row(record)\\n return self.parsed_table\",\n \"def _populate(self):\\n\\n # Assume the first word is what we want, and we can find well formed years\\n # This sucks, but will work for these ones.\\n # Roll on bibtex for citations in the CIM.\\n\\n citation_detail = self.doc.citation_detail\\n author = citation_detail.split(',')[0]\\n match = '([^\\\\w])19|20\\\\d\\\\d([^\\\\w])*?'\\n m = re.search(match, citation_detail)\\n if m:\\n year = m.group(0)\\n else:\\n year = None\\n\\n # one error in existing es-doc content to be fixed:\\n if 'van Vuuren DP' in author:\\n author = 'van Vuuren'\\n print 'applying vv fix'\\n\\n self.year = int(year)\\n\\n # We assume that this table will have entries which ne\\n\\n # I use the first three letters of a an authors name, and for\\n # three or more authors, EA, and then the year for my bibtex citation string\\n self.citeguess = author[0:3] + 'EA' + year[2:]\\n # This is what will appear in the table:\\n self.citestring = '%s et al. (%s)' % (author, year)\\n # Keep this for a reference list for checking against the eventual bibtex reference list.\\n self.text = citation_detail\",\n \"def _process(self, tables=None):\\n\\n if self._tables:\\n return self._tables\\n\\n tables = tables or {}\\n\\n for row in self.url.generator.iter_rp:\\n\\n table_id_key = row['Table ID'].strip().lower()\\n\\n if not row['Line Number'].strip():\\n if 'Universe' not in row['Table Title']:\\n if table_id_key not in tables:\\n tables[table_id_key] = Table(row['Table ID'], row['Table Title'].strip().title(),\\n seq=row['Sequence Number'],\\n startpos=int(row['Start Position']))\\n else:\\n tables[table_id_key].seq = row['Sequence Number']\\n tables[table_id_key].startpos = row['Start Position']\\n tables[table_id_key].subject = row['Subject Area']\\n\\n else:\\n tables[table_id_key].universe = row['Table Title'].replace('Universe: ', '').strip()\\n\\n else: # column row\\n try:\\n\\n line_no = int(row['Line Number'])\\n\\n if not line_no in tables[table_id_key].columns:\\n tables[table_id_key].columns[line_no] = Column(row['Table ID'],\\n f\\\"{row['Table ID']}_{line_no:03}\\\",\\n line_no,\\n description=row['Table Title'])\\n else:\\n tables[table_id_key].columns[line_no].description = row['Table Title']\\n\\n\\n except ValueError as e:\\n # Headings, which have fractional line numebrs\\n # print(row)\\n pass\\n\\n self._tables = tables\\n\\n return self._tables\",\n \"def parse_tables_from_html(html, md_file):\\n soup = BeautifulSoup(html, features=\\\"lxml\\\")\\n table_contents = \\\"\\\"\\n for table in soup.select('table'):\\n try:\\n table_content = process_table(table)\\n table_contents += table_content\\n except:\\n continue\\n\\n if not table_contents:\\n print(\\\"NO VALID TABLE\\\")\\n return\\n\\n # write to the file\\n with codecs.open(md_file, mode='w', encoding='utf-8') as file:\\n file.write(table_contents)\\n print(\\\"The Table is saved in\\\" + md_file)\",\n \"def _html_table(self):\\n return '</i>'.join(APtable._repr_html_(self).split('</i>')[1:])\",\n \"def parse_mbp_data(self, url):\\n body = self.get_content(url)\\n if body is None:\\n return None\\n\\n doc_body = pq(body)\\n content = doc_body('#main-container').html()\\n lines = content.splitlines()\\n\\n record = {\\n 'url': url,\\n 'price': self.get_price(lines),\\n 'year': self.get_year(lines),\\n 'bat_count': self.search_int(\\n r'循環\\\\D*(\\\\d+)',\\n content,\\n 1\\n ),\\n 'screen': self.search_int(\\n r'(1\\\\d{1})[吋\\\"\\\\']',\\n content,\\n 1\\n ),\\n 'cpu': self.search_string(\\n r'i5|i7',\\n content\\n ),\\n 'ram': self.search_int(\\n r'(8|16)G',\\n content,\\n 1\\n ),\\n 'hdd': self.search_int(\\n r'(128|256|512)G',\\n content,\\n 1\\n ),\\n }\\n return record\",\n \"def test_parse_classic_otu_table(self):\\r\\n data = self.otu_table1\\r\\n data_f = (data.split('\\\\n'))\\r\\n obs = parse_classic_otu_table(data_f)\\r\\n exp = (['Fing', 'Key', 'NA'],\\r\\n ['0', '1', '2', '3', '4'],\\r\\n array([[19111, 44536, 42], [1216, 3500, 6], [1803, 1184, 2],\\r\\n [1722, 4903, 17], [589, 2074, 34]]),\\r\\n self.expected_lineages1)\\r\\n self.assertEqual(obs[0], exp[0])\\r\\n self.assertEqual(obs[1], exp[1])\\r\\n assert_almost_equal(obs[2], exp[2])\\r\\n self.assertEqual(obs[3], exp[3])\\r\\n\\r\\n\\r\\n # test that the modified parse_classic performs correctly on OTU tables\\r\\n # without leading comments\\r\\n data = self.otu_table_without_leading_comment\\r\\n data_f = (data.split('\\\\n'))\\r\\n obs = parse_classic_otu_table(data_f)\\r\\n sams = ['let-7i', 'miR-7', 'miR-17n', 'miR-18a', 'miR-19a', 'miR-22',\\r\\n 'miR-25', 'miR-26a']\\r\\n otus = ['A2M', 'AAAS', 'AACS', 'AADACL1']\\r\\n vals = array([\\r\\n [-0.2, 0.03680505, 0.205, 0.23, 0.66, 0.08, -0.373, 0.26],\\r\\n [-0.09, -0.25, 0.274, 0.15, 0.12, 0.29, 0.029, -0.1148452],\\r\\n [0.33, 0.19, 0.27, 0.28, 0.19, 0.25, 0.089, 0.14],\\r\\n [0.49, -0.92, -0.723, -0.23, 0.08, 0.49, -0.386, -0.64]])\\r\\n exp = (sams, otus, vals, []) # no lineages\\r\\n # because float comps in arrays always errors\\r\\n self.assertEqual(obs[0], exp[0])\\r\\n self.assertEqual(obs[1], exp[1])\\r\\n self.assertEqual(obs[3], exp[3])\\r\\n self.assertTrue(all((obs[2] == exp[2]).tolist()))\",\n \"def create_table_from_table_metric(table_metric: TableMetric) -> Text:\\n\\n supported_metric = {\\n TableMetric.CONTINGENCY_TABLE,\\n TableMetric.TABLE_DESCRIPTIVE\\n }\\n\\n assert table_metric.name in supported_metric\\n\\n table_template = template.TABLE_TEMPLATE\\n\\n headers = ['​'] + list(table_metric.column_indexes)\\n header_string = \\\"|\\\".join(headers)\\n header_separator = \\\"|\\\".join([\\\":-----:\\\" for i in range(len(headers))])\\n\\n table_content = []\\n\\n for row in table_metric.rows:\\n # row header is in BOLD\\n row_header = template.BOLD.format(\\n content=str(row.row_index).strip())\\n row_values = [row_header] + [formatting.numeric_formatting(item.value)\\n for item in row.cells]\\n table_content.append(\\\"|\\\".join(row_values))\\n\\n table_content_string = \\\"\\\\n\\\".join(table_content)\\n\\n return table_template.format(\\n header=header_string,\\n header_separator=header_separator,\\n table_content=table_content_string\\n )\",\n \"def read_table(self):\\n\\n db = self.connection(database=\\\"imdb\\\")\\n\\n try:\\n cur = db.cursor()\\n sql = \\\"SELECT title FROM film;\\\"\\n cur.execute(sql)\\n return cur.fetchall()\\n except:\\n print(\\\"Cannot read from table!\\\")\\n\\n db.close()\",\n \"def read_mumax3_table(filename):\\n \\n table = pd.read_csv(filename, sep='\\\\t')\\n table.columns = ' '.join(table.columns).split()[1::2]\\n \\n return table\",\n \"def load_market_matrix():\\n\\tfnm = \\\"../datasets/bbc/bbc.mtx\\\"\\n \\tconverters = {\\\"termid\\\": toInt, \\\"docid\\\": toInt, \\\"freq\\\":toFloat}\\n \\tX = pandas.read_table(fnm, header=None, sep=\\\" \\\", skiprows=2, names= [\\\"termid\\\", \\\"docid\\\", \\\"freq\\\"], converters=converters)\\n \\tX[\\\"termid\\\"] = X[\\\"termid\\\"] - 1\\n\\tX[\\\"docid\\\"] = X[\\\"docid\\\"] - 1\\n\\treturn X\",\n \"def read_MCC_results(table):\\n f = open(table)\\n lines = f.readlines()\\n lines = lines[1:] # discard header line\\n f.close()\\n t = np.zeros(len(lines))\\n predicts = np.zeros((len(lines), 3))\\n actuals = np.zeros((len(lines), 3))\\n line_num = 0\\n for line in lines:\\n fields = line.split()\\n t[line_num] = Time.DateTime(fields[0]).secs\\n predicts[line_num, :] = [float(field) for field in fields[1:4]]\\n actuals[line_num, :] = [float(field) for field in fields[5:8]]\\n line_num = line_num + 1\\n return t, predicts, actuals\",\n \"def message_table(message):\\r\\n table = Table(['property', 'value'])\\r\\n table.align['property'] = 'r'\\r\\n table.align['value'] = 'l'\\r\\n\\r\\n table.add_row(['id', message['id']])\\r\\n table.add_row(['initial_entry_time', message['initial_entry_time']])\\r\\n table.add_row(['visibility_delay', message['visibility_delay']])\\r\\n table.add_row(['visibility_interval', message['visibility_interval']])\\r\\n table.add_row(['fields', message['fields']])\\r\\n return [table, message['body']]\",\n \"def parse_populations(\\n source, strict=True, encoding=\\\"utf8\\\", base64_metadata=True, table=None\\n):\\n sep = None\\n if strict:\\n sep = \\\"\\\\t\\\"\\n if table is None:\\n table = tables.PopulationTable()\\n # Read the header and find the indexes of the required fields.\\n header = source.readline().rstrip(\\\"\\\\n\\\").split(sep)\\n metadata_index = header.index(\\\"metadata\\\")\\n for line in source:\\n tokens = line.rstrip(\\\"\\\\n\\\").split(sep)\\n if len(tokens) >= 1:\\n metadata = tokens[metadata_index].encode(encoding)\\n if base64_metadata:\\n metadata = base64.b64decode(metadata)\\n table.add_row(metadata=metadata)\\n return table\",\n \"def read_table(self, table):\\n return READ_TABLE(table, db=self.db)\",\n \"def tables():\\n return {\\n \\\"MAT24_STD_OCTAD\\\" : STD_OCTAD,\\n }\",\n \"def parse_table(self, table_name):\\n table_offset = self.catalog.get(table_name)\\n if not table_offset:\\n logging.error(f\\\"Could not find table {table_name} in DataBase\\\")\\n return\\n table_offset = table_offset * self.page_size\\n table = self._tables_with_data.get(table_offset)\\n if not table:\\n table_def = self._table_defs.get(table_offset)\\n if table_def:\\n table = TableObj(offset=table_offset, val=table_def)\\n logging.info(f\\\"Table {table_name} has no data\\\")\\n else:\\n logging.error(f\\\"Could not find table {table_name} offset {table_offset}\\\")\\n return\\n access_table = AccessTable(table, self.version, self.page_size, self._data_pages, self._table_defs)\\n return access_table.parse()\",\n \"def _parse_table(self): # type: (Optional[str]) -> Tuple[Key, Item]\\n indent = self.extract()\\n self.inc() # Skip opening bracket\\n\\n is_aot = False\\n if self._current == \\\"[\\\":\\n if not self.inc():\\n raise self.parse_error(UnexpectedEofError)\\n\\n is_aot = True\\n\\n # Key\\n self.mark()\\n while self._current != \\\"]\\\" and self.inc():\\n pass\\n\\n name = self.extract()\\n key = Key(name, sep=\\\"\\\")\\n\\n self.inc() # Skip closing bracket\\n if is_aot:\\n # TODO: Verify close bracket\\n self.inc()\\n\\n cws, comment, trail = self._parse_comment_trail()\\n\\n result = Null()\\n values = Container()\\n\\n while not self.end():\\n item = self._parse_item()\\n if item:\\n _key, item = item\\n if not self._merge_ws(item, values):\\n values.append(_key, item)\\n else:\\n if self._current == \\\"[\\\":\\n _, name_next = self._peek_table()\\n\\n if self._is_child(name, name_next):\\n key_next, table_next = self._parse_table()\\n key_next = Key(key_next.key[len(name + \\\".\\\") :])\\n\\n values.append(key_next, table_next)\\n\\n # Picking up any sibling\\n while not self.end():\\n _, name_next = self._peek_table()\\n\\n if not self._is_child(name, name_next):\\n break\\n\\n key_next, table_next = self._parse_table()\\n key_next = Key(key_next.key[len(name + \\\".\\\") :])\\n\\n values.append(key_next, table_next)\\n else:\\n table = Table(\\n values, Trivia(indent, cws, comment, trail), is_aot\\n )\\n\\n result = table\\n if is_aot and (\\n not self._aot_stack or name != self._aot_stack[-1]\\n ):\\n result = self._parse_aot(table, name)\\n\\n break\\n else:\\n raise self.parse_error(\\n InternalParserError,\\n (\\\"_parse_item() returned None on a non-bracket character.\\\"),\\n )\\n\\n if isinstance(result, Null):\\n result = Table(values, Trivia(indent, cws, comment, trail), is_aot)\\n\\n return key, result\",\n \"def _get_table(self):\\n\\t\\treturn self._table\",\n \"def load_main_table(table_text):\\n\\n lines = table_text.split('\\\\n')\\n i = 1\\n cols = []\\n for thing in lines[1].split('\\\",\\\"'):\\n if thing in ['C ', 'I ', 'K ', 'E ', 'H ']:\\n cols.append(thing.strip() + str(i) + ' ')\\n if thing == 'H ':\\n i += 1\\n else:\\n cols.append(thing)\\n lines[1] = '\\\",\\\"'.join(cols)\\n text = \\\"\\\\n\\\".join(lines[1:])\\n df = pd.read_csv(StringIO(text))\\n df.index = df['Student ID']\\n\\n return df\",\n \"def build(f, font, tableTag=None):\\n lines = Tokenizer(f)\\n return parseTable(lines, font, tableTag=tableTag)\",\n \"def isccp4table(self, text):\\n #\\n # See e.g. http://www.ccp4.ac.uk/dist/html/loggraphformat.html\\n # for format of TABLES\\n #\\n # Note that this regular expression accommodates slight deviations\\n # by making the \\\"closing\\\" \\\":\\\" of the $TABLE line optional.\\n # This is done for consistency with loggraph's behaviour.\\n #\\n # Set up regular expression for entire table\\n # This is the \\\"strict\\\" form of the table\\n table = self.compile(\\n \\\"isccp4table\\\",\\n r\\\" *\\\\$TABLE ?:([^:]*):?[ \\\\n]+\\\\$(GRAPHS|SCATTER)[^:]*(:[^\\\\$]*)\\\\$\\\\$([^\\\\$]*)\\\\$\\\\$([^\\\\$]*)\\\\$\\\\$([^\\\\$]*)\\\\$\\\\$\\\",\\n ).search(text)\\n result = dict()\\n if table:\\n result[\\\"rawtable\\\"] = table.group(0)\\n result[\\\"title\\\"] = table.group(1).strip()\\n result[\\\"type\\\"] = table.group(2).strip()\\n result[\\\"graphs\\\"] = table.group(3)\\n result[\\\"columns\\\"] = table.group(4)\\n result[\\\"text\\\"] = table.group(5)\\n result[\\\"data\\\"] = table.group(6)\\n result[\\\"nlines\\\"] = table.group(0).count(\\\"\\\\n\\\")\\n return result\\n # If there wasn't a match then try a simpler match\\n # This relaxes some of the rules in the format definintion\\n table = self.compile(\\n \\\"isccp4simplertable\\\",\\n r\\\" *\\\\$TABLE ?:([^\\\\n]*)\\\\n+\\\\$(GRAPHS|SCATTER)[^:]*(:[^\\\\$]*)\\\\$\\\\$([^\\\\$]*)\\\\$\\\\$([^\\\\$]*)\\\\$\\\\$([^\\\\$]*)\\\\$\\\\$\\\",\\n ).search(text)\\n if table:\\n result[\\\"rawtable\\\"] = table.group(0)\\n result[\\\"title\\\"] = table.group(1).strip()\\n result[\\\"type\\\"] = table.group(2).strip()\\n result[\\\"graphs\\\"] = table.group(3)\\n result[\\\"columns\\\"] = table.group(4)\\n result[\\\"text\\\"] = table.group(5)\\n result[\\\"data\\\"] = table.group(6)\\n result[\\\"nlines\\\"] = table.group(0).count(\\\"\\\\n\\\")\\n return result\\n return result\",\n \"def __init__(self, tabletext=\\\"\\\"):\\n\\n # Table attributes\\n self.__title = \\\"\\\"\\n self.__type = \\\"GRAPHS\\\" # Default to GRAPHS\\n self.__graphs = \\\"\\\"\\n self.__columns = \\\"\\\"\\n self.__text = \\\"\\\"\\n self.__data = \\\"\\\"\\n # Derived data\\n self.__graph_list = []\\n self.__column_list = []\\n # Indicate the the object has been populated\\n self.__table_parse_error = False\\n self.__nonzero = False\\n # The \\\"raw\\\" table data from the log file\\n self.__rawtable = \\\"\\\"\\n # Attempt to populate the table\\n if tabletext:\\n self.__rawtable = tabletext\\n if not self.__buildtable(tabletext):\\n # Failed to extract table\\n # If it could be a title then use this\\n # instead\\n if str(tabletext).count(\\\"\\\\n\\\") == 0:\\n self.settitle(tabletext)\",\n \"def convert_table(mkd):\\n\\t\\n\\tmd_table_codes = re.findall(r\\\".*\\\\|.*\\\\n.*\\\\-.*(?:\\\\n.*\\\\|.*)*\\\", mkd, re.M)\\n\\tfor md_code in md_table_codes:\\n\\t\\t\\n\\t\\tmd_rows = re.findall(r\\\"(.*\\\\|.*)\\\", md_code, re.M)\\n\\t\\theader = md_rows.pop(0)\\n\\t\\tcolumn_count = md_rows.pop(0).count(\\\"-\\\")\\n\\n\\t\\ttex_code = \\\"\\\\\\\\begin{tabular}{|\\\"+\\\"l|\\\"*column_count+\\\"}\\\\n\\\\hline\\\\n\\\"\\n\\t\\ttex_code += header.strip(\\\" |\\\").replace(\\\"|\\\", \\\"&\\\")+\\\" \\\\\\\\\\\\\\\\\\\\n\\\\hline\\\\n\\\"\\n\\t\\tfor row in md_rows:\\n\\t\\t\\ttex_code += row.strip(\\\" |\\\").replace(\\\"|\\\", \\\"&\\\")+\\\" \\\\\\\\\\\\\\\\\\\\n\\\"\\n\\t\\ttex_code += \\\"\\\\hline\\\\n\\\\end{tabular}\\\"\\n\\n\\t\\tmkd = mkd.replace(md_code, tex_code)\\n\\n\\treturn mkd\",\n \"def WriteBody( self ):\\n\\n self.ParseHeader( sys.stdin.readline() )\\n\\n self.CreateTable()\\n\\n num_lines = 0\\n\\n total_lines = 0\\n sys.stderr.write(\\\"parsing..\\\")\\n \\n while 1:\\n line = sys.stdin.readline()\\n \\n if not line: break\\n if line[0] == \\\"#\\\": continue\\n if line[0:2] == \\\"//\\\": break\\n \\n if not (total_lines % 100) and total_lines > 0:\\n sys.stderr.write( \\\".%i..\\\" % total_lines)\\n print self.table \\n self.table.body = []\\n\\n total_lines = total_lines + 1\\n\\n (columns) = string.split( line[:-1], \\\"\\\\t\\\" )\\n \\n if not columns:\\n break\\n\\n if self.mUseIndex:\\n col_string = [str(total_lines),] + self.ParseColumns( columns )\\n else:\\n col_string = self.ParseColumns( columns )\\n \\n self.table.body.append( col_string ) \\n \\n print self.table\\n \\n sys.stderr.write(\\\"done\\\\n\\\")\",\n \"def make_table(self, content):\\n html = '<table class=\\\"table table-condensed\\\">'\\n\\n # Check for list or tuple\\n if type(content) is list or type(content) is tuple:\\n if len(content) > 0:\\n # If first item in list is dictionary continue\\n if type(content[0]) is dict:\\n # Make table header for every key\\n html += '<thead><tr>'\\n for key in content[0].keys():\\n html += '<th>' + key + '</th>'\\n html += '</tr></thead>'\\n\\n # Make table body\\n html += '<tbody>'\\n for dictonary in content:\\n # New table row for every dict item in list\\n html += '<tr>'\\n # New column for every value in dictionary\\n for value in dictonary.values():\\n html += '<td>' + str(value) + '</td>'\\n html += '</tr>'\\n html += '</tbody>'\\n else:\\n html += 'No content available'\\n\\n html += '</table>'\\n\\n self.table = html\\n\\n return html\",\n \"def parse_conll_eval_table(self, fp):\\n with open(fp, 'r') as tbl:\\n tbl.readline()\\n for row in tbl:\\n clean_row = re.sub('([\\\\\\\\\\\\\\\\%]|hline)', '', row)\\n cells = [x.strip() for x in clean_row.split('&')]\\n self[cells[0]] = {\\n 'precision': float(cells[1]),\\n 'recall': float(cells[2]),\\n 'fscore': float(cells[3])\\n }\\n assert self.keys(), 'Probably an empty/non-existant file.'\\n self[self._total_name] = self['Overall']\\n del self['Overall']\",\n \"def converttable(tablecode):\\n table = etree.XML(tablecode)\\n rows = iter(table)\\n headers = [col.text for col in next(rows)]\\n data = []\\n for row in rows:\\n values = [col.text for col in row]\\n debugprint(dict(zip(headers, values)), \\\"RAW JSON\\\")\\n data.append(dict(zip(headers, values)))\\n return data\",\n \"def get_TABLE_info():\\n defalt_width = 300\\n defalt_height = 500\\n defalt_thickness = 10\\n\\n message = 'Put width of table. (mm : int) (width >= 210)'\\n width = rs.GetInteger(message, defalt_width, None, None)\\n\\n message = 'Put height of table. (mm : int) (height >= 250)'\\n height = rs.GetInteger(message, defalt_height, None, None)\\n\\n message = 'Put thickness of material (1layer). (mm : int)'\\n t_m = rs.GetReal(message, defalt_thickness, None, None)\\n\\n TABLE_info = [width, height, t_m]\\n\\n info = [\\\"width : %s\\\" % width, \\\"height : %s\\\" % height, \\\"thickness of material : %s\\\" % t_m]\\n print (info)\\n\\n return TABLE_info\",\n \"def get_tables():\\n page_html = requests.get(conf.PAGE_URL).text\\n soup = BeautifulSoup(page_html, 'html.parser')\\n tables = soup.find_all(\\\"table\\\", {\\\"class\\\": conf.TABLE_CLASS_NAME})\\n if not tables:\\n raise ValueError(\\\"Table class not found\\\")\\n return tables\",\n \"def read_table(self, table_type):\\n\\n if table_type == 'hash':\\n entry_class = MPQHashTableEntry\\n elif table_type == 'block':\\n entry_class = MPQBlockTableEntry\\n else:\\n raise ValueError(\\\"Invalid table type.\\\")\\n\\n table_offset = self.header['%s_table_offset' % table_type]\\n table_entries = self.header['%s_table_entries' % table_type]\\n key = self._hash('(%s table)' % table_type, 'TABLE')\\n\\n self.file.seek(table_offset + self.header['offset'])\\n data = self.file.read(table_entries * 16)\\n data = self._decrypt(data, key)\\n\\n def unpack_entry(position):\\n entry_data = data[position*16:position*16+16]\\n return entry_class._make(\\n struct.unpack(entry_class.struct_format, entry_data))\\n\\n return [unpack_entry(i) for i in range(table_entries)]\",\n \"def _get_table_info(self):\\n highestbet = self.highestBetNotFold(),\\n bigb =self.bigBlind() if self._game_state == GAME_STATE_PRE_FLOP and not self.inSmallBlindPosition() else 0\\n return [\\\"blinds: small:%r big:%r\\\" % (self.small_blind, self.big_blind),\\n \\\"buy_ins: min:%r max:%r\\\" % (self.min_buy_in, self.max_buy_in),\\n \\\"bs: %r\\\" % self.betting_structure,\\n \\\"highestbet = %r\\\" % highestbet,\\n \\\"bigb = %r\\\" % bigb,]\",\n \"def split_md_table(string: str) -> Tuple[str, Tuple[str, ...], Tuple[str, ...], str, str]:\\n err = 'tabulate returned GFM pipe table with invalid first two lines: {}'\\n split = string.split('\\\\n', 2)\\n line_sep = '\\\\r\\\\n' if split[0][-1] == '\\\\r' else '\\\\n'\\n def table_body(pos: int) -> str: return '\\\\n'.join(split[pos:])\\n lines = list(map(lambda s: s.rstrip('\\\\r'), split[:2]))\\n\\n md_headers, headers, formats = '', (), None\\n for line in reversed(lines):\\n if formats:\\n match = re.match(r'^\\\\|.*[^\\\\\\\\]\\\\|$', line)\\n headers = tuple(map(\\n lambda s: s.strip(' '),\\n re.split(r'(?<=[^\\\\\\\\])\\\\|', line[1:-1])\\n ))\\n if match and len(headers) == len(formats):\\n md_headers = line\\n else:\\n raise TabulateHelperError(err.format(lines))\\n elif re.match(r'^\\\\|:?-+:?(\\\\|:?-+:?)*\\\\|$', line):\\n formats = tuple(line[1:-1].split('|'))\\n if formats:\\n return md_headers, headers, formats, table_body(pos=2 if headers else 1), line_sep\\n else:\\n raise TabulateHelperError(err.format(lines))\",\n \"def get_table_data(table):\\n pattern_body = re.compile(r'(?ims)\\\\<tbody\\\\>(.*?)\\\\</tbody\\\\>')\\n pattern_rows = re.compile(r'(?ims)\\\\<tr\\\\>(.*?)\\\\</tr\\\\>')\\n pattern_cols = re.compile(r'(?ims)\\\\<td.*?\\\\>([^<]+?)\\\\<.*?/td\\\\>')\\n\\n body = pattern_body.findall(table)[0]\\n return [\\n list(map(lambda x: html.unescape(x), pattern_cols.findall(row)[:3]))\\n for row in pattern_rows.findall(body)]\",\n \"def table(self):\\r\\n return self._table\",\n \"def parseInput(toParse):\\n splitified = toParse.split('--------')\\n statesPath = splitified[0].rstrip().strip()\\n availableStates = len(splitified[1].rstrip().strip().split())\\n probMatrix = splitified[2].rstrip().strip().splitlines()\\n\\n return(probMatrix, statesPath, availableStates)\",\n \"def test_parse_taxa_summary_table(self):\\r\\n actual = parse_taxa_summary_table(self.taxa_summary1.split('\\\\n'))\\r\\n self.assertItemsEqual(actual[0], self.taxa_summary1_expected[0])\\r\\n self.assertItemsEqual(actual[1], self.taxa_summary1_expected[1])\\r\\n assert_almost_equal(actual[2], self.taxa_summary1_expected[2])\",\n \"def table(self):\\n return self.t\",\n \"def test_format_otu_table(self):\\r\\n a = array([[1, 2, 3],\\r\\n [4, 5, 2718281828459045]])\\r\\n samples = ['a', 'b', 'c']\\r\\n otus = [1, 2]\\r\\n taxa = ['Bacteria', 'Archaea']\\r\\n res = format_otu_table(samples, otus, a)\\r\\n # confirm that parsing the res gives us a valid biom file with\\r\\n # expected observation and sample ids\\r\\n t = parse_biom_table(res.split('\\\\n'))\\r\\n self.assertEqual(t.ObservationIds, ('1', '2'))\\r\\n self.assertEqual(t.SampleIds, ('a', 'b', 'c'))\",\n \"def get_table(self, percent=False):\\n TABLE_SEPARATOR = '=>'\\n\\n d = self.data\\n headers = self.headers\\n group_numbers = self.totals\\n\\n logging.debug('print_table:')\\n logging.debug(d)\\n # print header\\n csv_header = ['group', 'students'] + [h.label for h in headers] + [h.label+'%' for h in headers]\\n\\n # print rows and calc totals\\n logging.debug(d)\\n logging.debug([h.fullname for h in headers])\\n\\n csv_body = []\\n for gr, prep in self.cfg.preps.items():\\n csv_body.append( [f'{gr} - {prep}'] + self.data_group(gr, get_student_numbers=True, add_percentes=True))\\n\\n csv_footer = ['all'] + self.data_group_all(get_student_numbers=True, add_percentes=True)\\n\\n print(csv_header, csv_body, csv_footer)\\n return (csv_header, csv_body, csv_footer)\",\n \"def get_table(self):\\n result_table = [row[:] for row in self.table] # Clone the result table\\n\\n # Htmlise all columns containing images\\n for col_num in self.image_column_nums():\\n for row_num in range(1, len(result_table)):\\n result_table[row_num][col_num] = self.htmlise(result_table[row_num][col_num])\\n\\n # Append images\\n for ((col,row), image_list) in self.images.items():\\n for image in image_list:\\n try:\\n result_table[row][col] += \\\"<br>\\\" + image\\n except IndexError:\\n pass # Testing must have aborted so discard image\\n\\n return result_table\",\n \"def _parse_qstat_tabular(qstat_output):\\n def parse_qstat_record(record):\\n name, state_code = map(str.strip, record.split('|'))\\n return name, Torque._job_states[state_code]\\n\\n jobs = qstat_output.splitlines()\\n parsed = {}\\n # @TODO: think of catch-and-log parsing exceptions\\n if jobs and (len(jobs) > 1 or jobs[0] != ''):\\n parsed = dict(map(parse_qstat_record, jobs))\\n\\n return parsed\",\n \"def print_mistakes_table():\\n conn = sq.connect(host='localhost', user='root',\\n password='student', database='quiz')\\n cursor = conn.cursor()\\n\\n cursor.execute(\\\"select * from mistakes\\\")\\n data = cursor.fetchall()\\n\\n table = PrettyTable()\\n table.field_names = ['Question', 'Given Answer','User Given Answer']\\n for row in data:\\n table.add_row(row)\\n conn.close()\\n\\n return table\",\n \"def parse_ipac_table(table_file):\\n file_lines = table_file.readlines()\\n if len(file_lines) < 5:\\n raise ValueError(\\\"No images found!\\\")\\n \\n columns = file_lines[0].replace(\\\"|\\\",\\\" \\\").split()\\n \\n # Each row in the table starting at index 4 is metadata for a new image / observation\\n metadatas = []\\n for image_data in file_lines[4:]:\\n line = image_data.replace(\\\"|\\\",\\\" \\\").split()\\n obsdate_idx = columns.index(\\\"obsdate\\\")\\n tmp = line[obsdate_idx] + \\\" \\\" + line[obsdate_idx+1]\\n del line[obsdate_idx+1]\\n line[obsdate_idx] = tmp\\n metadatas.append(dict(zip(columns, line)))\\n \\n return metadatas\",\n \"def rawtable(self):\\n return self.__rawtable\",\n \"def _parse_qstat_tabular(qstat_output):\\n def parse_qstat_record(record):\\n name, state_code = map(str.strip, record.split('|'))\\n return name, Torque._job_states[state_code]\\n\\n jobs = qstat_output.splitlines()\\n parsed = {}\\n # @TODO: think of catch-and-log parsing exceptions\\n if jobs and (len(jobs) > 1 or jobs[0] is not ''):\\n parsed = dict(map(parse_qstat_record, jobs))\\n\\n return parsed\",\n \"def _pdread2astrotable(csvgzdir):\\n df = pd.read_csv(csvgzdir)\\n tb = Table.from_pandas(df)\\n return tb\",\n \"def read_biology(url, header):\\n req = requests.get(url)\\n values = BeautifulSoup(req.content, 'html.parser').body.text\\n\\n df = pd.read_csv(StringIO(values), sep=';', header=None,\\n index_col=False, names=header)\\n res_dic = {}\\n for i, row in df.iterrows():\\n key = row['Analyse'].replace(' ', '_') # ou analyse?\\n value = row['Resultat']\\n\\n res_dic[key] = value\\n\\n return res_dic\",\n \"def setUp(self):\\r\\n self.bt_str = '{\\\"id\\\": \\\"None\\\",\\\"format\\\": \\\"Biological Observation Matrix 1.0.0\\\",\\\"format_url\\\": \\\"http://biom-format.org\\\",\\\"type\\\": \\\"OTU table\\\",\\\"generated_by\\\": \\\"BIOM-Format 1.2.0-dev\\\",\\\"date\\\": \\\"2013-11-28T16:50:27.438635\\\",\\\"matrix_type\\\": \\\"sparse\\\",\\\"matrix_element_type\\\": \\\"float\\\",\\\"shape\\\": [10, 10],\\\"data\\\": [[0,0,22.0],[0,4,15.0],[0,5,74.0],[0,6,34.0],[0,7,76.0],[0,9,48.0],[1,0,70.0],[1,2,30.0],[1,3,37.0],[1,4,24.0],[1,5,77.0],[1,6,71.0],[1,7,58.0],[1,8,43.0],[2,1,2.0],[2,2,90.0],[2,4,48.0],[2,5,54.0],[2,7,22.0],[2,8,91.0],[3,0,80.0],[3,1,86.0],[3,3,78.0],[3,7,12.0],[4,4,68.0],[4,7,76.0],[4,8,57.0],[5,2,23.0],[5,5,66.0],[5,7,51.0],[5,9,77.0],[6,0,31.0],[6,1,47.0],[6,2,16.0],[6,4,96.0],[6,5,9.0],[7,0,17.0],[7,2,52.0],[7,5,11.0],[7,7,22.0],[8,1,74.0],[8,2,7.0],[8,4,80.0],[8,7,59.0],[9,0,6.0],[9,2,34.0],[9,3,63.0],[9,4,77.0],[9,5,8.0],[9,6,38.0],[9,7,73.0],[9,8,98.0],[9,9,45.0]],\\\"rows\\\": [{\\\"id\\\": \\\"o1 \\\", \\\"metadata\\\": {\\\"taxonomy\\\": [\\\"bug1\\\"]}},{\\\"id\\\": \\\"o2\\\", \\\"metadata\\\": {\\\"taxonomy\\\": [\\\"bug2\\\"]}},{\\\"id\\\": \\\"o3\\\", \\\"metadata\\\": {\\\"taxonomy\\\": [\\\"bug3\\\"]}},{\\\"id\\\": \\\"o4\\\", \\\"metadata\\\": {\\\"taxonomy\\\": [\\\"bug4\\\"]}},{\\\"id\\\": \\\"o5\\\", \\\"metadata\\\": {\\\"taxonomy\\\": [\\\"bug5\\\"]}},{\\\"id\\\": \\\"o6\\\", \\\"metadata\\\": {\\\"taxonomy\\\": [\\\"bug6\\\"]}},{\\\"id\\\": \\\"o7\\\", \\\"metadata\\\": {\\\"taxonomy\\\": [\\\"bug7\\\"]}},{\\\"id\\\": \\\"o8\\\", \\\"metadata\\\": {\\\"taxonomy\\\": [\\\"bug8\\\"]}},{\\\"id\\\": \\\"o9\\\", \\\"metadata\\\": {\\\"taxonomy\\\": [\\\"bug9\\\"]}},{\\\"id\\\": \\\"o10\\\", \\\"metadata\\\": {\\\"taxonomy\\\": [\\\"bug10\\\"]}}],\\\"columns\\\": [{\\\"id\\\": \\\"s1\\\", \\\"metadata\\\": null},{\\\"id\\\": \\\"s2\\\", \\\"metadata\\\": null},{\\\"id\\\": \\\"s6\\\", \\\"metadata\\\": null},{\\\"id\\\": \\\"s4\\\", \\\"metadata\\\": null},{\\\"id\\\": \\\"s5\\\", \\\"metadata\\\": null},{\\\"id\\\": \\\"s10\\\", \\\"metadata\\\": null},{\\\"id\\\": \\\"s7\\\", \\\"metadata\\\": null},{\\\"id\\\": \\\"s8\\\", \\\"metadata\\\": null},{\\\"id\\\": \\\"s9\\\", \\\"metadata\\\": null},{\\\"id\\\": \\\"s3\\\", \\\"metadata\\\": null}]}'\\r\\n self.mf_ordered = ['#SampleIDt\\\\thsid\\\\tfield\\\\tval',\\r\\n 's1\\\\t1\\\\tf1\\\\t6.1',\\r\\n 's3\\\\t1\\\\tf1\\\\t0.0',\\r\\n 's7\\\\t1\\\\tf1\\\\t14.2',\\r\\n 's9\\\\t1\\\\tf2\\\\t6.5',\\r\\n 's2\\\\t1\\\\tf2\\\\t21',\\r\\n 's6\\\\t2\\\\tf3\\\\t0.3',\\r\\n 's5\\\\t2\\\\tf2\\\\t9.1',\\r\\n 's4\\\\t2\\\\tf3\\\\t0.8',\\r\\n 's8\\\\t2\\\\tf2\\\\t5.0',\\r\\n 's10\\\\t2\\\\tf2\\\\t11.']\\r\\n self.mf_non_ordered = ['#SampleIDt\\\\thsid\\\\tval',\\r\\n 'Sample9\\\\t1\\\\t6.5',\\r\\n 'Sample8\\\\t2\\\\t5.0',\\r\\n 'Sample1\\\\t1\\\\t6.1',\\r\\n 'Sample2\\\\t1\\\\t21',\\r\\n 'Sample6\\\\t2\\\\t0.3',\\r\\n 'Sample5\\\\t2\\\\t9.1',\\r\\n 'Sample7\\\\t1\\\\t14.2',\\r\\n 'Sample4\\\\t2\\\\t0.8',\\r\\n 'Sample10\\\\t2\\\\t11.',\\r\\n 'Sample3\\\\t1\\\\t0.0']\\r\\n self.cvs1 = ['1', '2']\\r\\n self.mds1 = [[6.1, 0.0, 14.2, 6.5, 21], [.3, 9.1, .8, 5.0, 11.]]\\r\\n self.otus1 = [\\r\\n array([[22., 48., 34., 0., 0.],\\r\\n [70., 0., 71., 43., 0.],\\r\\n [0., 0., 0., 91., 2.],\\r\\n [80., 0., 0., 0., 86.],\\r\\n [0., 0., 0., 57., 0.],\\r\\n [0., 77., 0., 0., 0.],\\r\\n [31., 0., 0., 0., 47.],\\r\\n [17., 0., 0., 0., 0.],\\r\\n [0., 0., 0., 0., 74.],\\r\\n [6., 45., 38., 98., 0.]]),\\r\\n array([[0., 15., 0., 76., 74.],\\r\\n [30., 24., 37., 58., 77.],\\r\\n [90., 48., 0., 22., 54.],\\r\\n [0., 0., 78., 12., 0.],\\r\\n [0., 68., 0., 76., 0.],\\r\\n [23., 0., 0., 51., 66.],\\r\\n [16., 96., 0., 0., 9.],\\r\\n [52., 0., 0., 22., 11.],\\r\\n [7., 80., 0., 59., 0.],\\r\\n [34., 77., 63., 73., 8.]])]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5795739","0.56989133","0.5626127","0.5613763","0.55284244","0.55272263","0.55172074","0.5440883","0.5421252","0.53791916","0.53787607","0.53451467","0.53356135","0.5328347","0.5308771","0.5279552","0.52757406","0.52719027","0.5256095","0.5256095","0.52544194","0.5246638","0.5244476","0.5236445","0.52326626","0.52254623","0.52086556","0.51702523","0.5165593","0.5159902","0.5155478","0.5137353","0.5125742","0.51252955","0.51235604","0.51215005","0.51065093","0.5102397","0.50777656","0.5073955","0.5069654","0.50662863","0.5061748","0.5058527","0.5055843","0.5054431","0.50486267","0.50406474","0.50349665","0.5023999","0.5012887","0.50027573","0.50008255","0.49992484","0.49958986","0.49907944","0.4987184","0.49863422","0.49560782","0.49503097","0.4949693","0.49490762","0.49470997","0.49382365","0.49261802","0.49179325","0.4914772","0.49126565","0.49114335","0.49087894","0.49083355","0.48874763","0.48837888","0.4882316","0.48786104","0.4875795","0.48733112","0.48672438","0.48630866","0.4857618","0.48554888","0.48401788","0.48384422","0.4836429","0.4834497","0.48333594","0.4831966","0.4831111","0.4820188","0.4816742","0.48111683","0.48087716","0.4805057","0.48042473","0.48005772","0.47975966","0.4795735","0.47944355","0.47943327","0.47938794"],"string":"[\n \"0.5795739\",\n \"0.56989133\",\n \"0.5626127\",\n \"0.5613763\",\n \"0.55284244\",\n \"0.55272263\",\n \"0.55172074\",\n \"0.5440883\",\n \"0.5421252\",\n \"0.53791916\",\n \"0.53787607\",\n \"0.53451467\",\n \"0.53356135\",\n \"0.5328347\",\n \"0.5308771\",\n \"0.5279552\",\n \"0.52757406\",\n \"0.52719027\",\n \"0.5256095\",\n \"0.5256095\",\n \"0.52544194\",\n \"0.5246638\",\n \"0.5244476\",\n \"0.5236445\",\n \"0.52326626\",\n \"0.52254623\",\n \"0.52086556\",\n \"0.51702523\",\n \"0.5165593\",\n \"0.5159902\",\n \"0.5155478\",\n \"0.5137353\",\n \"0.5125742\",\n \"0.51252955\",\n \"0.51235604\",\n \"0.51215005\",\n \"0.51065093\",\n \"0.5102397\",\n \"0.50777656\",\n \"0.5073955\",\n \"0.5069654\",\n \"0.50662863\",\n \"0.5061748\",\n \"0.5058527\",\n \"0.5055843\",\n \"0.5054431\",\n \"0.50486267\",\n \"0.50406474\",\n \"0.50349665\",\n \"0.5023999\",\n \"0.5012887\",\n \"0.50027573\",\n \"0.50008255\",\n \"0.49992484\",\n \"0.49958986\",\n \"0.49907944\",\n \"0.4987184\",\n \"0.49863422\",\n \"0.49560782\",\n \"0.49503097\",\n \"0.4949693\",\n \"0.49490762\",\n \"0.49470997\",\n \"0.49382365\",\n \"0.49261802\",\n \"0.49179325\",\n \"0.4914772\",\n \"0.49126565\",\n \"0.49114335\",\n \"0.49087894\",\n \"0.49083355\",\n \"0.48874763\",\n \"0.48837888\",\n \"0.4882316\",\n \"0.48786104\",\n \"0.4875795\",\n \"0.48733112\",\n \"0.48672438\",\n \"0.48630866\",\n \"0.4857618\",\n \"0.48554888\",\n \"0.48401788\",\n \"0.48384422\",\n \"0.4836429\",\n \"0.4834497\",\n \"0.48333594\",\n \"0.4831966\",\n \"0.4831111\",\n \"0.4820188\",\n \"0.4816742\",\n \"0.48111683\",\n \"0.48087716\",\n \"0.4805057\",\n \"0.48042473\",\n \"0.48005772\",\n \"0.47975966\",\n \"0.4795735\",\n \"0.47944355\",\n \"0.47943327\",\n \"0.47938794\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6301872"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94291,"cells":{"query":{"kind":"string","value":"Return a BIOM table and the original open filehandle as a tuple. Useful when additional computation needs to be performed on the file contents, such as an MD5 sum."},"document":{"kind":"string","value":"def load_biom_table_with_file_contents(biom_f):\n table = parse_biom_table(biom_f)\n if hasattr(biom_f, 'seek'):\n biom_f.seek(0)\n return table, biom_f"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_file(self) -> tuple:\r\n hash_md5 = hashlib.md5()\r\n with open(self.yara_base_file, \"rb\") as f:\r\n file_map = f.read()\r\n get_file_dict = get_matches(self, file_map)\r\n hash_md5.update(file_map)\r\n return hash_md5.hexdigest(), get_file_dict","def __enter__(self) -> Tuple[FileObj]:\n file_obj: FileObj = []\n for obj in self.__dict__.values():\n if hasattr(obj, 'close'):\n file_obj.append(obj)\n return tuple(file_obj)","def md5_tuple(file_path):\n return file_path, md5_hash(file_path)","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","def readFileTable(f, header):\n version, dataOffset, archiveFileCount, fileTableLength, endianness, fileCount = header\n \n def readFileRecords(f):\n for i in range(fileCount):\n recordBytes = f.read(FILE_RECORD_LENGTH)\n path, offset, size, endianness, archiveFileIndex = struct.unpack(\"<256sLLLL\", recordBytes)\n path, _ = path.decode('ascii').split(\"\\0\", 1)\n yield (path, offset, size, endianness, archiveFileIndex)\n \n return list(readFileRecords(f))","def read(filename):\n with open(filename, 'rb') as filehandle:\n header = read_header(filehandle)\n data = read_data(header, filehandle, filename)\n return (data, header)","def get_file_contents(db_cursor):\n\n db_cursor.execute(\"\"\"SELECT * FROM data\"\"\")\n db_rows = db_cursor.fetchall()\n return {row[0]: row[1] for row in db_rows if row != []}","def open_db(self):\n # if it is not open, open it.\n if self.h5file.isopen is True:\n return self.h5file\n else:\n self.h5file = tb.open_file(filename=self.filepath, mode='a')\n assert self.h5file.isopen\n return self.h5file","def c_open(file):\n data = cassy.CassyDaten(file)\n t = data.messung(1).datenreihe(\"t\").werte\n I = data.messung(1).datenreihe(\"I_A2\").werte\n U = data.messung(1).datenreihe(\"U_B2\").werte\n return t, U, I","def getBiomData(self, data):\r\n try:\r\n if isfile(data):\r\n otu_table = parse_biom_table(qiime_open(data, 'U'))\r\n return otu_table\r\n except TypeError:\r\n if any([type(data) in\r\n [DenseFunctionTable,\r\n DenseGeneTable,\r\n DenseMetaboliteTable,\r\n DenseOTUTable,\r\n DenseOrthologTable,\r\n DensePathwayTable,\r\n DenseTable,\r\n DenseTaxonTable,\r\n FunctionTable,\r\n GeneTable,\r\n MetaboliteTable,\r\n OTUTable,\r\n OrthologTable,\r\n PathwayTable,\r\n SparseFunctionTable,\r\n SparseGeneTable,\r\n SparseMetaboliteTable,\r\n SparseOTUTable,\r\n SparseOrthologTable,\r\n SparsePathwayTable,\r\n SparseTable,\r\n SparseTaxonTable]]):\r\n otu_table = data\r\n return otu_table\r\n else:\r\n raise TypeError('Data is neither a path to a biom table or a' +\r\n ' biom table object.')","def read(self) -> Tuple[Level, Any]:\n with DFReader(open(self.fullpath, \"rb\")) as reader:\n dflevel, region_offsets = reader.read_level_ex()\n region_data = reader.read_bytes(region_offsets[-1])\n return dflevel, (region_offsets, region_data)","def _get_file(self, path: str) -> Tuple[str, bytes]:\n self._trace(\"fetching: %s\" % path)\n meta, resp = self._connection.files_download(path)\n return (meta.rev, resp.content)","def content_md5(self):\n with self.open() as fileobj:\n return get_content_md5(fileobj)","def file_info(self, f):\n ld8 = self.ld8_extract(f) # get luna_date\n sid = self.sesid(ld8) # make luna_visitnum\n age = self.age_lookup.get(sid)\n return (sid, age)","def open_db(filename: str) -> Tuple[sqlite3.Connection, sqlite3.Cursor]:\n db_connection = sqlite3.connect(filename) # Create or connect to DB\n cursor = db_connection.cursor() # Read/write data\n return db_connection, cursor","def read(self, *args) -> \"PyObject *\":\n return _ida_fpro.qfile_t_read(self, *args)","def get_info(curf, begin, read, param_of_unpack):\n curf.seek(begin)\n info = curf.read(read)\n info = struct.unpack(param_of_unpack, info)\n return str(info[0])","def read_relations(db, openfile):\n pass","def get_contents_hash(self):\n md5 = hashlib.md5()\n with closing(self.open()) as handle:\n for chunk in handle.chunks():\n md5.update(chunk)\n return md5.hexdigest()","def get_fp(self, *args) -> \"FILE *\":\n return _ida_fpro.qfile_t_get_fp(self, *args)","def get_aligned(database):\n conn = sqlite3.connect(database, check_same_thread=False)\n cur = conn.cursor()\n data = cur.execute('SELECT `header`, `aligned` FROM SEQUENCES;').fetchall()\n for h, s in data:\n yield h, s","def totuple(self):\n return (self.pageid, self.filename, self.uploader, self.width,\n self.height, self.size, self.quality_image,\n self.featured_picture, self.valued_image, self.timestamp)","def get_data(self, path, owner='*'):\n sql = sa.select([history.c.data, history.c.content_type]).select_from(sa.join(history, active)).where(active.c.path == path)\n result = self.engine.execute(sql).first()\n if result:\n data, ctype = result\n if ctype == 'application/msgpack':\n import msgpack\n return msgpack.unpackb(data, encoding='utf8')\n else:\n return data, ctype","def read_stock(db, openfile):\n pass","def file_entry(file_path: str) -> Tuple[str, Any, str]:\n file_name = os.path.split(file_path)[1]\n file_handler = open(file_path, \"rb\")\n content_type = \"application/octet-stream\"\n\n return (file_name, file_handler, content_type)","def getTuple(n,type=\"R\",thing = \"T\"):\r\n if type == \"R\":\r\n n=n+\".root\"\r\n print \"getting file \"+n\r\n \r\n file=TFile(n)\r\n t=file.Get(thing)\r\n if type==\"X\":\r\n translate(n)\r\n t,file=getTuple(n,\"R\")\r\n return t,file","def get_content(self):\n filestream = StringIO()\n\n tableName, primKey = self.provider._split_path(self.path)\n if primKey is not None:\n conn = self.provider._init_connection()\n listFields = self.provider._get_field_list(conn, tableName)\n csvwriter = csv.DictWriter(filestream, listFields, extrasaction=\"ignore\")\n dictFields = {}\n for field_name in listFields:\n dictFields[field_name] = field_name\n csvwriter.writerow(dictFields)\n\n if primKey == \"_ENTIRE_CONTENTS\":\n cursor = conn.cursor(MySQLdb.cursors.DictCursor)\n cursor.execute(\"SELECT * from \" + self.provider._db + \".\" + tableName)\n result_set = cursor.fetchall()\n for row in result_set:\n csvwriter.writerow(row)\n cursor.close()\n else:\n row = self.provider._get_record_by_primary_key(conn, tableName, primKey)\n if row is not None:\n csvwriter.writerow(row)\n conn.close()\n\n # this suffices for small dbs, but\n # for a production big database, I imagine you would have a FileMixin that\n # does the retrieving and population even as the file object is being read\n filestream.seek(0)\n return filestream","def open_input(self, fn):\n\treturn (None, None)","def enumerate_files(self, table):\n for i in range(self.nrofrecords()):\n data = self.bank.readrec(i + 1)\n if data and data[0] == table.tableid:\n yield i + 1, data[1:]","def data(self) -> Tuple[List[str], List[List[str]]]:\n format = self.format\n # Check if the file contains header information. Initialize the header\n # with the optional names of columns in the format descriptor.\n has_header = format.get('header', True)\n columns = format.get('columns')\n rows = list()\n # Delimiter depends on the file format.\n delim = '\\t' if format['type'] == 'tsv' else ','\n f = codecs.iterdecode(self.load().open(), 'utf-8')\n for row in csv.reader(f, delimiter=delim):\n if has_header:\n # Set the has_header flag to False so that all following records\n # are added to the list of rows.\n has_header = False\n columns = row if columns is None else columns\n else:\n rows.append(row)\n columns = [None] * len(rows[0]) if not columns and rows else columns\n return (columns, rows)","def _get_file_helper(self):\n page = self.course.moodle.fetch(\n self._download_url % self.id,\n None\n )\n # The resource URL should magically 303 across to the actual file\n if page.history and page.history[0].status_code == 303:\n return page, page.content\n\n # If it doesn't 303 to the actual file then there might be a download\n # link to try\n bs = bs4.BeautifulSoup(page.text, 'lxml')\n\n div = bs.find('div', class_='resourceworkaround')\n\n if div: # it's a link to the resource\n link = div.find('a').href\n\n page = self.course.moodle.fetch(\n link,\n None\n )\n return page, page.content\n\n # Perhaps it's an embedded object\n obj = bs.find('object', id='resourceobject')\n if obj:\n link = obj['data']\n\n page = self.course.moodle.fetch(\n link,\n None\n )\n return page, page.content\n\n raise ValueError(\"No idea how to get that resource\")","def _open_read(self, existing_file_obj=None):\n # Use explicit file handle, if given.\n if existing_file_obj is not None:\n yield existing_file_obj\n\n # Use a file handle being actively used for writes, if available.\n # There is some danger to doing this because reads will seek the\n # file. However, revlog._writeentry performs a SEEK_END before all\n # writes, so we should be safe.\n elif self.writing_handle:\n yield self.writing_handle\n\n elif self.reading_handle:\n yield self.reading_handle\n\n # Otherwise open a new file handle.\n else:\n with self._open() as fp:\n yield fp","def get_cursor(file_name):\n con = lite.connect(file_name)\n con.row_factory = lite.Row\n return con.cursor()","def iterRegularFileContents(self):\n unpack = {}\n for (oldFileId, newFileId), stream in self.files.iteritems():\n if not files.frozenFileHasContents(stream):\n continue\n if files.frozenFileFlags(stream).isEncapsulatedContent():\n continue\n cont = files.frozenFileContentInfo(stream)\n unpack[newFileId] = cont.sha1()\n\n want_tag = '0 ' + ChangedFileTypes.file[4:]\n while True:\n f = self._nextFile()\n if not f:\n break\n name, tag, fobj, csf = f\n if len(name) != 36 or tag != want_tag:\n continue\n fileId = name[16:]\n sha1 = unpack.get(fileId)\n if not sha1:\n continue\n yield sha1, fobj","def get_content(self, file_path: str) -> Tuple[defaultdict, str]:\n if not os.path.exists(file_path): # If file doesn't exist\n raise FileNotFoundError(f\"{fg(1)} Could not find file: {file_path}{fg(15)}\\n\")\n html = self.__html__(file_path)\n metadata = self.__metadata__()\n return metadata, html","def to_workbook(self) -> tuple:\n\n # Initialize the bytestream\n f = io.BytesIO()\n wb = xw.Workbook(f, {\"in_memory\": True})\n\n # Open a workbook\n self._book = wb\n self._book.set_properties({\"category\": \"atomica:databook\"})\n self._formats = standard_formats(self._book)\n self._references = {} # Reset the references dict\n\n # Write the contents\n self._write_pops()\n self._write_tdve()\n self._write_interpops()\n self._write_transfers()\n\n # Clean internal variables related to writing the worbkook\n self._book = None\n self._formats = None\n self._references = None\n\n return f, wb","async def __getinfo(self) -> tuple:\n\n async with self.session.get(\n self.url,\n allow_redirects=True\n\n ) as response:\n # print(response)\n\n # Use redirected URL\n self.url = str(response.url)\n try:\n content_disposition = cgi.parse_header(\n response.headers['Content-Disposition'])\n filename = content_disposition[1]['filename']\n filename = urllib.parse.unquote_plus(filename)\n except KeyError:\n filename = response._real_url.name\n\n if not filename:\n guessed_extension = mimetypes.guess_extension(\n response.headers[\"Content-Type\"].split(\";\")[0])\n filename = f\"{gen_uuid(size=5)}{guessed_extension}\"\n\n try:\n size = int(response.headers['Content-Length'])\n except KeyError:\n size = 0\n return (\n filename,\n size,\n response.headers['Content-Type'],\n response._real_url\n )","def _filehandle(self):\n if not self._fh or self._is_closed():\n filename = self._rotated_logfile or self.filename\n if filename.endswith('.gz'):\n self._fh = gzip.open(filename, 'r')\n else:\n self._fh = open(filename, \"r\", 1)\n self._fh.seek(self._offset)\n\n return self._fh","def _get_db_connection():\n conn = sqlite3.connect(str(DB_FILE_PATH))\n c = conn.cursor()\n\n return conn, c","def get_tpm_blobs(\n self, path: Union[bytes, str]\n ) -> Tuple[TPM2B_PUBLIC, TPM2B_PRIVATE, str]:\n path = _to_bytes_or_null(path)\n tpm_2b_public = ffi.new(\"uint8_t **\")\n tpm_2b_public_size = ffi.new(\"size_t *\")\n tpm_2b_private = ffi.new(\"uint8_t **\")\n tpm_2b_private_size = ffi.new(\"size_t *\")\n policy = ffi.new(\"char **\")\n ret = lib.Fapi_GetTpmBlobs(\n self._ctx,\n path,\n tpm_2b_public,\n tpm_2b_public_size,\n tpm_2b_private,\n tpm_2b_private_size,\n policy,\n )\n _chkrc(ret)\n\n policy_str = ffi.string(policy[0]).decode(self.encoding)\n\n tpm_2b_public_buffer = bytes(\n ffi.buffer(tpm_2b_public[0], tpm_2b_public_size[0])\n )\n tpm_2b_public_unmarsh, _ = TPM2B_PUBLIC.unmarshal(tpm_2b_public_buffer)\n\n tpm_2b_private_buffer = bytes(\n ffi.buffer(tpm_2b_private[0], tpm_2b_private_size[0])\n )\n tpm_2b_private_unmarsh, _ = TPM2B_PRIVATE.unmarshal(tpm_2b_private_buffer)\n\n return (\n tpm_2b_public_unmarsh,\n tpm_2b_private_unmarsh,\n policy_str,\n )","def _hash_file(self, file_entry):\n if file_entry is None:\n return None\n\n if file_entry.IsDevice() or file_entry.IsPipe() or file_entry.IsSocket():\n # Ignore devices, FIFOs/pipes and sockets.\n return None\n\n hash_context = hashlib.sha256()\n\n try:\n file_object = file_entry.GetFileObject()\n except IOError as exception:\n logging.warning((\n 'Unable to open path specification:\\n{0:s}'\n 'with error: {1!s}').format(file_entry.path_spec.location, exception))\n return None\n\n if not file_object:\n return None\n\n try:\n data = file_object.read(self._READ_BUFFER_SIZE)\n while data:\n hash_context.update(data)\n data = file_object.read(self._READ_BUFFER_SIZE)\n except IOError as exception:\n logging.warning((\n 'Unable to read from path specification:\\n{0:s}'\n 'with error: {1!s}').format(file_entry.path_spec.location, exception))\n return None\n\n return hash_context.hexdigest()","def load_biom_table(table_f):\n return parse_biom_table(table_f)","def open_image_and_meta(image_bytes):\n with MemoryFile(image_bytes) as memfile:\n with memfile.open() as src:\n meta = src.meta\n arr = reshape_as_image(src.read())\n return arr, meta","def _open_sql_file(dbname):\n try:\n dbpath = pathlib.Path(dbname).resolve()\n conn = sqlite3.connect(f\"{dbpath.as_uri()}?mode=ro\", timeout=1, uri=True)\n c = conn.cursor()\n except sqlite3.Error as e:\n sys.exit(f\"An error occurred opening sqlite file: {e.args[0]} {dbname}\")\n return (conn, c)","def _read_lengths(self):\n\n stream = self.stream\n stream.seek(0)\n\n ###########\n # Read and set table lengths\n self.table_lengths = [None]*len(tables)\n\n (self.entire_file_length,\n header_length,\n self.smallest_character_code,\n self.largest_character_code) = repeat_call(stream.read_unsigned_byte2, 4)\n\n header_data_length_min = 18 # words\n self.table_lengths[tables.header] = max(\n header_data_length_min, header_length)\n\n self.number_of_chars = self.largest_character_code - \\\n self.smallest_character_code + 1\n self.table_lengths[tables.character_info] = self.number_of_chars\n\n # read the last lengths\n for i in range(tables.width, len(tables)):\n self.table_lengths[i] = stream.read_unsigned_byte2()\n\n ###########\n # Compute table pointers\n self.table_pointers = [None]*len(tables)\n\n # The header starts at 24 bytes\n self.table_pointers[tables.header] = 24\n\n for table in range(tables.header, tables.font_parameter):\n self.table_pointers[\n table+1] = self._position_in_table(table, self.table_lengths[table])\n\n ###########\n # Sanity check\n length = self._position_in_table(\n tables.font_parameter, self.table_lengths[tables.font_parameter])\n if length != self.word_ptr(0, self.entire_file_length):\n raise NameError('Bad TFM file')","def read_opsim_db(opsim_db_path='/global/projecta/projectdirs/lsst/groups/SSim/DC2/minion_1016_desc_dithered_v4.db'):\n conn = sqlite3.connect(opsim_db_path)\n # Check the table names\n cursor = conn.cursor()\n cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table';\")\n table_names = cursor.fetchall()\n print(table_names)\n # Turn table into Pandas df\n obs_history = pd.read_sql(sql=\"SELECT * from ObsHistory\", con=conn, index_col=None)\n field = pd.read_sql(sql=\"SELECT * from Field\", con=conn, index_col=None)\n return obs_history, field","def info(self, fp):\n keys = (\n (\"cas.meta.compression\", CAS._convert_meta),\n (\"cas.meta.lib\", CAS._convert_meta),\n (\"cas.meta.fp_algo\", CAS._convert_meta),\n (\"cas.meta.orig_size\", CAS._convert_meta),\n (\"cas.refcount\", CAS._convert_refcount),\n )\n\n return {key: conv(self.ioctx.get_xattr(fp, key))\n for key, conv in keys}","def read(self):\n self.connect()\n get_books = f\"select * from {self.book_table}\"\n try:\n self.cur.execute(get_books)\n self.con.commit()\n for i in self.cur:\n yield i\n except MySQLError as err:\n messagebox.showinfo(\"Failed to fetch files from database\")\n print(err)","def fileobject_to_dict(fo):\n if fo.allocated():\n # proc = subprocess.Popen(['./extract_strings', fo.inode()], stdout=subprocess.PIPE)\n # contents = proc.stdout.read()\n return {\n 'atime_dt': epoch_to_dt(fo.atime()),\n 'compressed_b': fo.compressed(),\n 'contents_t': string.translate(fo.contents(), filter),\n 'contents_display': string.translate(fo.contents(), filter),\n 'crtime_dt': epoch_to_dt(fo.crtime()),\n 'ctime_dt': epoch_to_dt(fo.ctime()),\n 'dtime_dt': epoch_to_dt(fo.dtime()),\n 'encrypted_b': fo.encrypted(),\n 'extension_facet': fo.ext(),\n 'fileid_i': int(fo._tags['id']),\n 'filename_display': fo.filename(),\n 'filename_t': fo.filename(),\n 'filesize_l': long(fo.filesize()),\n 'fragments_i': int(fo.fragments()),\n 'gid_i': int(fo._tags['gid']),\n #'id': uuid.uuid4(),\n 'id': hashlib.sha1(os.path.basename(IMAGE) + '_' + fo.inode()).hexdigest(),\n #'imagefile': fo._tags['imagefile'],\n 'inode_i': int(fo.inode()),\n 'libmagic_display': fo.libmagic(),\n 'libmagic_facet': fo.libmagic(),\n 'md5_s': fo.md5(),\n 'meta_type_i': fo._tags['meta_type'],\n 'mode_facet': int(fo._tags['mode']),\n 'mode_i': int(fo._tags['mode']),\n 'mtime_dt': epoch_to_dt(fo.mtime()),\n 'nlink_i': fo._tags['nlink'],\n 'name_type_s': fo.name_type(),\n 'partition_i': int(fo.partition()),\n 'sha1_s': fo.sha1(),\n 'uid_i': int(fo._tags['uid']),\n 'volume_display': IMAGE,\n 'volume_facet': os.path.basename(IMAGE)\n }\n else:\n return None","def get_two_stock_data():\n ticker1, ticker2 = 'INTC', 'AAPL'\n\n file1 = cbook.get_sample_data('INTC.dat.gz')\n file2 = cbook.get_sample_data('AAPL.dat.gz')\n M1 = fromstring(file1.read(), '<d')\n\n M1 = resize(M1, (M1.shape[0]//2, 2))\n\n M2 = fromstring(file2.read(), '<d')\n M2 = resize(M2, (M2.shape[0]//2, 2))\n\n d1, p1 = M1[:, 0], M1[:, 1]\n d2, p2 = M2[:, 0], M2[:, 1]\n return (d1, p1, d2, p2)","def read(self):\n return self.frame, self.boundary_lines","def getTiffAsMatrix(kv):\n file_name = kv[0].split('/')[-1]\n fbinary = kv[1]\n tiffmat = getOrthoTif(fbinary)\n return (file_name,tiffmat)","def _getConnection():\n db = sqlite.connect(db_path)\n db.row_factory = sqlite.Row\n cursor = db.cursor()\n return cursor, db","def get_connection_info(otu_table_fp, num_meta, meta_dict):\r\n con_by_sample = defaultdict(set)\r\n node_file = []\r\n edge_file = []\r\n red_nodes = defaultdict(int)\r\n red_node_file = []\r\n red_edge_file = []\r\n multi = defaultdict(list)\r\n edge_from = []\r\n to = []\r\n otu_dc = defaultdict(int)\r\n degree_counts = defaultdict(int)\r\n sample_dc = defaultdict(int)\r\n sample_num_seq = defaultdict(int)\r\n con_list = []\r\n\r\n otu_table = parse_biom_table(open(otu_table_fp, 'U'))\r\n\r\n # if lineages == []:\r\n # is_con = False\r\n # else:\r\n # is_con = True\r\n\r\n is_con = False\r\n # This could be moved to OTU table sub-class\r\n if (otu_table.ObservationMetadata is not None and\r\n 'taxonomy' in otu_table.ObservationMetadata[0]):\r\n is_con = True\r\n\r\n for (otu_values, otu_id, otu_metadata) in otu_table.iterObservations():\r\n # for idx,l in enumerate(otu_table):\r\n # data = l\r\n\r\n #to_otu = otu_ids[idx]\r\n con = ''\r\n if is_con:\r\n #con = ':'.join(lineages[idx][:6])\r\n con = ':'.join(otu_metadata['taxonomy'][:6])\r\n con = con.replace(\" \", \"_\")\r\n con = con.replace(\"\\t\", \"_\")\r\n # Not required: otu_values (data) is always numpy vector\r\n #counts = map(float,data)\r\n if con not in con_list:\r\n con_list.append(con)\r\n #non_zero_counts = nonzero(counts)[0]\r\n non_zero_counts = otu_values.nonzero()[0]\r\n degree = len(non_zero_counts)\r\n weighted_degree = sum(otu_values)\r\n# node_file_line = [to_otu,'','otu_node',str(degree),\\\r\n# str(weighted_degree),con]\r\n node_file_line = [otu_id, '', 'otu_node', str(degree),\r\n str(weighted_degree), con]\r\n node_file_line.extend(['otu'] * num_meta)\r\n node_file.append('\\t'.join(node_file_line))\r\n\r\n if len(non_zero_counts) != 1:\r\n red_node_file.append('\\t'.join(node_file_line))\r\n\r\n otu_dc[degree] += 1\r\n degree_counts[degree] += 1\r\n #samples = [sample_ids[i] for i in non_zero_counts]\r\n samples = [otu_table.SampleIds[i] for i in non_zero_counts]\r\n for i, s in enumerate(samples):\r\n if s not in meta_dict.keys():\r\n continue\r\n con_by_sample[s].update(samples[0:i])\r\n con_by_sample[s].update(samples[i + 1:])\r\n #sample_num_seq[s] += float(data[non_zero_counts[i]])\r\n sample_num_seq[s] += float(otu_values[non_zero_counts[i]])\r\n\r\n edge_from.append(s)\r\n # to.append(to_otu)\r\n to.append(otu_id)\r\n meta = meta_dict[s]\r\n meta[1] += 1\r\n #data_num = str(data[non_zero_counts[i]])\r\n data_num = str(otu_values[non_zero_counts[i]])\r\n # edge_file.append('\\t'.join([s, to_otu, \\\r\n # data_num, con, meta[0]]))\r\n edge_file.append('\\t'.join([s, otu_id,\r\n data_num, con, meta[0]]))\r\n #multi[to_otu].append((s,float(data[non_zero_counts[i]]), meta[0]))\r\n multi[otu_id].append(\r\n (s, float(otu_values[non_zero_counts[i]]), meta[0]))\r\n if len(non_zero_counts) == 1:\r\n #red_nodes[(sample_ids[non_zero_counts[0]],meta[0])] += degree\r\n red_nodes[(\r\n otu_table.SampleIds[non_zero_counts[0]],\r\n meta[0])] += degree\r\n else:\r\n # red_edge_file.append('\\t'.join([s, to_otu, \\\r\n # data_num, con, meta[0]]))\r\n red_edge_file.append('\\t'.join([s, otu_id,\r\n data_num, con, meta[0]]))\r\n\r\n num_otu_nodes = len(node_file)\r\n for s in meta_dict:\r\n meta = meta_dict[s]\r\n degree = meta[1]\r\n sample_dc[degree] += 1\r\n degree_counts[degree] += 1\r\n weighted_degree = sample_num_seq[s]\r\n node_file_line = '\\t'.join([s, s, 'user_node', str(meta[1]),\r\n str(weighted_degree), 'other', meta[0]])\r\n node_file.append(node_file_line)\r\n red_node_file.append(node_file_line)\r\n\r\n for n, d in red_nodes.items():\r\n red_node_file_line = ['@' + n[0], '',\r\n 'otu_collapsed', str(d), str(float(d)), 'other']\r\n red_node_file_line.extend(['otu'] * num_meta)\r\n red_node_file.append('\\t'.join(red_node_file_line))\r\n red_edge_file.append(\r\n '\\t'.join([n[0], '@' + n[0], \"1.0\", \"missed\", n[1]]))\r\n\r\n return con_by_sample, node_file, edge_file, red_node_file,\\\r\n red_edge_file, otu_dc, degree_counts, sample_dc","def check_file(f, open_close_pairs):\n\n opens = {}\n closes = {}\n open_for = {}\n for open_symbol, close_symbol in open_close_pairs:\n opens[open_symbol] = []\n open_for[close_symbol] = opens[open_symbol]\n closes[close_symbol] = []\n\n line_number = 0\n for line in f:\n line_number += 1\n column = 0\n for sym in line:\n column += 1\n if sym in opens and open_for.get(sym, None) == opens[sym]:\n if len(opens[sym]) == 0:\n opens[sym].append((line_number, column))\n else:\n opens[sym].pop()\n elif sym in opens:\n opens[sym].append((line_number, column))\n elif sym in closes:\n if len(open_for[sym]) > 0:\n open_for[sym].pop()\n else:\n closes[sym].append((line_number, column))\n\n return { (o, c) : (opens[o], closes[c]) for o, c in open_close_pairs }","def parse(self):\n # type: () -> Tuple[LineNo, int, LineNo, int]\n metadata = self.safely_parse_metadata()\n if len(metadata) > 2:\n raise UnsupportedCombinedDiff(self.text)\n assert len(metadata) == 2\n return tuple(flatten(metadata)) # type: ignore[return-value]","def to_tuple(self) -> tuple:\n return (self.transaction_number, self.date, self.description, self.memo, self.amount_debit,\n self.amount_credit, self.balance, self.check_number, self.fees, self.card_type,\n self.is_payment, self.is_transaction, self.user_id)","def get_reader(fname):\n\n if fname == \"-\":\n fh = sys.stdin\n else:\n fh = open(fname, \"r\")\n \n rdr = csv.reader(fh, dialect=\"psv\")\n return (rdr, fh)","def _read(self, item):\n return read_hdf5(self.file_name, title=self._get_h5_path(item))","def snapshot(self):\n return (self.block_header.state_root, self.chaindb.snapshot())","def read_file(self, filename, force_decompress=False):\n\n def decompress(data):\n \"\"\"Read the compression type and decompress file data.\"\"\"\n compression_type = ord(data[0:1])\n if compression_type == 0:\n return data\n elif compression_type == 2:\n return zlib.decompress(data[1:], 15)\n elif compression_type == 16:\n return bz2.decompress(data[1:])\n else:\n msg = \"Unsupported compression type: {}\".format(compression_type)\n raise RuntimeError(msg)\n\n hash_entry = self.get_hash_table_entry(filename)\n if hash_entry is None:\n return None\n block_entry = self.block_table[hash_entry.block_table_index]\n\n # Read the block.\n if block_entry.flags & MPQ_FILE_EXISTS:\n if block_entry.archived_size == 0:\n return None\n\n offset = block_entry.offset + self.header['offset']\n self.file.seek(offset)\n file_data = self.file.read(block_entry.archived_size)\n\n if block_entry.flags & MPQ_FILE_ENCRYPTED:\n raise NotImplementedError(\"Encryption is not supported yet.\")\n\n if not block_entry.flags & MPQ_FILE_SINGLE_UNIT:\n # File consists of many sectors. They all need to be\n # decompressed separately and united.\n sector_size = 512 << self.header['sector_size_shift']\n sectors = block_entry.size // sector_size + 1\n if block_entry.flags & MPQ_FILE_SECTOR_CRC:\n crc = True\n sectors += 1\n else:\n crc = False\n positions = struct.unpack('<%dI' % (sectors + 1),\n file_data[:4*(sectors+1)])\n result = BytesIO()\n sector_bytes_left = block_entry.size\n for i in range(len(positions) - (2 if crc else 1)):\n sector = file_data[positions[i]:positions[i+1]]\n if (block_entry.flags & MPQ_FILE_COMPRESS and\n (force_decompress or sector_bytes_left > len(sector))):\n sector = decompress(sector)\n\n sector_bytes_left -= len(sector)\n result.write(sector)\n file_data = result.getvalue()\n else:\n # Single unit files only need to be decompressed, but\n # compression only happens when at least one byte is gained.\n if (block_entry.flags & MPQ_FILE_COMPRESS and\n (force_decompress or block_entry.size > block_entry.archived_size)):\n file_data = decompress(file_data)\n\n return file_data","def file_loc(self):\n\t\treturn self.__dbfile","def openmat(filename, field = None):\n tmp = []\n \n try:\n \n data = loadmat(filename)\n \n if isinstance(field,(str, np.str)):\n tmp = data[field]\n elif isinstance(field, (tuple, list)):\n \n for key in data.keys():\n if '__header__' in key:\n continue\n if '__version__' in key:\n continue\n if '__globals__' in key:\n continue\n \n if key in field: \n tmp.append(data[key])\n else:\n \n for key in data.keys():\n if '__header__' in key:\n continue\n if '__version__' in key:\n continue\n if '__globals__' in key:\n continue\n \n tmp.append(data[key]) \n except:\n \n read_file = openmat_h5_(filename, field)\n \n tmp = read_file.parse()\n \n return tmp","def close_file_pair(pair):\n try:\n yield pair\n finally:\n pair[0].close()\n pair[1].close()","def DRI(fp):\n info = {\n 'Lr' : unpack('>H', fp.read(2))[0],\n 'Ri' : unpack('>H', fp.read(2))[0]\n }\n\n return info","def hdf5_file_opened(self):\n should_close = self._hdf5_file is None\n yield self.hdf5_file\n if should_close:\n self.close_and_delete_hdf5_handle()","def readbytes(self, *args) -> \"PyObject *\":\n return _ida_fpro.qfile_t_readbytes(self, *args)","def get_file_object(self):\n try:\n # FieldFile.open() and File.open() don't return file objects, so\n # accessing it directly\n return self.datafile.file.file # FileStoreItem.FieldFile.File.file\n except ValueError as exc:\n logger.error(\"Error opening %s: %s\", self.datafile, exc)\n return None","def get_pickle(get_file='simbad_mag_errors.pkl'):\n print \"Opening %s and unpickling the DataFrame..\" % get_file\n with open(get_file, 'r') as opened_file:\n df_unpickled = cPickle.load(opened_file)\n print \"..Done\"\n return df_unpickled","def get_content(file1, file2):\n with open(file1, 'r') as f1, open(file2, 'r') as f2:\n return [line for line in f1], [line for line in f2]","def open_and_read_file(file_path1, file_path2):\n\n # your code goes here\n file_object1 = open(file_path1)\n file_object2 = open(file_path2)\n contents = file_object1.read() + \" \" + file_object2.read()\n file_object1.close()\n file_object2.close()\n\n return contents","def _open_hdf5(self, file_path):\n\n if (file_path not in self._file_handles or\n not self._file_handles[file_path].is_open):\n self._file_handles[file_path] = pd.HDFStore(file_path, 'r')\n\n return self._file_handles[file_path]","def read_reduced():\n ### read in the reduced data\n reduced_data = parse(join(FILE_PATH, \"lm_sm_aggz.gctx\"))\n\n ### read in the signature info and set the index to the signature id for easy indexing in the next step\n sig_info = pd.read_csv(join(FILE_PATH, \"GSE92742_Broad_LINCS_sig_info.txt\"), sep=\"\\t\")\n sig_info.index = sig_info['sig_id']\n\n ### map the columns to the pert_id that generated the signature to allow for comparison in spark\n reduced_data.data_df.columns = sig_info.loc[pd.Index(reduced_data.data_df.columns)]['pert_id']\n ### return data_frame with pert_ids in row_major form ready for scala\n return reduced_data.data_df.transpose()","def _get_parsed_files(self):\n\n parsed = []\n with Historical_ROAs_Parsed_Table() as t:\n for row in t.execute(f'SELECT * FROM {t.name}'):\n parsed.append(row['file'])\n return parsed","def open_with_size(filename, *args):\n\n f = open_(filename, *args)\n if isinstance(f, gzip.GzipFile):\n fo = open(f.name, 'rb')\n fo.seek(-4, 2)\n r = fo.read()\n fo.close()\n return f, struct.unpack('<I', r)[0]\n else:\n f.seek(0, os.SEEK_END)\n buflen = f.tell()\n f.seek(4, os.SEEK_SET)\n return f, buflen","def connect(sqlite_file):\n conn = sqlite3.connect(sqlite_file)\n c = conn.cursor()\n return conn, c","def __openRow(fd):\n\n print(\" <tr>\", file=fd)","def tabdes(filename, body):\n # XXX checksums ignored\n head = Struct(\"!BiHBxxxB\")\n body = Struct(body)\n # foot = Struct(\"!4s\")\n\n data = []\n with open(filename, \"rb\") as f:\n buffer = f.read()\n _, _, count, length, _ = head.unpack_from(buffer, 0)\n offset = head.size\n for i in range(count):\n row = body.unpack_from(buffer, offset)\n data.append(row)\n offset += body.size\n else:\n print(\"read %d rows\" % len(data))\n # offset = 2 ** 16 - foot.size\n # _, foot.unpack_from(buffer, offset))\n return data","def mem_get(bytestring, compressed=True):\n ff = mem_open(bytestring, compressed)\n if ff is None:\n return (None, None)\n hdr = ff[0].header\n data = ff[0].data\n ff.close()\n return (hdr, data)","def loadDb(self,dbContent,base):\n \n db = utilities.db2bitarray(dbContent,self.dbSize,1,1,base)\n db = np.array(db).reshape(self.dbSize,-1)\n # track the size of each file\n fileSize = db.shape[-1]\n \n return (db,fileSize)","def open_file_in_dir(path: str) -> Tuple[io.FileIO, int]:\n directory = os.path.dirname(path)\n if not os.path.isdir(directory):\n raise ValueError('No directory {}'.format(directory))\n\n if not os.path.exists(path):\n file_fd = open(path, mode='x+b', buffering=0)\n else:\n file_fd = open(path, mode='r+b', buffering=0)\n\n dir_fd = os.open(directory, os.O_RDONLY)\n\n return file_fd, dir_fd","def ffi_pickle_contents(self) -> Tuple[int, float, float, float,\n np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:\n tic_id = 231663901\n ra = 62.2\n dec = -71.4\n tess_magnitude = 10\n time = np.arange(0, 100, 10)\n raw_flux = np.arange(10)\n corrected_flux = np.arange(10, 20)\n pca_flux = np.arange(20, 30)\n flux_error = np.arange(0, 1, 0.1)\n return tic_id, ra, dec, tess_magnitude, time, raw_flux, corrected_flux, pca_flux, flux_error","def read_tuple(self):\n cmd = self.read_command()\n return StormTuple(\n cmd['id'], cmd['comp'], cmd['stream'], cmd['task'], cmd['tuple'])","def read_file(self):\n self.write({\"datas\": self.choose_file})\n self._cr.commit()\n import_file = BytesIO(base64.decodestring(self.datas))\n file_read = StringIO(import_file.read().decode())\n reader = csv.DictReader(file_read, delimiter=\",\")\n return reader","def _getH5File(db):\n if isinstance(db, Database3):\n return db.h5db\n else:\n raise TypeError(\"Unsupported Database type ({})!\".format(type(db)))","def getRef(self):\n rnam = self.rnam\n if not rnam or rnam.data == chr(255)*4: return None\n if rnam.size != 4: raise Tes3Error(self.inName,_('SCPT.RNAM'),rnam.size,4,True)\n iMod = struct.unpack('3xB',rnam.data)[0]\n iObj = struct.unpack('i',rnam.data[:3]+'\\x00')[0]\n return (iMod,iObj)","def parseIntoDB(self, filehandle, cursor, alignTab, sequenceTab=None,\n update=None):\n c = filehandle.tell()\n filehandle.seek(0, 2)\n filesize = filehandle.tell()\n filehandle.seek(c)\n l = filehandle.readline()\n rc = 0\n count = 0\n if l.split()[0] != '##maf':\n return\n else:\n self.setpar(l.split()[1:])\n\n l=filehandle.readline()\n while l:\n la = l.split()\n## print la\n if(len(la)==0 or la[0]=='#'):\n## print \"skipping\"\n 1\n elif(la[0]=='a'):\n## print \"reading alignment\"\n count+=1\n self.readalign(la[1:], filehandle)\n self._dump(alignTab, sequenceTab)\n if(update and not count % 1000):\n cursor.execute(update % (int(filehandle.tell() * 100.\n / filesize)))\n else:\n## print \"end of records\"\n return\n l=filehandle.readline()","def info(dump_alloc_table: bytes, /) -> None:","def readfile(file, sub_im, cr):\n\n root, ext = os.path.splitext(file)\n\n if ext == '.tif':\n print('Reading tiff image:', file)\n par = readpar(root + '.mli.par')\n data = readtiff(file, sub_im, cr)\n\n else: # must be GAMMA flat binary float format\n print('Reading flat binary image', file)\n par = readpar(root + ext + '.par')\n data = readmli(file, par, sub_im, cr)\n\n # extract relevant metadata\n rho_r = float(par['range_pixel_spacing'].split()[0])\n rho_a = float(par['azimuth_pixel_spacing'].split()[0])\n theta = float(par['incidence_angle'].split()[0])\n\n return data, rho_r, rho_a, theta","def _get_table_info(self):\n highestbet = self.highestBetNotFold(),\n bigb =self.bigBlind() if self._game_state == GAME_STATE_PRE_FLOP and not self.inSmallBlindPosition() else 0\n return [\"blinds: small:%r big:%r\" % (self.small_blind, self.big_blind),\n \"buy_ins: min:%r max:%r\" % (self.min_buy_in, self.max_buy_in),\n \"bs: %r\" % self.betting_structure,\n \"highestbet = %r\" % highestbet,\n \"bigb = %r\" % bigb,]","def get_mediafile_blob_data(self, old):\n if old[\"is_directory\"]:\n return None\n\n try:\n db_mediafile = Mediafile.objects.get(pk=old[\"id\"])\n except Mediafile.DoesNotExist:\n return None\n filename = db_mediafile.original_filename\n\n if use_mediafile_database:\n with connections[\"mediafiles\"].cursor() as cursor:\n cursor.execute(\n f\"SELECT data FROM {mediafile_database_tablename} WHERE id = %s\",\n [old[\"id\"]],\n )\n row = cursor.fetchone()\n if row is None:\n return None\n data = row[0]\n else:\n data = db_mediafile.mediafile.open().read()\n\n blob = base64.b64encode(data).decode(\"utf-8\")\n return filename, len(data), blob","def read_syn_data():\n dipy_home = pjoin(os.path.expanduser('~'), '.dipy')\n folder = pjoin(dipy_home, 'syn_test')\n t1_name = pjoin(folder, 't1.nii.gz')\n b0_name = pjoin(folder, 'b0.nii.gz')\n\n md5_dict = {'t1': '701bda02bb769655c7d4a9b1df2b73a6',\n 'b0': 'e4b741f0c77b6039e67abb2885c97a78'}\n\n check_md5(t1_name, md5_dict['t1'])\n check_md5(b0_name, md5_dict['b0'])\n\n t1 = nib.load(t1_name)\n b0 = nib.load(b0_name)\n return t1, b0","def retrieve_secondary_file(self, src: str) -> tuple:\n if src.find(\"http://\") != -1:\n # location is on other server\n uri, file = HttpClient.get_remote_uri_and_filename(src)\n print(\"[CONNECTION] starting new client to retrieve an image\")\n new_client = HttpClient()\n new_client.main()\n\n http_command = new_client.create_secondary_http_command(file)\n loc = HttpClient.create_file_location(file)\n new_client.send(http_command)\n recv_raw = new_client.recv_all_data()\n new_client.disconnect()\n else:\n # location is on same server\n\n http_command = self.create_secondary_http_command(src)\n loc = HttpClient.create_file_location(src)\n self.send(http_command)\n recv_raw = self.recv_all_data()\n\n return loc, recv_raw","def read(self, with_holdout_split: bool = False) -> Union['DataFrame', Tuple['DataFrame', 'DataFrame']]:\n pass","def __get_file_chunk(self, buf=1000):\n data = self.file.read(buf)\n return data, len(data)","def get_block(handle, offset=0):\n\n if isinstance(handle, bamnostic.core.AlignmentFile):\n handle = handle._handle\n with open(handle.name, 'rb') as header_handle:\n header_handle.seek(offset) # get to the start of the BGZF block\n\n # Capture raw bytes of metadata header\n _, meta_raw = _bgzf_metaheader(header_handle)\n\n BSIZE_raw = header_handle.read(2)\n BSIZE = struct.unpack('<H', BSIZE_raw)[0]\n\n # capture the CRC32 and ISIZE fields in addition to compressed data\n # 6 = XLEN, 19 = spec offset, 8 = CRC32 & ISIZE -> -5\n block_tail = header_handle.read(BSIZE - 5)\n return meta_raw + BSIZE_raw + block_tail","def _genome_info_tuple(self, name, size=False):\n accession = self.assembly_accession(name)\n taxid = self.genome_taxid(name)\n annotations = bool(self.annotation_links(name))\n species = self.genomes[name].get(\"scientific_name\")\n other = self.genomes[name].get(\"genebuild\")\n if size:\n length = self.genomes[name][\"base_count\"]\n return name, accession, taxid, annotations, species, length, other\n return name, accession, taxid, annotations, species, other","def request_file(self, path: str, token: str) -> Tuple[IO[bytes], dict]:\n response = self.request('get', path, token, stream=True)\n stream = ReadWrapper(response.iter_content,\n int(response.headers['Content-Length']))\n return stream, response.headers","def read_table(self, table_type):\n\n if table_type == 'hash':\n entry_class = MPQHashTableEntry\n elif table_type == 'block':\n entry_class = MPQBlockTableEntry\n else:\n raise ValueError(\"Invalid table type.\")\n\n table_offset = self.header['%s_table_offset' % table_type]\n table_entries = self.header['%s_table_entries' % table_type]\n key = self._hash('(%s table)' % table_type, 'TABLE')\n\n self.file.seek(table_offset + self.header['offset'])\n data = self.file.read(table_entries * 16)\n data = self._decrypt(data, key)\n\n def unpack_entry(position):\n entry_data = data[position*16:position*16+16]\n return entry_class._make(\n struct.unpack(entry_class.struct_format, entry_data))\n\n return [unpack_entry(i) for i in range(table_entries)]","def readSeq(seqFile):\n line = seqFile.readline()\n seq1 = line.rstrip()\n line = seqFile.readline()\n seq2 = line.rstrip()\n return (seq1, seq2)"],"string":"[\n \"def get_file(self) -> tuple:\\r\\n hash_md5 = hashlib.md5()\\r\\n with open(self.yara_base_file, \\\"rb\\\") as f:\\r\\n file_map = f.read()\\r\\n get_file_dict = get_matches(self, file_map)\\r\\n hash_md5.update(file_map)\\r\\n return hash_md5.hexdigest(), get_file_dict\",\n \"def __enter__(self) -> Tuple[FileObj]:\\n file_obj: FileObj = []\\n for obj in self.__dict__.values():\\n if hasattr(obj, 'close'):\\n file_obj.append(obj)\\n return tuple(file_obj)\",\n \"def md5_tuple(file_path):\\n return file_path, md5_hash(file_path)\",\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 readFileTable(f, header):\\n version, dataOffset, archiveFileCount, fileTableLength, endianness, fileCount = header\\n \\n def readFileRecords(f):\\n for i in range(fileCount):\\n recordBytes = f.read(FILE_RECORD_LENGTH)\\n path, offset, size, endianness, archiveFileIndex = struct.unpack(\\\"<256sLLLL\\\", recordBytes)\\n path, _ = path.decode('ascii').split(\\\"\\\\0\\\", 1)\\n yield (path, offset, size, endianness, archiveFileIndex)\\n \\n return list(readFileRecords(f))\",\n \"def read(filename):\\n with open(filename, 'rb') as filehandle:\\n header = read_header(filehandle)\\n data = read_data(header, filehandle, filename)\\n return (data, header)\",\n \"def get_file_contents(db_cursor):\\n\\n db_cursor.execute(\\\"\\\"\\\"SELECT * FROM data\\\"\\\"\\\")\\n db_rows = db_cursor.fetchall()\\n return {row[0]: row[1] for row in db_rows if row != []}\",\n \"def open_db(self):\\n # if it is not open, open it.\\n if self.h5file.isopen is True:\\n return self.h5file\\n else:\\n self.h5file = tb.open_file(filename=self.filepath, mode='a')\\n assert self.h5file.isopen\\n return self.h5file\",\n \"def c_open(file):\\n data = cassy.CassyDaten(file)\\n t = data.messung(1).datenreihe(\\\"t\\\").werte\\n I = data.messung(1).datenreihe(\\\"I_A2\\\").werte\\n U = data.messung(1).datenreihe(\\\"U_B2\\\").werte\\n return t, U, I\",\n \"def getBiomData(self, data):\\r\\n try:\\r\\n if isfile(data):\\r\\n otu_table = parse_biom_table(qiime_open(data, 'U'))\\r\\n return otu_table\\r\\n except TypeError:\\r\\n if any([type(data) in\\r\\n [DenseFunctionTable,\\r\\n DenseGeneTable,\\r\\n DenseMetaboliteTable,\\r\\n DenseOTUTable,\\r\\n DenseOrthologTable,\\r\\n DensePathwayTable,\\r\\n DenseTable,\\r\\n DenseTaxonTable,\\r\\n FunctionTable,\\r\\n GeneTable,\\r\\n MetaboliteTable,\\r\\n OTUTable,\\r\\n OrthologTable,\\r\\n PathwayTable,\\r\\n SparseFunctionTable,\\r\\n SparseGeneTable,\\r\\n SparseMetaboliteTable,\\r\\n SparseOTUTable,\\r\\n SparseOrthologTable,\\r\\n SparsePathwayTable,\\r\\n SparseTable,\\r\\n SparseTaxonTable]]):\\r\\n otu_table = data\\r\\n return otu_table\\r\\n else:\\r\\n raise TypeError('Data is neither a path to a biom table or a' +\\r\\n ' biom table object.')\",\n \"def read(self) -> Tuple[Level, Any]:\\n with DFReader(open(self.fullpath, \\\"rb\\\")) as reader:\\n dflevel, region_offsets = reader.read_level_ex()\\n region_data = reader.read_bytes(region_offsets[-1])\\n return dflevel, (region_offsets, region_data)\",\n \"def _get_file(self, path: str) -> Tuple[str, bytes]:\\n self._trace(\\\"fetching: %s\\\" % path)\\n meta, resp = self._connection.files_download(path)\\n return (meta.rev, resp.content)\",\n \"def content_md5(self):\\n with self.open() as fileobj:\\n return get_content_md5(fileobj)\",\n \"def file_info(self, f):\\n ld8 = self.ld8_extract(f) # get luna_date\\n sid = self.sesid(ld8) # make luna_visitnum\\n age = self.age_lookup.get(sid)\\n return (sid, age)\",\n \"def open_db(filename: str) -> Tuple[sqlite3.Connection, sqlite3.Cursor]:\\n db_connection = sqlite3.connect(filename) # Create or connect to DB\\n cursor = db_connection.cursor() # Read/write data\\n return db_connection, cursor\",\n \"def read(self, *args) -> \\\"PyObject *\\\":\\n return _ida_fpro.qfile_t_read(self, *args)\",\n \"def get_info(curf, begin, read, param_of_unpack):\\n curf.seek(begin)\\n info = curf.read(read)\\n info = struct.unpack(param_of_unpack, info)\\n return str(info[0])\",\n \"def read_relations(db, openfile):\\n pass\",\n \"def get_contents_hash(self):\\n md5 = hashlib.md5()\\n with closing(self.open()) as handle:\\n for chunk in handle.chunks():\\n md5.update(chunk)\\n return md5.hexdigest()\",\n \"def get_fp(self, *args) -> \\\"FILE *\\\":\\n return _ida_fpro.qfile_t_get_fp(self, *args)\",\n \"def get_aligned(database):\\n conn = sqlite3.connect(database, check_same_thread=False)\\n cur = conn.cursor()\\n data = cur.execute('SELECT `header`, `aligned` FROM SEQUENCES;').fetchall()\\n for h, s in data:\\n yield h, s\",\n \"def totuple(self):\\n return (self.pageid, self.filename, self.uploader, self.width,\\n self.height, self.size, self.quality_image,\\n self.featured_picture, self.valued_image, self.timestamp)\",\n \"def get_data(self, path, owner='*'):\\n sql = sa.select([history.c.data, history.c.content_type]).select_from(sa.join(history, active)).where(active.c.path == path)\\n result = self.engine.execute(sql).first()\\n if result:\\n data, ctype = result\\n if ctype == 'application/msgpack':\\n import msgpack\\n return msgpack.unpackb(data, encoding='utf8')\\n else:\\n return data, ctype\",\n \"def read_stock(db, openfile):\\n pass\",\n \"def file_entry(file_path: str) -> Tuple[str, Any, str]:\\n file_name = os.path.split(file_path)[1]\\n file_handler = open(file_path, \\\"rb\\\")\\n content_type = \\\"application/octet-stream\\\"\\n\\n return (file_name, file_handler, content_type)\",\n \"def getTuple(n,type=\\\"R\\\",thing = \\\"T\\\"):\\r\\n if type == \\\"R\\\":\\r\\n n=n+\\\".root\\\"\\r\\n print \\\"getting file \\\"+n\\r\\n \\r\\n file=TFile(n)\\r\\n t=file.Get(thing)\\r\\n if type==\\\"X\\\":\\r\\n translate(n)\\r\\n t,file=getTuple(n,\\\"R\\\")\\r\\n return t,file\",\n \"def get_content(self):\\n filestream = StringIO()\\n\\n tableName, primKey = self.provider._split_path(self.path)\\n if primKey is not None:\\n conn = self.provider._init_connection()\\n listFields = self.provider._get_field_list(conn, tableName)\\n csvwriter = csv.DictWriter(filestream, listFields, extrasaction=\\\"ignore\\\")\\n dictFields = {}\\n for field_name in listFields:\\n dictFields[field_name] = field_name\\n csvwriter.writerow(dictFields)\\n\\n if primKey == \\\"_ENTIRE_CONTENTS\\\":\\n cursor = conn.cursor(MySQLdb.cursors.DictCursor)\\n cursor.execute(\\\"SELECT * from \\\" + self.provider._db + \\\".\\\" + tableName)\\n result_set = cursor.fetchall()\\n for row in result_set:\\n csvwriter.writerow(row)\\n cursor.close()\\n else:\\n row = self.provider._get_record_by_primary_key(conn, tableName, primKey)\\n if row is not None:\\n csvwriter.writerow(row)\\n conn.close()\\n\\n # this suffices for small dbs, but\\n # for a production big database, I imagine you would have a FileMixin that\\n # does the retrieving and population even as the file object is being read\\n filestream.seek(0)\\n return filestream\",\n \"def open_input(self, fn):\\n\\treturn (None, None)\",\n \"def enumerate_files(self, table):\\n for i in range(self.nrofrecords()):\\n data = self.bank.readrec(i + 1)\\n if data and data[0] == table.tableid:\\n yield i + 1, data[1:]\",\n \"def data(self) -> Tuple[List[str], List[List[str]]]:\\n format = self.format\\n # Check if the file contains header information. Initialize the header\\n # with the optional names of columns in the format descriptor.\\n has_header = format.get('header', True)\\n columns = format.get('columns')\\n rows = list()\\n # Delimiter depends on the file format.\\n delim = '\\\\t' if format['type'] == 'tsv' else ','\\n f = codecs.iterdecode(self.load().open(), 'utf-8')\\n for row in csv.reader(f, delimiter=delim):\\n if has_header:\\n # Set the has_header flag to False so that all following records\\n # are added to the list of rows.\\n has_header = False\\n columns = row if columns is None else columns\\n else:\\n rows.append(row)\\n columns = [None] * len(rows[0]) if not columns and rows else columns\\n return (columns, rows)\",\n \"def _get_file_helper(self):\\n page = self.course.moodle.fetch(\\n self._download_url % self.id,\\n None\\n )\\n # The resource URL should magically 303 across to the actual file\\n if page.history and page.history[0].status_code == 303:\\n return page, page.content\\n\\n # If it doesn't 303 to the actual file then there might be a download\\n # link to try\\n bs = bs4.BeautifulSoup(page.text, 'lxml')\\n\\n div = bs.find('div', class_='resourceworkaround')\\n\\n if div: # it's a link to the resource\\n link = div.find('a').href\\n\\n page = self.course.moodle.fetch(\\n link,\\n None\\n )\\n return page, page.content\\n\\n # Perhaps it's an embedded object\\n obj = bs.find('object', id='resourceobject')\\n if obj:\\n link = obj['data']\\n\\n page = self.course.moodle.fetch(\\n link,\\n None\\n )\\n return page, page.content\\n\\n raise ValueError(\\\"No idea how to get that resource\\\")\",\n \"def _open_read(self, existing_file_obj=None):\\n # Use explicit file handle, if given.\\n if existing_file_obj is not None:\\n yield existing_file_obj\\n\\n # Use a file handle being actively used for writes, if available.\\n # There is some danger to doing this because reads will seek the\\n # file. However, revlog._writeentry performs a SEEK_END before all\\n # writes, so we should be safe.\\n elif self.writing_handle:\\n yield self.writing_handle\\n\\n elif self.reading_handle:\\n yield self.reading_handle\\n\\n # Otherwise open a new file handle.\\n else:\\n with self._open() as fp:\\n yield fp\",\n \"def get_cursor(file_name):\\n con = lite.connect(file_name)\\n con.row_factory = lite.Row\\n return con.cursor()\",\n \"def iterRegularFileContents(self):\\n unpack = {}\\n for (oldFileId, newFileId), stream in self.files.iteritems():\\n if not files.frozenFileHasContents(stream):\\n continue\\n if files.frozenFileFlags(stream).isEncapsulatedContent():\\n continue\\n cont = files.frozenFileContentInfo(stream)\\n unpack[newFileId] = cont.sha1()\\n\\n want_tag = '0 ' + ChangedFileTypes.file[4:]\\n while True:\\n f = self._nextFile()\\n if not f:\\n break\\n name, tag, fobj, csf = f\\n if len(name) != 36 or tag != want_tag:\\n continue\\n fileId = name[16:]\\n sha1 = unpack.get(fileId)\\n if not sha1:\\n continue\\n yield sha1, fobj\",\n \"def get_content(self, file_path: str) -> Tuple[defaultdict, str]:\\n if not os.path.exists(file_path): # If file doesn't exist\\n raise FileNotFoundError(f\\\"{fg(1)} Could not find file: {file_path}{fg(15)}\\\\n\\\")\\n html = self.__html__(file_path)\\n metadata = self.__metadata__()\\n return metadata, html\",\n \"def to_workbook(self) -> tuple:\\n\\n # Initialize the bytestream\\n f = io.BytesIO()\\n wb = xw.Workbook(f, {\\\"in_memory\\\": True})\\n\\n # Open a workbook\\n self._book = wb\\n self._book.set_properties({\\\"category\\\": \\\"atomica:databook\\\"})\\n self._formats = standard_formats(self._book)\\n self._references = {} # Reset the references dict\\n\\n # Write the contents\\n self._write_pops()\\n self._write_tdve()\\n self._write_interpops()\\n self._write_transfers()\\n\\n # Clean internal variables related to writing the worbkook\\n self._book = None\\n self._formats = None\\n self._references = None\\n\\n return f, wb\",\n \"async def __getinfo(self) -> tuple:\\n\\n async with self.session.get(\\n self.url,\\n allow_redirects=True\\n\\n ) as response:\\n # print(response)\\n\\n # Use redirected URL\\n self.url = str(response.url)\\n try:\\n content_disposition = cgi.parse_header(\\n response.headers['Content-Disposition'])\\n filename = content_disposition[1]['filename']\\n filename = urllib.parse.unquote_plus(filename)\\n except KeyError:\\n filename = response._real_url.name\\n\\n if not filename:\\n guessed_extension = mimetypes.guess_extension(\\n response.headers[\\\"Content-Type\\\"].split(\\\";\\\")[0])\\n filename = f\\\"{gen_uuid(size=5)}{guessed_extension}\\\"\\n\\n try:\\n size = int(response.headers['Content-Length'])\\n except KeyError:\\n size = 0\\n return (\\n filename,\\n size,\\n response.headers['Content-Type'],\\n response._real_url\\n )\",\n \"def _filehandle(self):\\n if not self._fh or self._is_closed():\\n filename = self._rotated_logfile or self.filename\\n if filename.endswith('.gz'):\\n self._fh = gzip.open(filename, 'r')\\n else:\\n self._fh = open(filename, \\\"r\\\", 1)\\n self._fh.seek(self._offset)\\n\\n return self._fh\",\n \"def _get_db_connection():\\n conn = sqlite3.connect(str(DB_FILE_PATH))\\n c = conn.cursor()\\n\\n return conn, c\",\n \"def get_tpm_blobs(\\n self, path: Union[bytes, str]\\n ) -> Tuple[TPM2B_PUBLIC, TPM2B_PRIVATE, str]:\\n path = _to_bytes_or_null(path)\\n tpm_2b_public = ffi.new(\\\"uint8_t **\\\")\\n tpm_2b_public_size = ffi.new(\\\"size_t *\\\")\\n tpm_2b_private = ffi.new(\\\"uint8_t **\\\")\\n tpm_2b_private_size = ffi.new(\\\"size_t *\\\")\\n policy = ffi.new(\\\"char **\\\")\\n ret = lib.Fapi_GetTpmBlobs(\\n self._ctx,\\n path,\\n tpm_2b_public,\\n tpm_2b_public_size,\\n tpm_2b_private,\\n tpm_2b_private_size,\\n policy,\\n )\\n _chkrc(ret)\\n\\n policy_str = ffi.string(policy[0]).decode(self.encoding)\\n\\n tpm_2b_public_buffer = bytes(\\n ffi.buffer(tpm_2b_public[0], tpm_2b_public_size[0])\\n )\\n tpm_2b_public_unmarsh, _ = TPM2B_PUBLIC.unmarshal(tpm_2b_public_buffer)\\n\\n tpm_2b_private_buffer = bytes(\\n ffi.buffer(tpm_2b_private[0], tpm_2b_private_size[0])\\n )\\n tpm_2b_private_unmarsh, _ = TPM2B_PRIVATE.unmarshal(tpm_2b_private_buffer)\\n\\n return (\\n tpm_2b_public_unmarsh,\\n tpm_2b_private_unmarsh,\\n policy_str,\\n )\",\n \"def _hash_file(self, file_entry):\\n if file_entry is None:\\n return None\\n\\n if file_entry.IsDevice() or file_entry.IsPipe() or file_entry.IsSocket():\\n # Ignore devices, FIFOs/pipes and sockets.\\n return None\\n\\n hash_context = hashlib.sha256()\\n\\n try:\\n file_object = file_entry.GetFileObject()\\n except IOError as exception:\\n logging.warning((\\n 'Unable to open path specification:\\\\n{0:s}'\\n 'with error: {1!s}').format(file_entry.path_spec.location, exception))\\n return None\\n\\n if not file_object:\\n return None\\n\\n try:\\n data = file_object.read(self._READ_BUFFER_SIZE)\\n while data:\\n hash_context.update(data)\\n data = file_object.read(self._READ_BUFFER_SIZE)\\n except IOError as exception:\\n logging.warning((\\n 'Unable to read from path specification:\\\\n{0:s}'\\n 'with error: {1!s}').format(file_entry.path_spec.location, exception))\\n return None\\n\\n return hash_context.hexdigest()\",\n \"def load_biom_table(table_f):\\n return parse_biom_table(table_f)\",\n \"def open_image_and_meta(image_bytes):\\n with MemoryFile(image_bytes) as memfile:\\n with memfile.open() as src:\\n meta = src.meta\\n arr = reshape_as_image(src.read())\\n return arr, meta\",\n \"def _open_sql_file(dbname):\\n try:\\n dbpath = pathlib.Path(dbname).resolve()\\n conn = sqlite3.connect(f\\\"{dbpath.as_uri()}?mode=ro\\\", timeout=1, uri=True)\\n c = conn.cursor()\\n except sqlite3.Error as e:\\n sys.exit(f\\\"An error occurred opening sqlite file: {e.args[0]} {dbname}\\\")\\n return (conn, c)\",\n \"def _read_lengths(self):\\n\\n stream = self.stream\\n stream.seek(0)\\n\\n ###########\\n # Read and set table lengths\\n self.table_lengths = [None]*len(tables)\\n\\n (self.entire_file_length,\\n header_length,\\n self.smallest_character_code,\\n self.largest_character_code) = repeat_call(stream.read_unsigned_byte2, 4)\\n\\n header_data_length_min = 18 # words\\n self.table_lengths[tables.header] = max(\\n header_data_length_min, header_length)\\n\\n self.number_of_chars = self.largest_character_code - \\\\\\n self.smallest_character_code + 1\\n self.table_lengths[tables.character_info] = self.number_of_chars\\n\\n # read the last lengths\\n for i in range(tables.width, len(tables)):\\n self.table_lengths[i] = stream.read_unsigned_byte2()\\n\\n ###########\\n # Compute table pointers\\n self.table_pointers = [None]*len(tables)\\n\\n # The header starts at 24 bytes\\n self.table_pointers[tables.header] = 24\\n\\n for table in range(tables.header, tables.font_parameter):\\n self.table_pointers[\\n table+1] = self._position_in_table(table, self.table_lengths[table])\\n\\n ###########\\n # Sanity check\\n length = self._position_in_table(\\n tables.font_parameter, self.table_lengths[tables.font_parameter])\\n if length != self.word_ptr(0, self.entire_file_length):\\n raise NameError('Bad TFM file')\",\n \"def read_opsim_db(opsim_db_path='/global/projecta/projectdirs/lsst/groups/SSim/DC2/minion_1016_desc_dithered_v4.db'):\\n conn = sqlite3.connect(opsim_db_path)\\n # Check the table names\\n cursor = conn.cursor()\\n cursor.execute(\\\"SELECT name FROM sqlite_master WHERE type='table';\\\")\\n table_names = cursor.fetchall()\\n print(table_names)\\n # Turn table into Pandas df\\n obs_history = pd.read_sql(sql=\\\"SELECT * from ObsHistory\\\", con=conn, index_col=None)\\n field = pd.read_sql(sql=\\\"SELECT * from Field\\\", con=conn, index_col=None)\\n return obs_history, field\",\n \"def info(self, fp):\\n keys = (\\n (\\\"cas.meta.compression\\\", CAS._convert_meta),\\n (\\\"cas.meta.lib\\\", CAS._convert_meta),\\n (\\\"cas.meta.fp_algo\\\", CAS._convert_meta),\\n (\\\"cas.meta.orig_size\\\", CAS._convert_meta),\\n (\\\"cas.refcount\\\", CAS._convert_refcount),\\n )\\n\\n return {key: conv(self.ioctx.get_xattr(fp, key))\\n for key, conv in keys}\",\n \"def read(self):\\n self.connect()\\n get_books = f\\\"select * from {self.book_table}\\\"\\n try:\\n self.cur.execute(get_books)\\n self.con.commit()\\n for i in self.cur:\\n yield i\\n except MySQLError as err:\\n messagebox.showinfo(\\\"Failed to fetch files from database\\\")\\n print(err)\",\n \"def fileobject_to_dict(fo):\\n if fo.allocated():\\n # proc = subprocess.Popen(['./extract_strings', fo.inode()], stdout=subprocess.PIPE)\\n # contents = proc.stdout.read()\\n return {\\n 'atime_dt': epoch_to_dt(fo.atime()),\\n 'compressed_b': fo.compressed(),\\n 'contents_t': string.translate(fo.contents(), filter),\\n 'contents_display': string.translate(fo.contents(), filter),\\n 'crtime_dt': epoch_to_dt(fo.crtime()),\\n 'ctime_dt': epoch_to_dt(fo.ctime()),\\n 'dtime_dt': epoch_to_dt(fo.dtime()),\\n 'encrypted_b': fo.encrypted(),\\n 'extension_facet': fo.ext(),\\n 'fileid_i': int(fo._tags['id']),\\n 'filename_display': fo.filename(),\\n 'filename_t': fo.filename(),\\n 'filesize_l': long(fo.filesize()),\\n 'fragments_i': int(fo.fragments()),\\n 'gid_i': int(fo._tags['gid']),\\n #'id': uuid.uuid4(),\\n 'id': hashlib.sha1(os.path.basename(IMAGE) + '_' + fo.inode()).hexdigest(),\\n #'imagefile': fo._tags['imagefile'],\\n 'inode_i': int(fo.inode()),\\n 'libmagic_display': fo.libmagic(),\\n 'libmagic_facet': fo.libmagic(),\\n 'md5_s': fo.md5(),\\n 'meta_type_i': fo._tags['meta_type'],\\n 'mode_facet': int(fo._tags['mode']),\\n 'mode_i': int(fo._tags['mode']),\\n 'mtime_dt': epoch_to_dt(fo.mtime()),\\n 'nlink_i': fo._tags['nlink'],\\n 'name_type_s': fo.name_type(),\\n 'partition_i': int(fo.partition()),\\n 'sha1_s': fo.sha1(),\\n 'uid_i': int(fo._tags['uid']),\\n 'volume_display': IMAGE,\\n 'volume_facet': os.path.basename(IMAGE)\\n }\\n else:\\n return None\",\n \"def get_two_stock_data():\\n ticker1, ticker2 = 'INTC', 'AAPL'\\n\\n file1 = cbook.get_sample_data('INTC.dat.gz')\\n file2 = cbook.get_sample_data('AAPL.dat.gz')\\n M1 = fromstring(file1.read(), '<d')\\n\\n M1 = resize(M1, (M1.shape[0]//2, 2))\\n\\n M2 = fromstring(file2.read(), '<d')\\n M2 = resize(M2, (M2.shape[0]//2, 2))\\n\\n d1, p1 = M1[:, 0], M1[:, 1]\\n d2, p2 = M2[:, 0], M2[:, 1]\\n return (d1, p1, d2, p2)\",\n \"def read(self):\\n return self.frame, self.boundary_lines\",\n \"def getTiffAsMatrix(kv):\\n file_name = kv[0].split('/')[-1]\\n fbinary = kv[1]\\n tiffmat = getOrthoTif(fbinary)\\n return (file_name,tiffmat)\",\n \"def _getConnection():\\n db = sqlite.connect(db_path)\\n db.row_factory = sqlite.Row\\n cursor = db.cursor()\\n return cursor, db\",\n \"def get_connection_info(otu_table_fp, num_meta, meta_dict):\\r\\n con_by_sample = defaultdict(set)\\r\\n node_file = []\\r\\n edge_file = []\\r\\n red_nodes = defaultdict(int)\\r\\n red_node_file = []\\r\\n red_edge_file = []\\r\\n multi = defaultdict(list)\\r\\n edge_from = []\\r\\n to = []\\r\\n otu_dc = defaultdict(int)\\r\\n degree_counts = defaultdict(int)\\r\\n sample_dc = defaultdict(int)\\r\\n sample_num_seq = defaultdict(int)\\r\\n con_list = []\\r\\n\\r\\n otu_table = parse_biom_table(open(otu_table_fp, 'U'))\\r\\n\\r\\n # if lineages == []:\\r\\n # is_con = False\\r\\n # else:\\r\\n # is_con = True\\r\\n\\r\\n is_con = False\\r\\n # This could be moved to OTU table sub-class\\r\\n if (otu_table.ObservationMetadata is not None and\\r\\n 'taxonomy' in otu_table.ObservationMetadata[0]):\\r\\n is_con = True\\r\\n\\r\\n for (otu_values, otu_id, otu_metadata) in otu_table.iterObservations():\\r\\n # for idx,l in enumerate(otu_table):\\r\\n # data = l\\r\\n\\r\\n #to_otu = otu_ids[idx]\\r\\n con = ''\\r\\n if is_con:\\r\\n #con = ':'.join(lineages[idx][:6])\\r\\n con = ':'.join(otu_metadata['taxonomy'][:6])\\r\\n con = con.replace(\\\" \\\", \\\"_\\\")\\r\\n con = con.replace(\\\"\\\\t\\\", \\\"_\\\")\\r\\n # Not required: otu_values (data) is always numpy vector\\r\\n #counts = map(float,data)\\r\\n if con not in con_list:\\r\\n con_list.append(con)\\r\\n #non_zero_counts = nonzero(counts)[0]\\r\\n non_zero_counts = otu_values.nonzero()[0]\\r\\n degree = len(non_zero_counts)\\r\\n weighted_degree = sum(otu_values)\\r\\n# node_file_line = [to_otu,'','otu_node',str(degree),\\\\\\r\\n# str(weighted_degree),con]\\r\\n node_file_line = [otu_id, '', 'otu_node', str(degree),\\r\\n str(weighted_degree), con]\\r\\n node_file_line.extend(['otu'] * num_meta)\\r\\n node_file.append('\\\\t'.join(node_file_line))\\r\\n\\r\\n if len(non_zero_counts) != 1:\\r\\n red_node_file.append('\\\\t'.join(node_file_line))\\r\\n\\r\\n otu_dc[degree] += 1\\r\\n degree_counts[degree] += 1\\r\\n #samples = [sample_ids[i] for i in non_zero_counts]\\r\\n samples = [otu_table.SampleIds[i] for i in non_zero_counts]\\r\\n for i, s in enumerate(samples):\\r\\n if s not in meta_dict.keys():\\r\\n continue\\r\\n con_by_sample[s].update(samples[0:i])\\r\\n con_by_sample[s].update(samples[i + 1:])\\r\\n #sample_num_seq[s] += float(data[non_zero_counts[i]])\\r\\n sample_num_seq[s] += float(otu_values[non_zero_counts[i]])\\r\\n\\r\\n edge_from.append(s)\\r\\n # to.append(to_otu)\\r\\n to.append(otu_id)\\r\\n meta = meta_dict[s]\\r\\n meta[1] += 1\\r\\n #data_num = str(data[non_zero_counts[i]])\\r\\n data_num = str(otu_values[non_zero_counts[i]])\\r\\n # edge_file.append('\\\\t'.join([s, to_otu, \\\\\\r\\n # data_num, con, meta[0]]))\\r\\n edge_file.append('\\\\t'.join([s, otu_id,\\r\\n data_num, con, meta[0]]))\\r\\n #multi[to_otu].append((s,float(data[non_zero_counts[i]]), meta[0]))\\r\\n multi[otu_id].append(\\r\\n (s, float(otu_values[non_zero_counts[i]]), meta[0]))\\r\\n if len(non_zero_counts) == 1:\\r\\n #red_nodes[(sample_ids[non_zero_counts[0]],meta[0])] += degree\\r\\n red_nodes[(\\r\\n otu_table.SampleIds[non_zero_counts[0]],\\r\\n meta[0])] += degree\\r\\n else:\\r\\n # red_edge_file.append('\\\\t'.join([s, to_otu, \\\\\\r\\n # data_num, con, meta[0]]))\\r\\n red_edge_file.append('\\\\t'.join([s, otu_id,\\r\\n data_num, con, meta[0]]))\\r\\n\\r\\n num_otu_nodes = len(node_file)\\r\\n for s in meta_dict:\\r\\n meta = meta_dict[s]\\r\\n degree = meta[1]\\r\\n sample_dc[degree] += 1\\r\\n degree_counts[degree] += 1\\r\\n weighted_degree = sample_num_seq[s]\\r\\n node_file_line = '\\\\t'.join([s, s, 'user_node', str(meta[1]),\\r\\n str(weighted_degree), 'other', meta[0]])\\r\\n node_file.append(node_file_line)\\r\\n red_node_file.append(node_file_line)\\r\\n\\r\\n for n, d in red_nodes.items():\\r\\n red_node_file_line = ['@' + n[0], '',\\r\\n 'otu_collapsed', str(d), str(float(d)), 'other']\\r\\n red_node_file_line.extend(['otu'] * num_meta)\\r\\n red_node_file.append('\\\\t'.join(red_node_file_line))\\r\\n red_edge_file.append(\\r\\n '\\\\t'.join([n[0], '@' + n[0], \\\"1.0\\\", \\\"missed\\\", n[1]]))\\r\\n\\r\\n return con_by_sample, node_file, edge_file, red_node_file,\\\\\\r\\n red_edge_file, otu_dc, degree_counts, sample_dc\",\n \"def check_file(f, open_close_pairs):\\n\\n opens = {}\\n closes = {}\\n open_for = {}\\n for open_symbol, close_symbol in open_close_pairs:\\n opens[open_symbol] = []\\n open_for[close_symbol] = opens[open_symbol]\\n closes[close_symbol] = []\\n\\n line_number = 0\\n for line in f:\\n line_number += 1\\n column = 0\\n for sym in line:\\n column += 1\\n if sym in opens and open_for.get(sym, None) == opens[sym]:\\n if len(opens[sym]) == 0:\\n opens[sym].append((line_number, column))\\n else:\\n opens[sym].pop()\\n elif sym in opens:\\n opens[sym].append((line_number, column))\\n elif sym in closes:\\n if len(open_for[sym]) > 0:\\n open_for[sym].pop()\\n else:\\n closes[sym].append((line_number, column))\\n\\n return { (o, c) : (opens[o], closes[c]) for o, c in open_close_pairs }\",\n \"def parse(self):\\n # type: () -> Tuple[LineNo, int, LineNo, int]\\n metadata = self.safely_parse_metadata()\\n if len(metadata) > 2:\\n raise UnsupportedCombinedDiff(self.text)\\n assert len(metadata) == 2\\n return tuple(flatten(metadata)) # type: ignore[return-value]\",\n \"def to_tuple(self) -> tuple:\\n return (self.transaction_number, self.date, self.description, self.memo, self.amount_debit,\\n self.amount_credit, self.balance, self.check_number, self.fees, self.card_type,\\n self.is_payment, self.is_transaction, self.user_id)\",\n \"def get_reader(fname):\\n\\n if fname == \\\"-\\\":\\n fh = sys.stdin\\n else:\\n fh = open(fname, \\\"r\\\")\\n \\n rdr = csv.reader(fh, dialect=\\\"psv\\\")\\n return (rdr, fh)\",\n \"def _read(self, item):\\n return read_hdf5(self.file_name, title=self._get_h5_path(item))\",\n \"def snapshot(self):\\n return (self.block_header.state_root, self.chaindb.snapshot())\",\n \"def read_file(self, filename, force_decompress=False):\\n\\n def decompress(data):\\n \\\"\\\"\\\"Read the compression type and decompress file data.\\\"\\\"\\\"\\n compression_type = ord(data[0:1])\\n if compression_type == 0:\\n return data\\n elif compression_type == 2:\\n return zlib.decompress(data[1:], 15)\\n elif compression_type == 16:\\n return bz2.decompress(data[1:])\\n else:\\n msg = \\\"Unsupported compression type: {}\\\".format(compression_type)\\n raise RuntimeError(msg)\\n\\n hash_entry = self.get_hash_table_entry(filename)\\n if hash_entry is None:\\n return None\\n block_entry = self.block_table[hash_entry.block_table_index]\\n\\n # Read the block.\\n if block_entry.flags & MPQ_FILE_EXISTS:\\n if block_entry.archived_size == 0:\\n return None\\n\\n offset = block_entry.offset + self.header['offset']\\n self.file.seek(offset)\\n file_data = self.file.read(block_entry.archived_size)\\n\\n if block_entry.flags & MPQ_FILE_ENCRYPTED:\\n raise NotImplementedError(\\\"Encryption is not supported yet.\\\")\\n\\n if not block_entry.flags & MPQ_FILE_SINGLE_UNIT:\\n # File consists of many sectors. They all need to be\\n # decompressed separately and united.\\n sector_size = 512 << self.header['sector_size_shift']\\n sectors = block_entry.size // sector_size + 1\\n if block_entry.flags & MPQ_FILE_SECTOR_CRC:\\n crc = True\\n sectors += 1\\n else:\\n crc = False\\n positions = struct.unpack('<%dI' % (sectors + 1),\\n file_data[:4*(sectors+1)])\\n result = BytesIO()\\n sector_bytes_left = block_entry.size\\n for i in range(len(positions) - (2 if crc else 1)):\\n sector = file_data[positions[i]:positions[i+1]]\\n if (block_entry.flags & MPQ_FILE_COMPRESS and\\n (force_decompress or sector_bytes_left > len(sector))):\\n sector = decompress(sector)\\n\\n sector_bytes_left -= len(sector)\\n result.write(sector)\\n file_data = result.getvalue()\\n else:\\n # Single unit files only need to be decompressed, but\\n # compression only happens when at least one byte is gained.\\n if (block_entry.flags & MPQ_FILE_COMPRESS and\\n (force_decompress or block_entry.size > block_entry.archived_size)):\\n file_data = decompress(file_data)\\n\\n return file_data\",\n \"def file_loc(self):\\n\\t\\treturn self.__dbfile\",\n \"def openmat(filename, field = None):\\n tmp = []\\n \\n try:\\n \\n data = loadmat(filename)\\n \\n if isinstance(field,(str, np.str)):\\n tmp = data[field]\\n elif isinstance(field, (tuple, list)):\\n \\n for key in data.keys():\\n if '__header__' in key:\\n continue\\n if '__version__' in key:\\n continue\\n if '__globals__' in key:\\n continue\\n \\n if key in field: \\n tmp.append(data[key])\\n else:\\n \\n for key in data.keys():\\n if '__header__' in key:\\n continue\\n if '__version__' in key:\\n continue\\n if '__globals__' in key:\\n continue\\n \\n tmp.append(data[key]) \\n except:\\n \\n read_file = openmat_h5_(filename, field)\\n \\n tmp = read_file.parse()\\n \\n return tmp\",\n \"def close_file_pair(pair):\\n try:\\n yield pair\\n finally:\\n pair[0].close()\\n pair[1].close()\",\n \"def DRI(fp):\\n info = {\\n 'Lr' : unpack('>H', fp.read(2))[0],\\n 'Ri' : unpack('>H', fp.read(2))[0]\\n }\\n\\n return info\",\n \"def hdf5_file_opened(self):\\n should_close = self._hdf5_file is None\\n yield self.hdf5_file\\n if should_close:\\n self.close_and_delete_hdf5_handle()\",\n \"def readbytes(self, *args) -> \\\"PyObject *\\\":\\n return _ida_fpro.qfile_t_readbytes(self, *args)\",\n \"def get_file_object(self):\\n try:\\n # FieldFile.open() and File.open() don't return file objects, so\\n # accessing it directly\\n return self.datafile.file.file # FileStoreItem.FieldFile.File.file\\n except ValueError as exc:\\n logger.error(\\\"Error opening %s: %s\\\", self.datafile, exc)\\n return None\",\n \"def get_pickle(get_file='simbad_mag_errors.pkl'):\\n print \\\"Opening %s and unpickling the DataFrame..\\\" % get_file\\n with open(get_file, 'r') as opened_file:\\n df_unpickled = cPickle.load(opened_file)\\n print \\\"..Done\\\"\\n return df_unpickled\",\n \"def get_content(file1, file2):\\n with open(file1, 'r') as f1, open(file2, 'r') as f2:\\n return [line for line in f1], [line for line in f2]\",\n \"def open_and_read_file(file_path1, file_path2):\\n\\n # your code goes here\\n file_object1 = open(file_path1)\\n file_object2 = open(file_path2)\\n contents = file_object1.read() + \\\" \\\" + file_object2.read()\\n file_object1.close()\\n file_object2.close()\\n\\n return contents\",\n \"def _open_hdf5(self, file_path):\\n\\n if (file_path not in self._file_handles or\\n not self._file_handles[file_path].is_open):\\n self._file_handles[file_path] = pd.HDFStore(file_path, 'r')\\n\\n return self._file_handles[file_path]\",\n \"def read_reduced():\\n ### read in the reduced data\\n reduced_data = parse(join(FILE_PATH, \\\"lm_sm_aggz.gctx\\\"))\\n\\n ### read in the signature info and set the index to the signature id for easy indexing in the next step\\n sig_info = pd.read_csv(join(FILE_PATH, \\\"GSE92742_Broad_LINCS_sig_info.txt\\\"), sep=\\\"\\\\t\\\")\\n sig_info.index = sig_info['sig_id']\\n\\n ### map the columns to the pert_id that generated the signature to allow for comparison in spark\\n reduced_data.data_df.columns = sig_info.loc[pd.Index(reduced_data.data_df.columns)]['pert_id']\\n ### return data_frame with pert_ids in row_major form ready for scala\\n return reduced_data.data_df.transpose()\",\n \"def _get_parsed_files(self):\\n\\n parsed = []\\n with Historical_ROAs_Parsed_Table() as t:\\n for row in t.execute(f'SELECT * FROM {t.name}'):\\n parsed.append(row['file'])\\n return parsed\",\n \"def open_with_size(filename, *args):\\n\\n f = open_(filename, *args)\\n if isinstance(f, gzip.GzipFile):\\n fo = open(f.name, 'rb')\\n fo.seek(-4, 2)\\n r = fo.read()\\n fo.close()\\n return f, struct.unpack('<I', r)[0]\\n else:\\n f.seek(0, os.SEEK_END)\\n buflen = f.tell()\\n f.seek(4, os.SEEK_SET)\\n return f, buflen\",\n \"def connect(sqlite_file):\\n conn = sqlite3.connect(sqlite_file)\\n c = conn.cursor()\\n return conn, c\",\n \"def __openRow(fd):\\n\\n print(\\\" <tr>\\\", file=fd)\",\n \"def tabdes(filename, body):\\n # XXX checksums ignored\\n head = Struct(\\\"!BiHBxxxB\\\")\\n body = Struct(body)\\n # foot = Struct(\\\"!4s\\\")\\n\\n data = []\\n with open(filename, \\\"rb\\\") as f:\\n buffer = f.read()\\n _, _, count, length, _ = head.unpack_from(buffer, 0)\\n offset = head.size\\n for i in range(count):\\n row = body.unpack_from(buffer, offset)\\n data.append(row)\\n offset += body.size\\n else:\\n print(\\\"read %d rows\\\" % len(data))\\n # offset = 2 ** 16 - foot.size\\n # _, foot.unpack_from(buffer, offset))\\n return data\",\n \"def mem_get(bytestring, compressed=True):\\n ff = mem_open(bytestring, compressed)\\n if ff is None:\\n return (None, None)\\n hdr = ff[0].header\\n data = ff[0].data\\n ff.close()\\n return (hdr, data)\",\n \"def loadDb(self,dbContent,base):\\n \\n db = utilities.db2bitarray(dbContent,self.dbSize,1,1,base)\\n db = np.array(db).reshape(self.dbSize,-1)\\n # track the size of each file\\n fileSize = db.shape[-1]\\n \\n return (db,fileSize)\",\n \"def open_file_in_dir(path: str) -> Tuple[io.FileIO, int]:\\n directory = os.path.dirname(path)\\n if not os.path.isdir(directory):\\n raise ValueError('No directory {}'.format(directory))\\n\\n if not os.path.exists(path):\\n file_fd = open(path, mode='x+b', buffering=0)\\n else:\\n file_fd = open(path, mode='r+b', buffering=0)\\n\\n dir_fd = os.open(directory, os.O_RDONLY)\\n\\n return file_fd, dir_fd\",\n \"def ffi_pickle_contents(self) -> Tuple[int, float, float, float,\\n np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:\\n tic_id = 231663901\\n ra = 62.2\\n dec = -71.4\\n tess_magnitude = 10\\n time = np.arange(0, 100, 10)\\n raw_flux = np.arange(10)\\n corrected_flux = np.arange(10, 20)\\n pca_flux = np.arange(20, 30)\\n flux_error = np.arange(0, 1, 0.1)\\n return tic_id, ra, dec, tess_magnitude, time, raw_flux, corrected_flux, pca_flux, flux_error\",\n \"def read_tuple(self):\\n cmd = self.read_command()\\n return StormTuple(\\n cmd['id'], cmd['comp'], cmd['stream'], cmd['task'], cmd['tuple'])\",\n \"def read_file(self):\\n self.write({\\\"datas\\\": self.choose_file})\\n self._cr.commit()\\n import_file = BytesIO(base64.decodestring(self.datas))\\n file_read = StringIO(import_file.read().decode())\\n reader = csv.DictReader(file_read, delimiter=\\\",\\\")\\n return reader\",\n \"def _getH5File(db):\\n if isinstance(db, Database3):\\n return db.h5db\\n else:\\n raise TypeError(\\\"Unsupported Database type ({})!\\\".format(type(db)))\",\n \"def getRef(self):\\n rnam = self.rnam\\n if not rnam or rnam.data == chr(255)*4: return None\\n if rnam.size != 4: raise Tes3Error(self.inName,_('SCPT.RNAM'),rnam.size,4,True)\\n iMod = struct.unpack('3xB',rnam.data)[0]\\n iObj = struct.unpack('i',rnam.data[:3]+'\\\\x00')[0]\\n return (iMod,iObj)\",\n \"def parseIntoDB(self, filehandle, cursor, alignTab, sequenceTab=None,\\n update=None):\\n c = filehandle.tell()\\n filehandle.seek(0, 2)\\n filesize = filehandle.tell()\\n filehandle.seek(c)\\n l = filehandle.readline()\\n rc = 0\\n count = 0\\n if l.split()[0] != '##maf':\\n return\\n else:\\n self.setpar(l.split()[1:])\\n\\n l=filehandle.readline()\\n while l:\\n la = l.split()\\n## print la\\n if(len(la)==0 or la[0]=='#'):\\n## print \\\"skipping\\\"\\n 1\\n elif(la[0]=='a'):\\n## print \\\"reading alignment\\\"\\n count+=1\\n self.readalign(la[1:], filehandle)\\n self._dump(alignTab, sequenceTab)\\n if(update and not count % 1000):\\n cursor.execute(update % (int(filehandle.tell() * 100.\\n / filesize)))\\n else:\\n## print \\\"end of records\\\"\\n return\\n l=filehandle.readline()\",\n \"def info(dump_alloc_table: bytes, /) -> None:\",\n \"def readfile(file, sub_im, cr):\\n\\n root, ext = os.path.splitext(file)\\n\\n if ext == '.tif':\\n print('Reading tiff image:', file)\\n par = readpar(root + '.mli.par')\\n data = readtiff(file, sub_im, cr)\\n\\n else: # must be GAMMA flat binary float format\\n print('Reading flat binary image', file)\\n par = readpar(root + ext + '.par')\\n data = readmli(file, par, sub_im, cr)\\n\\n # extract relevant metadata\\n rho_r = float(par['range_pixel_spacing'].split()[0])\\n rho_a = float(par['azimuth_pixel_spacing'].split()[0])\\n theta = float(par['incidence_angle'].split()[0])\\n\\n return data, rho_r, rho_a, theta\",\n \"def _get_table_info(self):\\n highestbet = self.highestBetNotFold(),\\n bigb =self.bigBlind() if self._game_state == GAME_STATE_PRE_FLOP and not self.inSmallBlindPosition() else 0\\n return [\\\"blinds: small:%r big:%r\\\" % (self.small_blind, self.big_blind),\\n \\\"buy_ins: min:%r max:%r\\\" % (self.min_buy_in, self.max_buy_in),\\n \\\"bs: %r\\\" % self.betting_structure,\\n \\\"highestbet = %r\\\" % highestbet,\\n \\\"bigb = %r\\\" % bigb,]\",\n \"def get_mediafile_blob_data(self, old):\\n if old[\\\"is_directory\\\"]:\\n return None\\n\\n try:\\n db_mediafile = Mediafile.objects.get(pk=old[\\\"id\\\"])\\n except Mediafile.DoesNotExist:\\n return None\\n filename = db_mediafile.original_filename\\n\\n if use_mediafile_database:\\n with connections[\\\"mediafiles\\\"].cursor() as cursor:\\n cursor.execute(\\n f\\\"SELECT data FROM {mediafile_database_tablename} WHERE id = %s\\\",\\n [old[\\\"id\\\"]],\\n )\\n row = cursor.fetchone()\\n if row is None:\\n return None\\n data = row[0]\\n else:\\n data = db_mediafile.mediafile.open().read()\\n\\n blob = base64.b64encode(data).decode(\\\"utf-8\\\")\\n return filename, len(data), blob\",\n \"def read_syn_data():\\n dipy_home = pjoin(os.path.expanduser('~'), '.dipy')\\n folder = pjoin(dipy_home, 'syn_test')\\n t1_name = pjoin(folder, 't1.nii.gz')\\n b0_name = pjoin(folder, 'b0.nii.gz')\\n\\n md5_dict = {'t1': '701bda02bb769655c7d4a9b1df2b73a6',\\n 'b0': 'e4b741f0c77b6039e67abb2885c97a78'}\\n\\n check_md5(t1_name, md5_dict['t1'])\\n check_md5(b0_name, md5_dict['b0'])\\n\\n t1 = nib.load(t1_name)\\n b0 = nib.load(b0_name)\\n return t1, b0\",\n \"def retrieve_secondary_file(self, src: str) -> tuple:\\n if src.find(\\\"http://\\\") != -1:\\n # location is on other server\\n uri, file = HttpClient.get_remote_uri_and_filename(src)\\n print(\\\"[CONNECTION] starting new client to retrieve an image\\\")\\n new_client = HttpClient()\\n new_client.main()\\n\\n http_command = new_client.create_secondary_http_command(file)\\n loc = HttpClient.create_file_location(file)\\n new_client.send(http_command)\\n recv_raw = new_client.recv_all_data()\\n new_client.disconnect()\\n else:\\n # location is on same server\\n\\n http_command = self.create_secondary_http_command(src)\\n loc = HttpClient.create_file_location(src)\\n self.send(http_command)\\n recv_raw = self.recv_all_data()\\n\\n return loc, recv_raw\",\n \"def read(self, with_holdout_split: bool = False) -> Union['DataFrame', Tuple['DataFrame', 'DataFrame']]:\\n pass\",\n \"def __get_file_chunk(self, buf=1000):\\n data = self.file.read(buf)\\n return data, len(data)\",\n \"def get_block(handle, offset=0):\\n\\n if isinstance(handle, bamnostic.core.AlignmentFile):\\n handle = handle._handle\\n with open(handle.name, 'rb') as header_handle:\\n header_handle.seek(offset) # get to the start of the BGZF block\\n\\n # Capture raw bytes of metadata header\\n _, meta_raw = _bgzf_metaheader(header_handle)\\n\\n BSIZE_raw = header_handle.read(2)\\n BSIZE = struct.unpack('<H', BSIZE_raw)[0]\\n\\n # capture the CRC32 and ISIZE fields in addition to compressed data\\n # 6 = XLEN, 19 = spec offset, 8 = CRC32 & ISIZE -> -5\\n block_tail = header_handle.read(BSIZE - 5)\\n return meta_raw + BSIZE_raw + block_tail\",\n \"def _genome_info_tuple(self, name, size=False):\\n accession = self.assembly_accession(name)\\n taxid = self.genome_taxid(name)\\n annotations = bool(self.annotation_links(name))\\n species = self.genomes[name].get(\\\"scientific_name\\\")\\n other = self.genomes[name].get(\\\"genebuild\\\")\\n if size:\\n length = self.genomes[name][\\\"base_count\\\"]\\n return name, accession, taxid, annotations, species, length, other\\n return name, accession, taxid, annotations, species, other\",\n \"def request_file(self, path: str, token: str) -> Tuple[IO[bytes], dict]:\\n response = self.request('get', path, token, stream=True)\\n stream = ReadWrapper(response.iter_content,\\n int(response.headers['Content-Length']))\\n return stream, response.headers\",\n \"def read_table(self, table_type):\\n\\n if table_type == 'hash':\\n entry_class = MPQHashTableEntry\\n elif table_type == 'block':\\n entry_class = MPQBlockTableEntry\\n else:\\n raise ValueError(\\\"Invalid table type.\\\")\\n\\n table_offset = self.header['%s_table_offset' % table_type]\\n table_entries = self.header['%s_table_entries' % table_type]\\n key = self._hash('(%s table)' % table_type, 'TABLE')\\n\\n self.file.seek(table_offset + self.header['offset'])\\n data = self.file.read(table_entries * 16)\\n data = self._decrypt(data, key)\\n\\n def unpack_entry(position):\\n entry_data = data[position*16:position*16+16]\\n return entry_class._make(\\n struct.unpack(entry_class.struct_format, entry_data))\\n\\n return [unpack_entry(i) for i in range(table_entries)]\",\n \"def readSeq(seqFile):\\n line = seqFile.readline()\\n seq1 = line.rstrip()\\n line = seqFile.readline()\\n seq2 = line.rstrip()\\n return (seq1, seq2)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5903592","0.5517948","0.5293327","0.5092299","0.5019564","0.5009954","0.49709004","0.49704278","0.49154168","0.49107695","0.48602694","0.4815139","0.47660074","0.4726421","0.4725368","0.4721951","0.47156245","0.47033814","0.46824378","0.46797317","0.4666152","0.4654891","0.46443024","0.4623548","0.46179524","0.46070755","0.46045774","0.45729685","0.4558212","0.455664","0.45498285","0.45189953","0.45088553","0.44890502","0.44885445","0.44670472","0.4463631","0.44449207","0.4441873","0.44362852","0.44299856","0.44278124","0.44230026","0.4421514","0.4420262","0.4405153","0.440437","0.44023165","0.43986464","0.43872502","0.43829325","0.43740833","0.43679652","0.43662122","0.4365856","0.43517035","0.43491328","0.43488583","0.43415296","0.4341529","0.43399897","0.43352124","0.43344167","0.43329003","0.43309438","0.43290874","0.43244934","0.43214545","0.431996","0.43178132","0.43149066","0.43007424","0.42992342","0.429146","0.42901868","0.42895573","0.4284795","0.4284672","0.42829847","0.42817834","0.4278182","0.42731228","0.42727736","0.4266202","0.42643234","0.42590126","0.4257576","0.42553267","0.42494896","0.42486024","0.42466667","0.4246387","0.4243771","0.42418","0.42394865","0.4238013","0.42355093","0.4235441","0.42349046","0.423329"],"string":"[\n \"0.5903592\",\n \"0.5517948\",\n \"0.5293327\",\n \"0.5092299\",\n \"0.5019564\",\n \"0.5009954\",\n \"0.49709004\",\n \"0.49704278\",\n \"0.49154168\",\n \"0.49107695\",\n \"0.48602694\",\n \"0.4815139\",\n \"0.47660074\",\n \"0.4726421\",\n \"0.4725368\",\n \"0.4721951\",\n \"0.47156245\",\n \"0.47033814\",\n \"0.46824378\",\n \"0.46797317\",\n \"0.4666152\",\n \"0.4654891\",\n \"0.46443024\",\n \"0.4623548\",\n \"0.46179524\",\n \"0.46070755\",\n \"0.46045774\",\n \"0.45729685\",\n \"0.4558212\",\n \"0.455664\",\n \"0.45498285\",\n \"0.45189953\",\n \"0.45088553\",\n \"0.44890502\",\n \"0.44885445\",\n \"0.44670472\",\n \"0.4463631\",\n \"0.44449207\",\n \"0.4441873\",\n \"0.44362852\",\n \"0.44299856\",\n \"0.44278124\",\n \"0.44230026\",\n \"0.4421514\",\n \"0.4420262\",\n \"0.4405153\",\n \"0.440437\",\n \"0.44023165\",\n \"0.43986464\",\n \"0.43872502\",\n \"0.43829325\",\n \"0.43740833\",\n \"0.43679652\",\n \"0.43662122\",\n \"0.4365856\",\n \"0.43517035\",\n \"0.43491328\",\n \"0.43488583\",\n \"0.43415296\",\n \"0.4341529\",\n \"0.43399897\",\n \"0.43352124\",\n \"0.43344167\",\n \"0.43329003\",\n \"0.43309438\",\n \"0.43290874\",\n \"0.43244934\",\n \"0.43214545\",\n \"0.431996\",\n \"0.43178132\",\n \"0.43149066\",\n \"0.43007424\",\n \"0.42992342\",\n \"0.429146\",\n \"0.42901868\",\n \"0.42895573\",\n \"0.4284795\",\n \"0.4284672\",\n \"0.42829847\",\n \"0.42817834\",\n \"0.4278182\",\n \"0.42731228\",\n \"0.42727736\",\n \"0.4266202\",\n \"0.42643234\",\n \"0.42590126\",\n \"0.4257576\",\n \"0.42553267\",\n \"0.42494896\",\n \"0.42486024\",\n \"0.42466667\",\n \"0.4246387\",\n \"0.4243771\",\n \"0.42418\",\n \"0.42394865\",\n \"0.4238013\",\n \"0.42355093\",\n \"0.4235441\",\n \"0.42349046\",\n \"0.423329\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6167393"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94292,"cells":{"query":{"kind":"string","value":"Return a parsed JSON object."},"document":{"kind":"string","value":"def load_json_document(f):\n return json.load(f)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def json(self):\n return self._parsejson(self.raw)","def parse_json(data):\n return json.loads(data)","def json(self):\n return json.loads(self.text)","def openJson(self):\n json_file = open(self.file, 'r')\n json_data = json_file.read()\n result = json.loads(json_data)\n return result","def json(self, **kwargs):\n return json.loads(self.content, **kwargs)","def _get_json(self, url):\n try:\n resp = urllib.urlopen(url)\n except:\n resp = urllib.request.urlopen(url)\n json_string = resp.read()\n parsed_json = json.loads(json_string.decode('utf-8'))\n return parsed_json","def json(self):\n try:\n return self._json_provider.load(self._body())\n except ValueError:\n raise HTTPError(400, 'Misformated JSON object')","def parse(content):\n return json.loads(content)","def parse_json(response):\r\n return json.loads(response.content)","def json(self):\n\n return json.loads(self.text)","def _parsejson(x):\n return json.loads(x.read().decode('utf-8'))","def json_loads(self, string: str) -> object:\n return json.loads(string)","def json(self) -> Any:\n return json.loads(self)","def read_json(self):\n self._fopen.seek(self._json_start, 0)\n return json.loads(self._fopen.read().decode('utf-8'))","def get_jsonparsed_data(url):\n response = urlopen(url)\n data = response.read().decode(\"utf-8\")\n return json.loads(data)","def get_jsonparsed_data(url):\n response = urlopen(url)\n data = response.read().decode(\"utf-8\")\n return json.loads(data)","def get_jsonparsed_data(url):\n response = urlopen(url)\n data = response.read().decode(\"utf-8\")\n return json.loads(data)","def get_jsonparsed_data(url):\n response = urlopen(url)\n data = response.read().decode(\"utf-8\")\n return json.loads(data)","def get_json(response):\n return json.loads(response.data.decode('utf8'))","def extract_and_parse_json(response):\n return json.loads(response.text, object_hook=OrderedDict)","def read_json():\n return json.loads(web.data())","def get_json(self, script, depth=2):\n result = self.run_script(\n \"{} | ConvertTo-Json -Compress -Depth {}\".format(script, depth))\n if not result:\n return None\n try:\n return json.loads(result)\n except ValueError:\n self.logger.error(\"Returned data was not json. Data:\\n\\n%s\", result)\n raise ValueError(\"Returned data was not json\")","def get_json(self, *args, **kwargs):\r\n resp = self.request_with_auth(\"get\", *args, **kwargs)\r\n self.assertHttpOK(resp)\r\n self.assertTrue(resp[\"Content-Type\"].startswith(\"application/json\"))\r\n return json.loads(resp.content)","def _get_json(self, url: str) -> dict:\n r = self._req_get(url)\n return r.json() if r else None","def parse_json(json_string):\n\n return _convert_to_jsonc(simplejson.loads(json_string))","def from_json(self, content):\r\n return simplejson.loads(content)","def json_of_response(response):\n return json.loads(response.text)","def read_json(self, key):\n return json.loads(self.get_object(key))","def convert_json_to_object(file_content):\n object = json.loads(file_content)\n print(object)\n return object","def JSONtoObject(fileName):\n # TODO: ensure file exists first!!\n \n with open(fileName) as json_data:\n d = json.load(json_data)\n \n return d\n #return json.loads(d, object_hook=_json_object_hook)","def dump_to_json (self):\n return json.loads(self.dump())","def parse(self, stream, media_type=None, parser_context=None):\n parser_context = parser_context or {}\n encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)\n\n try:\n data = stream.read().decode(encoding)\n return json.loads(data)\n except ValueError as exc:\n raise ParseError('JSON parse error - %s' % six.text_type(exc))","def _parse_json(self, file_location: str) -> Dict:\n with open(file_location, mode=\"r\") as json_file:\n raw_json = json.loads(json_file.read())\n return raw_json","def get_json():\n try:\n return request.get_json(force=True)\n except Exception:\n raise AXApiInvalidParam(\"Invalid json supplied\")","def get_as_json(self, use_cache_if_available=True):\n obj_bytes = self.get_bytes(use_cache_if_available=use_cache_if_available)\n return json.loads(obj_bytes.decode(\"utf-8\"))","def _from_json(return_obj):\n\n return json.loads(return_obj.decode())","def json_loads(value):\n return json.loads(value)","def json(self):\n if self._json is None:\n if self.content_type is None:\n return None\n mime_type = self.content_type.split(';')[0]\n if mime_type != 'application/json':\n return None\n self._json = json.loads(self.body.decode())\n return self._json","def get_json_from_url(url):\r\n content = get_url(url)\r\n js = json.loads(content)\r\n return js","def load_json(response):\n return json.loads(response.data.decode('utf8'))","def json(self):\n return self._json","def parse_json(json_path):\n with open(json_path, 'r') as f:\n out = json.load(f)\n return out","def getJson(self,url):\n r = req.get(str(url),\"GET\")\n jsonResponse = json.loads(r.text)\n return jsonResponse","def getJsonObject(self):\n jsonObject = {\n 'id': self.id,\n 'name': self.name,\n 'cards': [self.cards[card].getJsonObject() for card in self.cards] if self.cards else [\"\"]\n }\n return jsonObject","def _getJason(self, url, use_session = False):\n print ('Retrieving Jason for %s' % url)\n if use_session:\n r = session.get(url)\n else:\n r = requests.get(url)\n data = json.loads(r.text)\n return data","def get_json():\n response = requests.get(JSON_URL)\n if response.status_code != 200:\n raise Exception(\"Could not not load json file!\")\n return response.json()","def parse_json(self, json_cfg: Dict) -> Any:\n raise NotImplementedError","def dict(self):\n\t\treturn self.json","def read_json(self, *args, **kwargs):\n with self.open('rb') as f:\n return json.load(f, *args, **kwargs)","def json(self) -> Dict[str, Union[List, Dict, str, int, float]]:","def parse_response(response):\n return json.loads(response.text)","def get_json(response):\n\n json_field_or_function = getattr(response, 'json', None)\n if callable(json_field_or_function):\n return response.json()\n else:\n return json.loads(response.content)","def get_json(self, url):\n json_response = self.testapp.get(url)\n self.assertEqual(json_response.status_int, 200)\n return self._parse_json_response(json_response, expect_errors=False)","def _read_json(cls, input_file):\n with open(input_file) as f:\n return json.load(f)","def _read_json(cls, input_file):\n with open(input_file) as f:\n return json.load(f)","def _read_json(cls, input_file):\n with open(input_file, 'rb') as f:\n return json.load(f)","def _read_json(cls, input_file):\n with open(input_file, 'rb') as f:\n return json.load(f)","def load_json(content):\n from ujson import loads\n return loads(content)","def get_json_from_url(url):\n content = get_url(url)\n js = json.loads(content)\n return js","def json(self) -> Any:\n return self.body.json()","def json(self):\n return self.__json","def get_json(self) -> dict:\n\n try:\n html = get(self.url, sessionid=self.sessionid)\n except HTTPError:\n raise HashTagNotFound(self.url.split(\"/\")[-2])\n parser = Parser()\n parser.feed(html)\n return parser.Data","def parse_response(self, r):\n data = (\"\".join(r.split(\"\\n\")[1:])).replace(\",]\",\"]\")\n obj = simplejson.loads(data)\n return obj","def from_json_string(my_obj):\n\n return(json.loads(my_obj))","def get_json(url):\n r = requests.get(url)\n return r.json()","def get_json(self) -> dict:\n\n try:\n html = get(self.url, sessionid=self.sessionid)\n except HTTPError:\n raise PostIdNotFound(self.post_id)\n parser = Parser()\n parser.feed(html)\n info = parser.Data\n return info","def getJson(self, soup):\n script = soup.find('script', type='application/ld+json')\n json_text = BeautifulSoup.get_text(script)\n return json.loads(json_text)","def load_json(request, json):\n return json","def get_json(response):\n\tif requests.__version__ >= \"1.0.0\":\n\t\treturn response.json()\n\telif requests.__version__ == \"0.14.2\":\n\t\treturn response.json\n\telse:\n\t\treturn json.loads(response.content)","def json_of_response(response):\n return json.loads(response.data.decode('utf8'))","def json_of_response(response):\n return json.loads(response.data.decode('utf8'))","def parse_response(self, response):\n\n return json.loads(response.text)","def _get_json(self, url, file=None):\n r = requests.get(url)\n # If status is not OK, raise error.\n if not r.ok:\n r.raise_for_status()\n # Otherwise load JSON.\n data = json.loads(r.text)\n # Optionally save JSON to disk.\n if file is not None:\n with open(file, 'w') as f:\n json.dump(data, f)\n return data","def parse_json_string(json_string):\n json_object = None\n\n if not isinstance(json_string, str):\n return json_string\n\n try:\n json_object = json.loads(json_string)\n except (ValueError, TypeError):\n pass\n return json_object","def _parse_json_file(json_path):\n app.app.logger.info('Reading JSON file %s' % json_path)\n with open(json_path, 'r') as f:\n # Remove comments using jsmin, as recommended by JSON creator:\n # https://plus.google.com/+DouglasCrockfordEsq/posts/RK8qyGVaGSr\n jsonDict = json.loads(jsmin.jsmin(f.read()))\n return jsonDict","def getjson(url, **kwargs):\n json = fetch_resource(url, **kwargs)\n return simplejson.loads(json)","def get_json(url):\n f = urllib.request.urlopen(url)\n response_text = f.read().decode('utf-8')\n response_data = json.loads(response_text)\n # pprint(response_data)\n return response_data","def get_json(filename) :\n result = json.load(open(filename,'r'))\n return result","def json(self, **kwargs):\n\t\ttry:\n\t\t\treturn self.response.json(**kwargs)\n\t\texcept ValueError:\n\t\t\t# No valid JSON encoding\n\t\t\treturn None","def get_json(url):\n f = urllib.request.urlopen(url)\n response_text = f.read().decode('utf-8')\n response_data = json.loads(response_text)\n\n return response_data","def parse(response):\n if isinstance(response, dict):\n json = response\n else:\n json = response.json()\n\n if json.get('Error'):\n raise Exception('Error in retrieval: ' + self.json['error'])\n\n return json","def get_json(input):\n\n if os.path.isfile(input):\n try:\n with open(input, 'r') as f:\n obj = json.load(f)\n f.close()\n except Exception as e:\n raise ValueError(\"Unable to read the JSON file: %s\" % input)\n else:\n try:\n obj = json.loads(input)\n except Exception as e:\n raise ValueError(\"Unable to read the JSON: %s\" % input)\n\n return obj","async def json(self, encoding=\"utf-8\", content_type=None, loads=json_loads):\n return loads(self.response.decode(encoding))","def load_json(json_string):\n return json.loads(json_string)","def getDataParsed():\r\n serialConsole.flush()\r\n rawData = serialConsole.readline().decode(\"utf-8\").rstrip()\r\n parsedJson = json.loads(rawData)\r\n return parsedJson","def _parse_json(dump):\n # return yaml.safe_load(dump) # slightly improved in python3?\n return json.loads(dump)","def parse(json_string: str) -> object:\n tokens = tokenize(json_string)\n\n value = _parse(tokens)\n if len(tokens) != 0:\n raise ParseError(\n f\"Invalid JSON at {tokens[0].value} \"\n f\"(line {tokens[0].line} column {tokens[0].column})\")\n\n return value","def get_json_data():\n return None","def test_to_json(self):\n\n self.parser.parse()\n json_string = self.parser.to_json()\n \n self.assertTrue(isinstance(json_string, str))","def parse(self, stream, media_type=None, parser_context=None):\n parser_context = parser_context or {}\n encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)\n\n try:\n decoded_stream = codecs.getreader(encoding)(stream)\n parse_constant = strict_constant if self.strict else None\n return ujson.load(decoded_stream, parse_constant=parse_constant)\n except ValueError as exc:\n raise ParseError('JSON parse error - %s' % str(exc))","def _remoteloadjson(path: str) -> JSONType:\n return json.loads(request.urlopen(path).read())","def recvjson(self):\n\n import json\n\n data = self.recvraw()\n return json.loads(data)","def get_json(url):\n f = urlopen(url)\n response_text = f.read()\n response_data = json.loads(str(response_text, \"utf-8\"))\n #pprint(response_data)\n return response_data","def get_page_contents_as_json(url, headers):\n json_string = get_page_contents(url, headers)\n json_object = json.loads(json_string)\n return json_object","def json_loads(s):\n return json.loads(s, cls=DataDecoder)","def __GetJson(self, url, auth, responseProcessor = None):\n\n conn = self.__GetConnection()\n conn.request(\"GET\", url, \"\", self.__MakeHeaders(auth))\n response = conn.getresponse()\n if (responseProcessor != None):\n if (responseProcessor(response) == False):\n return None\n\n self.__CheckResponse(response)\n data = response.read()\n return cjson.decode(data)","def parse_json(raw):\n return escape.recursive_unicode(escape.json_decode(raw)) if raw != None else None","def get_json(filename):\n with open(filename) as f:\n file_content = f.read()\n data = json.loads(file_content)\n return data","def json(self, pretty=True, full_dump=True):\n return json_dump(self, pretty, full_dump)","def read_json_to_object(fn):\n\n with open(fn, \"r\") as fid:\n obj = json.load(fid, object_hook=lambda d: SimpleNamespace(**d))\n return obj","async def json(self, *, loads=json.loads):\n body = await self.text()\n return loads(body)"],"string":"[\n \"def json(self):\\n return self._parsejson(self.raw)\",\n \"def parse_json(data):\\n return json.loads(data)\",\n \"def json(self):\\n return json.loads(self.text)\",\n \"def openJson(self):\\n json_file = open(self.file, 'r')\\n json_data = json_file.read()\\n result = json.loads(json_data)\\n return result\",\n \"def json(self, **kwargs):\\n return json.loads(self.content, **kwargs)\",\n \"def _get_json(self, url):\\n try:\\n resp = urllib.urlopen(url)\\n except:\\n resp = urllib.request.urlopen(url)\\n json_string = resp.read()\\n parsed_json = json.loads(json_string.decode('utf-8'))\\n return parsed_json\",\n \"def json(self):\\n try:\\n return self._json_provider.load(self._body())\\n except ValueError:\\n raise HTTPError(400, 'Misformated JSON object')\",\n \"def parse(content):\\n return json.loads(content)\",\n \"def parse_json(response):\\r\\n return json.loads(response.content)\",\n \"def json(self):\\n\\n return json.loads(self.text)\",\n \"def _parsejson(x):\\n return json.loads(x.read().decode('utf-8'))\",\n \"def json_loads(self, string: str) -> object:\\n return json.loads(string)\",\n \"def json(self) -> Any:\\n return json.loads(self)\",\n \"def read_json(self):\\n self._fopen.seek(self._json_start, 0)\\n return json.loads(self._fopen.read().decode('utf-8'))\",\n \"def get_jsonparsed_data(url):\\n response = urlopen(url)\\n data = response.read().decode(\\\"utf-8\\\")\\n return json.loads(data)\",\n \"def get_jsonparsed_data(url):\\n response = urlopen(url)\\n data = response.read().decode(\\\"utf-8\\\")\\n return json.loads(data)\",\n \"def get_jsonparsed_data(url):\\n response = urlopen(url)\\n data = response.read().decode(\\\"utf-8\\\")\\n return json.loads(data)\",\n \"def get_jsonparsed_data(url):\\n response = urlopen(url)\\n data = response.read().decode(\\\"utf-8\\\")\\n return json.loads(data)\",\n \"def get_json(response):\\n return json.loads(response.data.decode('utf8'))\",\n \"def extract_and_parse_json(response):\\n return json.loads(response.text, object_hook=OrderedDict)\",\n \"def read_json():\\n return json.loads(web.data())\",\n \"def get_json(self, script, depth=2):\\n result = self.run_script(\\n \\\"{} | ConvertTo-Json -Compress -Depth {}\\\".format(script, depth))\\n if not result:\\n return None\\n try:\\n return json.loads(result)\\n except ValueError:\\n self.logger.error(\\\"Returned data was not json. Data:\\\\n\\\\n%s\\\", result)\\n raise ValueError(\\\"Returned data was not json\\\")\",\n \"def get_json(self, *args, **kwargs):\\r\\n resp = self.request_with_auth(\\\"get\\\", *args, **kwargs)\\r\\n self.assertHttpOK(resp)\\r\\n self.assertTrue(resp[\\\"Content-Type\\\"].startswith(\\\"application/json\\\"))\\r\\n return json.loads(resp.content)\",\n \"def _get_json(self, url: str) -> dict:\\n r = self._req_get(url)\\n return r.json() if r else None\",\n \"def parse_json(json_string):\\n\\n return _convert_to_jsonc(simplejson.loads(json_string))\",\n \"def from_json(self, content):\\r\\n return simplejson.loads(content)\",\n \"def json_of_response(response):\\n return json.loads(response.text)\",\n \"def read_json(self, key):\\n return json.loads(self.get_object(key))\",\n \"def convert_json_to_object(file_content):\\n object = json.loads(file_content)\\n print(object)\\n return object\",\n \"def JSONtoObject(fileName):\\n # TODO: ensure file exists first!!\\n \\n with open(fileName) as json_data:\\n d = json.load(json_data)\\n \\n return d\\n #return json.loads(d, object_hook=_json_object_hook)\",\n \"def dump_to_json (self):\\n return json.loads(self.dump())\",\n \"def parse(self, stream, media_type=None, parser_context=None):\\n parser_context = parser_context or {}\\n encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)\\n\\n try:\\n data = stream.read().decode(encoding)\\n return json.loads(data)\\n except ValueError as exc:\\n raise ParseError('JSON parse error - %s' % six.text_type(exc))\",\n \"def _parse_json(self, file_location: str) -> Dict:\\n with open(file_location, mode=\\\"r\\\") as json_file:\\n raw_json = json.loads(json_file.read())\\n return raw_json\",\n \"def get_json():\\n try:\\n return request.get_json(force=True)\\n except Exception:\\n raise AXApiInvalidParam(\\\"Invalid json supplied\\\")\",\n \"def get_as_json(self, use_cache_if_available=True):\\n obj_bytes = self.get_bytes(use_cache_if_available=use_cache_if_available)\\n return json.loads(obj_bytes.decode(\\\"utf-8\\\"))\",\n \"def _from_json(return_obj):\\n\\n return json.loads(return_obj.decode())\",\n \"def json_loads(value):\\n return json.loads(value)\",\n \"def json(self):\\n if self._json is None:\\n if self.content_type is None:\\n return None\\n mime_type = self.content_type.split(';')[0]\\n if mime_type != 'application/json':\\n return None\\n self._json = json.loads(self.body.decode())\\n return self._json\",\n \"def get_json_from_url(url):\\r\\n content = get_url(url)\\r\\n js = json.loads(content)\\r\\n return js\",\n \"def load_json(response):\\n return json.loads(response.data.decode('utf8'))\",\n \"def json(self):\\n return self._json\",\n \"def parse_json(json_path):\\n with open(json_path, 'r') as f:\\n out = json.load(f)\\n return out\",\n \"def getJson(self,url):\\n r = req.get(str(url),\\\"GET\\\")\\n jsonResponse = json.loads(r.text)\\n return jsonResponse\",\n \"def getJsonObject(self):\\n jsonObject = {\\n 'id': self.id,\\n 'name': self.name,\\n 'cards': [self.cards[card].getJsonObject() for card in self.cards] if self.cards else [\\\"\\\"]\\n }\\n return jsonObject\",\n \"def _getJason(self, url, use_session = False):\\n print ('Retrieving Jason for %s' % url)\\n if use_session:\\n r = session.get(url)\\n else:\\n r = requests.get(url)\\n data = json.loads(r.text)\\n return data\",\n \"def get_json():\\n response = requests.get(JSON_URL)\\n if response.status_code != 200:\\n raise Exception(\\\"Could not not load json file!\\\")\\n return response.json()\",\n \"def parse_json(self, json_cfg: Dict) -> Any:\\n raise NotImplementedError\",\n \"def dict(self):\\n\\t\\treturn self.json\",\n \"def read_json(self, *args, **kwargs):\\n with self.open('rb') as f:\\n return json.load(f, *args, **kwargs)\",\n \"def json(self) -> Dict[str, Union[List, Dict, str, int, float]]:\",\n \"def parse_response(response):\\n return json.loads(response.text)\",\n \"def get_json(response):\\n\\n json_field_or_function = getattr(response, 'json', None)\\n if callable(json_field_or_function):\\n return response.json()\\n else:\\n return json.loads(response.content)\",\n \"def get_json(self, url):\\n json_response = self.testapp.get(url)\\n self.assertEqual(json_response.status_int, 200)\\n return self._parse_json_response(json_response, expect_errors=False)\",\n \"def _read_json(cls, input_file):\\n with open(input_file) as f:\\n return json.load(f)\",\n \"def _read_json(cls, input_file):\\n with open(input_file) as f:\\n return json.load(f)\",\n \"def _read_json(cls, input_file):\\n with open(input_file, 'rb') as f:\\n return json.load(f)\",\n \"def _read_json(cls, input_file):\\n with open(input_file, 'rb') as f:\\n return json.load(f)\",\n \"def load_json(content):\\n from ujson import loads\\n return loads(content)\",\n \"def get_json_from_url(url):\\n content = get_url(url)\\n js = json.loads(content)\\n return js\",\n \"def json(self) -> Any:\\n return self.body.json()\",\n \"def json(self):\\n return self.__json\",\n \"def get_json(self) -> dict:\\n\\n try:\\n html = get(self.url, sessionid=self.sessionid)\\n except HTTPError:\\n raise HashTagNotFound(self.url.split(\\\"/\\\")[-2])\\n parser = Parser()\\n parser.feed(html)\\n return parser.Data\",\n \"def parse_response(self, r):\\n data = (\\\"\\\".join(r.split(\\\"\\\\n\\\")[1:])).replace(\\\",]\\\",\\\"]\\\")\\n obj = simplejson.loads(data)\\n return obj\",\n \"def from_json_string(my_obj):\\n\\n return(json.loads(my_obj))\",\n \"def get_json(url):\\n r = requests.get(url)\\n return r.json()\",\n \"def get_json(self) -> dict:\\n\\n try:\\n html = get(self.url, sessionid=self.sessionid)\\n except HTTPError:\\n raise PostIdNotFound(self.post_id)\\n parser = Parser()\\n parser.feed(html)\\n info = parser.Data\\n return info\",\n \"def getJson(self, soup):\\n script = soup.find('script', type='application/ld+json')\\n json_text = BeautifulSoup.get_text(script)\\n return json.loads(json_text)\",\n \"def load_json(request, json):\\n return json\",\n \"def get_json(response):\\n\\tif requests.__version__ >= \\\"1.0.0\\\":\\n\\t\\treturn response.json()\\n\\telif requests.__version__ == \\\"0.14.2\\\":\\n\\t\\treturn response.json\\n\\telse:\\n\\t\\treturn json.loads(response.content)\",\n \"def json_of_response(response):\\n return json.loads(response.data.decode('utf8'))\",\n \"def json_of_response(response):\\n return json.loads(response.data.decode('utf8'))\",\n \"def parse_response(self, response):\\n\\n return json.loads(response.text)\",\n \"def _get_json(self, url, file=None):\\n r = requests.get(url)\\n # If status is not OK, raise error.\\n if not r.ok:\\n r.raise_for_status()\\n # Otherwise load JSON.\\n data = json.loads(r.text)\\n # Optionally save JSON to disk.\\n if file is not None:\\n with open(file, 'w') as f:\\n json.dump(data, f)\\n return data\",\n \"def parse_json_string(json_string):\\n json_object = None\\n\\n if not isinstance(json_string, str):\\n return json_string\\n\\n try:\\n json_object = json.loads(json_string)\\n except (ValueError, TypeError):\\n pass\\n return json_object\",\n \"def _parse_json_file(json_path):\\n app.app.logger.info('Reading JSON file %s' % json_path)\\n with open(json_path, 'r') as f:\\n # Remove comments using jsmin, as recommended by JSON creator:\\n # https://plus.google.com/+DouglasCrockfordEsq/posts/RK8qyGVaGSr\\n jsonDict = json.loads(jsmin.jsmin(f.read()))\\n return jsonDict\",\n \"def getjson(url, **kwargs):\\n json = fetch_resource(url, **kwargs)\\n return simplejson.loads(json)\",\n \"def get_json(url):\\n f = urllib.request.urlopen(url)\\n response_text = f.read().decode('utf-8')\\n response_data = json.loads(response_text)\\n # pprint(response_data)\\n return response_data\",\n \"def get_json(filename) :\\n result = json.load(open(filename,'r'))\\n return result\",\n \"def json(self, **kwargs):\\n\\t\\ttry:\\n\\t\\t\\treturn self.response.json(**kwargs)\\n\\t\\texcept ValueError:\\n\\t\\t\\t# No valid JSON encoding\\n\\t\\t\\treturn None\",\n \"def get_json(url):\\n f = urllib.request.urlopen(url)\\n response_text = f.read().decode('utf-8')\\n response_data = json.loads(response_text)\\n\\n return response_data\",\n \"def parse(response):\\n if isinstance(response, dict):\\n json = response\\n else:\\n json = response.json()\\n\\n if json.get('Error'):\\n raise Exception('Error in retrieval: ' + self.json['error'])\\n\\n return json\",\n \"def get_json(input):\\n\\n if os.path.isfile(input):\\n try:\\n with open(input, 'r') as f:\\n obj = json.load(f)\\n f.close()\\n except Exception as e:\\n raise ValueError(\\\"Unable to read the JSON file: %s\\\" % input)\\n else:\\n try:\\n obj = json.loads(input)\\n except Exception as e:\\n raise ValueError(\\\"Unable to read the JSON: %s\\\" % input)\\n\\n return obj\",\n \"async def json(self, encoding=\\\"utf-8\\\", content_type=None, loads=json_loads):\\n return loads(self.response.decode(encoding))\",\n \"def load_json(json_string):\\n return json.loads(json_string)\",\n \"def getDataParsed():\\r\\n serialConsole.flush()\\r\\n rawData = serialConsole.readline().decode(\\\"utf-8\\\").rstrip()\\r\\n parsedJson = json.loads(rawData)\\r\\n return parsedJson\",\n \"def _parse_json(dump):\\n # return yaml.safe_load(dump) # slightly improved in python3?\\n return json.loads(dump)\",\n \"def parse(json_string: str) -> object:\\n tokens = tokenize(json_string)\\n\\n value = _parse(tokens)\\n if len(tokens) != 0:\\n raise ParseError(\\n f\\\"Invalid JSON at {tokens[0].value} \\\"\\n f\\\"(line {tokens[0].line} column {tokens[0].column})\\\")\\n\\n return value\",\n \"def get_json_data():\\n return None\",\n \"def test_to_json(self):\\n\\n self.parser.parse()\\n json_string = self.parser.to_json()\\n \\n self.assertTrue(isinstance(json_string, str))\",\n \"def parse(self, stream, media_type=None, parser_context=None):\\n parser_context = parser_context or {}\\n encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)\\n\\n try:\\n decoded_stream = codecs.getreader(encoding)(stream)\\n parse_constant = strict_constant if self.strict else None\\n return ujson.load(decoded_stream, parse_constant=parse_constant)\\n except ValueError as exc:\\n raise ParseError('JSON parse error - %s' % str(exc))\",\n \"def _remoteloadjson(path: str) -> JSONType:\\n return json.loads(request.urlopen(path).read())\",\n \"def recvjson(self):\\n\\n import json\\n\\n data = self.recvraw()\\n return json.loads(data)\",\n \"def get_json(url):\\n f = urlopen(url)\\n response_text = f.read()\\n response_data = json.loads(str(response_text, \\\"utf-8\\\"))\\n #pprint(response_data)\\n return response_data\",\n \"def get_page_contents_as_json(url, headers):\\n json_string = get_page_contents(url, headers)\\n json_object = json.loads(json_string)\\n return json_object\",\n \"def json_loads(s):\\n return json.loads(s, cls=DataDecoder)\",\n \"def __GetJson(self, url, auth, responseProcessor = None):\\n\\n conn = self.__GetConnection()\\n conn.request(\\\"GET\\\", url, \\\"\\\", self.__MakeHeaders(auth))\\n response = conn.getresponse()\\n if (responseProcessor != None):\\n if (responseProcessor(response) == False):\\n return None\\n\\n self.__CheckResponse(response)\\n data = response.read()\\n return cjson.decode(data)\",\n \"def parse_json(raw):\\n return escape.recursive_unicode(escape.json_decode(raw)) if raw != None else None\",\n \"def get_json(filename):\\n with open(filename) as f:\\n file_content = f.read()\\n data = json.loads(file_content)\\n return data\",\n \"def json(self, pretty=True, full_dump=True):\\n return json_dump(self, pretty, full_dump)\",\n \"def read_json_to_object(fn):\\n\\n with open(fn, \\\"r\\\") as fid:\\n obj = json.load(fid, object_hook=lambda d: SimpleNamespace(**d))\\n return obj\",\n \"async def json(self, *, loads=json.loads):\\n body = await self.text()\\n return loads(body)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73147","0.7164479","0.7052984","0.70459557","0.69945663","0.69648427","0.69155174","0.6909238","0.6883624","0.68454266","0.67840165","0.6775863","0.67642134","0.67337215","0.6694092","0.6694092","0.6694092","0.6694092","0.66517884","0.6608782","0.65929335","0.6556722","0.65177184","0.6502583","0.64878607","0.6482714","0.64587164","0.6447555","0.64439017","0.64193124","0.6391434","0.6389344","0.63695204","0.6353953","0.63394606","0.63393855","0.62897635","0.6286033","0.6280681","0.62804","0.627933","0.6277912","0.6272756","0.62681204","0.62642866","0.62597746","0.62579423","0.6257125","0.6255825","0.6248963","0.6219606","0.62145686","0.61984533","0.61973876","0.61973876","0.61969626","0.61969626","0.6193145","0.61741906","0.6164568","0.6164536","0.6163894","0.6162112","0.61467534","0.613816","0.6137672","0.6134756","0.6132258","0.612734","0.61254287","0.61254287","0.61084956","0.61040163","0.61004645","0.6096719","0.60961807","0.6095321","0.6093403","0.60859495","0.60832095","0.6080717","0.6069305","0.6067498","0.6063849","0.6051663","0.60503","0.60501295","0.6049806","0.6048331","0.60428184","0.6036853","0.60365856","0.60283643","0.6024698","0.60151917","0.6012839","0.59971696","0.5990541","0.5985968","0.5976619","0.5974485"],"string":"[\n \"0.73147\",\n \"0.7164479\",\n \"0.7052984\",\n \"0.70459557\",\n \"0.69945663\",\n \"0.69648427\",\n \"0.69155174\",\n \"0.6909238\",\n \"0.6883624\",\n \"0.68454266\",\n \"0.67840165\",\n \"0.6775863\",\n \"0.67642134\",\n \"0.67337215\",\n \"0.6694092\",\n \"0.6694092\",\n \"0.6694092\",\n \"0.6694092\",\n \"0.66517884\",\n \"0.6608782\",\n \"0.65929335\",\n \"0.6556722\",\n \"0.65177184\",\n \"0.6502583\",\n \"0.64878607\",\n \"0.6482714\",\n \"0.64587164\",\n \"0.6447555\",\n \"0.64439017\",\n \"0.64193124\",\n \"0.6391434\",\n \"0.6389344\",\n \"0.63695204\",\n \"0.6353953\",\n \"0.63394606\",\n \"0.63393855\",\n \"0.62897635\",\n \"0.6286033\",\n \"0.6280681\",\n \"0.62804\",\n \"0.627933\",\n \"0.6277912\",\n \"0.6272756\",\n \"0.62681204\",\n \"0.62642866\",\n \"0.62597746\",\n \"0.62579423\",\n \"0.6257125\",\n \"0.6255825\",\n \"0.6248963\",\n \"0.6219606\",\n \"0.62145686\",\n \"0.61984533\",\n \"0.61973876\",\n \"0.61973876\",\n \"0.61969626\",\n \"0.61969626\",\n \"0.6193145\",\n \"0.61741906\",\n \"0.6164568\",\n \"0.6164536\",\n \"0.6163894\",\n \"0.6162112\",\n \"0.61467534\",\n \"0.613816\",\n \"0.6137672\",\n \"0.6134756\",\n \"0.6132258\",\n \"0.612734\",\n \"0.61254287\",\n \"0.61254287\",\n \"0.61084956\",\n \"0.61040163\",\n \"0.61004645\",\n \"0.6096719\",\n \"0.60961807\",\n \"0.6095321\",\n \"0.6093403\",\n \"0.60859495\",\n \"0.60832095\",\n \"0.6080717\",\n \"0.6069305\",\n \"0.6067498\",\n \"0.6063849\",\n \"0.6051663\",\n \"0.60503\",\n \"0.60501295\",\n \"0.6049806\",\n \"0.6048331\",\n \"0.60428184\",\n \"0.6036853\",\n \"0.60365856\",\n \"0.60283643\",\n \"0.6024698\",\n \"0.60151917\",\n \"0.6012839\",\n \"0.59971696\",\n \"0.5990541\",\n \"0.5985968\",\n \"0.5976619\",\n \"0.5974485\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94293,"cells":{"query":{"kind":"string","value":"Parse a sample/observation metadata file, return a ``MetadataMap``. If ``lines`` is ``None``, this function will return ``None``."},"document":{"kind":"string","value":"def load_metadata(lines):\n if lines is not None:\n return MetadataMap.from_file(lines)\n\n return None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def parseMetadataMap(lines):\r\n return MetadataMap(*parse_mapping_file_to_dict(lines))","def get_sample_info(lines):\r\n mapping_data, header, comments = parse_mapping_file(lines)\r\n labels = [\"from\", \"to\", \"eweight\", \"consensus_lin\"]\r\n node_labels = [\"node_name\", \"node_disp_name\", \"ntype\", \"degree\",\r\n \"weighted_degree\", \"consensus_lin\"]\r\n cat_by_sample = {}\r\n sample_by_cat = defaultdict(list)\r\n meta_dict = {}\r\n category_labels = header[1:-1]\r\n labels.extend(category_labels)\r\n node_labels.extend(category_labels)\r\n label_list = [[] for c in category_labels]\r\n for r in mapping_data:\r\n categories = r[0:len(category_labels) + 1]\r\n sample = categories[0]\r\n meta_dict[sample] = ['\\t'.join(categories[1:]), 0]\r\n\r\n cat_by_sample[sample] = [(l.strip(), c.strip())\r\n for l, c in zip(category_labels, categories[1:])]\r\n\r\n cat_list = []\r\n for i, (l, c) in enumerate(zip(category_labels, categories[1:])):\r\n if c not in label_list[i]:\r\n label_list[i].append(c)\r\n l = l.strip()\r\n c = c.strip()\r\n cat_list.append((l, c))\r\n sample_by_cat[(l, c)].append(sample)\r\n\r\n cat_by_sample[sample] = cat_list\r\n\r\n return cat_by_sample, sample_by_cat, len(category_labels), meta_dict,\\\r\n labels, node_labels, label_list","def process_lines(self, lines):\n line_index = 0\n n_lines = len(lines)\n while line_index < n_lines:\n if lines[line_index].startswith(\"HIERARCHY\"):\n line_index = self._read_skeleton(lines, line_index, n_lines)\n if lines[line_index].startswith(\"MOTION\"):\n self._read_frametime(lines, line_index+2)\n line_index = self._read_frames(lines, line_index+3, n_lines)\n else:\n line_index += 1","def read_meta(metafn=None):\n\n metadata = {}\n\n # potential future improvement: strip quotation marks from strings, where applicable. Will then need to adjust\n # the indices used to get the dates and times in the functions above \n # (get_DEM_img_times: dtstrings = {\"sourceImage1\":(5,19, '%Y%m%d%H%M%S')})\n\n #each key is equated with '='. This loop strips and seperates then fills the dictonary.\n with open(metafn) as f: \n for line in f:\n if not line.strip(';') == \"END\":\n val = line.strip().split('=')\n if len(val) == 1:\n continue\n else:\n metadata.setdefault(val[0].strip(), []).append(val[1].strip().strip(';')) \n else:\n break\n\t\n return metadata","def parse_mapping_file(lines, strip_quotes=True, suppress_stripping=False):\r\n if hasattr(lines, \"upper\"):\r\n # Try opening if a string was passed\r\n try:\r\n lines = open(lines, 'U')\r\n except IOError:\r\n raise QiimeParseError(\"A string was passed that doesn't refer \"\r\n \"to an accessible filepath.\")\r\n\r\n if strip_quotes:\r\n if suppress_stripping:\r\n # remove quotes but not spaces\r\n strip_f = lambda x: x.replace('\"', '')\r\n else:\r\n # remove quotes and spaces\r\n strip_f = lambda x: x.replace('\"', '').strip()\r\n else:\r\n if suppress_stripping:\r\n # don't remove quotes or spaces\r\n strip_f = lambda x: x\r\n else:\r\n # remove spaces but not quotes\r\n strip_f = lambda x: x.strip()\r\n\r\n # Create lists to store the results\r\n mapping_data = []\r\n header = []\r\n comments = []\r\n\r\n # Begin iterating over lines\r\n for line in lines:\r\n line = strip_f(line)\r\n if not line or (suppress_stripping and not line.strip()):\r\n # skip blank lines when not stripping lines\r\n continue\r\n\r\n if line.startswith('#'):\r\n line = line[1:]\r\n if not header:\r\n header = line.strip().split('\\t')\r\n else:\r\n comments.append(line)\r\n else:\r\n # Will add empty string to empty fields\r\n tmp_line = map(strip_f, line.split('\\t'))\r\n if len(tmp_line) < len(header):\r\n tmp_line.extend([''] * (len(header) - len(tmp_line)))\r\n mapping_data.append(tmp_line)\r\n if not header:\r\n raise QiimeParseError(\"No header line was found in mapping file.\")\r\n if not mapping_data:\r\n raise QiimeParseError(\"No data found in mapping file.\")\r\n\r\n return mapping_data, header, comments","def parse_metadata_file(self, file):\n\n file_keys = list(file.keys())\n\n if 'labelAnnotations' in file_keys:\n file_annots = file['labelAnnotations']\n file_top_score = np.asarray(\n [x['score'] for x in file_annots]).mean()\n file_top_desc = [x['description'] for x in file_annots]\n else:\n file_top_score = np.nan\n file_top_desc = ['']\n\n file_colors = file['imagePropertiesAnnotation']['dominantColors'][\n 'colors']\n file_crops = file['cropHintsAnnotation']['cropHints']\n\n file_color_score = np.asarray([x['score'] for x in file_colors]).mean()\n file_color_pixelfrac = np.asarray(\n [x['pixelFraction'] for x in file_colors]).mean()\n\n file_crop_conf = np.asarray(\n [x['confidence'] for x in file_crops]).mean()\n\n if 'importanceFraction' in file_crops[0].keys():\n file_crop_importance = np.asarray(\n [x['importanceFraction'] for x in file_crops]).mean()\n else:\n file_crop_importance = np.nan\n\n df_metadata = {\n 'annots_score': file_top_score,\n 'color_score': file_color_score,\n 'color_pixelfrac': file_color_pixelfrac,\n 'crop_conf': file_crop_conf,\n 'crop_importance': file_crop_importance,\n 'annots_top_desc': self.sentence_sep.join(file_top_desc)\n }\n\n df_metadata = pd.DataFrame.from_dict(df_metadata, orient='index').T\n df_metadata = df_metadata.add_prefix('metadata_')\n\n return df_metadata","def test_getSampleMetadata(self):\r\n exp = {'BarcodeSequence': 'AGCACGAGCCTA', 'Treatment': 'Control',\r\n 'DOB': '20061218', 'Description': '354'}\r\n obs = self.overview_map.getSampleMetadata('PC.354')\r\n self.assertEqual(obs, exp)\r\n\r\n exp = {'BarcodeSequence': 'ACCAGCGACTAG', 'Treatment': 'Control',\r\n 'DOB': '20070314', 'Description': '481'}\r\n obs = self.map_with_comments.getSampleMetadata('PC.481')\r\n self.assertEqual(obs, exp)\r\n\r\n exp = {'BarcodeSequence': 'ACGGTGAGTGTC', 'Treatment': 'Fast',\r\n 'DOB': '20080116', 'Description': '636'}\r\n obs = self.map_with_comments.getSampleMetadata('PC.636')\r\n self.assertEqual(obs, exp)\r\n\r\n exp = {}\r\n obs = self.no_metadata.getSampleMetadata('PC.636')\r\n self.assertEqual(obs, exp)","def parse_metadata_file(self, file):\n \n file_keys = list(file.keys())\n \n if 'labelAnnotations' in file_keys:\n #file_annots = file['labelAnnotations'][:int(len(file['labelAnnotations']) * 0.5)]\n file_annots = file['labelAnnotations'][:]\n file_top_score = np.asarray([x['score'] for x in file_annots]).mean()\n file_top_desc = [x['description'] for x in file_annots]\n else:\n file_top_score = np.nan\n file_top_desc = ['']\n \n file_colors = file['imagePropertiesAnnotation']['dominantColors']['colors']\n file_crops = file['cropHintsAnnotation']['cropHints']\n\n file_color_score = np.asarray([x['score'] for x in file_colors]).mean()\n file_color_pixelfrac = np.asarray([x['pixelFraction'] for x in file_colors]).mean()\n\n file_crop_conf = np.asarray([x['confidence'] for x in file_crops]).mean()\n \n if 'importanceFraction' in file_crops[0].keys():\n file_crop_importance = np.asarray([x['importanceFraction'] for x in file_crops]).mean()\n else:\n file_crop_importance = np.nan\n\n df_metadata = {\n 'annots_score': file_top_score,\n 'color_score': file_color_score,\n 'color_pixelfrac': file_color_pixelfrac,\n 'crop_conf': file_crop_conf,\n 'crop_importance': file_crop_importance,\n 'annots_top_desc': self.sentence_sep.join(file_top_desc)\n }\n \n df_metadata = pd.DataFrame.from_dict(df_metadata, orient='index').T\n df_metadata = df_metadata.add_prefix('metadata_')\n \n return df_metadata","def get_metadata(sessions):\n if not isinstance(sessions, list):\n sessions = list(sessions)\n\n for line in sessions:\n session_id = line['Sess.ID']\n if session_id: # we loaded a line with session info\n session_name = '{}_{}'.format(line['Experiment'], line['Sess.ID'])\n\n # Check if session is already in database\n # if database is not None and session_name in database.index:\n # print(colored('Session is already in database','yellow'))\n # continue\n\n # Create the metadata\n session_metadata = {}\n session_metadata['session_id'] = session_id\n session_metadata['experiment'] = line['Experiment']\n session_metadata['date'] = line['Date']\n session_metadata['mouse_id'] = line['MouseID']\n session_metadata['software'] = line['Software']\n session_metadata['number'] = line['Number']\n\n # initialize video data\n session_metadata['video_file_paths'] = []\n session_metadata['tdms_file_paths'] = []\n session_metadata['videodata'] = []\n\n # load data from .tdms and .avi fils\n for recording in line['Recordings']:\n path = os.path.join(line['Base fld'], line['Exp fld'], recording)\n videopaths = []\n for f in os.listdir(path):\n if '.avi' in f:\n videopaths.append(os.path.join(path, f))\n elif '.tdms' == f[-5:]:\n tdmspath = os.path.join(path, f)\n\n # add file paths to metadata\n session_metadata['video_file_paths'].append(videopaths)\n session_metadata['tdms_file_paths'].append(tdmspath)\n\n # Loop over each video and get the relevant data [e.g., number of frames, fps...]\n session_metadata['videodata'].append(get_session_videodata(videopaths))\n\n # Add to dictionary (or update entry)\n metadata_dict[session_name] = session_metadata\n return metadata_dict","def test_getSampleMetadata(self):\n exp = {'BarcodeSequence': 'AGCACGAGCCTA', 'Treatment': 'Control',\n 'DOB': '20061218', 'Description': '354'}\n obs = self.overview_map.getSampleMetadata('PC.354')\n self.assertEqual(obs, exp)\n\n exp = {'BarcodeSequence': 'ACCAGCGACTAG', 'Treatment': 'Control',\n 'DOB': '20070314', 'Description': '481'}\n obs = self.map_with_comments.getSampleMetadata('PC.481')\n self.assertEqual(obs, exp)\n\n exp = {'BarcodeSequence': 'ACGGTGAGTGTC', 'Treatment': 'Fast',\n 'DOB': '20080116', 'Description': '636'}\n obs = self.map_with_comments.getSampleMetadata('PC.636')\n self.assertEqual(obs, exp)\n\n exp = {}\n obs = self.no_metadata.getSampleMetadata('PC.636')\n self.assertEqual(obs, exp)","def parse_metadata(self):\n import csv\n f = open(self.seq_id_list)\n self.names = f.readlines()\n f.close()\n num_samples = len(self.names)\n for i in range(len(self.names)):\n self.names[i] = self.names[i].replace(\"\\n\", \"\")\n # Go through the combined metadata file - it has most of the data we need.\n metadata = csv.DictReader(open(self.nasmnt + \"WGSspades/reports/combinedMetadata.csv\"))\n metadata_count = 0\n for row in metadata:\n # There has to be a more elegant way to do this.\n if row[\"SampleName\"] in self.names:\n data = dict()\n data[\"Investigator\"] = row[\"Investigator\"]\n data[\"Coverage\"] = row[\"AverageCoverageDepth\"]\n data[\"TotalLength\"] = row[\"TotalLength\"]\n data[\"rST\"] = row[\"rMLSTsequenceType\"]\n data[\"PipelineVersion\"] = row[\"PipelineVersion\"]\n data[\"MLST\"] = row[\"MLSTsequencetype\"]\n data[\"geneSeekr\"] = row[\"geneSeekrProfile\"].split(\";\")\n self.metadata[row[\"SampleName\"]] = data\n metadata_count += 1\n # Need to look in external WGS spades as well.\n metadata = csv.DictReader(open(self.nasmnt + \"External_WGSspades/reports/combinedMetadata.csv\"))\n for row in metadata:\n # There has to be a more elegant way to do this.\n if row[\"SampleName\"] in self.names:\n data = dict()\n data[\"Investigator\"] = row[\"Investigator\"]\n data[\"Coverage\"] = row[\"AverageCoverageDepth\"]\n data[\"TotalLength\"] = row[\"TotalLength\"]\n data[\"rST\"] = row[\"rMLSTsequenceType\"]\n data[\"PipelineVersion\"] = row[\"PipelineVersion\"]\n data[\"MLST\"] = row[\"MLSTsequencetype\"]\n data[\"geneSeekr\"] = row[\"geneSeekrProfile\"].split(\";\")\n self.metadata[row[\"SampleName\"]] = data\n metadata_count += 1\n\n\n\n # Also need to go through the rMLST file to make sure that all rMLST genes are covered.\n rMLST_data = csv.DictReader(open(self.nasmnt + \"WGSspades/reports/rmlst.csv\"))\n metadata_count = 0\n for row in rMLST_data:\n if row[\"Strain\"] in self.names:\n self.metadata[row[\"Strain\"]][\"Matches\"] = row[\"Matches\"]\n metadata_count += 1\n # Check external runs.\n rMLST_data = csv.DictReader(open(self.nasmnt + \"External_WGSspades/reports/rmlst.csv\"))\n for row in rMLST_data:\n if row[\"Strain\"] in self.names:\n self.metadata[row[\"Strain\"]][\"Matches\"] = row[\"Matches\"]\n\n\n\n # Finally, need to get info on the MLST sequence type.\n metadata_count = 0\n mlst_data = csv.DictReader(open(self.nasmnt + \"WGSspades/reports/mlst.csv\"))\n for row in mlst_data:\n if row[\"Strain\"] in self.names:\n mlst = list()\n for i in range(1, 8):\n mlst.append(row[str(i)])\n self.metadata[row[\"Strain\"]][\"mlst_info\"] = mlst\n metadata_count += 1\n\n # Also from External.\n mlst_data = csv.DictReader(open(self.nasmnt + \"External_WGSspades/reports/mlst.csv\"))\n for row in mlst_data:\n if row[\"Strain\"] in self.names:\n mlst = list()\n for i in range(1, 8):\n mlst.append(row[str(i)])\n self.metadata[row[\"Strain\"]][\"mlst_info\"] = mlst\n metadata_count += 1\n\n # Go through the ROGA Summary file from the access DB to get strain/textual IDs, and 1' and 2' enzymes.\n try: # Assume we're using ROGA summary OLF. If it isn't there, assume ROGA summary OLC\n df = pd.read_excel('ROGA_summary_OLF.xlsx')\n for i in df.index:\n if df['SeqTracking_SEQID'][i] in self.names:\n seqid = df['SeqTracking_SEQID'][i]\n self.metadata[seqid][\"IsolateID\"] = df['Isolate ID'][i]\n self.metadata[seqid][\"TextualID\"] = df['Textual ID'][i]\n self.metadata[seqid][\"1Enzyme\"] = df[\"1' Enzyme\"][i]\n self.metadata[seqid][\"2Enzyme\"] = df[\"2' Enzyme\"][i]\n self.metadata[seqid][\"Source\"] = df['Source'][i]\n self.metadata[seqid][\"ReceivedDate\"] = df['ReceivedDate'][i]\n self.metadata[seqid][\"SequenceDate\"] = df['SequenceDate'][i]\n self.metadata[seqid][\"SequencedBy\"] = df['SequenceBy'][i]\n metadata_count += 1\n\n\n except FileNotFoundError: # Should be a file not found error - look it up.\n metadata_count = 0\n df = pd.read_excel('ROGA_summary_OLC.xlsx')\n for i in df.index:\n if df['SeqTracking_SEQID'][i] in self.names:\n seqid = df['SeqTracking_SEQID'][i]\n self.metadata[seqid][\"IsolateID\"] = df['OLN ID'][i]\n self.metadata[seqid][\"TextualID\"] = df['Lab ID'][i]\n self.metadata[seqid][\"ReceivedDate\"] = df['ReceivedDate'][i]\n self.metadata[seqid][\"SequenceDate\"] = df['SequenceDate'][i]\n self.metadata[seqid][\"SequencedBy\"] = df['SequenceBy'][i]\n metadata_count += 1\n # print(self.metadata)\n self.check_for_empty_data()","def test_parseMetadataMap(self):\n obs = MetadataMap.parseMetadataMap(self.overview_map_str)\n self.assertEqual(obs, self.overview_map)","def get_Metadata(metafile):\n\n mslist_file = open(metafile, 'r')\n LINES = mslist_file.readlines()\n mslist_file.close()\n\n nBlocks = 6 # these are the number of correlator cards (PILOT survey value)\n \n obs_date = 'Observed from'\n code = 'Code'\n duration = 'Total elapsed time'\n antenna = 'antennas'\n frame = 'Frame'\n \n for i in range(len(LINES)):\n line = LINES[i]\n if line.find(antenna) >=0:\n TOKS = line.split()\n n_ant = TOKS[5][-2:]\n if line.find(obs_date) >=0:\n TOKS = line.split()\n start_obs_date = TOKS[6]\n end_obs_date = TOKS[8]\n if line.find(duration) >=0:\n TOKS = line.split()\n tobs = float(TOKS[10]) # in second\n if line.find(code) >= 0:\n next_line = LINES[i+1]\n TOKS = next_line.split()\n field = TOKS[5]\n ra = TOKS[6][:-5]\n dec = TOKS[7][:-4]\n if line.find(frame) >= 0:\n next_line = LINES[i+1]\n TOKS = next_line.split()\n total_obs_bw = float(TOKS[10])*nBlocks/1000.0 # kHz to MHz \n \n return n_ant, start_obs_date, end_obs_date, tobs, field, ra, dec, total_obs_bw","def test_parseMetadataMap(self):\r\n obs = MetadataMap.parseMetadataMap(self.overview_map_str)\r\n self.assertEqual(obs, self.overview_map)","def read_metadata(metapath):\r\n with open(metapath) as metaFile:\r\n metadata = {}\r\n for line in metaFile.readlines():\r\n if \"=\" in line: # Get only key-value pairs\r\n l = line.split(\"=\")\r\n metadata[l[0].strip()] = l[1].strip()\r\n\r\n return metadata","def parse_metadata(filename):\n with open(filename, 'r') as f:\n reader = csv.DictReader(f)\n metadata = {}\n for row in reader:\n key = row.pop('sample_filename')\n if key in metadata:\n print('WARNING: duplicate sample_id \"' + key + '\" found in \"' + filename + '\". The previous value(s) will be overwritten.')\n metadata[key] = row\n return metadata","def MinimalBpseqParser(lines):\n result = {'HEADER':[], 'SEQ_STRUCT':[]}\n \n for line in lines:\n if line.startswith('Filename') or line.startswith('Organism') or\\\n line.startswith('Accession') or line.startswith('Citation') or\\\n \":\" in line:\n result['HEADER'].append(line.strip())\n elif len(line.split()) == 3:\n result['SEQ_STRUCT'].append(line.strip())\n else:\n continue #unknown\n return result","def _parse_metadata(histline: str) -> Optional[Tuple[datetime, int, str]]:\n matches = PATTERN.match(histline)\n if matches:\n g = matches.groups()\n return (parse_datetime_sec(g[0]), int(g[1]), g[2])\n return None","def get_metadata(diagnostics_dir, verbose=False):\n metafile = find_metadata_file(diagnostics_dir, 'mslist-2*txt', verbose=False)\n\n with open(metafile, 'r') as mslist_file:\n lines = mslist_file.readlines()\n\n nBlocks = 6 # these are the number of correlator cards (PILOT survey value)\n \n obs_metadata = ObservationMetadata()\n\n obs_date = 'Observed from'\n fields = 'Fields'\n code = 'Code'\n duration = 'Total elapsed time'\n antenna = 'antennas'\n frame = 'Frame'\n \n field_list = []\n\n for i in range(len(lines)):\n line = lines[i]\n if line.find(antenna) >=0:\n toks = line.split()\n obs_metadata.n_ant = toks[5][-2:]\n if line.find(obs_date) >=0:\n toks = line.split()\n obs_metadata.start_obs_date = toks[6]\n obs_metadata.end_obs_date = toks[8]\n if line.find(duration) >=0:\n toks = line.split()\n obs_metadata.tobs = float(toks[10]) # in second\n\n # Field details\n if line.find(fields) >=0:\n toks = line.split()\n obs_metadata.num_fields = int(toks[-1])\n\n if line.find(code) >= 0:\n for j in range(obs_metadata.num_fields):\n field_metadata = FieldMetadata()\n field_line = lines[i+j+1]\n toks = field_line.split()\n field_metadata.name = toks[5]\n field_metadata.ra = toks[6][:-5]\n field_metadata.dec = toks[7][:-4]\n field_metadata.num_rows = int(toks[9])\n obs_metadata.fields.append(field_metadata)\n\n if line.find(frame) >= 0:\n next_line = lines[i+1]\n toks = next_line.split()\n obs_metadata.total_obs_bw = float(toks[10])*nBlocks/1000.0 # kHz to MHz \n \n return obs_metadata #n_ant, start_obs_date, end_obs_date, tobs, field, ra, dec, total_obs_bw","def parse_metadata_file(filename,\n logger,\n study_id=None,\n genome_name=None,\n case_list=False):\n \n logger.debug('Starting validation of meta file', extra={'filename_': filename})\n \n metaDictionary = {}\n with open(filename, 'rU') as metafile:\n for line_index, line in enumerate(metafile):\n # skip empty lines:\n if line.strip() == '':\n continue\n if ':' not in line:\n logger.error(\n \"Invalid %s file entry, no ':' found\",\n {True: 'case list', False: 'meta'}[case_list],\n extra={'filename_': filename,\n 'line_number': line_index + 1})\n meta_file_type = None\n return metaDictionary, meta_file_type\n key_value = line.split(':', 1)\n if len(key_value) == 2:\n metaDictionary[key_value[0]] = key_value[1].strip()\n\n if case_list:\n meta_file_type = MetaFileTypes.CASE_LIST\n else:\n meta_file_type = get_meta_file_type(metaDictionary, logger, filename)\n # if type could not be inferred, no further validations are possible\n if meta_file_type is None:\n return metaDictionary, meta_file_type\n\n missing_fields = []\n for field in META_FIELD_MAP[meta_file_type]:\n mandatory = META_FIELD_MAP[meta_file_type][field]\n if field not in metaDictionary and mandatory:\n logger.error(\"Missing field '%s' in %s file\",\n field,\n {True: 'case list', False: 'meta'}[case_list],\n extra={'filename_': filename})\n missing_fields.append(field)\n\n if missing_fields:\n meta_file_type = None\n # all further checks would depend on these fields being present\n return metaDictionary, meta_file_type\n\n # validate genetic_alteration_type, datatype, stable_id\n stable_id_mandatory = META_FIELD_MAP[meta_file_type].get('stable_id',\n False)\n if stable_id_mandatory:\n valid_types_and_id = validate_types_and_id(metaDictionary, logger, filename)\n if not valid_types_and_id:\n # invalid meta file type\n meta_file_type = None\n return metaDictionary, meta_file_type\n\n for field in metaDictionary:\n if field not in META_FIELD_MAP[meta_file_type]:\n logger.warning(\n 'Unrecognized field in %s file',\n {True: 'case list', False: 'meta'}[case_list],\n extra={'filename_': filename,\n 'cause': field})\n\n # check that cancer study identifiers across files so far are consistent.\n if (\n study_id is not None and\n 'cancer_study_identifier' in metaDictionary and\n study_id != metaDictionary['cancer_study_identifier']):\n logger.error(\n \"Cancer study identifier is not consistent across \"\n \"files, expected '%s'\",\n study_id,\n extra={'filename_': filename,\n 'cause': metaDictionary['cancer_study_identifier']})\n # not a valid meta file in this study\n meta_file_type = None\n return metaDictionary, meta_file_type\n\n # type-specific validations\n if meta_file_type in (MetaFileTypes.SEG, MetaFileTypes.GISTIC_GENES):\n if genome_name is not None and metaDictionary['reference_genome_id'] != genome_name:\n logger.error(\n 'Reference_genome_id is not %s',\n genome_name,\n extra={'filename_': filename,\n 'cause': metaDictionary['reference_genome_id']})\n meta_file_type = None\n if meta_file_type == MetaFileTypes.MUTATION:\n if ('swissprot_identifier' in metaDictionary and\n metaDictionary['swissprot_identifier'] not in ('name',\n 'accession')):\n logger.error(\n \"Invalid swissprot_identifier specification, must be either \"\n \"'name' or 'accession'\",\n extra={'filename_': filename,\n 'cause': metaDictionary['swissprot_identifier']})\n meta_file_type = None\n\n logger.info('Validation of meta file complete', extra={'filename_': filename})\n return metaDictionary, meta_file_type","def getTracksFromMitiFile(lines):\n\n tracks = {}\n\n for line in lines:\n items = line.strip().split()\n if len(items) < 9 or len(items) > 10:\n raise Exception(\"are input data file lines in MITI format? Found one had %i items\" % len(items))\n curTrackId = int(items[0])\n\n if not tracks.has_key(curTrackId):\n tracks[curTrackId] = Track([])\n\n newDet = Detection(line)\n tracks[curTrackId].addDetection(newDet)\n \n\n return tracks","def Parse(filename):\n\n f = open(filename, 'r')\n\n metadata = Metadata()\n data = [] # array of dataset\n dataset = None\n\n for num, line in enumerate(f):\n try:\n line = line.strip()\n if not line: continue\n\n if not metadata.complete:\n metadata.Parse(line)\n continue\n\n if re.match('[a-z_]', line):\n continue\n\n if line.startswith('# StopWatch'): # Start of a new dataset\n if dataset:\n if dataset.summary:\n metadata.UpdateWith(dataset)\n else:\n data.append(dataset)\n\n dataset = DataSet(line)\n continue\n\n if line.startswith('#'):\n continue\n\n # must be data at this stage\n try:\n (time, value) = line.split(None, 1)\n except ValueError:\n print 'skipping line %d: %s' % (num, line)\n continue\n\n if dataset and not dataset.summary:\n dataset.Add(float(time), float(value))\n\n except Exception:\n print 'Error parsing line %d' % num, sys.exc_info()[0]\n raise\n data.append(dataset)\n if not metadata.complete:\n print \"\"\"Error missing metadata. Did you mount debugfs?\n [adb shell mount -t debugfs none /sys/kernel/debug]\"\"\"\n sys.exit(1)\n return (metadata, data)","def parse_lines(lines):\n for line in lines:\n yield Record(line)","def ExtractTrackInformation(lines):\n\n # The starting line should be something like ' TRACK 01 AUDIO'\n # and we want to create ``data = {'track': '1'}``\n # NB: Cue format has a 99 track limit\n data = {\"track\": CueMetadata.ExtractProperty(lines[0], \"TRACK\")[0:2].lstrip(\"0\")}\n\n # Parse the remaining lines for this track to find the track starting time\n # which is typically, but not necessarily, a line starting with ' INDEX 01'\n # Also want to pick up any extra tags in the block and store it in ``data``,\n # eg, the 'TITLE' field. Since not all fields are valid but remarks are\n # it's necessary to \"un-remark\" the lines starting with 'REM '\n times = {}\n for line in lines[1:]:\n if not line.startswith(' ' * 4):\n break\n line = line.strip()\n # Don't consider multi-artist albums\n if line.startswith(\"PERFORMER\"):\n continue\n line = line.replace(\"INDEX \", \"INDEX\") # Turn 'INDEX 01' into 'INDEX01', etc.\n line = line.replace(\"REM \", \"\") # Make remarks appear as valid tags\n name = line.split(\" \")[0]\n info = CueMetadata.ExtractProperty(line, name)\n if not info:\n continue\n name = name.lower()\n if \"INDEX\" in line:\n # Handle these time codes separately since there may be more than one\n times[name] = time.CueTimeToMKATime(info)\n else:\n data[name] = info\n # In CUE files, 'INDEX 00' is (typically) used for pre-gap and 'INDEX 01' denotes\n # the start of the actual track. Higher indices are possible, but rarely used,\n # typically for access to portions of songs. Here we want to prefer 'INDEX 01'\n # and use 'INDEX 00' if there is no 'INDEX 01' while ignoring higher indices.\n for idx in [\"index01\", \"index00\"]:\n if idx in times:\n time_code = idx\n break\n else:\n raise CueFormatError(f\"No valid time codes found for track {data['track']}\")\n data[\"start_time\"] = times[time_code]\n return data","def parse_metadata(metadata):\n id_to_classes_recount = {}\n with open(metadata, \"r\") as file:\n header = next(file)\n for line in file:\n try:\n splitted_line = line.split(\"\\n\")[0].split(\"\\t\")\n file_id = splitted_line[22]\n project = splitted_line[77]\n sample_type = splitted_line[107]\n if project == \"TCGA-LIHC\":\n if sample_type == 'Primary Tumor':\n id_to_classes_recount[file_id] = 1\n elif sample_type == 'Solid Tissue Normal':\n id_to_classes_recount[file_id] = 0\n elif sample_type == 'Recurrent Tumor':\n id_to_classes_recount[file_id] = 1\n else:\n print(sample_type)\n except:\n pass\n return id_to_classes_recount","def sample_ids_from_metadata_description(mapping_f, valid_states_str):\r\n map_data, map_header, map_comments = parse_mapping_file(mapping_f)\r\n valid_states = parse_metadata_state_descriptions(valid_states_str)\r\n sample_ids = get_sample_ids(map_data, map_header, valid_states)\r\n\r\n if len(sample_ids) < 1:\r\n raise ValueError(\"All samples have been filtered out for the criteria\" +\r\n \" described in the valid states\")\r\n\r\n return sample_ids","def test_parse_metadata_0(self):\n data = ET.parse(\"data/metadata_0.xml\")\n data_str = ET.tostring(data.getroot())\n\n dict = tesse_ros_bridge.utils.parse_metadata(data_str)\n self.assertEqual(dict['position'], [-5.692576, 2.499105, 10.63836])\n self.assertEqual(dict['quaternion'], [0, 0.5372996, 0, 0.8433914])\n self.assertEqual(dict['velocity'], [0, -0.0004944276, 0])\n self.assertEqual(dict['ang_vel'], [0, 0, 0])\n self.assertEqual(dict['acceleration'], [0, 0.001516496, 0])\n self.assertEqual(dict['ang_accel'], [0, 0, 0])\n self.assertEqual(dict['time'], 7.935)\n self.assertEqual(dict['collision_status'], False)","def extract_metadata(rawfile,codeversions={}):\r\n import datetime\r\n add_standard_metadata(rawfile)\r\n # get monochromator-related information\r\n mom = average_metadata(rawfile['$entry/instrument/crystal/omega'])\r\n tk_angle = average_metadata(rawfile['$entry/instrument/crystal/takeoff_angle'])\r\n # get the date\r\n date_form = datetime.datetime.strptime(str(rawfile['$entry/start_time']),\"%Y-%m-%d %H:%M:%S\")\r\n mono_change = datetime.datetime(2009,04,01)\r\n if date_form < mono_change:\r\n monotype = \"115\"\r\n else:\r\n monotype = \"335\"\r\n hklval = pick_hkl(mom - tk_angle/2.0,monotype)\r\n if len(hklval)==3: # i.e. h,k,l found\r\n rawfile.add_metadata(\"_pd_instr_monochr_pre_spec\",\r\n hklval + \" reflection from Ge crystal, \"+monotype+\" cut\",tag=\"CIF\")\r\n wavelength = calc_wavelength(hklval,tk_angle)\r\n rawfile.add_metadata(\"_diffrn_radiation_wavelength\",\"%.3f\" % wavelength,tag=\"CIF\")\r\n rawfile.add_metadata(\"_[local]_diffrn_radiation_wavelength_determination\",\r\n \"Wavelength is calculated from monochromator hkl and takeoff angle and is therefore approximate\",\r\n tag=\"CIF\")\r\n # The following is changed later if the primary collimator is found to be inserted\r\n rawfile.add_metadata(\"_pd_instr_divg_eq_src/mono\",\"%.3f\" % (0.099*2.0*wavelength),tag=\"CIF\")\r\n # Do some logic to obtain collimator positions\r\n pcr = average_metadata(rawfile[\"$entry/instrument/collimator/primary_collimator_rotation\"])\r\n pcx = average_metadata(rawfile[\"$entry/instrument/collimator/primary_collimator_translation\"])\r\n if pcx > 120:\r\n if abs(pcr-360.0)<5 or abs(pcr) < 5: # 5' collimator\r\n coll_string = \"A 5' primary collimator pre-monochromator\"\r\n rawfile.add_metadata(\"_pd_instr_divg_eq_src/mono\",\"0.0833\",tag=\"CIF\")\r\n else:\r\n coll_string = \"A 10' primary collimator pre-monochromator\"\r\n rawfile.add_metadata(\"_pd_instr_divg_eq_src/mono\",\"0.1667\",tag=\"CIF\")\r\n else: coll_string = \"No primary monochromator \"\r\n try:\r\n scr = average_metadata(rawfile['$entry/sample/secondary_collimator'])\r\n if scr>0.5:\r\n coll_string += \" and a 10' secondary collimator post-monochromator.\"\r\n rawfile.add_metadata(\"_pd_instr_divg_eq_mono/spec\",\"0.1667\",tag=\"CIF\")\r\n else:\r\n coll_string += \" and no secondary collimator.\"\r\n rawfile.add_metadata(\"_diffrn_radiation_collimation\",coll_string,tag=\"CIF\")\r\n except AttributeError: #some early files are missing secondary collimator\r\n pass\r\n # These values were in the CIF writing area of the Java routines, best put here\r\n try:\r\n program_release = str(rawfile[\"$entry/program_revision\"])\r\n except AttributeError:\r\n program_release = str(rawfile[\"$entry/sics_release\"])\r\n rawfile.add_metadata(\"_computing_data_collection\",str(rawfile[\"$entry/program_name\"]) + \" \" + \\\r\n program_release,\"CIF\")\r\n # List the code versions used for data reduction\r\n codelist = \"\"\r\n for key in codeversions.keys():\r\n codelist += \"%-20s: %s\\n\" % (key,codeversions[key])\r\n rawfile.add_metadata(\"_computing_data_reduction\", str(\"Gumtree Echidna/Python routines, Git versions:\\n\" + codelist),\"CIF\")\r\n rawfile.add_metadata(\"_pd_spec_special_details\",sanitize(str(rawfile[\"$entry/sample/name\"])),\"CIF\")\r\n rawfile.add_metadata(\"_[local]_data_collection_description\",str(rawfile[\"$entry/sample/description\"]),\"CIF\")\r\n start_time = str(rawfile[\"$entry/start_time\"]).replace(\" \",\"T\")\r\n end_time = str(rawfile[\"$entry/end_time\"]).replace(\" \",\"T\")\r\n rawfile.add_metadata(\"_pd_meas_datetime_initiated\", start_time,\"CIF\")\r\n rawfile.add_metadata(\"_[local]_datetime_completed\", end_time,\"CIF\")\r\n try:\r\n username = str(rawfile[\"user_name\"])\r\n except:\r\n username = \"?\"\r\n rawfile.add_metadata(\"_pd_meas_info_author_name\", sanitize(username),\"CIF\")\r\n rawfile.add_metadata(\"_pd_meas_info_author_email\", str(rawfile[ \"$entry/user/email\"]),\"CIF\")\r\n rawfile.add_metadata(\"_pd_meas_info_author_phone\", str(rawfile[ \"$entry/user/phone\"]),\"CIF\")\r\n rawfile.add_metadata(\"_pd_instr_2theta_monochr_pre\",\"%.3f\" % tk_angle,\"CIF\")\r\n rawfile.add_metadata(\"_pd_instr_dist_mono/spec\", \"%.1f\" % average_metadata(rawfile[ \"$entry/sample/mono_sample_mm\"]),\"CIF\")\r\n rawfile.add_metadata(\"_pd_instr_dist_spec/detc\",\"%.1f\" % average_metadata(rawfile[\"$entry/instrument/detector/radius\"]),\"CIF\")\r\n try:\r\n rawfile.add_metadata(\"_diffrn_source_power\", \"%.2f\" % (average_metadata(rawfile[\"$entry/instrument/source/power\"])*1000),\"CIF\")\r\n except AttributeError: #sometimes source power is missing\r\n pass\r\n # imgCIF information about geometry\r\n # axis loop\r\n names = (('_axis.id','_axis.type','_axis.equipment','_axis.depends_on'),)\r\n values = [['source','gravity','stth','horizontal','vertical'],\r\n ['.','.','rotation','rotation','translation'],\r\n ['source','gravity','detector','detector','detector'],\r\n ['.','.','.','stth','stth']]\r\n rawfile.__dict__['ms'].AddCifItem((names,(values,)))\r\n radius = rawfile.__dict__['ms'][\"_pd_instr_dist_spec/detc\"]\r\n # add the vectors:\r\n \"\"\"\r\n source 0 0 1 . . .\r\n gravity -1 0 0 . . .\r\n stth 1 0 0 . . .\r\n horizontal 1 0 0 . . .\r\n vertical 1 0 0 0 0 -728\r\n \"\"\"\r\n vector_dict = {\"_axis.vector[1]\":['0','-1','1','1','1'],\r\n \"_axis.vector[2]\":['0','0','0','0','0'],\r\n \"_axis.vector[3]\":['1','0','0','0','0'],\r\n \"_axis.offset[1]\":['.','.','.','.','.'],\r\n \"_axis.offset[2]\":['.','.','.','.','.'],\r\n \"_axis.offset[3]\":['1','0','0','0',\"-\"+radius]}\r\n rawfile.__dict__['ms'].AddToLoop('_axis.id',vector_dict)\r\n # Add information about the stth positions for later use\r\n rawfile.add_metadata(\"_diffrn_scan.id\",\"1\",\"CIF\")\r\n rawfile.add_metadata(\"_diffrn_scan.frames\",rawfile.shape[0],\"CIF\")\r\n frame_ids = map(lambda a:\"%d\" % a,range(rawfile.shape[0]))\r\n stths = rawfile.stth[:]\r\n names = ((\"_diffrn_scan_frame.frame_id\",\"_diffrn_scan_frame.frame_number\"),)\r\n values = [frame_ids,range(1,rawfile.shape[0]+1)] #Spec says start from 1\r\n rawfile.__dict__['ms'].AddCifItem((names,(values,)))\r\n names = ((\"_diffrn_scan_frame_axis.frame_id\",\"_diffrn_scan_frame_axis.axis_id\",\r\n \"_diffrn_scan_frame_axis.angle\"),)\r\n values = [frame_ids,['stth']*rawfile.shape[0],map(float,stths)]\r\n rawfile.__dict__['ms'].AddCifItem((names,(values,)))\r\n return rawfile","def parse_meta_file(fname):\n flds = {}\n basename = re.match('(^.+?)\\..+', os.path.basename(fname)).groups()[0]\n flds['basename'] = basename\n with open(fname) as f:\n text = f.read()\n # split into items\n for item in re.split(';', text):\n # remove whitespace at beginning\n item = re.sub('^\\s+', '', item)\n match = re.match('(\\w+) = (\\[|\\{)(.*)(\\]|\\})', item, re.DOTALL)\n if match:\n key, _, value, _ = match.groups()\n # remove more whitespace\n value = re.sub('^\\s+', '', value)\n value = re.sub('\\s+$', '', value)\n # print key,':', value\n flds[key] = value\n # now check the needed things are there\n needed_keys = ['dimList', 'nDims', 'nrecords', 'dataprec']\n for k in needed_keys:\n assert k in flds\n # transform datatypes\n flds['nDims'] = int(flds['nDims'])\n flds['nrecords'] = int(flds['nrecords'])\n # endianness is set by _read_mds\n flds['dataprec'] = np.dtype(re.sub(\"'\", '', flds['dataprec']))\n flds['dimList'] = [[int(h) for h in\n re.split(',', g)] for g in\n re.split(',\\n', flds['dimList'])]\n if 'fldList' in flds:\n flds['fldList'] = [re.match(\"'*(\\w+)\", g).groups()[0] for g in\n re.split(\"'\\s+'\", flds['fldList'])]\n assert flds['nrecords'] == len(flds['fldList'])\n return flds","def test_filter_mapping_file_by_metadata_states(self):\r\n actual = filter_mapping_file_by_metadata_states(\r\n self.tutorial_mapping_f,\r\n \"Treatment:Control\")\r\n expected = \"\"\"#SampleID\tBarcodeSequence\tLinkerPrimerSequence\tTreatment\tDOB\tDescription\r\nPC.354\tAGCACGAGCCTA\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._354\r\nPC.355\tAACTCGTCGATG\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._355\r\nPC.356\tACAGACCACTCA\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061126\tControl_mouse_I.D._356\r\nPC.481\tACCAGCGACTAG\tYATGCTGCCTCCCGTAGGAGT\tControl\t20070314\tControl_mouse_I.D._481\r\nPC.593\tAGCAGCACTTGT\tYATGCTGCCTCCCGTAGGAGT\tControl\t20071210\tControl_mouse_I.D._593\"\"\"\r\n self.assertEqual(actual, expected)","def metadata(self, tokens):\n\n return self.process_value_pairs(tokens, \"metadata\")","def read_metadata(\n filename: Union[Path, str], marker: str = \"---\", **kwargs: Any\n) -> Dict[str, Any]:\n return read_header(filename, marker, **kwargs)[0]","def get_metadata(self, chunk, coords):\n\n return chunk.get_metadata(coords)","def load_metadata(self, path):\n self.paths = []\n self.annotations = []\n\n with open(path, \"r\") as f:\n for line in f:\n line = line.strip().split(\" \")\n \n rgb_path = line[0]\n\n if len(line) > 1:\n bounding_boxes = np.array([list(map(int, box.split(','))) for box in line[1:]])\n else:\n bounding_boxes = []\n \n self.annotations.append({\n \"rgb_path\": rgb_path, \n \"bounding_boxes\": bounding_boxes,\n })","def get_taxa(taxa_fname, sample_ids):\n try:\n lines = open(taxa_fname, 'U').readlines()\n except (TypeError, IOError):\n raise MissingFileError, 'Taxa summary file required for this analysis'\n map = parse_mapping_file(lines)\n return map","def parse_lines(filename):\n line_counter = 0\n with open(filename, 'r') as rf:\n for line_txt in rf:\n try:\n d = json.loads(line_txt)\n tup = (\n d['attributed_to'],\n int(d['date_time'][8:10]),\n d.get('used_first_time_today', False),\n d.get('first_utm_source', 'unknown') \n )\n except:\n print('Error parsing line_txt:', line_txt)\n line_counter += 1\n if line_counter % 10 ** 6 == 0:\n print('read %dM lines' % (line_counter // 10 ** 6))\n yield tup # yield: https://stackoverflow.com/a/231855","def test_filter_mapping_file_by_metadata_states(self):\n actual = filter_mapping_file_by_metadata_states(self.tutorial_mapping_f,\"Treatment:Control\")\n expected = \"\"\"#SampleID\tBarcodeSequence\tLinkerPrimerSequence\tTreatment\tDOB\tDescription\nPC.354\tAGCACGAGCCTA\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._354\nPC.355\tAACTCGTCGATG\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061218\tControl_mouse_I.D._355\nPC.356\tACAGACCACTCA\tYATGCTGCCTCCCGTAGGAGT\tControl\t20061126\tControl_mouse_I.D._356\nPC.481\tACCAGCGACTAG\tYATGCTGCCTCCCGTAGGAGT\tControl\t20070314\tControl_mouse_I.D._481\nPC.593\tAGCAGCACTTGT\tYATGCTGCCTCCCGTAGGAGT\tControl\t20071210\tControl_mouse_I.D._593\"\"\"\n self.assertEqual(actual,expected)","def parsemeta(metalines):\n def parseline(line):\n res = [val.strip() for val in line[5:].split(u':', 1)]\n key, value = (res[0], res[1]) if len(res) == 2 else (res[0], u'')\n if re.match(r'^-?\\d*[\\.|,]?\\d+$', value):\n value = float(value)\n elif re.match(r'^\\[(.*)\\]', value):\n value = [val.strip() for val in value[1:-1].split(u',')]\n value = [float(val) if re.match(r'^-?\\d*[\\.|,]?\\d+$', val) else val for val in value]\n return key, value\n return OrderedDict(parseline(line) for line in metalines if line.startswith(u'#CTE_'))","def parse_metadata_line(self, line, get_set=False):\n self.E_str = \"parse_metadata_line\"\n\n metadata_name_regex = \"[A-Za-z0-9_-]+\"\n metadata_regex = f\"{VAR_REGEX}\\['{metadata_name_regex}'\\]\"\n metadata_regex += f\"|{VAR_REGEX}\\['{metadata_name_regex}'\\]\"\n\n corr_syn = \"\\n\\tTo Set: <var_name>['<metadata_name>'] = <value>\\n\"\n corr_syn = \"\\n\\tTo Get: <var_name>['<metadata_name>']\"\n\n # First get the all the parts of the line that contain metadata references\n value = False\n str_part, non_str = gen_parse.get_str_between_delims(line, '\"')\n metadata_parts = re.findall(metadata_regex, line)\n\n # Now get the metadata name and variable name for each reference\n new_line = line\n all_var_names, all_metadata_names = [], []\n for var_i, var in enumerate(metadata_parts):\n new_line = new_line.replace(var, f\"METADATA_{var_i}\")\n\n # First get the variable name\n var = var.strip(' $')\n words = var.split('[')\n if len(words) != 2:\n self.print_error(f\"Syntax Error: Correct metadata syntax {corr_syn}\")\n var_name = words[0]\n\n # Is the metadata setting data or getting it?\n if get_set is not False:\n get_set = \"get\"\n if var_name in non_str.split('=')[0]:\n get_set = \"set\"\n\n # Next get the metadata name\n metadata_name, _ = gen_parse.get_str_between_delims(words[1], \"'\")\n if not metadata_name:\n metadata_name, _ = gen_parse.get_str_between_delims(words[1], '\"')\n if not metadata_name:\n self.print_error(f\"Correct syntax for metadata is: {corr_syn}\")\n\n # Now get the metadata value\n if var_name not in self.variables:\n self.print_error(f\"Undeclared variable '{var_name}'\")\n Var = getattr(self, var_name)\n\n err = metadata_name not in Var.metadata and get_set is not False\n err *= get_set == \"get\"\n if err:\n err_msg = f\"Can't find metadata '{metadata_name}' in variable '{var_name}'\"\n err_msg += \"\\n\\n\"\n err_msg += f\"{var_name} metadata: {Var.metadata}\"\n self.print_error(err_msg)\n\n all_var_names.append(var_name)\n all_metadata_names.append(metadata_name)\n\n return all_var_names, all_metadata_names, new_line","def parse_file(self):\n # the header was already read in the init, start at the first sample line\n\n for line in self._stream_handle:\n\n # create the dictionary of key/value pairs composed of the labels and the values from the\n # record being parsed\n # ex: data_dict = {'sci_bsipar_temp':10.67, n1, n2, nn}\n data_dict = self._read_data(line)\n\n if GliderParser._has_science_data(data_dict, self._particle_class):\n # create the timestamp\n timestamp = ntplib.system_to_ntp_time(float(data_dict[GliderParticleKey.M_PRESENT_TIME]))\n # create the particle\n self._record_buffer.append(self._extract_sample(\n self._particle_class, None, data_dict, internal_timestamp=timestamp))","def parse(self, lines):\n # convert file to string deleting end of line charcters\n citations_string = self.prepare_file(lines)\n # extract the entries from the string\n entries = list(self.find_entries(citations_string))\n entries.append(len(citations_string))\n # parse each entry to generate a citation\n for idx, jdx in zip(entries[:-1], entries[1:]):\n self.parse_entry(citations_string[idx:jdx])\n return self.force_field.citations","def parse(lines):\n blob_info = defaultdict(list, {})\n\n i = None\n for i, line in enumerate(lines):\n ld = line.split('%')\n\n # parse the first block with the generic stats\n lda = ld[0].split()\n blob_info['frame'].append(int(lda[0]))\n blob_info['time'].append(float(lda[1]))\n blob_info['centroid'].append((float(lda[2]), float(lda[3])))\n blob_info['area'].append(int(lda[4]))\n blob_info['std_vector'].append((float(lda[5]), float(lda[6])))\n blob_info['std_ortho'].append(float(lda[7]))\n blob_info['size'].append((float(lda[8]), float(lda[9])))\n\n # if there are geometry sections, parse them too.\n if len(ld) == 4:\n blob_info['midline'].append(tuple(zip(*alternate([int(x) for x in ld[1].split()]))))\n\n # contour data\n ldc = ld[3].split()\n blob_info['contour_start'].append((int(ldc[0]), int(ldc[1])))\n blob_info['contour_encode_len'].append(int(ldc[2]))\n blob_info['contour_encoded'].append(ldc[3])\n else:\n blob_info['midline'].append(None)\n blob_info['contour_start'].append((0, 0))\n blob_info['contour_encode_len'].append(None)\n blob_info['contour_encoded'].append(None)\n\n # check if blob was empty\n if i is None:\n return None\n\n # prevent referencing non-existant fields\n blob_info.default_factory = None\n\n # verify everything is the same length\n frames = len(blob_info['frame'])\n assert all(len(v) == frames for v in blob_info.values())\n\n return blob_info","def parse(lines, descriptions):\n # TODO does startswith with an empty string always return true?\n result = {}\n for description in descriptions: # Fill dict with empty arrays for all entries\n result[description[0]] = []\n\n for line in lines:\n words = line.split()\n for description in descriptions:\n try:\n result[description[0]].append(parse_line(words, description[0], description[1]))\n break\n except ValueError:\n pass\n return result","def parse_mapping_file_to_dict(*args, **kwargs):\r\n mapping_data, header, comments = parse_mapping_file(*args, **kwargs)\r\n return mapping_file_to_dict(mapping_data, header), comments","def _parse_metadata(config):\n if not config.active or config.device_metadata is None:\n return None\n\n width, height = config.width, config.height\n points = []\n for point in config.device_metadata.split(\"|\"):\n try:\n x, y = point.split(\";\")\n points.append([float(x) * width, float(y) * height])\n except:\n return None\n\n if len(points) != 4:\n return None\n\n return points","def get_metadata(hf_patients_file, metadata_file, output_file):\n\n # Use 'dicom_id' as names for row indices\n hf_patients = pd.read_csv(hf_patients_file, sep=',', index_col=\"dicom_id\")\n\n # Use 'dicom' as name\n metadata = pd.read_csv(metadata_file, index_col=\"dicom\", dtype={\"StudyDate\": str, \"StudyTime\": str})\n\n # Disregard all columns except 'subject_id' and 'study_id'\n hf_patients = pd.concat([hf_patients['study_id'], hf_patients['subject_id']], axis=1)\n\n # Find study date/time for heart failure patients\n study_date = metadata[\"StudyDate\"][hf_patients.index]\n study_time = metadata[\"StudyTime\"][hf_patients.index]\n\n result = pd.concat([hf_patients, study_date, study_time], axis=1)\n result = result.rename(columns={\"StudyDate\": \"study_date\", \"StudyTime\": \"study_time\"})\n\n result.to_csv(output_file)","def build_metadata(self, meta):\n if meta is None:\n try:\n self.parser = GenericParser(\n fn_re='{}/(e\\d+s\\d+)_.*/Production.nc'.format(self.data_folder),\n group_names=['sim'],\n group_transforms=[lambda x: x],\n top_fn='',\n step_ps=self.timestep\n )\n meta = gather_metadata('{}/e*/*nc'.format(self.data_folder), parser)\n except:\n logger.warning(\"Could not automatically build metadata\")\n return None\n else:\n if not isinstance(meta, pd.DataFrame):\n meta = load_meta(meta)\n return meta","def parse_metadata(source_text):\n meta = {}\n key = None\n lines = source_text.split('\\n')\n META_RE = re.compile(r'^[ ]{0,3}(?P<key>[A-Za-z0-9_-]+):\\s*(?P<value>.*)')\n META_MORE_RE = re.compile(r'^[ ]{4,}(?P<value>.*)')\n while 1:\n line = lines.pop(0)\n if line.strip() == '':\n break # blank line - done\n m1 = META_RE.match(line)\n if m1:\n key = m1.group('key').lower().strip()\n value = m1.group('value').strip()\n try:\n meta[key].append(value)\n except KeyError:\n meta[key] = [value]\n else:\n m2 = META_MORE_RE.match(line)\n if m2 and key:\n # Add another line to existing key\n meta[key].append(m2.group('value').strip())\n else:\n lines.insert(0, line)\n break # no meta data - done\n return (meta, '\\n'.join(lines))","def read_metadata_record(raw_features_string):\n all_data = json.loads(raw_features_string)\n metadata_keys = {\"sha256\", \"appeared\", \"label\", \"avclass\"}\n return {k: all_data[k] for k in all_data.keys() & metadata_keys}","def _parse_metadata ( self ):\n self.date = []\n self.atcorr_refl = []\n self.saa = []\n self.sza = []\n self.vaa = []\n self.vza = []\n self.res = []\n self._mask = []\n\n for md_file in self.metadata:\n tree = xml.etree.ElementTree.ElementTree ( file=md_file ).getroot()\n dirname = os.path.dirname ( md_file )\n try:\n self.date.append(\n datetime.datetime.strptime(tree[0][1].text, \"%Y-%m-%d %H:%M:%S\") )\n except:\n self.date.append(\n datetime.datetime.strptime(tree[0][1].text, \"%Y-%m-%d %H:%M:%S.%f\") )\n self.atcorr_refl.append(\n os.path.join ( dirname, tree[1][2].text ) )\n self.saa.append( float ( tree[4][10][0].text ) )\n self.sza.append( float ( tree[4][10][1].text ) )\n self.vaa.append( float ( tree[4][10][2].text ) )\n self.vza.append( float ( tree[4][10][3].text ) )\n self.res.append( float ( tree[2][1].text ) )\n self._mask.append( os.path.join ( dirname, tree[1][5].text ) )","def extract_metadata(source,\n is_metadata=is_metadata_line,\n parser=get_metadata,\n container=MetaData.from_raw_fields):\n class in_metadata(object):\n def __init__(self):\n self.in_metadata = True\n def __call__(self, line):\n if not is_metadata(line):\n self.in_metadata = False\n return self.in_metadata\n\n # Split the source, assuming metadata is at the beginning\n # (Keep only the group data, i)\n grouping = itertools.groupby(source, key=in_metadata())\n #grouping = itertools.imap(operator.itemgetter(1), grouping)\n has_metadata, first_group = next(grouping)\n if has_metadata:\n # We need to strictly consume all the group members here or\n # they will be lost to the groupby iterator process\n metadata_lines = list(first_group)\n _, body_iterator = next(grouping)\n else:\n # Use the first group if no metadata was seen\n metadata_lines = []\n body_iterator = first_group\n\n parsed = load(metadata_lines,\n is_metadata=is_metadata,\n container=container,\n parser=parser)\n return parsed, body_iterator","def extract_metadata(self):\n metadata_file_path = self.create_metadata_file(\".metadata.txt\")\n mt = self.mimetype\n metadata_processing_method = self.metadata_mimetype_methods.get(mt)\n if metadata_processing_method:\n # TODO: should we return metadata and write it here instead of in processing method?\n metadata_processing_method(metadata_file_path)","def LoadMetadata(filename):\r\n## print filename\r\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'*.zvi'))\r\n if globbed:\r\n return LoadZVIMetaData(globbed[0])\r\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'*.xml'))\r\n if globbed:\r\n return LoadAxioVisionXMLMetaData(globbed[0])\r\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'metadata.txt'))\r\n if globbed:\r\n return LoadMMMetaData(globbed[0])\r\n return None\r\n #no further valid options, crash horribly\r","def __init__(self, src_lines):\n self.study_id = None\n self.citation = None\n self.abstract = None\n self.authors = []\n self.study_matrices = {}\n self.history_date = None\n self.history_time = None\n self.history_person = None\n self.history_event = None\n self.analyses = []\n \n self.parse_src_lines(src_lines)","def _parse_metadata ( self ):\n self.date = []\n self.atcorr_refl = []\n self.saa = []\n self.sza = []\n self.vaa = []\n self.vza = []\n self.res = []\n self._mask = []\n for md_file in self.metadata:\n # This is required to get rid of the namespace cruft\n it = xml.etree.ElementTree.iterparse ( md_file )\n for _, el in it:\n el.tag = el.tag.split('}', 1)[1] # strip all namespaces\n tree = it.root\n\n dirname = os.path.dirname ( md_file )\n\n self.date.append( datetime.datetime.strptime(\n tree.find(\"global_metadata/acquisition_date\").text,\n \"%Y-%m-%d\") )\n\n for c in tree.findall (\"global_metadata/corner\"):\n if c.attrib['location'] == \"UL\":\n ulx = float ( c.attrib['longitude'] )\n uly = float ( c.attrib['latitude'] )\n else:\n lrx = float ( c.attrib['longitude'] )\n lry = float ( c.attrib['latitude'] )\n\n self.vaa.append ( get_vaa ( lrx, lry, ulx, uly ) )\n\n #self.atcorr_refl.append( os.path.join ( dirname, tree[1][2].text ) )\n self.saa.append(\n float ( tree.find(\"global_metadata/solar_angles\").attrib['azimuth'] ) )\n self.sza.append(\n float ( tree.find(\"global_metadata/solar_angles\").attrib['zenith'] ) )\n self.vza.append( 0.0 ) # Note that LDCM can look sideways a bit!\n self.res.append( 30. ) # 30m\n\n images = []\n mask = []\n for b in tree.findall(\"bands/band\"):\n if b.attrib['product'] == \"toa_refl\":\n fname = b.find(\"file_name\").text\n if fname.find ( \"qa.tif\" ) < 0:\n images.append ( os.path.join ( dirname, fname ) )\n elif b.attrib['product'] == \"cfmask\":\n mask = os.path.join ( dirname, fname )\n # Create VRT?\n subprocess.call ([\"gdalbuildvrt\", \"-overwrite\", \"-separate\",\n os.path.join ( dirname, md_file.replace(\".xml\", \"_crop.vrt\" )) ] + images )\n self.atcorr_refl.append ( os.path.join ( dirname,\n md_file.replace(\".xml\", \"_crop.vrt\" )) )\n self._mask.append( mask )","def parse_mca(f):\n for line in f:\n yield RECORD_TYPES[RecordIdentity(line[:2])].from_string(line)","def parse_metadata(path, site):\n headers = ['name', 'lat', 'lon', 'altitude', 'depth', 'prefecture', 'otherlat', 'otherlon', 'instrument']\n site_info = pd.read_csv(path, index_col=0, header=None).loc[site].values[0:9]\n return {header: site_info[i] for i, header in enumerate(headers)}","def parse_file(self, infile, chardict, labeldict):\n examples = []\n fin = io.open(infile, 'r')\n # idx is for the index of the row in the \n # original file before shuffling and randomization\n idx = 0\n for line in fin: \n entity, label = map(clean, line.rstrip().split('\\t')[:2])\n # print entity\n ent = map(lambda c:chardict[c], list(entity))\n lab = map(lambda l:labeldict[l] if l in labeldict else 0, label.split(','))\n examples.append((idx, ent, lab))\n idx += 1\n fin.close()\n print \"num_rows:\", len(examples), \" index\", idx\n return examples","def parse(self, src, line):\n r = line.split('\\t')\n p = {}\n if src == 'sf':\n p['businessID'] = r[0]\n p['name'] = r[1]\n p['address'] = r[2]\n p['city'] = r[3]\n p['state'] = r[4]\n p['zip'] = r[5]\n p['latitude'] = r[6]\n p['longitude'] = r[7]\n p['phone'] = r[8]\n elif src == 'nyc':\n p['businessID'] = r[0]\n p['name'] = r[1]\n # nyc separates the building number from the street name\n p['address'] = ' '.join([r[3].strip(), r[4].strip()])\n p['city'] = 'NYC'\n p['state'] = 'NY'\n p['zip'] = r[5]\n p['latitude'] = None\n p['longitude'] = None\n p['phone'] = r[6]\n return p","def test_metadata(self):\n cr = CaseReader(self.filename)\n self.assertEqual(cr.format_version, format_version,\n msg='incorrect format version')\n self.assertIsNone(cr.parameters,\n msg='parameter metadata should be None')\n self.assertIsNone(cr.unknowns, msg='unknown metadata should be None')","def test_parse_sample_file(self):\n parser = wv2_xml.Parser(\n 'imars_etl/drivers_metadata/wv2_xml/test_files/'\n 'WV02_20140218163417_103001002E0EB600_14FEB18163417-M1BS-'\n '500534956040_01_P004.xml'\n )\n metadata_read = parser.get_metadata()\n print('md: {}'.format(metadata_read))\n expected_subset = {\n \"time\": \"2014-02-18T16:34:17.926650\"\n }\n\n assert expected_subset.items() <= metadata_read.items()","def test_sample_ids_from_metadata_description(self):\n self.assertRaises(ValueError, sample_ids_from_metadata_description,\n self.tutorial_mapping_f, \"Treatment:Foo\")\n self.tutorial_mapping_f.seek(0)\n self.assertRaises(ValueError, sample_ids_from_metadata_description,\n self.tutorial_mapping_f, \"DOB:!20061218,!20070314,!20071112,\"\n \"!20080116\")","def parse(self):\n try:\n self.open_file()\n lines = list(self._file)\n\n if len(lines) > 0:\n text = ''.join(lines)\n regex = 'Song \\d+\\nStart (\\d+:\\d+:\\d+)\\nEnd (\\d+:\\d+:\\d+)\\nLength (\\d+.\\d+)'\n match = re.findall(regex, text)\n if len(match):\n starts = []\n ends = []\n lengths = []\n\n for i in range(len(match)):\n starts.append(match[i][0])\n ends.append(match[i][1])\n lengths.append(float(match[i][2]))\n\n for i in range(len(match)):\n self.debug_data.append({\n 'start':starts[i],'end':ends[i],'length':lengths[i]})\n\n match = re.search('T\\d_S(\\d{4})_.*.txt', self._filepath)\n if match:\n self._experiment_metadata['session_id'] = int(match.groups()[0])\n else:\n raise EIMParsingError(\"No valid session id found in filename %s\" % self._filepath)\n\n finally:\n if self._file and not self._file.closed:\n self.close_file()","def read_metadata(self, file=None):\n if file is None:\n file = self.meta_data_file\n\n try:\n self.meta_data = self.input_dataframe(file, index_col=None)\n except IOError:\n self.meta_data = self.create_default_meta_data(self.expression_matrix)","def test_parse_mapping_file(self):\r\n s1 = ['#sample\\ta\\tb', '#comment line to skip',\r\n 'x \\t y \\t z ', ' ', '#more skip', 'i\\tj\\tk']\r\n exp = ([['x', 'y', 'z'], ['i', 'j', 'k']],\r\n ['sample', 'a', 'b'],\r\n ['comment line to skip', 'more skip'])\r\n obs = parse_mapping_file(s1)\r\n self.assertEqual(obs, exp)\r\n\r\n # We don't currently support this, but we should soon...\r\n # check that first non-comment, non-blank line is used as\r\n # header\r\n # s1 = ['sample\\ta\\tb', '#comment line to skip',\\\r\n # 'x \\t y \\t z ', ' ', '#more skip', 'i\\tj\\tk']\r\n # exp = ([['x','y','z'],['i','j','k']],\\\r\n # ['sample','a','b'],\\\r\n # ['comment line to skip','more skip'])\r\n # obs = parse_mapping_file(s1)\r\n # self.assertEqual(obs, exp)\r\n\r\n # check that we strip double quotes by default\r\n s2 = ['#sample\\ta\\tb', '#comment line to skip',\r\n '\"x \"\\t\" y \"\\t z ', ' ', '\"#more skip\"', 'i\\t\"j\"\\tk']\r\n obs = parse_mapping_file(s2)\r\n self.assertEqual(obs, exp)","def parse_map(file):\n with open(FILE) as f:\n return Map([line[:-1] for line in f])","def extract_metadata(parser_config, snippet):\n return parser_config['implementation'](snippet)","def extract_meta_data(video_file_name, output_file=meta.txt, *args, **kwargs):","def extract_points(fp: T.BinaryIO) -> T.Optional[T.List[geo.Point]]:\n\n points = None\n movie_timescale = None\n media_timescale = None\n elst_entries = None\n\n for h, s in parser.parse_path(fp, [b\"moov\", [b\"mvhd\", b\"trak\"]]):\n if h.type == b\"trak\":\n trak_start_offset = s.tell()\n\n descriptions = sample_parser.parse_descriptions_from_trak(\n s, maxsize=h.maxsize\n )\n camm_descriptions = [d for d in descriptions if d[\"format\"] == b\"camm\"]\n if camm_descriptions:\n s.seek(trak_start_offset, io.SEEK_SET)\n camm_samples = _extract_camm_samples(s, h.maxsize)\n\n points_with_nones = (\n _parse_point_from_sample(fp, sample)\n for sample in camm_samples\n if sample.description[\"format\"] == b\"camm\"\n )\n\n points = [p for p in points_with_nones if p is not None]\n if points:\n s.seek(trak_start_offset)\n elst_data = parser.parse_box_data_first(\n s, [b\"edts\", b\"elst\"], maxsize=h.maxsize\n )\n if elst_data is not None:\n elst_entries = cparser.EditBox.parse(elst_data)[\"entries\"]\n\n s.seek(trak_start_offset)\n mdhd_data = parser.parse_box_data_firstx(\n s, [b\"mdia\", b\"mdhd\"], maxsize=h.maxsize\n )\n mdhd = cparser.MediaHeaderBox.parse(mdhd_data)\n media_timescale = mdhd[\"timescale\"]\n else:\n assert h.type == b\"mvhd\"\n if not movie_timescale:\n mvhd = cparser.MovieHeaderBox.parse(s.read(h.maxsize))\n movie_timescale = mvhd[\"timescale\"]\n\n # exit when both found\n if movie_timescale is not None and points:\n break\n\n if points and movie_timescale and media_timescale and elst_entries:\n segments = [\n elst_entry_to_seconds(entry, movie_timescale, media_timescale)\n for entry in elst_entries\n ]\n points = list(filter_points_by_elst(points, segments))\n\n return points","def read_metadata_record(raw_features_string):\n full_metadata = json.loads(raw_features_string)\n return {\"sha256\": full_metadata[\"sha256\"], \"appeared\": full_metadata[\"appeared\"], \"label\": full_metadata[\"label\"]}","def read_file(inp_fn):\n lines = [line.strip().split(\",\")\n for line in open(inp_fn)\n if not (line.startswith(\"#\"))]\n return [(int(line[0]), year_record({\"male\": int(line[-3]),\n \"female\": int(line[-2]),\n \"unknown\": int(line[-1])},\n None, None))\n for line in lines[1:]]","def get_lineid_content():\n lineid_content = {}\n lines_file_path = os.path.join(DATA_PATH + MOVIE_LINES_FILE)\n\n with open(lines_file_path, 'r', errors='ignore') as f:\n # +++$+++ is used to split the section in a single line\n # A correct formed line includes five sections\n # The first section is lineID\n # The last section is line content\n # Here we only need lineID and content\n\n for line in f:\n line_sections = line.split(' +++$+++ ')\n assert len(line_sections) == 5\n if line_sections[4][-1] == '\\n':\n line_sections[4] = line_sections[4][:-1]\n lineid_content[line_sections[0]] = line_sections[4]\n\n return lineid_content","def medline_parser(filename):\n pmid_abstract_dict = {}\n with open(filename) as handle:\n for record in Medline.parse(handle):\n if 'AB' in record.keys():\n pmid, abstract = record['PMID'], record['AB']\n pmid_abstract_dict[pmid] = abstract\n return pmid_abstract_dict","def get_metadata_from_path(path):\n try:\n import yaml\n # assumes index card is in the top-level of path\n index_card = os.path.join(path, \"M_index.yaml\")\n with open(index_card, \"r\") as stream:\n file_info = yaml.safe_load(stream)\n\n metadata_dict = {}\n metadata_dict[\"book_id\"] = file_info[\"book_id\"]\n metadata_dict[\"timestamp_start\"] = file_info[\"start_time\"]\n metadata_dict[\"type\"] = file_info[\"type\"]\n metadata_dict[\"obsid\"] = _convert_book_id_to_obsid(file_info[\"book_id\"])\n # get optional bits\n if \"stop_time\" in file_info:\n metadata_dict[\"timestamp_end\"] = file_info[\"stop_time\"]\n if \"observatory\" in file_info:\n metadata_dict[\"observatory\"] = file_info[\"observatory\"]\n if \"telescope\" in file_info:\n metadata_dict[\"telescope\"] = file_info[\"telescope\"]\n if \"stream_ids\" in file_info:\n metadata_dict[\"stream_ids\"] = file_info[\"stream_ids\"]\n if \"subtype\" in file_info:\n metadata_dict[\"subtype\"] = file_info[\"subtype\"]\n if \"tags\" in file_info:\n metadata_dict[\"tags\"] = file_info[\"tags\"]\n if \"scanification\" in file_info:\n metadata_dict[\"scanification\"] = file_info[\"scanification\"]\n if \"hwp_rate_hz\" in file_info:\n metadata_dict[\"hwp_rate_hz\"] = file_info[\"hwp_rate_hz\"]\n if \"sequencer_ref\" in file_info:\n metadata_dict[\"sequencer_ref\"] = file_info[\"sequencer_ref\"]\n return metadata_dict\n except (ImportError, FileNotFoundError, KeyError):\n pass\n\n return None","def test_parse_mapping_file_to_dict(self):\r\n s1 = ['#sample\\ta\\tb', '#comment line to skip',\r\n 'x \\t y \\t z ', ' ', '#more skip', 'i\\tj\\tk']\r\n exp = ([['x', 'y', 'z'], ['i', 'j', 'k']],\r\n ['sample', 'a', 'b'],\r\n ['comment line to skip', 'more skip'])\r\n mapdict, comments = parse_mapping_file_to_dict(s1)\r\n expdict = {'x': {'a': 'y', 'b': 'z'}, 'i': {'a': 'j', 'b': 'k'}}\r\n self.assertEqual(mapdict, expdict)\r\n self.assertEqual(comments, ['comment line to skip', 'more skip'])","def parse_metadata(self):\n micro_metadata = {}\n ext_meta = None\n self.content_type = 'text/html'\n if self.source_metadata:\n #print(self.source_metadata)\n if len(self.source_metadata)>1:\n try:\n for sm in self.source_metadata:\n if str(sm.get('type').split('/')[-1]).lower() in self.SCHEMA_ORG_CREATIVEWORKS:\n ext_meta = sm\n except:\n pass\n self.source_name = self.getEnumSourceNames().MICRODATA_EMBEDDED\n if not ext_meta:\n ext_meta = self.source_metadata[0]\n\n if ext_meta is not None:\n self.logger.info('FsF-F2-01M : Trying to extract Microdata metadata from -: {}'.format(self.source_name))\n # TODO check syntax - not ending with /, type and @type\n # TODO (important) extend mapping to detect other pids (link to related entities)?\n # TODO replace check_context_type list context comparison by regex\n check_context_type = ['Dataset', 'Collection']\n try:\n #if ext_meta['@context'] in check_context_type['@context'] and ext_meta['@type'] in check_context_type[\"@type\"]:\n if str(ext_meta.get('type')).find('schema.org') > -1:\n micro_metadata = jmespath.search(self.metadata_mapping.value, ext_meta)\n self.namespaces.append('http://schema.org/')\n else:\n self.logger.info('FsF-F2-01M : Failed to parse non schema.org type Microdata')\n except Exception as err:\n #print(err.with_traceback())\n self.logger.info('FsF-F2-01M : Failed to parse Microdata -: {}'.format(err))\n else:\n self.logger.info('FsF-F2-01M : Could not identify Microdata metadata')\n\n return self.source_name, micro_metadata","def loadContentSamplesFile(self, lines):\n refgenome = set()\n \n for line in lines:\n if line.startswith(\"#\"):\n continue\n \n tokens = line.rstrip(\"\\n\").split(\"\\t\")\n \n # create and fill a \"GbsSample\" object\n for samplesCol in [\"genotype\", \"flowcell\", \"lane\"]:\n if \"_\" in tokens[self.samplesCol2idx[samplesCol]]:\n msg = \"underscore in %s '%s', replace by dash '-'\" \\\n % (samplesCol, tokens[self.samplesCol2idx[samplesCol]])\n raise ValueError(msg)\n if \" \" in tokens[self.samplesCol2idx[samplesCol]]:\n msg = \"space in %s '%s', replace by dash '-'\" \\\n % (samplesCol, tokens[self.samplesCol2idx[samplesCol]])\n raise ValueError(msg)\n if \".\" in tokens[self.samplesCol2idx[samplesCol]]:\n msg = \"dot in %s '%s', replace by dash '-'\" \\\n % (samplesCol, tokens[self.samplesCol2idx[samplesCol]])\n raise ValueError(msg)\n geno = tokens[self.samplesCol2idx[\"genotype\"]]\n flowcell = tokens[self.samplesCol2idx[\"flowcell\"]]\n laneNum = int(tokens[self.samplesCol2idx[\"lane\"]])\n barcode = tokens[self.samplesCol2idx[\"barcode\"]]\n if self.fclnToKeep is not None and \\\n \"%s_%i\" % (flowcell, laneNum) != self.fclnToKeep:\n continue\n iSample = GbsSample(geno, flowcell, laneNum, barcode,\n \"before\" if int(self.lSteps[0]) < 3 \\\n else \"after\")\n iSample.refGenome = tokens[self.samplesCol2idx[\"ref_genome\"]]\n iSample.library = tokens[self.samplesCol2idx[\"library\"]]\n iSample.seqCenter = tokens[self.samplesCol2idx[\"seq_center\"]]\n iSample.seqPlatform = tokens[self.samplesCol2idx[\"seq_platform\"]]\n iSample.seqPlatformModel = tokens[self.samplesCol2idx[\"seq_platform_model\"]]\n iSample.date = tokens[self.samplesCol2idx[\"date\"]]\n iSample.initFastqFile1 \\\n = \"%s/%s\" % (self.pathToInReadsDir,\n tokens[self.samplesCol2idx[\"fastq_file_R1\"]])\n if tokens[self.samplesCol2idx[\"fastq_file_R2\"]] != \"\":\n iSample.initFastqFile2 \\\n = \"%s/%s\" % (self.pathToInReadsDir,\n tokens[self.samplesCol2idx[\"fastq_file_R2\"]])\n if iSample.id not in self.dSamples:\n self.dSamples[iSample.id] = iSample\n refgenome.add(iSample.refGenome)\n\n if flowcell not in self.dFlowcells:\n self.dFlowcells[flowcell] = []\n if laneNum not in self.dFlowcells[flowcell]:\n self.dFlowcells[flowcell].append(laneNum)\n\n # create and fill a \"GbsLane\" object\n laneId = \"%s_%i\" % (flowcell, laneNum)\n if laneId not in self.dLanes:\n self.dLanes[laneId] = GbsLane(laneId, flowcell, laneNum)\n self.dLanes[laneId].insert(iSample)\n\n # create and fill a \"GbsGeno\" object\n if geno not in self.dGenos:\n self.dGenos[geno] = GbsGeno(geno)\n self.dGenos[geno].insert(iSample)\n \n if (\"4\" in self.lSteps or \"5\" in self.lSteps or \"6\" in self.lSteps \\\n or \"7\" in self.lSteps or \"8\" in self.lSteps) \\\n and len(refgenome) > 1:\n print(refgenome)\n msg = \"samples file contains more than one reference genome\"\n raise ValueError(msg)","def parse_lineage(tsv_filename, sample_names, allow_missing=True):\n\n samples = {}\n\n if file_is_missing(tsv_filename, allow_missing):\n for name in sample_names:\n samples[name] = { 'lineage' : None,\n 'clade': None,\n 'pangolin_ver': None,\n 'pangodata_ver': None,\n 'nextclade_ver': None }\n return { 'samples': samples }\n\n lineages = pd.read_table(tsv_filename, sep='\\t')\n try:\n df = lineages[['isolate',\n 'pango_lineage',\n 'nextstrain_clade',\n 'pangolin_version',\n 'pangoLEARN_version',\n 'nextclade_version'\n ]]\n except KeyError:\n df = lineages[['isolate',\n 'pango_lineage',\n 'nextstrain_clade',\n 'pangolin_version',\n 'version',\n 'nextclade_version'\n ]]\n\n # Pull each row, identify sid \n for row in df.itertuples():\n if row.isolate.startswith(\"Consensus\"):\n sid = re.findall(\"_(.*?)\\.\", row.isolate)[0]\n else:\n sid = str(row.isolate)\n\n assert sid in sample_names\n\n # Pull Pangolin lineage\n lineage = str(row.pango_lineage)\n clade = str(row.nextstrain_clade)\n pangolin = str(row.pangolin_version)\n try:\n pangodata = str(row.pangoLEARN_version)\n except AttributeError:\n pangodata = str(row.version)\n nextclade = str(row.nextclade_version)\n samples[sid] = { 'lineage' : lineage,\n 'clade': clade,\n 'pangolin_ver': pangolin,\n 'pangodata_ver': pangodata,\n 'nextclade_ver': nextclade }\n\n assert len(samples) == len(sample_names)\n return { 'samples': samples }","def parse_line(line, patterns=None):\n if patterns is None:\n patterns = LINE_PATTERNS\n\n for line_re in patterns:\n match = line_re.match(line)\n if match:\n data = match.groupdict()\n av_pairs = data['av_pairs']\n data['av_pairs'] = cleanup_av_pairs(av_pairs)\n return data\n\n return None","def parse(self, filehandle):\n l = filehandle.readline()\n if l.split()[0] != '##maf':\n return\n else:\n self.setpar(l.split()[1:])\n\n l=filehandle.readline()\n while l:\n la = l.split()\n## print la\n if(len(la)==0 or la[0]=='#'):\n## print \"skipping\"\n 1\n elif(la[0]=='a'):\n## print \"reading alignment\"\n self.readalign(la[1:], filehandle)\n else:\n## print \"end of records\"\n return\n\n l=filehandle.readline()","def parse_record(self, in_rec):\n \n geo_util = geo.Geo()\n \n self.metadata = {}\n for k, v in in_rec.items():\n if k == 'metadata2': continue\n elif k == 'geometry':\n self.metadata['geometry'] = v\n coords = v['coordinates']\n self.metadata['wkt'] = geo_util.convert_imageGeom(\\\n coords, 'wkt')\n elif k == 'metadata':\n for m in v:\n key = to_camelCase(m[0])\n self.metadata[key] = m[1]\n else:\n self.metadata[k] = v","def load_metadata(self):\n handler = open('meta.xml').read()\n soup = BeautifulSoup(handler, 'xml')\n\n for meta in soup.find_all(re.compile(\"^title\")):\n if meta.string:\n self.meta_title = unicode(meta.string)\n\n for meta in soup.find_all(re.compile(\"^initial.creator\")):\n if meta.string:\n self.meta_initial_creator = unicode(meta.string)\n\n for meta in soup.find_all(re.compile(\"^date\")):\n if meta.string:\n self.meta_date = unicode(meta.string)","def load_metainfo(filename, dependencyLoader=None, extraArgsHandling=InfoKindEl.ADD_EXTRA_ARGS, uri=None):\n path = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), \"../../../../nomad-meta-info/meta_info/nomad_meta_info/{}\".format(filename)))\n return loadJsonFile(path, dependencyLoader, extraArgsHandling, uri)","def read_metadata_file():\n metadata = None\n if not os.path.isfile(META_DATA_FILE):\n ppg.log_info(\"No metadata found. The earthquake splitting might have not been ran yet.\")\n else:\n ppg.log_info(\"Found metadata file\")\n metadata = pd.read_csv(META_DATA_FILE)\n return metadata","def create_meta_dict_L1(adcp_meta):\n meta_dict = {}\n with open(adcp_meta) as csv_file:\n csv_reader = csv.reader(csv_file, delimiter=',')\n line_count = 0\n next(csv_reader, None) # Skip header row\n for row in csv_reader:\n # extract all metadata from csv file into dictionary -- some items not passed to netCDF file but are extracted anyway\n if row[0] == '' and row[1] == '':\n print('Metadata file contains a blank row; skipping this row !')\n elif row[0] != '' and row[1] == '':\n print('Metadata item in csv file has blank value; skipping this row '\n 'in metadata file !')\n else:\n meta_dict[row[0]] = row[1]\n\n # Add conventions metadata to meta_dict\n meta_dict['deployment_type'] = 'Sub Surface'\n meta_dict['flag_meaning'] = 'no_quality_control, good_value, probably_good_value, probably_bad_value, ' \\\n 'bad_value, changed_value, value_below_detection, value_in_excess, ' \\\n 'interpolated_value, missing_value'\n meta_dict['flag_references'] = 'BODC SeaDataNet'\n meta_dict['flag_values'] = '0, 1, 2, 3, 4, 5, 6, 7, 8, 9'\n meta_dict['keywords'] = 'Oceans > Ocean Circulation > Ocean Currents'\n meta_dict['keywords_vocabulary'] = 'GCMD Science Keywords'\n meta_dict['naming_authority'] = 'BODC, MEDS, CF v72'\n meta_dict['variable_code_reference'] = 'BODC P01'\n meta_dict['Conventions'] = \"CF-1.8\"\n\n return meta_dict","def parse_feature(self, feature_key, lines):\n ...","def get_metadata(self, t: Optional[int] = None) -> Dict:\n real_t = None if t is None else int(self._resolve_index(t))\n if self._is_tiff:\n ret = self._reader.metadata(index=..., page=real_t)\n else:\n ret = self._reader.metadata(index=real_t)\n self._parse_yaml_description(ret)\n if real_t is not None:\n ret[\"frame_no\"] = real_t\n return ret","def test_metadata():\n # Note: The json file should have been created with previous tests\n with open(file_struct.features_file) as f:\n data = json.load(f)\n assert(\"metadata\" in data.keys())\n metadata = data[\"metadata\"]\n assert(\"timestamp\" in metadata.keys())\n assert(metadata[\"versions\"][\"numpy\"] == np.__version__)\n assert(metadata[\"versions\"][\"msaf\"] == msaf.__version__)\n assert(metadata[\"versions\"][\"librosa\"] == librosa.__version__)","def get_metadata_from_json(sample_metadata_path):\n\n try:\n return normalize_metadata(json.loads(open(sample_metadata_path).read()))\n except IOError:\n logging.exception('get_metadata')\n return {}","def load_metadata_from_file(filename):\n try:\n extension = os.path.splitext(filename)[1]\n return _metadata_loader[extension](filename)\n except KeyError:\n raise TypeError('Cannot read metadata from file %s, extension %s not ' \n 'supported at this time' % (filename, extension))","def get_metadata(self,\n params: typing.Optional[typing.Mapping[str, str]] = None):\n raise NotImplementedError('This data connector does not provide metadata')","def _parse_metadata(self, md):\n md = ast.literal_eval(md)\n dd = defaultdict(list)\n\n for entry in md:\n try:\n for k, v in entry.items():\n dd[k].append(v)\n except AttributeError:\n continue\n return dd","def read(self, file_info, **kwargs):\n\n # We need to import at least the standard fields\n user_fields = kwargs.pop(\"fields\", {})\n fields = self.standard_fields | set(user_fields)\n\n # We catch the user mapping here, since we do not want to deal with\n # user-defined names in the further processing. Instead, we use our own\n # mapping\n user_mapping = kwargs.pop(\"mapping\", None)\n\n # Load the dataset from the file:\n dataset = super().read(\n file_info, fields=fields, mapping=self.mapping, **kwargs\n )\n\n dataset[\"time\"] = self._get_time_field(dataset, file_info)\n\n # Remove fields that we do not need any longer (expect the user asked\n # for them explicitly)\n dataset = dataset.drop_vars(\n {\"UTC_start\", \"Profile_time\"} - set(user_fields),\n )\n\n if user_mapping is not None:\n dataset = dataset.rename(user_mapping)\n\n return dataset","def test_mapping_file_to_dict(self):\r\n s1 = ['#sample\\ta\\tb', '#comment line to skip',\r\n 'x \\t y \\t z ', ' ', '#more skip', 'i\\tj\\tk']\r\n exp = ([['x', 'y', 'z'], ['i', 'j', 'k']],\r\n ['sample', 'a', 'b'],\r\n ['comment line to skip', 'more skip'])\r\n mapres = parse_mapping_file(s1) # map_data, header, comments\r\n mapdict = mapping_file_to_dict(*mapres[:2])\r\n expdict = {'x': {'a': 'y', 'b': 'z'}, 'i': {'a': 'j', 'b': 'k'}}\r\n self.assertEqual(mapdict, expdict)","def _parse_filename(filename, metadata):\n\n file_noext = os.path.splitext(filename)[0]\n fname = file_noext.split(\"_\")\n\n metadata[\"scene_id\"] = fname[1]\n metadata[\n \"beam_mode\"] = sat_properties.radarsat_product_characteristics[\n fname[2]]\n metadata[\"product_type\"] = fname[-1]\n try:\n metadata[\n \"product_description\"] = sat_properties.radarsat_1_data_products[\n fname[-1][:3]]['description']\n except Exception:\n metadata[\"product_description\"] = \"\"\n\n metadata[\"scene_mean_time\"] = datetime.datetime.strptime(\n fname[3] + fname[4], \"%Y%m%d%H%M%S\")\n\n return metadata","def identify_contents_metadata(cube, filename):\n metadata = {}\n\n try:\n # This could be None if cube.var_name isn't defined\n metadata['var_name'] = cube.var_name\n metadata['units'] = str(cube.units)\n metadata['long_name'] = cube.long_name\n metadata['standard_name'] = cube.standard_name\n metadata['time_units'] = cube.coord('time').units.origin\n metadata['calendar'] = cube.coord('time').units.calendar\n # CMIP5 doesn't have an activity id and so supply a default\n metadata['activity_id'] = cube.attributes.get('activity_id',\n 'HighResMIP')\n try:\n metadata['institute'] = cube.attributes['institution_id']\n except KeyError:\n # CMIP5 uses institute_id but we should not be processing CMIP5\n # data but handle it just in case\n metadata['institute'] = cube.attributes['institute_id']\n except Exception as exc:\n msg = ('Unable to extract metadata from the contents of file {}\\n{}'.\n format(filename, exc.__str__()))\n raise FileValidationError(msg)\n\n return metadata","def loadMetaChunkToServerMap (fileName):\n if not os.path.exists(fileName):\n print \"File \", fileName, \" does not exists\"\n sys.exit(1)\n\n infile = open (fileName, \"r\")\n count = 0\n while infile:\n count = count + 1\n line = infile.readline()\n if not line:\n break\n print \"DEBUGME : processing line %s, %d\" % (line, count)\n lineParts = line.split(' ')\n gChunkMap[lineParts[0]] = ChunkInfo(lineParts[0], lineParts[1], lineParts[2])\n # Add a ChunkHostInfo\n numServers = int(lineParts[2])\n for i in range(numServers):\n i = i * 3\n gChunkMap[lineParts[0]].addChunkHostInfo(ChunkHostInfo(lineParts[i+3], lineParts[i+4], lineParts[i+5]))","def metadata(sceneid, pmin=2, pmax=98, **kwargs):\n scene_params = _sentinel_parse_scene_id(sceneid)\n path_prefix = os.path.join(scene_params[\"aws_bucket\"], scene_params[\"aws_prefix\"])\n preview_file = os.path.join(path_prefix, scene_params[\"preview_file\"])\n\n dst_crs = CRS({\"init\": \"EPSG:4326\"})\n with rasterio.open(preview_file) as src:\n bounds = transform_bounds(\n *[src.crs, dst_crs] + list(src.bounds), densify_pts=21\n )\n\n info = {\"sceneid\": sceneid}\n info[\"bounds\"] = {\"value\": bounds, \"crs\": dst_crs.to_string()}\n\n addresses = [\n \"{}/{}/B{}.jp2\".format(path_prefix, scene_params[\"preview_prefix\"], band)\n for band in scene_params[\"bands\"]\n ]\n _stats_worker = partial(_sentinel_stats, percentiles=(pmin, pmax), **kwargs)\n with futures.ThreadPoolExecutor(max_workers=MAX_THREADS) as executor:\n responses = executor.map(_stats_worker, addresses)\n\n info[\"statistics\"] = {\n b: v for b, d in zip(scene_params[\"bands\"], responses) for k, v in d.items()\n }\n return info","def createMetadata(request, datafile):\n samples = []\n datafile = datafile.split(',')\n for f in datafile:\n filename = f.replace('[', '').replace(']', '').replace('\"', '').replace(' ', '')\n cont = subprocess.Popen(\n [\"curl -u \" + request.session.get('username') + \":\" + request.session.get('password') + \" -k -s \" + filename[1:]],\n stdout=subprocess.PIPE, shell=True).communicate()[0]\n with open(request.session.get('username') + \"/data.txt\", \"w\") as datafile:\n datafile.write(cont)\n with open(datafile.name, \"r\") as tfile:\n for line in tfile:\n if \"!Sample_geo_accession\" in line:\n line = line.split('\\t')\n for x in range(0, len(line)):\n samples.append(line[x].replace('\\n', ''))\n samples = filter(None, samples)\n tfile.seek(0)\n with open(request.session.get('username') + \"/meta.txt\", \"w\") as meta:\n for i in range(0, len(samples)):\n for line in tfile:\n if \"!Sample\" in line:\n line = line.split('\\t')\n line[i] = line[i].replace(\"!Sample_\", \"\").replace(\"\\n\", \"\").replace(\"'\", \"\").replace(\",\", \"\").replace(\"\\\"\", \"\")\n if line[i] == \"geo_accession\":\n line[i] = \"sample_id\"\n elif line[1] == \"\\\"female\\\"\" or line[1] == \"\\\"male\\\"\":\n line[0] = \"sex\"\n if \"title\" not in line[0]:\n meta.write(re.sub(r'[^\\x00-\\x7F]+', ' ', line[i]) + '\\t')\n meta.write('\\n')\n tfile.seek(0)\n meta.close()\n datafile.close()\n call([\"rm\", request.session.get('username') + \"/data.txt\"])\n return meta","def extract_metadata(file_name, token_type, create_labels, remove_stop_words):\n metadata = {'file': file_name}\n\n with open(file_name, 'r') as file:\n rows = file.readlines()\n\n rules = [\n ['Message-ID:', 'id'],\n ['Subject:', 'subject'],\n ]\n\n for (index, row) in enumerate(rows):\n row = row.lstrip('> \\t')\n for (pattern, prop) in rules:\n if row.startswith(pattern):\n metadata[prop] = row.replace(pattern,'')\n\n if 'body' not in metadata:\n if row.startswith('\\n'):\n metadata['body'] = '\\n'.join(rows[index:])\n\n elif '-----Original Message-----' in row:\n del metadata['body']\n\n if 'body' in metadata:\n if create_labels:\n metadata['label'] = create_label(metadata['body'])\n metadata['original_body'] = metadata['body']\n metadata['body'] = clean_text(metadata['body'], token_type, remove_stop_words)\n clean_subject = cleanse(metadata['subject'])\n metadata['subject'] = '' if clean_subject.count(' ') == len(clean_subject) else clean_subject\n\n return metadata"],"string":"[\n \"def parseMetadataMap(lines):\\r\\n return MetadataMap(*parse_mapping_file_to_dict(lines))\",\n \"def get_sample_info(lines):\\r\\n mapping_data, header, comments = parse_mapping_file(lines)\\r\\n labels = [\\\"from\\\", \\\"to\\\", \\\"eweight\\\", \\\"consensus_lin\\\"]\\r\\n node_labels = [\\\"node_name\\\", \\\"node_disp_name\\\", \\\"ntype\\\", \\\"degree\\\",\\r\\n \\\"weighted_degree\\\", \\\"consensus_lin\\\"]\\r\\n cat_by_sample = {}\\r\\n sample_by_cat = defaultdict(list)\\r\\n meta_dict = {}\\r\\n category_labels = header[1:-1]\\r\\n labels.extend(category_labels)\\r\\n node_labels.extend(category_labels)\\r\\n label_list = [[] for c in category_labels]\\r\\n for r in mapping_data:\\r\\n categories = r[0:len(category_labels) + 1]\\r\\n sample = categories[0]\\r\\n meta_dict[sample] = ['\\\\t'.join(categories[1:]), 0]\\r\\n\\r\\n cat_by_sample[sample] = [(l.strip(), c.strip())\\r\\n for l, c in zip(category_labels, categories[1:])]\\r\\n\\r\\n cat_list = []\\r\\n for i, (l, c) in enumerate(zip(category_labels, categories[1:])):\\r\\n if c not in label_list[i]:\\r\\n label_list[i].append(c)\\r\\n l = l.strip()\\r\\n c = c.strip()\\r\\n cat_list.append((l, c))\\r\\n sample_by_cat[(l, c)].append(sample)\\r\\n\\r\\n cat_by_sample[sample] = cat_list\\r\\n\\r\\n return cat_by_sample, sample_by_cat, len(category_labels), meta_dict,\\\\\\r\\n labels, node_labels, label_list\",\n \"def process_lines(self, lines):\\n line_index = 0\\n n_lines = len(lines)\\n while line_index < n_lines:\\n if lines[line_index].startswith(\\\"HIERARCHY\\\"):\\n line_index = self._read_skeleton(lines, line_index, n_lines)\\n if lines[line_index].startswith(\\\"MOTION\\\"):\\n self._read_frametime(lines, line_index+2)\\n line_index = self._read_frames(lines, line_index+3, n_lines)\\n else:\\n line_index += 1\",\n \"def read_meta(metafn=None):\\n\\n metadata = {}\\n\\n # potential future improvement: strip quotation marks from strings, where applicable. Will then need to adjust\\n # the indices used to get the dates and times in the functions above \\n # (get_DEM_img_times: dtstrings = {\\\"sourceImage1\\\":(5,19, '%Y%m%d%H%M%S')})\\n\\n #each key is equated with '='. This loop strips and seperates then fills the dictonary.\\n with open(metafn) as f: \\n for line in f:\\n if not line.strip(';') == \\\"END\\\":\\n val = line.strip().split('=')\\n if len(val) == 1:\\n continue\\n else:\\n metadata.setdefault(val[0].strip(), []).append(val[1].strip().strip(';')) \\n else:\\n break\\n\\t\\n return metadata\",\n \"def parse_mapping_file(lines, strip_quotes=True, suppress_stripping=False):\\r\\n if hasattr(lines, \\\"upper\\\"):\\r\\n # Try opening if a string was passed\\r\\n try:\\r\\n lines = open(lines, 'U')\\r\\n except IOError:\\r\\n raise QiimeParseError(\\\"A string was passed that doesn't refer \\\"\\r\\n \\\"to an accessible filepath.\\\")\\r\\n\\r\\n if strip_quotes:\\r\\n if suppress_stripping:\\r\\n # remove quotes but not spaces\\r\\n strip_f = lambda x: x.replace('\\\"', '')\\r\\n else:\\r\\n # remove quotes and spaces\\r\\n strip_f = lambda x: x.replace('\\\"', '').strip()\\r\\n else:\\r\\n if suppress_stripping:\\r\\n # don't remove quotes or spaces\\r\\n strip_f = lambda x: x\\r\\n else:\\r\\n # remove spaces but not quotes\\r\\n strip_f = lambda x: x.strip()\\r\\n\\r\\n # Create lists to store the results\\r\\n mapping_data = []\\r\\n header = []\\r\\n comments = []\\r\\n\\r\\n # Begin iterating over lines\\r\\n for line in lines:\\r\\n line = strip_f(line)\\r\\n if not line or (suppress_stripping and not line.strip()):\\r\\n # skip blank lines when not stripping lines\\r\\n continue\\r\\n\\r\\n if line.startswith('#'):\\r\\n line = line[1:]\\r\\n if not header:\\r\\n header = line.strip().split('\\\\t')\\r\\n else:\\r\\n comments.append(line)\\r\\n else:\\r\\n # Will add empty string to empty fields\\r\\n tmp_line = map(strip_f, line.split('\\\\t'))\\r\\n if len(tmp_line) < len(header):\\r\\n tmp_line.extend([''] * (len(header) - len(tmp_line)))\\r\\n mapping_data.append(tmp_line)\\r\\n if not header:\\r\\n raise QiimeParseError(\\\"No header line was found in mapping file.\\\")\\r\\n if not mapping_data:\\r\\n raise QiimeParseError(\\\"No data found in mapping file.\\\")\\r\\n\\r\\n return mapping_data, header, comments\",\n \"def parse_metadata_file(self, file):\\n\\n file_keys = list(file.keys())\\n\\n if 'labelAnnotations' in file_keys:\\n file_annots = file['labelAnnotations']\\n file_top_score = np.asarray(\\n [x['score'] for x in file_annots]).mean()\\n file_top_desc = [x['description'] for x in file_annots]\\n else:\\n file_top_score = np.nan\\n file_top_desc = ['']\\n\\n file_colors = file['imagePropertiesAnnotation']['dominantColors'][\\n 'colors']\\n file_crops = file['cropHintsAnnotation']['cropHints']\\n\\n file_color_score = np.asarray([x['score'] for x in file_colors]).mean()\\n file_color_pixelfrac = np.asarray(\\n [x['pixelFraction'] for x in file_colors]).mean()\\n\\n file_crop_conf = np.asarray(\\n [x['confidence'] for x in file_crops]).mean()\\n\\n if 'importanceFraction' in file_crops[0].keys():\\n file_crop_importance = np.asarray(\\n [x['importanceFraction'] for x in file_crops]).mean()\\n else:\\n file_crop_importance = np.nan\\n\\n df_metadata = {\\n 'annots_score': file_top_score,\\n 'color_score': file_color_score,\\n 'color_pixelfrac': file_color_pixelfrac,\\n 'crop_conf': file_crop_conf,\\n 'crop_importance': file_crop_importance,\\n 'annots_top_desc': self.sentence_sep.join(file_top_desc)\\n }\\n\\n df_metadata = pd.DataFrame.from_dict(df_metadata, orient='index').T\\n df_metadata = df_metadata.add_prefix('metadata_')\\n\\n return df_metadata\",\n \"def test_getSampleMetadata(self):\\r\\n exp = {'BarcodeSequence': 'AGCACGAGCCTA', 'Treatment': 'Control',\\r\\n 'DOB': '20061218', 'Description': '354'}\\r\\n obs = self.overview_map.getSampleMetadata('PC.354')\\r\\n self.assertEqual(obs, exp)\\r\\n\\r\\n exp = {'BarcodeSequence': 'ACCAGCGACTAG', 'Treatment': 'Control',\\r\\n 'DOB': '20070314', 'Description': '481'}\\r\\n obs = self.map_with_comments.getSampleMetadata('PC.481')\\r\\n self.assertEqual(obs, exp)\\r\\n\\r\\n exp = {'BarcodeSequence': 'ACGGTGAGTGTC', 'Treatment': 'Fast',\\r\\n 'DOB': '20080116', 'Description': '636'}\\r\\n obs = self.map_with_comments.getSampleMetadata('PC.636')\\r\\n self.assertEqual(obs, exp)\\r\\n\\r\\n exp = {}\\r\\n obs = self.no_metadata.getSampleMetadata('PC.636')\\r\\n self.assertEqual(obs, exp)\",\n \"def parse_metadata_file(self, file):\\n \\n file_keys = list(file.keys())\\n \\n if 'labelAnnotations' in file_keys:\\n #file_annots = file['labelAnnotations'][:int(len(file['labelAnnotations']) * 0.5)]\\n file_annots = file['labelAnnotations'][:]\\n file_top_score = np.asarray([x['score'] for x in file_annots]).mean()\\n file_top_desc = [x['description'] for x in file_annots]\\n else:\\n file_top_score = np.nan\\n file_top_desc = ['']\\n \\n file_colors = file['imagePropertiesAnnotation']['dominantColors']['colors']\\n file_crops = file['cropHintsAnnotation']['cropHints']\\n\\n file_color_score = np.asarray([x['score'] for x in file_colors]).mean()\\n file_color_pixelfrac = np.asarray([x['pixelFraction'] for x in file_colors]).mean()\\n\\n file_crop_conf = np.asarray([x['confidence'] for x in file_crops]).mean()\\n \\n if 'importanceFraction' in file_crops[0].keys():\\n file_crop_importance = np.asarray([x['importanceFraction'] for x in file_crops]).mean()\\n else:\\n file_crop_importance = np.nan\\n\\n df_metadata = {\\n 'annots_score': file_top_score,\\n 'color_score': file_color_score,\\n 'color_pixelfrac': file_color_pixelfrac,\\n 'crop_conf': file_crop_conf,\\n 'crop_importance': file_crop_importance,\\n 'annots_top_desc': self.sentence_sep.join(file_top_desc)\\n }\\n \\n df_metadata = pd.DataFrame.from_dict(df_metadata, orient='index').T\\n df_metadata = df_metadata.add_prefix('metadata_')\\n \\n return df_metadata\",\n \"def get_metadata(sessions):\\n if not isinstance(sessions, list):\\n sessions = list(sessions)\\n\\n for line in sessions:\\n session_id = line['Sess.ID']\\n if session_id: # we loaded a line with session info\\n session_name = '{}_{}'.format(line['Experiment'], line['Sess.ID'])\\n\\n # Check if session is already in database\\n # if database is not None and session_name in database.index:\\n # print(colored('Session is already in database','yellow'))\\n # continue\\n\\n # Create the metadata\\n session_metadata = {}\\n session_metadata['session_id'] = session_id\\n session_metadata['experiment'] = line['Experiment']\\n session_metadata['date'] = line['Date']\\n session_metadata['mouse_id'] = line['MouseID']\\n session_metadata['software'] = line['Software']\\n session_metadata['number'] = line['Number']\\n\\n # initialize video data\\n session_metadata['video_file_paths'] = []\\n session_metadata['tdms_file_paths'] = []\\n session_metadata['videodata'] = []\\n\\n # load data from .tdms and .avi fils\\n for recording in line['Recordings']:\\n path = os.path.join(line['Base fld'], line['Exp fld'], recording)\\n videopaths = []\\n for f in os.listdir(path):\\n if '.avi' in f:\\n videopaths.append(os.path.join(path, f))\\n elif '.tdms' == f[-5:]:\\n tdmspath = os.path.join(path, f)\\n\\n # add file paths to metadata\\n session_metadata['video_file_paths'].append(videopaths)\\n session_metadata['tdms_file_paths'].append(tdmspath)\\n\\n # Loop over each video and get the relevant data [e.g., number of frames, fps...]\\n session_metadata['videodata'].append(get_session_videodata(videopaths))\\n\\n # Add to dictionary (or update entry)\\n metadata_dict[session_name] = session_metadata\\n return metadata_dict\",\n \"def test_getSampleMetadata(self):\\n exp = {'BarcodeSequence': 'AGCACGAGCCTA', 'Treatment': 'Control',\\n 'DOB': '20061218', 'Description': '354'}\\n obs = self.overview_map.getSampleMetadata('PC.354')\\n self.assertEqual(obs, exp)\\n\\n exp = {'BarcodeSequence': 'ACCAGCGACTAG', 'Treatment': 'Control',\\n 'DOB': '20070314', 'Description': '481'}\\n obs = self.map_with_comments.getSampleMetadata('PC.481')\\n self.assertEqual(obs, exp)\\n\\n exp = {'BarcodeSequence': 'ACGGTGAGTGTC', 'Treatment': 'Fast',\\n 'DOB': '20080116', 'Description': '636'}\\n obs = self.map_with_comments.getSampleMetadata('PC.636')\\n self.assertEqual(obs, exp)\\n\\n exp = {}\\n obs = self.no_metadata.getSampleMetadata('PC.636')\\n self.assertEqual(obs, exp)\",\n \"def parse_metadata(self):\\n import csv\\n f = open(self.seq_id_list)\\n self.names = f.readlines()\\n f.close()\\n num_samples = len(self.names)\\n for i in range(len(self.names)):\\n self.names[i] = self.names[i].replace(\\\"\\\\n\\\", \\\"\\\")\\n # Go through the combined metadata file - it has most of the data we need.\\n metadata = csv.DictReader(open(self.nasmnt + \\\"WGSspades/reports/combinedMetadata.csv\\\"))\\n metadata_count = 0\\n for row in metadata:\\n # There has to be a more elegant way to do this.\\n if row[\\\"SampleName\\\"] in self.names:\\n data = dict()\\n data[\\\"Investigator\\\"] = row[\\\"Investigator\\\"]\\n data[\\\"Coverage\\\"] = row[\\\"AverageCoverageDepth\\\"]\\n data[\\\"TotalLength\\\"] = row[\\\"TotalLength\\\"]\\n data[\\\"rST\\\"] = row[\\\"rMLSTsequenceType\\\"]\\n data[\\\"PipelineVersion\\\"] = row[\\\"PipelineVersion\\\"]\\n data[\\\"MLST\\\"] = row[\\\"MLSTsequencetype\\\"]\\n data[\\\"geneSeekr\\\"] = row[\\\"geneSeekrProfile\\\"].split(\\\";\\\")\\n self.metadata[row[\\\"SampleName\\\"]] = data\\n metadata_count += 1\\n # Need to look in external WGS spades as well.\\n metadata = csv.DictReader(open(self.nasmnt + \\\"External_WGSspades/reports/combinedMetadata.csv\\\"))\\n for row in metadata:\\n # There has to be a more elegant way to do this.\\n if row[\\\"SampleName\\\"] in self.names:\\n data = dict()\\n data[\\\"Investigator\\\"] = row[\\\"Investigator\\\"]\\n data[\\\"Coverage\\\"] = row[\\\"AverageCoverageDepth\\\"]\\n data[\\\"TotalLength\\\"] = row[\\\"TotalLength\\\"]\\n data[\\\"rST\\\"] = row[\\\"rMLSTsequenceType\\\"]\\n data[\\\"PipelineVersion\\\"] = row[\\\"PipelineVersion\\\"]\\n data[\\\"MLST\\\"] = row[\\\"MLSTsequencetype\\\"]\\n data[\\\"geneSeekr\\\"] = row[\\\"geneSeekrProfile\\\"].split(\\\";\\\")\\n self.metadata[row[\\\"SampleName\\\"]] = data\\n metadata_count += 1\\n\\n\\n\\n # Also need to go through the rMLST file to make sure that all rMLST genes are covered.\\n rMLST_data = csv.DictReader(open(self.nasmnt + \\\"WGSspades/reports/rmlst.csv\\\"))\\n metadata_count = 0\\n for row in rMLST_data:\\n if row[\\\"Strain\\\"] in self.names:\\n self.metadata[row[\\\"Strain\\\"]][\\\"Matches\\\"] = row[\\\"Matches\\\"]\\n metadata_count += 1\\n # Check external runs.\\n rMLST_data = csv.DictReader(open(self.nasmnt + \\\"External_WGSspades/reports/rmlst.csv\\\"))\\n for row in rMLST_data:\\n if row[\\\"Strain\\\"] in self.names:\\n self.metadata[row[\\\"Strain\\\"]][\\\"Matches\\\"] = row[\\\"Matches\\\"]\\n\\n\\n\\n # Finally, need to get info on the MLST sequence type.\\n metadata_count = 0\\n mlst_data = csv.DictReader(open(self.nasmnt + \\\"WGSspades/reports/mlst.csv\\\"))\\n for row in mlst_data:\\n if row[\\\"Strain\\\"] in self.names:\\n mlst = list()\\n for i in range(1, 8):\\n mlst.append(row[str(i)])\\n self.metadata[row[\\\"Strain\\\"]][\\\"mlst_info\\\"] = mlst\\n metadata_count += 1\\n\\n # Also from External.\\n mlst_data = csv.DictReader(open(self.nasmnt + \\\"External_WGSspades/reports/mlst.csv\\\"))\\n for row in mlst_data:\\n if row[\\\"Strain\\\"] in self.names:\\n mlst = list()\\n for i in range(1, 8):\\n mlst.append(row[str(i)])\\n self.metadata[row[\\\"Strain\\\"]][\\\"mlst_info\\\"] = mlst\\n metadata_count += 1\\n\\n # Go through the ROGA Summary file from the access DB to get strain/textual IDs, and 1' and 2' enzymes.\\n try: # Assume we're using ROGA summary OLF. If it isn't there, assume ROGA summary OLC\\n df = pd.read_excel('ROGA_summary_OLF.xlsx')\\n for i in df.index:\\n if df['SeqTracking_SEQID'][i] in self.names:\\n seqid = df['SeqTracking_SEQID'][i]\\n self.metadata[seqid][\\\"IsolateID\\\"] = df['Isolate ID'][i]\\n self.metadata[seqid][\\\"TextualID\\\"] = df['Textual ID'][i]\\n self.metadata[seqid][\\\"1Enzyme\\\"] = df[\\\"1' Enzyme\\\"][i]\\n self.metadata[seqid][\\\"2Enzyme\\\"] = df[\\\"2' Enzyme\\\"][i]\\n self.metadata[seqid][\\\"Source\\\"] = df['Source'][i]\\n self.metadata[seqid][\\\"ReceivedDate\\\"] = df['ReceivedDate'][i]\\n self.metadata[seqid][\\\"SequenceDate\\\"] = df['SequenceDate'][i]\\n self.metadata[seqid][\\\"SequencedBy\\\"] = df['SequenceBy'][i]\\n metadata_count += 1\\n\\n\\n except FileNotFoundError: # Should be a file not found error - look it up.\\n metadata_count = 0\\n df = pd.read_excel('ROGA_summary_OLC.xlsx')\\n for i in df.index:\\n if df['SeqTracking_SEQID'][i] in self.names:\\n seqid = df['SeqTracking_SEQID'][i]\\n self.metadata[seqid][\\\"IsolateID\\\"] = df['OLN ID'][i]\\n self.metadata[seqid][\\\"TextualID\\\"] = df['Lab ID'][i]\\n self.metadata[seqid][\\\"ReceivedDate\\\"] = df['ReceivedDate'][i]\\n self.metadata[seqid][\\\"SequenceDate\\\"] = df['SequenceDate'][i]\\n self.metadata[seqid][\\\"SequencedBy\\\"] = df['SequenceBy'][i]\\n metadata_count += 1\\n # print(self.metadata)\\n self.check_for_empty_data()\",\n \"def test_parseMetadataMap(self):\\n obs = MetadataMap.parseMetadataMap(self.overview_map_str)\\n self.assertEqual(obs, self.overview_map)\",\n \"def get_Metadata(metafile):\\n\\n mslist_file = open(metafile, 'r')\\n LINES = mslist_file.readlines()\\n mslist_file.close()\\n\\n nBlocks = 6 # these are the number of correlator cards (PILOT survey value)\\n \\n obs_date = 'Observed from'\\n code = 'Code'\\n duration = 'Total elapsed time'\\n antenna = 'antennas'\\n frame = 'Frame'\\n \\n for i in range(len(LINES)):\\n line = LINES[i]\\n if line.find(antenna) >=0:\\n TOKS = line.split()\\n n_ant = TOKS[5][-2:]\\n if line.find(obs_date) >=0:\\n TOKS = line.split()\\n start_obs_date = TOKS[6]\\n end_obs_date = TOKS[8]\\n if line.find(duration) >=0:\\n TOKS = line.split()\\n tobs = float(TOKS[10]) # in second\\n if line.find(code) >= 0:\\n next_line = LINES[i+1]\\n TOKS = next_line.split()\\n field = TOKS[5]\\n ra = TOKS[6][:-5]\\n dec = TOKS[7][:-4]\\n if line.find(frame) >= 0:\\n next_line = LINES[i+1]\\n TOKS = next_line.split()\\n total_obs_bw = float(TOKS[10])*nBlocks/1000.0 # kHz to MHz \\n \\n return n_ant, start_obs_date, end_obs_date, tobs, field, ra, dec, total_obs_bw\",\n \"def test_parseMetadataMap(self):\\r\\n obs = MetadataMap.parseMetadataMap(self.overview_map_str)\\r\\n self.assertEqual(obs, self.overview_map)\",\n \"def read_metadata(metapath):\\r\\n with open(metapath) as metaFile:\\r\\n metadata = {}\\r\\n for line in metaFile.readlines():\\r\\n if \\\"=\\\" in line: # Get only key-value pairs\\r\\n l = line.split(\\\"=\\\")\\r\\n metadata[l[0].strip()] = l[1].strip()\\r\\n\\r\\n return metadata\",\n \"def parse_metadata(filename):\\n with open(filename, 'r') as f:\\n reader = csv.DictReader(f)\\n metadata = {}\\n for row in reader:\\n key = row.pop('sample_filename')\\n if key in metadata:\\n print('WARNING: duplicate sample_id \\\"' + key + '\\\" found in \\\"' + filename + '\\\". The previous value(s) will be overwritten.')\\n metadata[key] = row\\n return metadata\",\n \"def MinimalBpseqParser(lines):\\n result = {'HEADER':[], 'SEQ_STRUCT':[]}\\n \\n for line in lines:\\n if line.startswith('Filename') or line.startswith('Organism') or\\\\\\n line.startswith('Accession') or line.startswith('Citation') or\\\\\\n \\\":\\\" in line:\\n result['HEADER'].append(line.strip())\\n elif len(line.split()) == 3:\\n result['SEQ_STRUCT'].append(line.strip())\\n else:\\n continue #unknown\\n return result\",\n \"def _parse_metadata(histline: str) -> Optional[Tuple[datetime, int, str]]:\\n matches = PATTERN.match(histline)\\n if matches:\\n g = matches.groups()\\n return (parse_datetime_sec(g[0]), int(g[1]), g[2])\\n return None\",\n \"def get_metadata(diagnostics_dir, verbose=False):\\n metafile = find_metadata_file(diagnostics_dir, 'mslist-2*txt', verbose=False)\\n\\n with open(metafile, 'r') as mslist_file:\\n lines = mslist_file.readlines()\\n\\n nBlocks = 6 # these are the number of correlator cards (PILOT survey value)\\n \\n obs_metadata = ObservationMetadata()\\n\\n obs_date = 'Observed from'\\n fields = 'Fields'\\n code = 'Code'\\n duration = 'Total elapsed time'\\n antenna = 'antennas'\\n frame = 'Frame'\\n \\n field_list = []\\n\\n for i in range(len(lines)):\\n line = lines[i]\\n if line.find(antenna) >=0:\\n toks = line.split()\\n obs_metadata.n_ant = toks[5][-2:]\\n if line.find(obs_date) >=0:\\n toks = line.split()\\n obs_metadata.start_obs_date = toks[6]\\n obs_metadata.end_obs_date = toks[8]\\n if line.find(duration) >=0:\\n toks = line.split()\\n obs_metadata.tobs = float(toks[10]) # in second\\n\\n # Field details\\n if line.find(fields) >=0:\\n toks = line.split()\\n obs_metadata.num_fields = int(toks[-1])\\n\\n if line.find(code) >= 0:\\n for j in range(obs_metadata.num_fields):\\n field_metadata = FieldMetadata()\\n field_line = lines[i+j+1]\\n toks = field_line.split()\\n field_metadata.name = toks[5]\\n field_metadata.ra = toks[6][:-5]\\n field_metadata.dec = toks[7][:-4]\\n field_metadata.num_rows = int(toks[9])\\n obs_metadata.fields.append(field_metadata)\\n\\n if line.find(frame) >= 0:\\n next_line = lines[i+1]\\n toks = next_line.split()\\n obs_metadata.total_obs_bw = float(toks[10])*nBlocks/1000.0 # kHz to MHz \\n \\n return obs_metadata #n_ant, start_obs_date, end_obs_date, tobs, field, ra, dec, total_obs_bw\",\n \"def parse_metadata_file(filename,\\n logger,\\n study_id=None,\\n genome_name=None,\\n case_list=False):\\n \\n logger.debug('Starting validation of meta file', extra={'filename_': filename})\\n \\n metaDictionary = {}\\n with open(filename, 'rU') as metafile:\\n for line_index, line in enumerate(metafile):\\n # skip empty lines:\\n if line.strip() == '':\\n continue\\n if ':' not in line:\\n logger.error(\\n \\\"Invalid %s file entry, no ':' found\\\",\\n {True: 'case list', False: 'meta'}[case_list],\\n extra={'filename_': filename,\\n 'line_number': line_index + 1})\\n meta_file_type = None\\n return metaDictionary, meta_file_type\\n key_value = line.split(':', 1)\\n if len(key_value) == 2:\\n metaDictionary[key_value[0]] = key_value[1].strip()\\n\\n if case_list:\\n meta_file_type = MetaFileTypes.CASE_LIST\\n else:\\n meta_file_type = get_meta_file_type(metaDictionary, logger, filename)\\n # if type could not be inferred, no further validations are possible\\n if meta_file_type is None:\\n return metaDictionary, meta_file_type\\n\\n missing_fields = []\\n for field in META_FIELD_MAP[meta_file_type]:\\n mandatory = META_FIELD_MAP[meta_file_type][field]\\n if field not in metaDictionary and mandatory:\\n logger.error(\\\"Missing field '%s' in %s file\\\",\\n field,\\n {True: 'case list', False: 'meta'}[case_list],\\n extra={'filename_': filename})\\n missing_fields.append(field)\\n\\n if missing_fields:\\n meta_file_type = None\\n # all further checks would depend on these fields being present\\n return metaDictionary, meta_file_type\\n\\n # validate genetic_alteration_type, datatype, stable_id\\n stable_id_mandatory = META_FIELD_MAP[meta_file_type].get('stable_id',\\n False)\\n if stable_id_mandatory:\\n valid_types_and_id = validate_types_and_id(metaDictionary, logger, filename)\\n if not valid_types_and_id:\\n # invalid meta file type\\n meta_file_type = None\\n return metaDictionary, meta_file_type\\n\\n for field in metaDictionary:\\n if field not in META_FIELD_MAP[meta_file_type]:\\n logger.warning(\\n 'Unrecognized field in %s file',\\n {True: 'case list', False: 'meta'}[case_list],\\n extra={'filename_': filename,\\n 'cause': field})\\n\\n # check that cancer study identifiers across files so far are consistent.\\n if (\\n study_id is not None and\\n 'cancer_study_identifier' in metaDictionary and\\n study_id != metaDictionary['cancer_study_identifier']):\\n logger.error(\\n \\\"Cancer study identifier is not consistent across \\\"\\n \\\"files, expected '%s'\\\",\\n study_id,\\n extra={'filename_': filename,\\n 'cause': metaDictionary['cancer_study_identifier']})\\n # not a valid meta file in this study\\n meta_file_type = None\\n return metaDictionary, meta_file_type\\n\\n # type-specific validations\\n if meta_file_type in (MetaFileTypes.SEG, MetaFileTypes.GISTIC_GENES):\\n if genome_name is not None and metaDictionary['reference_genome_id'] != genome_name:\\n logger.error(\\n 'Reference_genome_id is not %s',\\n genome_name,\\n extra={'filename_': filename,\\n 'cause': metaDictionary['reference_genome_id']})\\n meta_file_type = None\\n if meta_file_type == MetaFileTypes.MUTATION:\\n if ('swissprot_identifier' in metaDictionary and\\n metaDictionary['swissprot_identifier'] not in ('name',\\n 'accession')):\\n logger.error(\\n \\\"Invalid swissprot_identifier specification, must be either \\\"\\n \\\"'name' or 'accession'\\\",\\n extra={'filename_': filename,\\n 'cause': metaDictionary['swissprot_identifier']})\\n meta_file_type = None\\n\\n logger.info('Validation of meta file complete', extra={'filename_': filename})\\n return metaDictionary, meta_file_type\",\n \"def getTracksFromMitiFile(lines):\\n\\n tracks = {}\\n\\n for line in lines:\\n items = line.strip().split()\\n if len(items) < 9 or len(items) > 10:\\n raise Exception(\\\"are input data file lines in MITI format? Found one had %i items\\\" % len(items))\\n curTrackId = int(items[0])\\n\\n if not tracks.has_key(curTrackId):\\n tracks[curTrackId] = Track([])\\n\\n newDet = Detection(line)\\n tracks[curTrackId].addDetection(newDet)\\n \\n\\n return tracks\",\n \"def Parse(filename):\\n\\n f = open(filename, 'r')\\n\\n metadata = Metadata()\\n data = [] # array of dataset\\n dataset = None\\n\\n for num, line in enumerate(f):\\n try:\\n line = line.strip()\\n if not line: continue\\n\\n if not metadata.complete:\\n metadata.Parse(line)\\n continue\\n\\n if re.match('[a-z_]', line):\\n continue\\n\\n if line.startswith('# StopWatch'): # Start of a new dataset\\n if dataset:\\n if dataset.summary:\\n metadata.UpdateWith(dataset)\\n else:\\n data.append(dataset)\\n\\n dataset = DataSet(line)\\n continue\\n\\n if line.startswith('#'):\\n continue\\n\\n # must be data at this stage\\n try:\\n (time, value) = line.split(None, 1)\\n except ValueError:\\n print 'skipping line %d: %s' % (num, line)\\n continue\\n\\n if dataset and not dataset.summary:\\n dataset.Add(float(time), float(value))\\n\\n except Exception:\\n print 'Error parsing line %d' % num, sys.exc_info()[0]\\n raise\\n data.append(dataset)\\n if not metadata.complete:\\n print \\\"\\\"\\\"Error missing metadata. Did you mount debugfs?\\n [adb shell mount -t debugfs none /sys/kernel/debug]\\\"\\\"\\\"\\n sys.exit(1)\\n return (metadata, data)\",\n \"def parse_lines(lines):\\n for line in lines:\\n yield Record(line)\",\n \"def ExtractTrackInformation(lines):\\n\\n # The starting line should be something like ' TRACK 01 AUDIO'\\n # and we want to create ``data = {'track': '1'}``\\n # NB: Cue format has a 99 track limit\\n data = {\\\"track\\\": CueMetadata.ExtractProperty(lines[0], \\\"TRACK\\\")[0:2].lstrip(\\\"0\\\")}\\n\\n # Parse the remaining lines for this track to find the track starting time\\n # which is typically, but not necessarily, a line starting with ' INDEX 01'\\n # Also want to pick up any extra tags in the block and store it in ``data``,\\n # eg, the 'TITLE' field. Since not all fields are valid but remarks are\\n # it's necessary to \\\"un-remark\\\" the lines starting with 'REM '\\n times = {}\\n for line in lines[1:]:\\n if not line.startswith(' ' * 4):\\n break\\n line = line.strip()\\n # Don't consider multi-artist albums\\n if line.startswith(\\\"PERFORMER\\\"):\\n continue\\n line = line.replace(\\\"INDEX \\\", \\\"INDEX\\\") # Turn 'INDEX 01' into 'INDEX01', etc.\\n line = line.replace(\\\"REM \\\", \\\"\\\") # Make remarks appear as valid tags\\n name = line.split(\\\" \\\")[0]\\n info = CueMetadata.ExtractProperty(line, name)\\n if not info:\\n continue\\n name = name.lower()\\n if \\\"INDEX\\\" in line:\\n # Handle these time codes separately since there may be more than one\\n times[name] = time.CueTimeToMKATime(info)\\n else:\\n data[name] = info\\n # In CUE files, 'INDEX 00' is (typically) used for pre-gap and 'INDEX 01' denotes\\n # the start of the actual track. Higher indices are possible, but rarely used,\\n # typically for access to portions of songs. Here we want to prefer 'INDEX 01'\\n # and use 'INDEX 00' if there is no 'INDEX 01' while ignoring higher indices.\\n for idx in [\\\"index01\\\", \\\"index00\\\"]:\\n if idx in times:\\n time_code = idx\\n break\\n else:\\n raise CueFormatError(f\\\"No valid time codes found for track {data['track']}\\\")\\n data[\\\"start_time\\\"] = times[time_code]\\n return data\",\n \"def parse_metadata(metadata):\\n id_to_classes_recount = {}\\n with open(metadata, \\\"r\\\") as file:\\n header = next(file)\\n for line in file:\\n try:\\n splitted_line = line.split(\\\"\\\\n\\\")[0].split(\\\"\\\\t\\\")\\n file_id = splitted_line[22]\\n project = splitted_line[77]\\n sample_type = splitted_line[107]\\n if project == \\\"TCGA-LIHC\\\":\\n if sample_type == 'Primary Tumor':\\n id_to_classes_recount[file_id] = 1\\n elif sample_type == 'Solid Tissue Normal':\\n id_to_classes_recount[file_id] = 0\\n elif sample_type == 'Recurrent Tumor':\\n id_to_classes_recount[file_id] = 1\\n else:\\n print(sample_type)\\n except:\\n pass\\n return id_to_classes_recount\",\n \"def sample_ids_from_metadata_description(mapping_f, valid_states_str):\\r\\n map_data, map_header, map_comments = parse_mapping_file(mapping_f)\\r\\n valid_states = parse_metadata_state_descriptions(valid_states_str)\\r\\n sample_ids = get_sample_ids(map_data, map_header, valid_states)\\r\\n\\r\\n if len(sample_ids) < 1:\\r\\n raise ValueError(\\\"All samples have been filtered out for the criteria\\\" +\\r\\n \\\" described in the valid states\\\")\\r\\n\\r\\n return sample_ids\",\n \"def test_parse_metadata_0(self):\\n data = ET.parse(\\\"data/metadata_0.xml\\\")\\n data_str = ET.tostring(data.getroot())\\n\\n dict = tesse_ros_bridge.utils.parse_metadata(data_str)\\n self.assertEqual(dict['position'], [-5.692576, 2.499105, 10.63836])\\n self.assertEqual(dict['quaternion'], [0, 0.5372996, 0, 0.8433914])\\n self.assertEqual(dict['velocity'], [0, -0.0004944276, 0])\\n self.assertEqual(dict['ang_vel'], [0, 0, 0])\\n self.assertEqual(dict['acceleration'], [0, 0.001516496, 0])\\n self.assertEqual(dict['ang_accel'], [0, 0, 0])\\n self.assertEqual(dict['time'], 7.935)\\n self.assertEqual(dict['collision_status'], False)\",\n \"def extract_metadata(rawfile,codeversions={}):\\r\\n import datetime\\r\\n add_standard_metadata(rawfile)\\r\\n # get monochromator-related information\\r\\n mom = average_metadata(rawfile['$entry/instrument/crystal/omega'])\\r\\n tk_angle = average_metadata(rawfile['$entry/instrument/crystal/takeoff_angle'])\\r\\n # get the date\\r\\n date_form = datetime.datetime.strptime(str(rawfile['$entry/start_time']),\\\"%Y-%m-%d %H:%M:%S\\\")\\r\\n mono_change = datetime.datetime(2009,04,01)\\r\\n if date_form < mono_change:\\r\\n monotype = \\\"115\\\"\\r\\n else:\\r\\n monotype = \\\"335\\\"\\r\\n hklval = pick_hkl(mom - tk_angle/2.0,monotype)\\r\\n if len(hklval)==3: # i.e. h,k,l found\\r\\n rawfile.add_metadata(\\\"_pd_instr_monochr_pre_spec\\\",\\r\\n hklval + \\\" reflection from Ge crystal, \\\"+monotype+\\\" cut\\\",tag=\\\"CIF\\\")\\r\\n wavelength = calc_wavelength(hklval,tk_angle)\\r\\n rawfile.add_metadata(\\\"_diffrn_radiation_wavelength\\\",\\\"%.3f\\\" % wavelength,tag=\\\"CIF\\\")\\r\\n rawfile.add_metadata(\\\"_[local]_diffrn_radiation_wavelength_determination\\\",\\r\\n \\\"Wavelength is calculated from monochromator hkl and takeoff angle and is therefore approximate\\\",\\r\\n tag=\\\"CIF\\\")\\r\\n # The following is changed later if the primary collimator is found to be inserted\\r\\n rawfile.add_metadata(\\\"_pd_instr_divg_eq_src/mono\\\",\\\"%.3f\\\" % (0.099*2.0*wavelength),tag=\\\"CIF\\\")\\r\\n # Do some logic to obtain collimator positions\\r\\n pcr = average_metadata(rawfile[\\\"$entry/instrument/collimator/primary_collimator_rotation\\\"])\\r\\n pcx = average_metadata(rawfile[\\\"$entry/instrument/collimator/primary_collimator_translation\\\"])\\r\\n if pcx > 120:\\r\\n if abs(pcr-360.0)<5 or abs(pcr) < 5: # 5' collimator\\r\\n coll_string = \\\"A 5' primary collimator pre-monochromator\\\"\\r\\n rawfile.add_metadata(\\\"_pd_instr_divg_eq_src/mono\\\",\\\"0.0833\\\",tag=\\\"CIF\\\")\\r\\n else:\\r\\n coll_string = \\\"A 10' primary collimator pre-monochromator\\\"\\r\\n rawfile.add_metadata(\\\"_pd_instr_divg_eq_src/mono\\\",\\\"0.1667\\\",tag=\\\"CIF\\\")\\r\\n else: coll_string = \\\"No primary monochromator \\\"\\r\\n try:\\r\\n scr = average_metadata(rawfile['$entry/sample/secondary_collimator'])\\r\\n if scr>0.5:\\r\\n coll_string += \\\" and a 10' secondary collimator post-monochromator.\\\"\\r\\n rawfile.add_metadata(\\\"_pd_instr_divg_eq_mono/spec\\\",\\\"0.1667\\\",tag=\\\"CIF\\\")\\r\\n else:\\r\\n coll_string += \\\" and no secondary collimator.\\\"\\r\\n rawfile.add_metadata(\\\"_diffrn_radiation_collimation\\\",coll_string,tag=\\\"CIF\\\")\\r\\n except AttributeError: #some early files are missing secondary collimator\\r\\n pass\\r\\n # These values were in the CIF writing area of the Java routines, best put here\\r\\n try:\\r\\n program_release = str(rawfile[\\\"$entry/program_revision\\\"])\\r\\n except AttributeError:\\r\\n program_release = str(rawfile[\\\"$entry/sics_release\\\"])\\r\\n rawfile.add_metadata(\\\"_computing_data_collection\\\",str(rawfile[\\\"$entry/program_name\\\"]) + \\\" \\\" + \\\\\\r\\n program_release,\\\"CIF\\\")\\r\\n # List the code versions used for data reduction\\r\\n codelist = \\\"\\\"\\r\\n for key in codeversions.keys():\\r\\n codelist += \\\"%-20s: %s\\\\n\\\" % (key,codeversions[key])\\r\\n rawfile.add_metadata(\\\"_computing_data_reduction\\\", str(\\\"Gumtree Echidna/Python routines, Git versions:\\\\n\\\" + codelist),\\\"CIF\\\")\\r\\n rawfile.add_metadata(\\\"_pd_spec_special_details\\\",sanitize(str(rawfile[\\\"$entry/sample/name\\\"])),\\\"CIF\\\")\\r\\n rawfile.add_metadata(\\\"_[local]_data_collection_description\\\",str(rawfile[\\\"$entry/sample/description\\\"]),\\\"CIF\\\")\\r\\n start_time = str(rawfile[\\\"$entry/start_time\\\"]).replace(\\\" \\\",\\\"T\\\")\\r\\n end_time = str(rawfile[\\\"$entry/end_time\\\"]).replace(\\\" \\\",\\\"T\\\")\\r\\n rawfile.add_metadata(\\\"_pd_meas_datetime_initiated\\\", start_time,\\\"CIF\\\")\\r\\n rawfile.add_metadata(\\\"_[local]_datetime_completed\\\", end_time,\\\"CIF\\\")\\r\\n try:\\r\\n username = str(rawfile[\\\"user_name\\\"])\\r\\n except:\\r\\n username = \\\"?\\\"\\r\\n rawfile.add_metadata(\\\"_pd_meas_info_author_name\\\", sanitize(username),\\\"CIF\\\")\\r\\n rawfile.add_metadata(\\\"_pd_meas_info_author_email\\\", str(rawfile[ \\\"$entry/user/email\\\"]),\\\"CIF\\\")\\r\\n rawfile.add_metadata(\\\"_pd_meas_info_author_phone\\\", str(rawfile[ \\\"$entry/user/phone\\\"]),\\\"CIF\\\")\\r\\n rawfile.add_metadata(\\\"_pd_instr_2theta_monochr_pre\\\",\\\"%.3f\\\" % tk_angle,\\\"CIF\\\")\\r\\n rawfile.add_metadata(\\\"_pd_instr_dist_mono/spec\\\", \\\"%.1f\\\" % average_metadata(rawfile[ \\\"$entry/sample/mono_sample_mm\\\"]),\\\"CIF\\\")\\r\\n rawfile.add_metadata(\\\"_pd_instr_dist_spec/detc\\\",\\\"%.1f\\\" % average_metadata(rawfile[\\\"$entry/instrument/detector/radius\\\"]),\\\"CIF\\\")\\r\\n try:\\r\\n rawfile.add_metadata(\\\"_diffrn_source_power\\\", \\\"%.2f\\\" % (average_metadata(rawfile[\\\"$entry/instrument/source/power\\\"])*1000),\\\"CIF\\\")\\r\\n except AttributeError: #sometimes source power is missing\\r\\n pass\\r\\n # imgCIF information about geometry\\r\\n # axis loop\\r\\n names = (('_axis.id','_axis.type','_axis.equipment','_axis.depends_on'),)\\r\\n values = [['source','gravity','stth','horizontal','vertical'],\\r\\n ['.','.','rotation','rotation','translation'],\\r\\n ['source','gravity','detector','detector','detector'],\\r\\n ['.','.','.','stth','stth']]\\r\\n rawfile.__dict__['ms'].AddCifItem((names,(values,)))\\r\\n radius = rawfile.__dict__['ms'][\\\"_pd_instr_dist_spec/detc\\\"]\\r\\n # add the vectors:\\r\\n \\\"\\\"\\\"\\r\\n source 0 0 1 . . .\\r\\n gravity -1 0 0 . . .\\r\\n stth 1 0 0 . . .\\r\\n horizontal 1 0 0 . . .\\r\\n vertical 1 0 0 0 0 -728\\r\\n \\\"\\\"\\\"\\r\\n vector_dict = {\\\"_axis.vector[1]\\\":['0','-1','1','1','1'],\\r\\n \\\"_axis.vector[2]\\\":['0','0','0','0','0'],\\r\\n \\\"_axis.vector[3]\\\":['1','0','0','0','0'],\\r\\n \\\"_axis.offset[1]\\\":['.','.','.','.','.'],\\r\\n \\\"_axis.offset[2]\\\":['.','.','.','.','.'],\\r\\n \\\"_axis.offset[3]\\\":['1','0','0','0',\\\"-\\\"+radius]}\\r\\n rawfile.__dict__['ms'].AddToLoop('_axis.id',vector_dict)\\r\\n # Add information about the stth positions for later use\\r\\n rawfile.add_metadata(\\\"_diffrn_scan.id\\\",\\\"1\\\",\\\"CIF\\\")\\r\\n rawfile.add_metadata(\\\"_diffrn_scan.frames\\\",rawfile.shape[0],\\\"CIF\\\")\\r\\n frame_ids = map(lambda a:\\\"%d\\\" % a,range(rawfile.shape[0]))\\r\\n stths = rawfile.stth[:]\\r\\n names = ((\\\"_diffrn_scan_frame.frame_id\\\",\\\"_diffrn_scan_frame.frame_number\\\"),)\\r\\n values = [frame_ids,range(1,rawfile.shape[0]+1)] #Spec says start from 1\\r\\n rawfile.__dict__['ms'].AddCifItem((names,(values,)))\\r\\n names = ((\\\"_diffrn_scan_frame_axis.frame_id\\\",\\\"_diffrn_scan_frame_axis.axis_id\\\",\\r\\n \\\"_diffrn_scan_frame_axis.angle\\\"),)\\r\\n values = [frame_ids,['stth']*rawfile.shape[0],map(float,stths)]\\r\\n rawfile.__dict__['ms'].AddCifItem((names,(values,)))\\r\\n return rawfile\",\n \"def parse_meta_file(fname):\\n flds = {}\\n basename = re.match('(^.+?)\\\\..+', os.path.basename(fname)).groups()[0]\\n flds['basename'] = basename\\n with open(fname) as f:\\n text = f.read()\\n # split into items\\n for item in re.split(';', text):\\n # remove whitespace at beginning\\n item = re.sub('^\\\\s+', '', item)\\n match = re.match('(\\\\w+) = (\\\\[|\\\\{)(.*)(\\\\]|\\\\})', item, re.DOTALL)\\n if match:\\n key, _, value, _ = match.groups()\\n # remove more whitespace\\n value = re.sub('^\\\\s+', '', value)\\n value = re.sub('\\\\s+$', '', value)\\n # print key,':', value\\n flds[key] = value\\n # now check the needed things are there\\n needed_keys = ['dimList', 'nDims', 'nrecords', 'dataprec']\\n for k in needed_keys:\\n assert k in flds\\n # transform datatypes\\n flds['nDims'] = int(flds['nDims'])\\n flds['nrecords'] = int(flds['nrecords'])\\n # endianness is set by _read_mds\\n flds['dataprec'] = np.dtype(re.sub(\\\"'\\\", '', flds['dataprec']))\\n flds['dimList'] = [[int(h) for h in\\n re.split(',', g)] for g in\\n re.split(',\\\\n', flds['dimList'])]\\n if 'fldList' in flds:\\n flds['fldList'] = [re.match(\\\"'*(\\\\w+)\\\", g).groups()[0] for g in\\n re.split(\\\"'\\\\s+'\\\", flds['fldList'])]\\n assert flds['nrecords'] == len(flds['fldList'])\\n return flds\",\n \"def test_filter_mapping_file_by_metadata_states(self):\\r\\n actual = filter_mapping_file_by_metadata_states(\\r\\n self.tutorial_mapping_f,\\r\\n \\\"Treatment:Control\\\")\\r\\n expected = \\\"\\\"\\\"#SampleID\\tBarcodeSequence\\tLinkerPrimerSequence\\tTreatment\\tDOB\\tDescription\\r\\nPC.354\\tAGCACGAGCCTA\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._354\\r\\nPC.355\\tAACTCGTCGATG\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._355\\r\\nPC.356\\tACAGACCACTCA\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061126\\tControl_mouse_I.D._356\\r\\nPC.481\\tACCAGCGACTAG\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20070314\\tControl_mouse_I.D._481\\r\\nPC.593\\tAGCAGCACTTGT\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20071210\\tControl_mouse_I.D._593\\\"\\\"\\\"\\r\\n self.assertEqual(actual, expected)\",\n \"def metadata(self, tokens):\\n\\n return self.process_value_pairs(tokens, \\\"metadata\\\")\",\n \"def read_metadata(\\n filename: Union[Path, str], marker: str = \\\"---\\\", **kwargs: Any\\n) -> Dict[str, Any]:\\n return read_header(filename, marker, **kwargs)[0]\",\n \"def get_metadata(self, chunk, coords):\\n\\n return chunk.get_metadata(coords)\",\n \"def load_metadata(self, path):\\n self.paths = []\\n self.annotations = []\\n\\n with open(path, \\\"r\\\") as f:\\n for line in f:\\n line = line.strip().split(\\\" \\\")\\n \\n rgb_path = line[0]\\n\\n if len(line) > 1:\\n bounding_boxes = np.array([list(map(int, box.split(','))) for box in line[1:]])\\n else:\\n bounding_boxes = []\\n \\n self.annotations.append({\\n \\\"rgb_path\\\": rgb_path, \\n \\\"bounding_boxes\\\": bounding_boxes,\\n })\",\n \"def get_taxa(taxa_fname, sample_ids):\\n try:\\n lines = open(taxa_fname, 'U').readlines()\\n except (TypeError, IOError):\\n raise MissingFileError, 'Taxa summary file required for this analysis'\\n map = parse_mapping_file(lines)\\n return map\",\n \"def parse_lines(filename):\\n line_counter = 0\\n with open(filename, 'r') as rf:\\n for line_txt in rf:\\n try:\\n d = json.loads(line_txt)\\n tup = (\\n d['attributed_to'],\\n int(d['date_time'][8:10]),\\n d.get('used_first_time_today', False),\\n d.get('first_utm_source', 'unknown') \\n )\\n except:\\n print('Error parsing line_txt:', line_txt)\\n line_counter += 1\\n if line_counter % 10 ** 6 == 0:\\n print('read %dM lines' % (line_counter // 10 ** 6))\\n yield tup # yield: https://stackoverflow.com/a/231855\",\n \"def test_filter_mapping_file_by_metadata_states(self):\\n actual = filter_mapping_file_by_metadata_states(self.tutorial_mapping_f,\\\"Treatment:Control\\\")\\n expected = \\\"\\\"\\\"#SampleID\\tBarcodeSequence\\tLinkerPrimerSequence\\tTreatment\\tDOB\\tDescription\\nPC.354\\tAGCACGAGCCTA\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._354\\nPC.355\\tAACTCGTCGATG\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061218\\tControl_mouse_I.D._355\\nPC.356\\tACAGACCACTCA\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20061126\\tControl_mouse_I.D._356\\nPC.481\\tACCAGCGACTAG\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20070314\\tControl_mouse_I.D._481\\nPC.593\\tAGCAGCACTTGT\\tYATGCTGCCTCCCGTAGGAGT\\tControl\\t20071210\\tControl_mouse_I.D._593\\\"\\\"\\\"\\n self.assertEqual(actual,expected)\",\n \"def parsemeta(metalines):\\n def parseline(line):\\n res = [val.strip() for val in line[5:].split(u':', 1)]\\n key, value = (res[0], res[1]) if len(res) == 2 else (res[0], u'')\\n if re.match(r'^-?\\\\d*[\\\\.|,]?\\\\d+$', value):\\n value = float(value)\\n elif re.match(r'^\\\\[(.*)\\\\]', value):\\n value = [val.strip() for val in value[1:-1].split(u',')]\\n value = [float(val) if re.match(r'^-?\\\\d*[\\\\.|,]?\\\\d+$', val) else val for val in value]\\n return key, value\\n return OrderedDict(parseline(line) for line in metalines if line.startswith(u'#CTE_'))\",\n \"def parse_metadata_line(self, line, get_set=False):\\n self.E_str = \\\"parse_metadata_line\\\"\\n\\n metadata_name_regex = \\\"[A-Za-z0-9_-]+\\\"\\n metadata_regex = f\\\"{VAR_REGEX}\\\\['{metadata_name_regex}'\\\\]\\\"\\n metadata_regex += f\\\"|{VAR_REGEX}\\\\['{metadata_name_regex}'\\\\]\\\"\\n\\n corr_syn = \\\"\\\\n\\\\tTo Set: <var_name>['<metadata_name>'] = <value>\\\\n\\\"\\n corr_syn = \\\"\\\\n\\\\tTo Get: <var_name>['<metadata_name>']\\\"\\n\\n # First get the all the parts of the line that contain metadata references\\n value = False\\n str_part, non_str = gen_parse.get_str_between_delims(line, '\\\"')\\n metadata_parts = re.findall(metadata_regex, line)\\n\\n # Now get the metadata name and variable name for each reference\\n new_line = line\\n all_var_names, all_metadata_names = [], []\\n for var_i, var in enumerate(metadata_parts):\\n new_line = new_line.replace(var, f\\\"METADATA_{var_i}\\\")\\n\\n # First get the variable name\\n var = var.strip(' $')\\n words = var.split('[')\\n if len(words) != 2:\\n self.print_error(f\\\"Syntax Error: Correct metadata syntax {corr_syn}\\\")\\n var_name = words[0]\\n\\n # Is the metadata setting data or getting it?\\n if get_set is not False:\\n get_set = \\\"get\\\"\\n if var_name in non_str.split('=')[0]:\\n get_set = \\\"set\\\"\\n\\n # Next get the metadata name\\n metadata_name, _ = gen_parse.get_str_between_delims(words[1], \\\"'\\\")\\n if not metadata_name:\\n metadata_name, _ = gen_parse.get_str_between_delims(words[1], '\\\"')\\n if not metadata_name:\\n self.print_error(f\\\"Correct syntax for metadata is: {corr_syn}\\\")\\n\\n # Now get the metadata value\\n if var_name not in self.variables:\\n self.print_error(f\\\"Undeclared variable '{var_name}'\\\")\\n Var = getattr(self, var_name)\\n\\n err = metadata_name not in Var.metadata and get_set is not False\\n err *= get_set == \\\"get\\\"\\n if err:\\n err_msg = f\\\"Can't find metadata '{metadata_name}' in variable '{var_name}'\\\"\\n err_msg += \\\"\\\\n\\\\n\\\"\\n err_msg += f\\\"{var_name} metadata: {Var.metadata}\\\"\\n self.print_error(err_msg)\\n\\n all_var_names.append(var_name)\\n all_metadata_names.append(metadata_name)\\n\\n return all_var_names, all_metadata_names, new_line\",\n \"def parse_file(self):\\n # the header was already read in the init, start at the first sample line\\n\\n for line in self._stream_handle:\\n\\n # create the dictionary of key/value pairs composed of the labels and the values from the\\n # record being parsed\\n # ex: data_dict = {'sci_bsipar_temp':10.67, n1, n2, nn}\\n data_dict = self._read_data(line)\\n\\n if GliderParser._has_science_data(data_dict, self._particle_class):\\n # create the timestamp\\n timestamp = ntplib.system_to_ntp_time(float(data_dict[GliderParticleKey.M_PRESENT_TIME]))\\n # create the particle\\n self._record_buffer.append(self._extract_sample(\\n self._particle_class, None, data_dict, internal_timestamp=timestamp))\",\n \"def parse(self, lines):\\n # convert file to string deleting end of line charcters\\n citations_string = self.prepare_file(lines)\\n # extract the entries from the string\\n entries = list(self.find_entries(citations_string))\\n entries.append(len(citations_string))\\n # parse each entry to generate a citation\\n for idx, jdx in zip(entries[:-1], entries[1:]):\\n self.parse_entry(citations_string[idx:jdx])\\n return self.force_field.citations\",\n \"def parse(lines):\\n blob_info = defaultdict(list, {})\\n\\n i = None\\n for i, line in enumerate(lines):\\n ld = line.split('%')\\n\\n # parse the first block with the generic stats\\n lda = ld[0].split()\\n blob_info['frame'].append(int(lda[0]))\\n blob_info['time'].append(float(lda[1]))\\n blob_info['centroid'].append((float(lda[2]), float(lda[3])))\\n blob_info['area'].append(int(lda[4]))\\n blob_info['std_vector'].append((float(lda[5]), float(lda[6])))\\n blob_info['std_ortho'].append(float(lda[7]))\\n blob_info['size'].append((float(lda[8]), float(lda[9])))\\n\\n # if there are geometry sections, parse them too.\\n if len(ld) == 4:\\n blob_info['midline'].append(tuple(zip(*alternate([int(x) for x in ld[1].split()]))))\\n\\n # contour data\\n ldc = ld[3].split()\\n blob_info['contour_start'].append((int(ldc[0]), int(ldc[1])))\\n blob_info['contour_encode_len'].append(int(ldc[2]))\\n blob_info['contour_encoded'].append(ldc[3])\\n else:\\n blob_info['midline'].append(None)\\n blob_info['contour_start'].append((0, 0))\\n blob_info['contour_encode_len'].append(None)\\n blob_info['contour_encoded'].append(None)\\n\\n # check if blob was empty\\n if i is None:\\n return None\\n\\n # prevent referencing non-existant fields\\n blob_info.default_factory = None\\n\\n # verify everything is the same length\\n frames = len(blob_info['frame'])\\n assert all(len(v) == frames for v in blob_info.values())\\n\\n return blob_info\",\n \"def parse(lines, descriptions):\\n # TODO does startswith with an empty string always return true?\\n result = {}\\n for description in descriptions: # Fill dict with empty arrays for all entries\\n result[description[0]] = []\\n\\n for line in lines:\\n words = line.split()\\n for description in descriptions:\\n try:\\n result[description[0]].append(parse_line(words, description[0], description[1]))\\n break\\n except ValueError:\\n pass\\n return result\",\n \"def parse_mapping_file_to_dict(*args, **kwargs):\\r\\n mapping_data, header, comments = parse_mapping_file(*args, **kwargs)\\r\\n return mapping_file_to_dict(mapping_data, header), comments\",\n \"def _parse_metadata(config):\\n if not config.active or config.device_metadata is None:\\n return None\\n\\n width, height = config.width, config.height\\n points = []\\n for point in config.device_metadata.split(\\\"|\\\"):\\n try:\\n x, y = point.split(\\\";\\\")\\n points.append([float(x) * width, float(y) * height])\\n except:\\n return None\\n\\n if len(points) != 4:\\n return None\\n\\n return points\",\n \"def get_metadata(hf_patients_file, metadata_file, output_file):\\n\\n # Use 'dicom_id' as names for row indices\\n hf_patients = pd.read_csv(hf_patients_file, sep=',', index_col=\\\"dicom_id\\\")\\n\\n # Use 'dicom' as name\\n metadata = pd.read_csv(metadata_file, index_col=\\\"dicom\\\", dtype={\\\"StudyDate\\\": str, \\\"StudyTime\\\": str})\\n\\n # Disregard all columns except 'subject_id' and 'study_id'\\n hf_patients = pd.concat([hf_patients['study_id'], hf_patients['subject_id']], axis=1)\\n\\n # Find study date/time for heart failure patients\\n study_date = metadata[\\\"StudyDate\\\"][hf_patients.index]\\n study_time = metadata[\\\"StudyTime\\\"][hf_patients.index]\\n\\n result = pd.concat([hf_patients, study_date, study_time], axis=1)\\n result = result.rename(columns={\\\"StudyDate\\\": \\\"study_date\\\", \\\"StudyTime\\\": \\\"study_time\\\"})\\n\\n result.to_csv(output_file)\",\n \"def build_metadata(self, meta):\\n if meta is None:\\n try:\\n self.parser = GenericParser(\\n fn_re='{}/(e\\\\d+s\\\\d+)_.*/Production.nc'.format(self.data_folder),\\n group_names=['sim'],\\n group_transforms=[lambda x: x],\\n top_fn='',\\n step_ps=self.timestep\\n )\\n meta = gather_metadata('{}/e*/*nc'.format(self.data_folder), parser)\\n except:\\n logger.warning(\\\"Could not automatically build metadata\\\")\\n return None\\n else:\\n if not isinstance(meta, pd.DataFrame):\\n meta = load_meta(meta)\\n return meta\",\n \"def parse_metadata(source_text):\\n meta = {}\\n key = None\\n lines = source_text.split('\\\\n')\\n META_RE = re.compile(r'^[ ]{0,3}(?P<key>[A-Za-z0-9_-]+):\\\\s*(?P<value>.*)')\\n META_MORE_RE = re.compile(r'^[ ]{4,}(?P<value>.*)')\\n while 1:\\n line = lines.pop(0)\\n if line.strip() == '':\\n break # blank line - done\\n m1 = META_RE.match(line)\\n if m1:\\n key = m1.group('key').lower().strip()\\n value = m1.group('value').strip()\\n try:\\n meta[key].append(value)\\n except KeyError:\\n meta[key] = [value]\\n else:\\n m2 = META_MORE_RE.match(line)\\n if m2 and key:\\n # Add another line to existing key\\n meta[key].append(m2.group('value').strip())\\n else:\\n lines.insert(0, line)\\n break # no meta data - done\\n return (meta, '\\\\n'.join(lines))\",\n \"def read_metadata_record(raw_features_string):\\n all_data = json.loads(raw_features_string)\\n metadata_keys = {\\\"sha256\\\", \\\"appeared\\\", \\\"label\\\", \\\"avclass\\\"}\\n return {k: all_data[k] for k in all_data.keys() & metadata_keys}\",\n \"def _parse_metadata ( self ):\\n self.date = []\\n self.atcorr_refl = []\\n self.saa = []\\n self.sza = []\\n self.vaa = []\\n self.vza = []\\n self.res = []\\n self._mask = []\\n\\n for md_file in self.metadata:\\n tree = xml.etree.ElementTree.ElementTree ( file=md_file ).getroot()\\n dirname = os.path.dirname ( md_file )\\n try:\\n self.date.append(\\n datetime.datetime.strptime(tree[0][1].text, \\\"%Y-%m-%d %H:%M:%S\\\") )\\n except:\\n self.date.append(\\n datetime.datetime.strptime(tree[0][1].text, \\\"%Y-%m-%d %H:%M:%S.%f\\\") )\\n self.atcorr_refl.append(\\n os.path.join ( dirname, tree[1][2].text ) )\\n self.saa.append( float ( tree[4][10][0].text ) )\\n self.sza.append( float ( tree[4][10][1].text ) )\\n self.vaa.append( float ( tree[4][10][2].text ) )\\n self.vza.append( float ( tree[4][10][3].text ) )\\n self.res.append( float ( tree[2][1].text ) )\\n self._mask.append( os.path.join ( dirname, tree[1][5].text ) )\",\n \"def extract_metadata(source,\\n is_metadata=is_metadata_line,\\n parser=get_metadata,\\n container=MetaData.from_raw_fields):\\n class in_metadata(object):\\n def __init__(self):\\n self.in_metadata = True\\n def __call__(self, line):\\n if not is_metadata(line):\\n self.in_metadata = False\\n return self.in_metadata\\n\\n # Split the source, assuming metadata is at the beginning\\n # (Keep only the group data, i)\\n grouping = itertools.groupby(source, key=in_metadata())\\n #grouping = itertools.imap(operator.itemgetter(1), grouping)\\n has_metadata, first_group = next(grouping)\\n if has_metadata:\\n # We need to strictly consume all the group members here or\\n # they will be lost to the groupby iterator process\\n metadata_lines = list(first_group)\\n _, body_iterator = next(grouping)\\n else:\\n # Use the first group if no metadata was seen\\n metadata_lines = []\\n body_iterator = first_group\\n\\n parsed = load(metadata_lines,\\n is_metadata=is_metadata,\\n container=container,\\n parser=parser)\\n return parsed, body_iterator\",\n \"def extract_metadata(self):\\n metadata_file_path = self.create_metadata_file(\\\".metadata.txt\\\")\\n mt = self.mimetype\\n metadata_processing_method = self.metadata_mimetype_methods.get(mt)\\n if metadata_processing_method:\\n # TODO: should we return metadata and write it here instead of in processing method?\\n metadata_processing_method(metadata_file_path)\",\n \"def LoadMetadata(filename):\\r\\n## print filename\\r\\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'*.zvi'))\\r\\n if globbed:\\r\\n return LoadZVIMetaData(globbed[0])\\r\\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'*.xml'))\\r\\n if globbed:\\r\\n return LoadAxioVisionXMLMetaData(globbed[0])\\r\\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'metadata.txt'))\\r\\n if globbed:\\r\\n return LoadMMMetaData(globbed[0])\\r\\n return None\\r\\n #no further valid options, crash horribly\\r\",\n \"def __init__(self, src_lines):\\n self.study_id = None\\n self.citation = None\\n self.abstract = None\\n self.authors = []\\n self.study_matrices = {}\\n self.history_date = None\\n self.history_time = None\\n self.history_person = None\\n self.history_event = None\\n self.analyses = []\\n \\n self.parse_src_lines(src_lines)\",\n \"def _parse_metadata ( self ):\\n self.date = []\\n self.atcorr_refl = []\\n self.saa = []\\n self.sza = []\\n self.vaa = []\\n self.vza = []\\n self.res = []\\n self._mask = []\\n for md_file in self.metadata:\\n # This is required to get rid of the namespace cruft\\n it = xml.etree.ElementTree.iterparse ( md_file )\\n for _, el in it:\\n el.tag = el.tag.split('}', 1)[1] # strip all namespaces\\n tree = it.root\\n\\n dirname = os.path.dirname ( md_file )\\n\\n self.date.append( datetime.datetime.strptime(\\n tree.find(\\\"global_metadata/acquisition_date\\\").text,\\n \\\"%Y-%m-%d\\\") )\\n\\n for c in tree.findall (\\\"global_metadata/corner\\\"):\\n if c.attrib['location'] == \\\"UL\\\":\\n ulx = float ( c.attrib['longitude'] )\\n uly = float ( c.attrib['latitude'] )\\n else:\\n lrx = float ( c.attrib['longitude'] )\\n lry = float ( c.attrib['latitude'] )\\n\\n self.vaa.append ( get_vaa ( lrx, lry, ulx, uly ) )\\n\\n #self.atcorr_refl.append( os.path.join ( dirname, tree[1][2].text ) )\\n self.saa.append(\\n float ( tree.find(\\\"global_metadata/solar_angles\\\").attrib['azimuth'] ) )\\n self.sza.append(\\n float ( tree.find(\\\"global_metadata/solar_angles\\\").attrib['zenith'] ) )\\n self.vza.append( 0.0 ) # Note that LDCM can look sideways a bit!\\n self.res.append( 30. ) # 30m\\n\\n images = []\\n mask = []\\n for b in tree.findall(\\\"bands/band\\\"):\\n if b.attrib['product'] == \\\"toa_refl\\\":\\n fname = b.find(\\\"file_name\\\").text\\n if fname.find ( \\\"qa.tif\\\" ) < 0:\\n images.append ( os.path.join ( dirname, fname ) )\\n elif b.attrib['product'] == \\\"cfmask\\\":\\n mask = os.path.join ( dirname, fname )\\n # Create VRT?\\n subprocess.call ([\\\"gdalbuildvrt\\\", \\\"-overwrite\\\", \\\"-separate\\\",\\n os.path.join ( dirname, md_file.replace(\\\".xml\\\", \\\"_crop.vrt\\\" )) ] + images )\\n self.atcorr_refl.append ( os.path.join ( dirname,\\n md_file.replace(\\\".xml\\\", \\\"_crop.vrt\\\" )) )\\n self._mask.append( mask )\",\n \"def parse_mca(f):\\n for line in f:\\n yield RECORD_TYPES[RecordIdentity(line[:2])].from_string(line)\",\n \"def parse_metadata(path, site):\\n headers = ['name', 'lat', 'lon', 'altitude', 'depth', 'prefecture', 'otherlat', 'otherlon', 'instrument']\\n site_info = pd.read_csv(path, index_col=0, header=None).loc[site].values[0:9]\\n return {header: site_info[i] for i, header in enumerate(headers)}\",\n \"def parse_file(self, infile, chardict, labeldict):\\n examples = []\\n fin = io.open(infile, 'r')\\n # idx is for the index of the row in the \\n # original file before shuffling and randomization\\n idx = 0\\n for line in fin: \\n entity, label = map(clean, line.rstrip().split('\\\\t')[:2])\\n # print entity\\n ent = map(lambda c:chardict[c], list(entity))\\n lab = map(lambda l:labeldict[l] if l in labeldict else 0, label.split(','))\\n examples.append((idx, ent, lab))\\n idx += 1\\n fin.close()\\n print \\\"num_rows:\\\", len(examples), \\\" index\\\", idx\\n return examples\",\n \"def parse(self, src, line):\\n r = line.split('\\\\t')\\n p = {}\\n if src == 'sf':\\n p['businessID'] = r[0]\\n p['name'] = r[1]\\n p['address'] = r[2]\\n p['city'] = r[3]\\n p['state'] = r[4]\\n p['zip'] = r[5]\\n p['latitude'] = r[6]\\n p['longitude'] = r[7]\\n p['phone'] = r[8]\\n elif src == 'nyc':\\n p['businessID'] = r[0]\\n p['name'] = r[1]\\n # nyc separates the building number from the street name\\n p['address'] = ' '.join([r[3].strip(), r[4].strip()])\\n p['city'] = 'NYC'\\n p['state'] = 'NY'\\n p['zip'] = r[5]\\n p['latitude'] = None\\n p['longitude'] = None\\n p['phone'] = r[6]\\n return p\",\n \"def test_metadata(self):\\n cr = CaseReader(self.filename)\\n self.assertEqual(cr.format_version, format_version,\\n msg='incorrect format version')\\n self.assertIsNone(cr.parameters,\\n msg='parameter metadata should be None')\\n self.assertIsNone(cr.unknowns, msg='unknown metadata should be None')\",\n \"def test_parse_sample_file(self):\\n parser = wv2_xml.Parser(\\n 'imars_etl/drivers_metadata/wv2_xml/test_files/'\\n 'WV02_20140218163417_103001002E0EB600_14FEB18163417-M1BS-'\\n '500534956040_01_P004.xml'\\n )\\n metadata_read = parser.get_metadata()\\n print('md: {}'.format(metadata_read))\\n expected_subset = {\\n \\\"time\\\": \\\"2014-02-18T16:34:17.926650\\\"\\n }\\n\\n assert expected_subset.items() <= metadata_read.items()\",\n \"def test_sample_ids_from_metadata_description(self):\\n self.assertRaises(ValueError, sample_ids_from_metadata_description,\\n self.tutorial_mapping_f, \\\"Treatment:Foo\\\")\\n self.tutorial_mapping_f.seek(0)\\n self.assertRaises(ValueError, sample_ids_from_metadata_description,\\n self.tutorial_mapping_f, \\\"DOB:!20061218,!20070314,!20071112,\\\"\\n \\\"!20080116\\\")\",\n \"def parse(self):\\n try:\\n self.open_file()\\n lines = list(self._file)\\n\\n if len(lines) > 0:\\n text = ''.join(lines)\\n regex = 'Song \\\\d+\\\\nStart (\\\\d+:\\\\d+:\\\\d+)\\\\nEnd (\\\\d+:\\\\d+:\\\\d+)\\\\nLength (\\\\d+.\\\\d+)'\\n match = re.findall(regex, text)\\n if len(match):\\n starts = []\\n ends = []\\n lengths = []\\n\\n for i in range(len(match)):\\n starts.append(match[i][0])\\n ends.append(match[i][1])\\n lengths.append(float(match[i][2]))\\n\\n for i in range(len(match)):\\n self.debug_data.append({\\n 'start':starts[i],'end':ends[i],'length':lengths[i]})\\n\\n match = re.search('T\\\\d_S(\\\\d{4})_.*.txt', self._filepath)\\n if match:\\n self._experiment_metadata['session_id'] = int(match.groups()[0])\\n else:\\n raise EIMParsingError(\\\"No valid session id found in filename %s\\\" % self._filepath)\\n\\n finally:\\n if self._file and not self._file.closed:\\n self.close_file()\",\n \"def read_metadata(self, file=None):\\n if file is None:\\n file = self.meta_data_file\\n\\n try:\\n self.meta_data = self.input_dataframe(file, index_col=None)\\n except IOError:\\n self.meta_data = self.create_default_meta_data(self.expression_matrix)\",\n \"def test_parse_mapping_file(self):\\r\\n s1 = ['#sample\\\\ta\\\\tb', '#comment line to skip',\\r\\n 'x \\\\t y \\\\t z ', ' ', '#more skip', 'i\\\\tj\\\\tk']\\r\\n exp = ([['x', 'y', 'z'], ['i', 'j', 'k']],\\r\\n ['sample', 'a', 'b'],\\r\\n ['comment line to skip', 'more skip'])\\r\\n obs = parse_mapping_file(s1)\\r\\n self.assertEqual(obs, exp)\\r\\n\\r\\n # We don't currently support this, but we should soon...\\r\\n # check that first non-comment, non-blank line is used as\\r\\n # header\\r\\n # s1 = ['sample\\\\ta\\\\tb', '#comment line to skip',\\\\\\r\\n # 'x \\\\t y \\\\t z ', ' ', '#more skip', 'i\\\\tj\\\\tk']\\r\\n # exp = ([['x','y','z'],['i','j','k']],\\\\\\r\\n # ['sample','a','b'],\\\\\\r\\n # ['comment line to skip','more skip'])\\r\\n # obs = parse_mapping_file(s1)\\r\\n # self.assertEqual(obs, exp)\\r\\n\\r\\n # check that we strip double quotes by default\\r\\n s2 = ['#sample\\\\ta\\\\tb', '#comment line to skip',\\r\\n '\\\"x \\\"\\\\t\\\" y \\\"\\\\t z ', ' ', '\\\"#more skip\\\"', 'i\\\\t\\\"j\\\"\\\\tk']\\r\\n obs = parse_mapping_file(s2)\\r\\n self.assertEqual(obs, exp)\",\n \"def parse_map(file):\\n with open(FILE) as f:\\n return Map([line[:-1] for line in f])\",\n \"def extract_metadata(parser_config, snippet):\\n return parser_config['implementation'](snippet)\",\n \"def extract_meta_data(video_file_name, output_file=meta.txt, *args, **kwargs):\",\n \"def extract_points(fp: T.BinaryIO) -> T.Optional[T.List[geo.Point]]:\\n\\n points = None\\n movie_timescale = None\\n media_timescale = None\\n elst_entries = None\\n\\n for h, s in parser.parse_path(fp, [b\\\"moov\\\", [b\\\"mvhd\\\", b\\\"trak\\\"]]):\\n if h.type == b\\\"trak\\\":\\n trak_start_offset = s.tell()\\n\\n descriptions = sample_parser.parse_descriptions_from_trak(\\n s, maxsize=h.maxsize\\n )\\n camm_descriptions = [d for d in descriptions if d[\\\"format\\\"] == b\\\"camm\\\"]\\n if camm_descriptions:\\n s.seek(trak_start_offset, io.SEEK_SET)\\n camm_samples = _extract_camm_samples(s, h.maxsize)\\n\\n points_with_nones = (\\n _parse_point_from_sample(fp, sample)\\n for sample in camm_samples\\n if sample.description[\\\"format\\\"] == b\\\"camm\\\"\\n )\\n\\n points = [p for p in points_with_nones if p is not None]\\n if points:\\n s.seek(trak_start_offset)\\n elst_data = parser.parse_box_data_first(\\n s, [b\\\"edts\\\", b\\\"elst\\\"], maxsize=h.maxsize\\n )\\n if elst_data is not None:\\n elst_entries = cparser.EditBox.parse(elst_data)[\\\"entries\\\"]\\n\\n s.seek(trak_start_offset)\\n mdhd_data = parser.parse_box_data_firstx(\\n s, [b\\\"mdia\\\", b\\\"mdhd\\\"], maxsize=h.maxsize\\n )\\n mdhd = cparser.MediaHeaderBox.parse(mdhd_data)\\n media_timescale = mdhd[\\\"timescale\\\"]\\n else:\\n assert h.type == b\\\"mvhd\\\"\\n if not movie_timescale:\\n mvhd = cparser.MovieHeaderBox.parse(s.read(h.maxsize))\\n movie_timescale = mvhd[\\\"timescale\\\"]\\n\\n # exit when both found\\n if movie_timescale is not None and points:\\n break\\n\\n if points and movie_timescale and media_timescale and elst_entries:\\n segments = [\\n elst_entry_to_seconds(entry, movie_timescale, media_timescale)\\n for entry in elst_entries\\n ]\\n points = list(filter_points_by_elst(points, segments))\\n\\n return points\",\n \"def read_metadata_record(raw_features_string):\\n full_metadata = json.loads(raw_features_string)\\n return {\\\"sha256\\\": full_metadata[\\\"sha256\\\"], \\\"appeared\\\": full_metadata[\\\"appeared\\\"], \\\"label\\\": full_metadata[\\\"label\\\"]}\",\n \"def read_file(inp_fn):\\n lines = [line.strip().split(\\\",\\\")\\n for line in open(inp_fn)\\n if not (line.startswith(\\\"#\\\"))]\\n return [(int(line[0]), year_record({\\\"male\\\": int(line[-3]),\\n \\\"female\\\": int(line[-2]),\\n \\\"unknown\\\": int(line[-1])},\\n None, None))\\n for line in lines[1:]]\",\n \"def get_lineid_content():\\n lineid_content = {}\\n lines_file_path = os.path.join(DATA_PATH + MOVIE_LINES_FILE)\\n\\n with open(lines_file_path, 'r', errors='ignore') as f:\\n # +++$+++ is used to split the section in a single line\\n # A correct formed line includes five sections\\n # The first section is lineID\\n # The last section is line content\\n # Here we only need lineID and content\\n\\n for line in f:\\n line_sections = line.split(' +++$+++ ')\\n assert len(line_sections) == 5\\n if line_sections[4][-1] == '\\\\n':\\n line_sections[4] = line_sections[4][:-1]\\n lineid_content[line_sections[0]] = line_sections[4]\\n\\n return lineid_content\",\n \"def medline_parser(filename):\\n pmid_abstract_dict = {}\\n with open(filename) as handle:\\n for record in Medline.parse(handle):\\n if 'AB' in record.keys():\\n pmid, abstract = record['PMID'], record['AB']\\n pmid_abstract_dict[pmid] = abstract\\n return pmid_abstract_dict\",\n \"def get_metadata_from_path(path):\\n try:\\n import yaml\\n # assumes index card is in the top-level of path\\n index_card = os.path.join(path, \\\"M_index.yaml\\\")\\n with open(index_card, \\\"r\\\") as stream:\\n file_info = yaml.safe_load(stream)\\n\\n metadata_dict = {}\\n metadata_dict[\\\"book_id\\\"] = file_info[\\\"book_id\\\"]\\n metadata_dict[\\\"timestamp_start\\\"] = file_info[\\\"start_time\\\"]\\n metadata_dict[\\\"type\\\"] = file_info[\\\"type\\\"]\\n metadata_dict[\\\"obsid\\\"] = _convert_book_id_to_obsid(file_info[\\\"book_id\\\"])\\n # get optional bits\\n if \\\"stop_time\\\" in file_info:\\n metadata_dict[\\\"timestamp_end\\\"] = file_info[\\\"stop_time\\\"]\\n if \\\"observatory\\\" in file_info:\\n metadata_dict[\\\"observatory\\\"] = file_info[\\\"observatory\\\"]\\n if \\\"telescope\\\" in file_info:\\n metadata_dict[\\\"telescope\\\"] = file_info[\\\"telescope\\\"]\\n if \\\"stream_ids\\\" in file_info:\\n metadata_dict[\\\"stream_ids\\\"] = file_info[\\\"stream_ids\\\"]\\n if \\\"subtype\\\" in file_info:\\n metadata_dict[\\\"subtype\\\"] = file_info[\\\"subtype\\\"]\\n if \\\"tags\\\" in file_info:\\n metadata_dict[\\\"tags\\\"] = file_info[\\\"tags\\\"]\\n if \\\"scanification\\\" in file_info:\\n metadata_dict[\\\"scanification\\\"] = file_info[\\\"scanification\\\"]\\n if \\\"hwp_rate_hz\\\" in file_info:\\n metadata_dict[\\\"hwp_rate_hz\\\"] = file_info[\\\"hwp_rate_hz\\\"]\\n if \\\"sequencer_ref\\\" in file_info:\\n metadata_dict[\\\"sequencer_ref\\\"] = file_info[\\\"sequencer_ref\\\"]\\n return metadata_dict\\n except (ImportError, FileNotFoundError, KeyError):\\n pass\\n\\n return None\",\n \"def test_parse_mapping_file_to_dict(self):\\r\\n s1 = ['#sample\\\\ta\\\\tb', '#comment line to skip',\\r\\n 'x \\\\t y \\\\t z ', ' ', '#more skip', 'i\\\\tj\\\\tk']\\r\\n exp = ([['x', 'y', 'z'], ['i', 'j', 'k']],\\r\\n ['sample', 'a', 'b'],\\r\\n ['comment line to skip', 'more skip'])\\r\\n mapdict, comments = parse_mapping_file_to_dict(s1)\\r\\n expdict = {'x': {'a': 'y', 'b': 'z'}, 'i': {'a': 'j', 'b': 'k'}}\\r\\n self.assertEqual(mapdict, expdict)\\r\\n self.assertEqual(comments, ['comment line to skip', 'more skip'])\",\n \"def parse_metadata(self):\\n micro_metadata = {}\\n ext_meta = None\\n self.content_type = 'text/html'\\n if self.source_metadata:\\n #print(self.source_metadata)\\n if len(self.source_metadata)>1:\\n try:\\n for sm in self.source_metadata:\\n if str(sm.get('type').split('/')[-1]).lower() in self.SCHEMA_ORG_CREATIVEWORKS:\\n ext_meta = sm\\n except:\\n pass\\n self.source_name = self.getEnumSourceNames().MICRODATA_EMBEDDED\\n if not ext_meta:\\n ext_meta = self.source_metadata[0]\\n\\n if ext_meta is not None:\\n self.logger.info('FsF-F2-01M : Trying to extract Microdata metadata from -: {}'.format(self.source_name))\\n # TODO check syntax - not ending with /, type and @type\\n # TODO (important) extend mapping to detect other pids (link to related entities)?\\n # TODO replace check_context_type list context comparison by regex\\n check_context_type = ['Dataset', 'Collection']\\n try:\\n #if ext_meta['@context'] in check_context_type['@context'] and ext_meta['@type'] in check_context_type[\\\"@type\\\"]:\\n if str(ext_meta.get('type')).find('schema.org') > -1:\\n micro_metadata = jmespath.search(self.metadata_mapping.value, ext_meta)\\n self.namespaces.append('http://schema.org/')\\n else:\\n self.logger.info('FsF-F2-01M : Failed to parse non schema.org type Microdata')\\n except Exception as err:\\n #print(err.with_traceback())\\n self.logger.info('FsF-F2-01M : Failed to parse Microdata -: {}'.format(err))\\n else:\\n self.logger.info('FsF-F2-01M : Could not identify Microdata metadata')\\n\\n return self.source_name, micro_metadata\",\n \"def loadContentSamplesFile(self, lines):\\n refgenome = set()\\n \\n for line in lines:\\n if line.startswith(\\\"#\\\"):\\n continue\\n \\n tokens = line.rstrip(\\\"\\\\n\\\").split(\\\"\\\\t\\\")\\n \\n # create and fill a \\\"GbsSample\\\" object\\n for samplesCol in [\\\"genotype\\\", \\\"flowcell\\\", \\\"lane\\\"]:\\n if \\\"_\\\" in tokens[self.samplesCol2idx[samplesCol]]:\\n msg = \\\"underscore in %s '%s', replace by dash '-'\\\" \\\\\\n % (samplesCol, tokens[self.samplesCol2idx[samplesCol]])\\n raise ValueError(msg)\\n if \\\" \\\" in tokens[self.samplesCol2idx[samplesCol]]:\\n msg = \\\"space in %s '%s', replace by dash '-'\\\" \\\\\\n % (samplesCol, tokens[self.samplesCol2idx[samplesCol]])\\n raise ValueError(msg)\\n if \\\".\\\" in tokens[self.samplesCol2idx[samplesCol]]:\\n msg = \\\"dot in %s '%s', replace by dash '-'\\\" \\\\\\n % (samplesCol, tokens[self.samplesCol2idx[samplesCol]])\\n raise ValueError(msg)\\n geno = tokens[self.samplesCol2idx[\\\"genotype\\\"]]\\n flowcell = tokens[self.samplesCol2idx[\\\"flowcell\\\"]]\\n laneNum = int(tokens[self.samplesCol2idx[\\\"lane\\\"]])\\n barcode = tokens[self.samplesCol2idx[\\\"barcode\\\"]]\\n if self.fclnToKeep is not None and \\\\\\n \\\"%s_%i\\\" % (flowcell, laneNum) != self.fclnToKeep:\\n continue\\n iSample = GbsSample(geno, flowcell, laneNum, barcode,\\n \\\"before\\\" if int(self.lSteps[0]) < 3 \\\\\\n else \\\"after\\\")\\n iSample.refGenome = tokens[self.samplesCol2idx[\\\"ref_genome\\\"]]\\n iSample.library = tokens[self.samplesCol2idx[\\\"library\\\"]]\\n iSample.seqCenter = tokens[self.samplesCol2idx[\\\"seq_center\\\"]]\\n iSample.seqPlatform = tokens[self.samplesCol2idx[\\\"seq_platform\\\"]]\\n iSample.seqPlatformModel = tokens[self.samplesCol2idx[\\\"seq_platform_model\\\"]]\\n iSample.date = tokens[self.samplesCol2idx[\\\"date\\\"]]\\n iSample.initFastqFile1 \\\\\\n = \\\"%s/%s\\\" % (self.pathToInReadsDir,\\n tokens[self.samplesCol2idx[\\\"fastq_file_R1\\\"]])\\n if tokens[self.samplesCol2idx[\\\"fastq_file_R2\\\"]] != \\\"\\\":\\n iSample.initFastqFile2 \\\\\\n = \\\"%s/%s\\\" % (self.pathToInReadsDir,\\n tokens[self.samplesCol2idx[\\\"fastq_file_R2\\\"]])\\n if iSample.id not in self.dSamples:\\n self.dSamples[iSample.id] = iSample\\n refgenome.add(iSample.refGenome)\\n\\n if flowcell not in self.dFlowcells:\\n self.dFlowcells[flowcell] = []\\n if laneNum not in self.dFlowcells[flowcell]:\\n self.dFlowcells[flowcell].append(laneNum)\\n\\n # create and fill a \\\"GbsLane\\\" object\\n laneId = \\\"%s_%i\\\" % (flowcell, laneNum)\\n if laneId not in self.dLanes:\\n self.dLanes[laneId] = GbsLane(laneId, flowcell, laneNum)\\n self.dLanes[laneId].insert(iSample)\\n\\n # create and fill a \\\"GbsGeno\\\" object\\n if geno not in self.dGenos:\\n self.dGenos[geno] = GbsGeno(geno)\\n self.dGenos[geno].insert(iSample)\\n \\n if (\\\"4\\\" in self.lSteps or \\\"5\\\" in self.lSteps or \\\"6\\\" in self.lSteps \\\\\\n or \\\"7\\\" in self.lSteps or \\\"8\\\" in self.lSteps) \\\\\\n and len(refgenome) > 1:\\n print(refgenome)\\n msg = \\\"samples file contains more than one reference genome\\\"\\n raise ValueError(msg)\",\n \"def parse_lineage(tsv_filename, sample_names, allow_missing=True):\\n\\n samples = {}\\n\\n if file_is_missing(tsv_filename, allow_missing):\\n for name in sample_names:\\n samples[name] = { 'lineage' : None,\\n 'clade': None,\\n 'pangolin_ver': None,\\n 'pangodata_ver': None,\\n 'nextclade_ver': None }\\n return { 'samples': samples }\\n\\n lineages = pd.read_table(tsv_filename, sep='\\\\t')\\n try:\\n df = lineages[['isolate',\\n 'pango_lineage',\\n 'nextstrain_clade',\\n 'pangolin_version',\\n 'pangoLEARN_version',\\n 'nextclade_version'\\n ]]\\n except KeyError:\\n df = lineages[['isolate',\\n 'pango_lineage',\\n 'nextstrain_clade',\\n 'pangolin_version',\\n 'version',\\n 'nextclade_version'\\n ]]\\n\\n # Pull each row, identify sid \\n for row in df.itertuples():\\n if row.isolate.startswith(\\\"Consensus\\\"):\\n sid = re.findall(\\\"_(.*?)\\\\.\\\", row.isolate)[0]\\n else:\\n sid = str(row.isolate)\\n\\n assert sid in sample_names\\n\\n # Pull Pangolin lineage\\n lineage = str(row.pango_lineage)\\n clade = str(row.nextstrain_clade)\\n pangolin = str(row.pangolin_version)\\n try:\\n pangodata = str(row.pangoLEARN_version)\\n except AttributeError:\\n pangodata = str(row.version)\\n nextclade = str(row.nextclade_version)\\n samples[sid] = { 'lineage' : lineage,\\n 'clade': clade,\\n 'pangolin_ver': pangolin,\\n 'pangodata_ver': pangodata,\\n 'nextclade_ver': nextclade }\\n\\n assert len(samples) == len(sample_names)\\n return { 'samples': samples }\",\n \"def parse_line(line, patterns=None):\\n if patterns is None:\\n patterns = LINE_PATTERNS\\n\\n for line_re in patterns:\\n match = line_re.match(line)\\n if match:\\n data = match.groupdict()\\n av_pairs = data['av_pairs']\\n data['av_pairs'] = cleanup_av_pairs(av_pairs)\\n return data\\n\\n return None\",\n \"def parse(self, filehandle):\\n l = filehandle.readline()\\n if l.split()[0] != '##maf':\\n return\\n else:\\n self.setpar(l.split()[1:])\\n\\n l=filehandle.readline()\\n while l:\\n la = l.split()\\n## print la\\n if(len(la)==0 or la[0]=='#'):\\n## print \\\"skipping\\\"\\n 1\\n elif(la[0]=='a'):\\n## print \\\"reading alignment\\\"\\n self.readalign(la[1:], filehandle)\\n else:\\n## print \\\"end of records\\\"\\n return\\n\\n l=filehandle.readline()\",\n \"def parse_record(self, in_rec):\\n \\n geo_util = geo.Geo()\\n \\n self.metadata = {}\\n for k, v in in_rec.items():\\n if k == 'metadata2': continue\\n elif k == 'geometry':\\n self.metadata['geometry'] = v\\n coords = v['coordinates']\\n self.metadata['wkt'] = geo_util.convert_imageGeom(\\\\\\n coords, 'wkt')\\n elif k == 'metadata':\\n for m in v:\\n key = to_camelCase(m[0])\\n self.metadata[key] = m[1]\\n else:\\n self.metadata[k] = v\",\n \"def load_metadata(self):\\n handler = open('meta.xml').read()\\n soup = BeautifulSoup(handler, 'xml')\\n\\n for meta in soup.find_all(re.compile(\\\"^title\\\")):\\n if meta.string:\\n self.meta_title = unicode(meta.string)\\n\\n for meta in soup.find_all(re.compile(\\\"^initial.creator\\\")):\\n if meta.string:\\n self.meta_initial_creator = unicode(meta.string)\\n\\n for meta in soup.find_all(re.compile(\\\"^date\\\")):\\n if meta.string:\\n self.meta_date = unicode(meta.string)\",\n \"def load_metainfo(filename, dependencyLoader=None, extraArgsHandling=InfoKindEl.ADD_EXTRA_ARGS, uri=None):\\n path = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), \\\"../../../../nomad-meta-info/meta_info/nomad_meta_info/{}\\\".format(filename)))\\n return loadJsonFile(path, dependencyLoader, extraArgsHandling, uri)\",\n \"def read_metadata_file():\\n metadata = None\\n if not os.path.isfile(META_DATA_FILE):\\n ppg.log_info(\\\"No metadata found. The earthquake splitting might have not been ran yet.\\\")\\n else:\\n ppg.log_info(\\\"Found metadata file\\\")\\n metadata = pd.read_csv(META_DATA_FILE)\\n return metadata\",\n \"def create_meta_dict_L1(adcp_meta):\\n meta_dict = {}\\n with open(adcp_meta) as csv_file:\\n csv_reader = csv.reader(csv_file, delimiter=',')\\n line_count = 0\\n next(csv_reader, None) # Skip header row\\n for row in csv_reader:\\n # extract all metadata from csv file into dictionary -- some items not passed to netCDF file but are extracted anyway\\n if row[0] == '' and row[1] == '':\\n print('Metadata file contains a blank row; skipping this row !')\\n elif row[0] != '' and row[1] == '':\\n print('Metadata item in csv file has blank value; skipping this row '\\n 'in metadata file !')\\n else:\\n meta_dict[row[0]] = row[1]\\n\\n # Add conventions metadata to meta_dict\\n meta_dict['deployment_type'] = 'Sub Surface'\\n meta_dict['flag_meaning'] = 'no_quality_control, good_value, probably_good_value, probably_bad_value, ' \\\\\\n 'bad_value, changed_value, value_below_detection, value_in_excess, ' \\\\\\n 'interpolated_value, missing_value'\\n meta_dict['flag_references'] = 'BODC SeaDataNet'\\n meta_dict['flag_values'] = '0, 1, 2, 3, 4, 5, 6, 7, 8, 9'\\n meta_dict['keywords'] = 'Oceans > Ocean Circulation > Ocean Currents'\\n meta_dict['keywords_vocabulary'] = 'GCMD Science Keywords'\\n meta_dict['naming_authority'] = 'BODC, MEDS, CF v72'\\n meta_dict['variable_code_reference'] = 'BODC P01'\\n meta_dict['Conventions'] = \\\"CF-1.8\\\"\\n\\n return meta_dict\",\n \"def parse_feature(self, feature_key, lines):\\n ...\",\n \"def get_metadata(self, t: Optional[int] = None) -> Dict:\\n real_t = None if t is None else int(self._resolve_index(t))\\n if self._is_tiff:\\n ret = self._reader.metadata(index=..., page=real_t)\\n else:\\n ret = self._reader.metadata(index=real_t)\\n self._parse_yaml_description(ret)\\n if real_t is not None:\\n ret[\\\"frame_no\\\"] = real_t\\n return ret\",\n \"def test_metadata():\\n # Note: The json file should have been created with previous tests\\n with open(file_struct.features_file) as f:\\n data = json.load(f)\\n assert(\\\"metadata\\\" in data.keys())\\n metadata = data[\\\"metadata\\\"]\\n assert(\\\"timestamp\\\" in metadata.keys())\\n assert(metadata[\\\"versions\\\"][\\\"numpy\\\"] == np.__version__)\\n assert(metadata[\\\"versions\\\"][\\\"msaf\\\"] == msaf.__version__)\\n assert(metadata[\\\"versions\\\"][\\\"librosa\\\"] == librosa.__version__)\",\n \"def get_metadata_from_json(sample_metadata_path):\\n\\n try:\\n return normalize_metadata(json.loads(open(sample_metadata_path).read()))\\n except IOError:\\n logging.exception('get_metadata')\\n return {}\",\n \"def load_metadata_from_file(filename):\\n try:\\n extension = os.path.splitext(filename)[1]\\n return _metadata_loader[extension](filename)\\n except KeyError:\\n raise TypeError('Cannot read metadata from file %s, extension %s not ' \\n 'supported at this time' % (filename, extension))\",\n \"def get_metadata(self,\\n params: typing.Optional[typing.Mapping[str, str]] = None):\\n raise NotImplementedError('This data connector does not provide metadata')\",\n \"def _parse_metadata(self, md):\\n md = ast.literal_eval(md)\\n dd = defaultdict(list)\\n\\n for entry in md:\\n try:\\n for k, v in entry.items():\\n dd[k].append(v)\\n except AttributeError:\\n continue\\n return dd\",\n \"def read(self, file_info, **kwargs):\\n\\n # We need to import at least the standard fields\\n user_fields = kwargs.pop(\\\"fields\\\", {})\\n fields = self.standard_fields | set(user_fields)\\n\\n # We catch the user mapping here, since we do not want to deal with\\n # user-defined names in the further processing. Instead, we use our own\\n # mapping\\n user_mapping = kwargs.pop(\\\"mapping\\\", None)\\n\\n # Load the dataset from the file:\\n dataset = super().read(\\n file_info, fields=fields, mapping=self.mapping, **kwargs\\n )\\n\\n dataset[\\\"time\\\"] = self._get_time_field(dataset, file_info)\\n\\n # Remove fields that we do not need any longer (expect the user asked\\n # for them explicitly)\\n dataset = dataset.drop_vars(\\n {\\\"UTC_start\\\", \\\"Profile_time\\\"} - set(user_fields),\\n )\\n\\n if user_mapping is not None:\\n dataset = dataset.rename(user_mapping)\\n\\n return dataset\",\n \"def test_mapping_file_to_dict(self):\\r\\n s1 = ['#sample\\\\ta\\\\tb', '#comment line to skip',\\r\\n 'x \\\\t y \\\\t z ', ' ', '#more skip', 'i\\\\tj\\\\tk']\\r\\n exp = ([['x', 'y', 'z'], ['i', 'j', 'k']],\\r\\n ['sample', 'a', 'b'],\\r\\n ['comment line to skip', 'more skip'])\\r\\n mapres = parse_mapping_file(s1) # map_data, header, comments\\r\\n mapdict = mapping_file_to_dict(*mapres[:2])\\r\\n expdict = {'x': {'a': 'y', 'b': 'z'}, 'i': {'a': 'j', 'b': 'k'}}\\r\\n self.assertEqual(mapdict, expdict)\",\n \"def _parse_filename(filename, metadata):\\n\\n file_noext = os.path.splitext(filename)[0]\\n fname = file_noext.split(\\\"_\\\")\\n\\n metadata[\\\"scene_id\\\"] = fname[1]\\n metadata[\\n \\\"beam_mode\\\"] = sat_properties.radarsat_product_characteristics[\\n fname[2]]\\n metadata[\\\"product_type\\\"] = fname[-1]\\n try:\\n metadata[\\n \\\"product_description\\\"] = sat_properties.radarsat_1_data_products[\\n fname[-1][:3]]['description']\\n except Exception:\\n metadata[\\\"product_description\\\"] = \\\"\\\"\\n\\n metadata[\\\"scene_mean_time\\\"] = datetime.datetime.strptime(\\n fname[3] + fname[4], \\\"%Y%m%d%H%M%S\\\")\\n\\n return metadata\",\n \"def identify_contents_metadata(cube, filename):\\n metadata = {}\\n\\n try:\\n # This could be None if cube.var_name isn't defined\\n metadata['var_name'] = cube.var_name\\n metadata['units'] = str(cube.units)\\n metadata['long_name'] = cube.long_name\\n metadata['standard_name'] = cube.standard_name\\n metadata['time_units'] = cube.coord('time').units.origin\\n metadata['calendar'] = cube.coord('time').units.calendar\\n # CMIP5 doesn't have an activity id and so supply a default\\n metadata['activity_id'] = cube.attributes.get('activity_id',\\n 'HighResMIP')\\n try:\\n metadata['institute'] = cube.attributes['institution_id']\\n except KeyError:\\n # CMIP5 uses institute_id but we should not be processing CMIP5\\n # data but handle it just in case\\n metadata['institute'] = cube.attributes['institute_id']\\n except Exception as exc:\\n msg = ('Unable to extract metadata from the contents of file {}\\\\n{}'.\\n format(filename, exc.__str__()))\\n raise FileValidationError(msg)\\n\\n return metadata\",\n \"def loadMetaChunkToServerMap (fileName):\\n if not os.path.exists(fileName):\\n print \\\"File \\\", fileName, \\\" does not exists\\\"\\n sys.exit(1)\\n\\n infile = open (fileName, \\\"r\\\")\\n count = 0\\n while infile:\\n count = count + 1\\n line = infile.readline()\\n if not line:\\n break\\n print \\\"DEBUGME : processing line %s, %d\\\" % (line, count)\\n lineParts = line.split(' ')\\n gChunkMap[lineParts[0]] = ChunkInfo(lineParts[0], lineParts[1], lineParts[2])\\n # Add a ChunkHostInfo\\n numServers = int(lineParts[2])\\n for i in range(numServers):\\n i = i * 3\\n gChunkMap[lineParts[0]].addChunkHostInfo(ChunkHostInfo(lineParts[i+3], lineParts[i+4], lineParts[i+5]))\",\n \"def metadata(sceneid, pmin=2, pmax=98, **kwargs):\\n scene_params = _sentinel_parse_scene_id(sceneid)\\n path_prefix = os.path.join(scene_params[\\\"aws_bucket\\\"], scene_params[\\\"aws_prefix\\\"])\\n preview_file = os.path.join(path_prefix, scene_params[\\\"preview_file\\\"])\\n\\n dst_crs = CRS({\\\"init\\\": \\\"EPSG:4326\\\"})\\n with rasterio.open(preview_file) as src:\\n bounds = transform_bounds(\\n *[src.crs, dst_crs] + list(src.bounds), densify_pts=21\\n )\\n\\n info = {\\\"sceneid\\\": sceneid}\\n info[\\\"bounds\\\"] = {\\\"value\\\": bounds, \\\"crs\\\": dst_crs.to_string()}\\n\\n addresses = [\\n \\\"{}/{}/B{}.jp2\\\".format(path_prefix, scene_params[\\\"preview_prefix\\\"], band)\\n for band in scene_params[\\\"bands\\\"]\\n ]\\n _stats_worker = partial(_sentinel_stats, percentiles=(pmin, pmax), **kwargs)\\n with futures.ThreadPoolExecutor(max_workers=MAX_THREADS) as executor:\\n responses = executor.map(_stats_worker, addresses)\\n\\n info[\\\"statistics\\\"] = {\\n b: v for b, d in zip(scene_params[\\\"bands\\\"], responses) for k, v in d.items()\\n }\\n return info\",\n \"def createMetadata(request, datafile):\\n samples = []\\n datafile = datafile.split(',')\\n for f in datafile:\\n filename = f.replace('[', '').replace(']', '').replace('\\\"', '').replace(' ', '')\\n cont = subprocess.Popen(\\n [\\\"curl -u \\\" + request.session.get('username') + \\\":\\\" + request.session.get('password') + \\\" -k -s \\\" + filename[1:]],\\n stdout=subprocess.PIPE, shell=True).communicate()[0]\\n with open(request.session.get('username') + \\\"/data.txt\\\", \\\"w\\\") as datafile:\\n datafile.write(cont)\\n with open(datafile.name, \\\"r\\\") as tfile:\\n for line in tfile:\\n if \\\"!Sample_geo_accession\\\" in line:\\n line = line.split('\\\\t')\\n for x in range(0, len(line)):\\n samples.append(line[x].replace('\\\\n', ''))\\n samples = filter(None, samples)\\n tfile.seek(0)\\n with open(request.session.get('username') + \\\"/meta.txt\\\", \\\"w\\\") as meta:\\n for i in range(0, len(samples)):\\n for line in tfile:\\n if \\\"!Sample\\\" in line:\\n line = line.split('\\\\t')\\n line[i] = line[i].replace(\\\"!Sample_\\\", \\\"\\\").replace(\\\"\\\\n\\\", \\\"\\\").replace(\\\"'\\\", \\\"\\\").replace(\\\",\\\", \\\"\\\").replace(\\\"\\\\\\\"\\\", \\\"\\\")\\n if line[i] == \\\"geo_accession\\\":\\n line[i] = \\\"sample_id\\\"\\n elif line[1] == \\\"\\\\\\\"female\\\\\\\"\\\" or line[1] == \\\"\\\\\\\"male\\\\\\\"\\\":\\n line[0] = \\\"sex\\\"\\n if \\\"title\\\" not in line[0]:\\n meta.write(re.sub(r'[^\\\\x00-\\\\x7F]+', ' ', line[i]) + '\\\\t')\\n meta.write('\\\\n')\\n tfile.seek(0)\\n meta.close()\\n datafile.close()\\n call([\\\"rm\\\", request.session.get('username') + \\\"/data.txt\\\"])\\n return meta\",\n \"def extract_metadata(file_name, token_type, create_labels, remove_stop_words):\\n metadata = {'file': file_name}\\n\\n with open(file_name, 'r') as file:\\n rows = file.readlines()\\n\\n rules = [\\n ['Message-ID:', 'id'],\\n ['Subject:', 'subject'],\\n ]\\n\\n for (index, row) in enumerate(rows):\\n row = row.lstrip('> \\\\t')\\n for (pattern, prop) in rules:\\n if row.startswith(pattern):\\n metadata[prop] = row.replace(pattern,'')\\n\\n if 'body' not in metadata:\\n if row.startswith('\\\\n'):\\n metadata['body'] = '\\\\n'.join(rows[index:])\\n\\n elif '-----Original Message-----' in row:\\n del metadata['body']\\n\\n if 'body' in metadata:\\n if create_labels:\\n metadata['label'] = create_label(metadata['body'])\\n metadata['original_body'] = metadata['body']\\n metadata['body'] = clean_text(metadata['body'], token_type, remove_stop_words)\\n clean_subject = cleanse(metadata['subject'])\\n metadata['subject'] = '' if clean_subject.count(' ') == len(clean_subject) else clean_subject\\n\\n return metadata\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8028162","0.5969158","0.58202237","0.57127655","0.56976295","0.56358564","0.5572141","0.55685896","0.556603","0.5544489","0.55414313","0.5443912","0.5436588","0.5433023","0.5427803","0.5423232","0.53913337","0.5390329","0.5361068","0.53360075","0.52867633","0.52782154","0.5271059","0.5260443","0.525197","0.5208082","0.52003556","0.5194747","0.51939666","0.51579696","0.5109985","0.50747025","0.50597095","0.50483984","0.5035302","0.50304526","0.50262046","0.5026118","0.50249547","0.50161594","0.50130296","0.5006077","0.49837285","0.49829236","0.4980243","0.49681595","0.49657747","0.4963939","0.4952166","0.4948751","0.49470976","0.49453062","0.49350342","0.49292752","0.49252602","0.49231008","0.49106947","0.49098626","0.49079737","0.4899399","0.48993298","0.4896533","0.4890665","0.48883104","0.48873743","0.4879336","0.48765928","0.48580912","0.48510376","0.48449358","0.48275778","0.4821151","0.48186034","0.48148435","0.4812345","0.4808401","0.48083013","0.48071858","0.48068842","0.48055384","0.4804821","0.48022348","0.47998857","0.4798136","0.47826743","0.47676834","0.47649446","0.47601375","0.47595653","0.47558925","0.47544202","0.47497126","0.47455254","0.47453317","0.4743488","0.47354332","0.47341618","0.47202504","0.4714753","0.4711243"],"string":"[\n \"0.8028162\",\n \"0.5969158\",\n \"0.58202237\",\n \"0.57127655\",\n \"0.56976295\",\n \"0.56358564\",\n \"0.5572141\",\n \"0.55685896\",\n \"0.556603\",\n \"0.5544489\",\n \"0.55414313\",\n \"0.5443912\",\n \"0.5436588\",\n \"0.5433023\",\n \"0.5427803\",\n \"0.5423232\",\n \"0.53913337\",\n \"0.5390329\",\n \"0.5361068\",\n \"0.53360075\",\n \"0.52867633\",\n \"0.52782154\",\n \"0.5271059\",\n \"0.5260443\",\n \"0.525197\",\n \"0.5208082\",\n \"0.52003556\",\n \"0.5194747\",\n \"0.51939666\",\n \"0.51579696\",\n \"0.5109985\",\n \"0.50747025\",\n \"0.50597095\",\n \"0.50483984\",\n \"0.5035302\",\n \"0.50304526\",\n \"0.50262046\",\n \"0.5026118\",\n \"0.50249547\",\n \"0.50161594\",\n \"0.50130296\",\n \"0.5006077\",\n \"0.49837285\",\n \"0.49829236\",\n \"0.4980243\",\n \"0.49681595\",\n \"0.49657747\",\n \"0.4963939\",\n \"0.4952166\",\n \"0.4948751\",\n \"0.49470976\",\n \"0.49453062\",\n \"0.49350342\",\n \"0.49292752\",\n \"0.49252602\",\n \"0.49231008\",\n \"0.49106947\",\n \"0.49098626\",\n \"0.49079737\",\n \"0.4899399\",\n \"0.48993298\",\n \"0.4896533\",\n \"0.4890665\",\n \"0.48883104\",\n \"0.48873743\",\n \"0.4879336\",\n \"0.48765928\",\n \"0.48580912\",\n \"0.48510376\",\n \"0.48449358\",\n \"0.48275778\",\n \"0.4821151\",\n \"0.48186034\",\n \"0.48148435\",\n \"0.4812345\",\n \"0.4808401\",\n \"0.48083013\",\n \"0.48071858\",\n \"0.48068842\",\n \"0.48055384\",\n \"0.4804821\",\n \"0.48022348\",\n \"0.47998857\",\n \"0.4798136\",\n \"0.47826743\",\n \"0.47676834\",\n \"0.47649446\",\n \"0.47601375\",\n \"0.47595653\",\n \"0.47558925\",\n \"0.47544202\",\n \"0.47497126\",\n \"0.47455254\",\n \"0.47453317\",\n \"0.4743488\",\n \"0.47354332\",\n \"0.47341618\",\n \"0.47202504\",\n \"0.4714753\",\n \"0.4711243\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8175402"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94294,"cells":{"query":{"kind":"string","value":"Initialize the contact tag."},"document":{"kind":"string","value":"def __init__(\n self,\n tag: typing.Optional[int],\n contact: typing.Optional[int],\n **kwargs: typing.Dict,\n ) -> None:\n super().__init__(**kwargs)\n self.tag = tag\n self.contact = contact"},"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, contact):\n\n\t\tself._id = UserClassroom.__ID\n\t\tself._contact = contact\n\t\tself.size = 1\n\n\t\tUserClassroom.__ID += 1","def __init__(self, uid=\"\", first_name=\"\", last_name=\"\", email=\"\", phone=\"\", description=\"\",\n company_uid=None, testing=False):\n\n # Initialization of the parent class\n super(Contact, self).__init__(uid, first_name, last_name, email, phone, description, company_uid,\n testing=testing)","def __init__(self, contact = None):\n try:\n self.__contact = contact\n if not self.__contact:\n FRegulatoryLogger.ERROR(logger, \"The name on the contact is the unique identifier of the contact. Kindly provide a valid acm.FContact object\")\n return None\n self.__reg_date_of_birth = None\n self.__reg_first_name = None\n self.__reg_last_name = None\n self.__reg_national_id = None\n self.__reg_crm_id = None\n self.__crm_id_source = None\n self.__reg_exchange_id = None\n self.__reg_unique_name = None\n self.__client_type = None\n self.__is_general_partner = None\n if contact:\n self.__refresh(contact)\n self.__integration_utils = FIntegrationUtils.FIntegrationUtils()\n except Exception as e :\n FRegulatoryLogger.ERROR(logger, str(e))","def __init__(self, contact, phone_number, first_name, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.contact = contact\n self.phone_number = phone_number\n self.first_name = first_name","def __init__(self):\n self.tag = None","def init_cid(self) -> None:\n self.position = 0","def __init__(__self__, *,\n contact_id: pulumi.Input[str],\n is_essential: pulumi.Input[bool]):\n pulumi.set(__self__, \"contact_id\", contact_id)\n pulumi.set(__self__, \"is_essential\", is_essential)","def __init__(__self__, *,\n contact_id: pulumi.Input[str],\n is_essential: pulumi.Input[bool]):\n pulumi.set(__self__, \"contact_id\", contact_id)\n pulumi.set(__self__, \"is_essential\", is_essential)","def setUp(self):\n self.new_contact = Contact(\"zoo\", \"vier\", 254719702373, \"kemwaura@gmail.com\")","def __init__(self):\n self.swagger_types = {\n 'source_contact': 'AddressableEntityRef',\n 'target_contact': 'AddressableEntityRef',\n 'resulting_contact': 'AddressableEntityRef'\n }\n\n self.attribute_map = {\n 'source_contact': 'sourceContact',\n 'target_contact': 'targetContact',\n 'resulting_contact': 'resultingContact'\n }\n\n self._source_contact = None\n self._target_contact = None\n self._resulting_contact = None","def __init__(self, tag):\n self.tag = tag","def contact(self, contact):\n\n self._contact = contact","def contact(self, contact):\n\n self._contact = contact","def __init__(__self__, *,\n channel_target_info: Optional[pulumi.Input['ContactChannelTargetInfoArgs']] = None,\n contact_target_info: Optional[pulumi.Input['ContactTargetInfoArgs']] = None):\n if channel_target_info is not None:\n pulumi.set(__self__, \"channel_target_info\", channel_target_info)\n if contact_target_info is not None:\n pulumi.set(__self__, \"contact_target_info\", contact_target_info)","def __init__(self, contact_loader):\n self.contacts_by_group_list = contact_loader.contacts_by_group_list\n self.contact_list = None","def __init__(self):\n try:\n self.contact_api_key = helpers.config_section_map(\"Full Contact\")[\"api_key\"]\n except Exception:\n self.contact_api_key = None\n click.secho(\"[!] Did not find a Full Contact API key.\",fg=\"yellow\")","def __init__(self, tag):\n self.tag = tag.lower()\n self.attrs = {}\n self.contents = ()","def __init__(self, contact_detail):\n\t\tself.first_name = contact_detail['First Name'].strip()\n\t\tself.last_name = contact_detail['Last Name'].strip()\n\t\tself.mobile = contact_detail['Mobile Phone'].strip()\n\t\tself.email = contact_detail['E-mail Address'].strip()","def contact(self, contact):\n\n self.logger.debug(\"In 'contact' setter.\")\n\n self._contact = contact","def __init__(self, contacts_client):\n self.contacts_client = contacts_client","def setUp(self):\n # Below creating the new contact object to test.\n self.new_contact = Contact(\n \"James\", \"Muriuki\", \"0712345678\", \"james@moringaschool.com\")","def initDocTagText(self):\n self.doc, self.tag, self.text = Doc().tagtext()","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def __init__(self, tag=None, sender=None, template_name=None, html_content=None, html_url=None, subject=None, reply_to=None, to_field=None, attachment_url=None, is_active=None): # noqa: E501 # noqa: E501\n\n self._tag = None\n self._sender = None\n self._template_name = None\n self._html_content = None\n self._html_url = None\n self._subject = None\n self._reply_to = None\n self._to_field = None\n self._attachment_url = None\n self._is_active = None\n self.discriminator = None\n\n if tag is not None:\n self.tag = tag\n if sender is not None:\n self.sender = sender\n if template_name is not None:\n self.template_name = template_name\n if html_content is not None:\n self.html_content = html_content\n if html_url is not None:\n self.html_url = html_url\n if subject is not None:\n self.subject = subject\n if reply_to is not None:\n self.reply_to = reply_to\n if to_field is not None:\n self.to_field = to_field\n if attachment_url is not None:\n self.attachment_url = attachment_url\n if is_active is not None:\n self.is_active = is_active","def initialize(self):\r\n pass","def initialize(self):\r\n pass","def initialize(self):\n\t\tpass","def contact_info(self, contact_info):\n\n self._contact_info = contact_info","def __init__(self, tagged_sents, default_tag='nc0s000'):\n self._default_tag = default_tag","def __init__(self):\n\n\t\tself.__contacts = None\n\t\tself.__accounts = None\n\t\tself.__deals = None\n\t\tself.__key_modified = dict()","def init(self):\n logger.info(mm_cnofs.ackn_str)\n self.acknowledgements = mm_cnofs.ackn_str\n self.references = '\\n'.join((mm_cnofs.refs['mission'],\n mm_cnofs.refs['vefi']))\n\n return","def initialize(self) -> None:\n pass","def _initialize(self):\n pass","def _initialize(self):\n pass","def _initialize(self):\n pass","def __init__(self, first_name=\" \", last_name=\" \", phone_number=0, phone_number_type=\" \", contact_list=[]):\n self.first_name = first_name\n self.last_name = last_name\n self.phone_number = phone_number\n self.phone_number_type = phone_number_type\n self.valid_phone_number_types = [\"home\", \"office\", \"cell\"]\n self.contact_list = contact_list","def __init__(self, buf=None, *args, **kwargs):\n super(Message, self).__init__(buf, *args, **kwargs)\n self.__initialized = True","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(self, context):\r\n pass","def initialize(self, context):\n pass","def initialize(self, context):\n pass","def initialize(self, context):\n pass","def initialize(self):\n self.ros.enable()\n self.phone_link.enable()","def initialize(self):\n self.ID = uuid.uuid4()\n self.TMDB_ID = 0\n self.title = \"\"\n self.release_date = \"\"\n self.popularity = \"\"\n self.overview = \"\"","def __init__(self, bstream):\r\n # Tag itself doesn't do this. Must be overridden.\r\n self.name = \"\"\r\n ## named tags..? Are named tags only named when in a tag_compound that defines their names? And tag_compounds are always named?\r\n #self.value = \"\" needed?\r\n #payload... varies by subclass.\r\n self._parseContent(bstream)","def __init__(self, char_name, char_description):\r\n self.name = char_name\r\n self.description = char_description\r\n self.conversation = None\r\n self.bribe = None","def init(self):\n\n logger.info(mm_chain.ackn_str)\n self.acknowledgements = mm_chain.ackn_str\n self.references = mm_chain.refs['chain']\n\n return","def __init__(self, caption, tag):\n self._caption = caption\n self._tag = tag.replace(\" \", \"\")","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","def init(self):\n pass","def __init__(self, tags=''):\n self.tags = tags","def on_initialize(self) -> None:\n pass","def __init__(self, _from, _to, _cc=None, _bcc=None, _subject='', _body='', _attach=None):\n self._from = _from\n self._to = _to\n self._cc = _cc\n self._bcc = _bcc\n self._subject = _subject\n self._body = _body\n self._attach = _attach","def onload(self):\n\t\tload_address_and_contact(self)","def initialize(self, cwrap):\n pass","def init(self, domain, category, methodname, params={},login=\"\",passwd=\"\",tags=\"\"):\n if tags<>\"\":\n self.tags = tags\n self.domain=domain\n self.category=category\n self.methodname=methodname\n self.params=params\n self.login=login\n self.passwd=passwd \n self.tagBodyEncode()","def initialize(self):\n return","def initialize(self):\n self.event = self.handler.event\n self.what = self.event\n self.on_what = self.event.object\n self.when = datetime.now()\n self.who = self.handler.mtool.getAuthenticatedMember().getId()\n self.where = self.event.object","def __init__(self, contacts=None, sent=None, received=None): # noqa: E501 # noqa: E501\n\n self._contacts = None\n self._sent = None\n self._received = None\n self.discriminator = None\n\n self.contacts = contacts\n self.sent = sent\n self.received = received","def init(self) -> None:\n ...","def initialize(self):\n pass # pragma: no cover","def init():\n return _nfc.init()","def __init__(self, phone):\r\n self.phone = phone","def __init__(self, phone):\r\n self.phone = phone","def __init__(self, phone):\r\n self.phone = phone","def __init__(self, phone):\r\n self.phone = phone","def __init__(self, phone):\r\n self.phone = phone","def contact_person(self, contact_person):\n\n self._contact_person = contact_person","def contact_person(self, contact_person):\n\n self._contact_person = contact_person","def __init__(self, tag):\r\n self.tag = tag.lower()","def __init__ (self):\n self.tag = 0\n self.mDict = {}","def _init(self, position):\n\t\tself._position = position"],"string":"[\n \"def __init__(self, contact):\\n\\n\\t\\tself._id = UserClassroom.__ID\\n\\t\\tself._contact = contact\\n\\t\\tself.size = 1\\n\\n\\t\\tUserClassroom.__ID += 1\",\n \"def __init__(self, uid=\\\"\\\", first_name=\\\"\\\", last_name=\\\"\\\", email=\\\"\\\", phone=\\\"\\\", description=\\\"\\\",\\n company_uid=None, testing=False):\\n\\n # Initialization of the parent class\\n super(Contact, self).__init__(uid, first_name, last_name, email, phone, description, company_uid,\\n testing=testing)\",\n \"def __init__(self, contact = None):\\n try:\\n self.__contact = contact\\n if not self.__contact:\\n FRegulatoryLogger.ERROR(logger, \\\"The name on the contact is the unique identifier of the contact. Kindly provide a valid acm.FContact object\\\")\\n return None\\n self.__reg_date_of_birth = None\\n self.__reg_first_name = None\\n self.__reg_last_name = None\\n self.__reg_national_id = None\\n self.__reg_crm_id = None\\n self.__crm_id_source = None\\n self.__reg_exchange_id = None\\n self.__reg_unique_name = None\\n self.__client_type = None\\n self.__is_general_partner = None\\n if contact:\\n self.__refresh(contact)\\n self.__integration_utils = FIntegrationUtils.FIntegrationUtils()\\n except Exception as e :\\n FRegulatoryLogger.ERROR(logger, str(e))\",\n \"def __init__(self, contact, phone_number, first_name, *args, **kwargs):\\n super().__init__(*args, **kwargs)\\n self.contact = contact\\n self.phone_number = phone_number\\n self.first_name = first_name\",\n \"def __init__(self):\\n self.tag = None\",\n \"def init_cid(self) -> None:\\n self.position = 0\",\n \"def __init__(__self__, *,\\n contact_id: pulumi.Input[str],\\n is_essential: pulumi.Input[bool]):\\n pulumi.set(__self__, \\\"contact_id\\\", contact_id)\\n pulumi.set(__self__, \\\"is_essential\\\", is_essential)\",\n \"def __init__(__self__, *,\\n contact_id: pulumi.Input[str],\\n is_essential: pulumi.Input[bool]):\\n pulumi.set(__self__, \\\"contact_id\\\", contact_id)\\n pulumi.set(__self__, \\\"is_essential\\\", is_essential)\",\n \"def setUp(self):\\n self.new_contact = Contact(\\\"zoo\\\", \\\"vier\\\", 254719702373, \\\"kemwaura@gmail.com\\\")\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'source_contact': 'AddressableEntityRef',\\n 'target_contact': 'AddressableEntityRef',\\n 'resulting_contact': 'AddressableEntityRef'\\n }\\n\\n self.attribute_map = {\\n 'source_contact': 'sourceContact',\\n 'target_contact': 'targetContact',\\n 'resulting_contact': 'resultingContact'\\n }\\n\\n self._source_contact = None\\n self._target_contact = None\\n self._resulting_contact = None\",\n \"def __init__(self, tag):\\n self.tag = tag\",\n \"def contact(self, contact):\\n\\n self._contact = contact\",\n \"def contact(self, contact):\\n\\n self._contact = contact\",\n \"def __init__(__self__, *,\\n channel_target_info: Optional[pulumi.Input['ContactChannelTargetInfoArgs']] = None,\\n contact_target_info: Optional[pulumi.Input['ContactTargetInfoArgs']] = None):\\n if channel_target_info is not None:\\n pulumi.set(__self__, \\\"channel_target_info\\\", channel_target_info)\\n if contact_target_info is not None:\\n pulumi.set(__self__, \\\"contact_target_info\\\", contact_target_info)\",\n \"def __init__(self, contact_loader):\\n self.contacts_by_group_list = contact_loader.contacts_by_group_list\\n self.contact_list = None\",\n \"def __init__(self):\\n try:\\n self.contact_api_key = helpers.config_section_map(\\\"Full Contact\\\")[\\\"api_key\\\"]\\n except Exception:\\n self.contact_api_key = None\\n click.secho(\\\"[!] Did not find a Full Contact API key.\\\",fg=\\\"yellow\\\")\",\n \"def __init__(self, tag):\\n self.tag = tag.lower()\\n self.attrs = {}\\n self.contents = ()\",\n \"def __init__(self, contact_detail):\\n\\t\\tself.first_name = contact_detail['First Name'].strip()\\n\\t\\tself.last_name = contact_detail['Last Name'].strip()\\n\\t\\tself.mobile = contact_detail['Mobile Phone'].strip()\\n\\t\\tself.email = contact_detail['E-mail Address'].strip()\",\n \"def contact(self, contact):\\n\\n self.logger.debug(\\\"In 'contact' setter.\\\")\\n\\n self._contact = contact\",\n \"def __init__(self, contacts_client):\\n self.contacts_client = contacts_client\",\n \"def setUp(self):\\n # Below creating the new contact object to test.\\n self.new_contact = Contact(\\n \\\"James\\\", \\\"Muriuki\\\", \\\"0712345678\\\", \\\"james@moringaschool.com\\\")\",\n \"def initDocTagText(self):\\n self.doc, self.tag, self.text = Doc().tagtext()\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def __init__(self, tag=None, sender=None, template_name=None, html_content=None, html_url=None, subject=None, reply_to=None, to_field=None, attachment_url=None, is_active=None): # noqa: E501 # noqa: E501\\n\\n self._tag = None\\n self._sender = None\\n self._template_name = None\\n self._html_content = None\\n self._html_url = None\\n self._subject = None\\n self._reply_to = None\\n self._to_field = None\\n self._attachment_url = None\\n self._is_active = None\\n self.discriminator = None\\n\\n if tag is not None:\\n self.tag = tag\\n if sender is not None:\\n self.sender = sender\\n if template_name is not None:\\n self.template_name = template_name\\n if html_content is not None:\\n self.html_content = html_content\\n if html_url is not None:\\n self.html_url = html_url\\n if subject is not None:\\n self.subject = subject\\n if reply_to is not None:\\n self.reply_to = reply_to\\n if to_field is not None:\\n self.to_field = to_field\\n if attachment_url is not None:\\n self.attachment_url = attachment_url\\n if is_active is not None:\\n self.is_active = is_active\",\n \"def initialize(self):\\r\\n pass\",\n \"def initialize(self):\\r\\n pass\",\n \"def initialize(self):\\n\\t\\tpass\",\n \"def contact_info(self, contact_info):\\n\\n self._contact_info = contact_info\",\n \"def __init__(self, tagged_sents, default_tag='nc0s000'):\\n self._default_tag = default_tag\",\n \"def __init__(self):\\n\\n\\t\\tself.__contacts = None\\n\\t\\tself.__accounts = None\\n\\t\\tself.__deals = None\\n\\t\\tself.__key_modified = dict()\",\n \"def init(self):\\n logger.info(mm_cnofs.ackn_str)\\n self.acknowledgements = mm_cnofs.ackn_str\\n self.references = '\\\\n'.join((mm_cnofs.refs['mission'],\\n mm_cnofs.refs['vefi']))\\n\\n return\",\n \"def initialize(self) -> None:\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def __init__(self, first_name=\\\" \\\", last_name=\\\" \\\", phone_number=0, phone_number_type=\\\" \\\", contact_list=[]):\\n self.first_name = first_name\\n self.last_name = last_name\\n self.phone_number = phone_number\\n self.phone_number_type = phone_number_type\\n self.valid_phone_number_types = [\\\"home\\\", \\\"office\\\", \\\"cell\\\"]\\n self.contact_list = contact_list\",\n \"def __init__(self, buf=None, *args, **kwargs):\\n super(Message, self).__init__(buf, *args, **kwargs)\\n self.__initialized = True\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(self, context):\\r\\n pass\",\n \"def initialize(self, context):\\n pass\",\n \"def initialize(self, context):\\n pass\",\n \"def initialize(self, context):\\n pass\",\n \"def initialize(self):\\n self.ros.enable()\\n self.phone_link.enable()\",\n \"def initialize(self):\\n self.ID = uuid.uuid4()\\n self.TMDB_ID = 0\\n self.title = \\\"\\\"\\n self.release_date = \\\"\\\"\\n self.popularity = \\\"\\\"\\n self.overview = \\\"\\\"\",\n \"def __init__(self, bstream):\\r\\n # Tag itself doesn't do this. Must be overridden.\\r\\n self.name = \\\"\\\"\\r\\n ## named tags..? Are named tags only named when in a tag_compound that defines their names? And tag_compounds are always named?\\r\\n #self.value = \\\"\\\" needed?\\r\\n #payload... varies by subclass.\\r\\n self._parseContent(bstream)\",\n \"def __init__(self, char_name, char_description):\\r\\n self.name = char_name\\r\\n self.description = char_description\\r\\n self.conversation = None\\r\\n self.bribe = None\",\n \"def init(self):\\n\\n logger.info(mm_chain.ackn_str)\\n self.acknowledgements = mm_chain.ackn_str\\n self.references = mm_chain.refs['chain']\\n\\n return\",\n \"def __init__(self, caption, tag):\\n self._caption = caption\\n self._tag = tag.replace(\\\" \\\", \\\"\\\")\",\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 \"def init(self):\\n pass\",\n \"def __init__(self, tags=''):\\n self.tags = tags\",\n \"def on_initialize(self) -> None:\\n pass\",\n \"def __init__(self, _from, _to, _cc=None, _bcc=None, _subject='', _body='', _attach=None):\\n self._from = _from\\n self._to = _to\\n self._cc = _cc\\n self._bcc = _bcc\\n self._subject = _subject\\n self._body = _body\\n self._attach = _attach\",\n \"def onload(self):\\n\\t\\tload_address_and_contact(self)\",\n \"def initialize(self, cwrap):\\n pass\",\n \"def init(self, domain, category, methodname, params={},login=\\\"\\\",passwd=\\\"\\\",tags=\\\"\\\"):\\n if tags<>\\\"\\\":\\n self.tags = tags\\n self.domain=domain\\n self.category=category\\n self.methodname=methodname\\n self.params=params\\n self.login=login\\n self.passwd=passwd \\n self.tagBodyEncode()\",\n \"def initialize(self):\\n return\",\n \"def initialize(self):\\n self.event = self.handler.event\\n self.what = self.event\\n self.on_what = self.event.object\\n self.when = datetime.now()\\n self.who = self.handler.mtool.getAuthenticatedMember().getId()\\n self.where = self.event.object\",\n \"def __init__(self, contacts=None, sent=None, received=None): # noqa: E501 # noqa: E501\\n\\n self._contacts = None\\n self._sent = None\\n self._received = None\\n self.discriminator = None\\n\\n self.contacts = contacts\\n self.sent = sent\\n self.received = received\",\n \"def init(self) -> None:\\n ...\",\n \"def initialize(self):\\n pass # pragma: no cover\",\n \"def init():\\n return _nfc.init()\",\n \"def __init__(self, phone):\\r\\n self.phone = phone\",\n \"def __init__(self, phone):\\r\\n self.phone = phone\",\n \"def __init__(self, phone):\\r\\n self.phone = phone\",\n \"def __init__(self, phone):\\r\\n self.phone = phone\",\n \"def __init__(self, phone):\\r\\n self.phone = phone\",\n \"def contact_person(self, contact_person):\\n\\n self._contact_person = contact_person\",\n \"def contact_person(self, contact_person):\\n\\n self._contact_person = contact_person\",\n \"def __init__(self, tag):\\r\\n self.tag = tag.lower()\",\n \"def __init__ (self):\\n self.tag = 0\\n self.mDict = {}\",\n \"def _init(self, position):\\n\\t\\tself._position = position\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6380634","0.63572264","0.62336594","0.61620253","0.60732037","0.6036036","0.60072947","0.60072947","0.60046685","0.6001961","0.5892605","0.58892137","0.58892137","0.58549345","0.58439875","0.57779026","0.57670283","0.5691324","0.56651187","0.5649181","0.5645289","0.5642232","0.5589417","0.5589417","0.5589417","0.5589417","0.5589417","0.55779946","0.5576385","0.5576385","0.55624014","0.55591416","0.5553269","0.5538311","0.5530503","0.55295527","0.552804","0.552804","0.552804","0.55234724","0.551216","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.5505954","0.547451","0.54655224","0.54655224","0.54655224","0.54455817","0.5428948","0.5419821","0.5406856","0.539788","0.53917","0.53683686","0.53683686","0.53683686","0.53683686","0.53683686","0.53683686","0.53683686","0.53683686","0.5348318","0.53248614","0.53034204","0.528949","0.5282309","0.5277172","0.52767485","0.52749455","0.5269021","0.5258745","0.52557075","0.52524424","0.52522665","0.52522665","0.52522665","0.52522665","0.52522665","0.52440155","0.52440155","0.52427435","0.5233813","0.5229799"],"string":"[\n \"0.6380634\",\n \"0.63572264\",\n \"0.62336594\",\n \"0.61620253\",\n \"0.60732037\",\n \"0.6036036\",\n \"0.60072947\",\n \"0.60072947\",\n \"0.60046685\",\n \"0.6001961\",\n \"0.5892605\",\n \"0.58892137\",\n \"0.58892137\",\n \"0.58549345\",\n \"0.58439875\",\n \"0.57779026\",\n \"0.57670283\",\n \"0.5691324\",\n \"0.56651187\",\n \"0.5649181\",\n \"0.5645289\",\n \"0.5642232\",\n \"0.5589417\",\n \"0.5589417\",\n \"0.5589417\",\n \"0.5589417\",\n \"0.5589417\",\n \"0.55779946\",\n \"0.5576385\",\n \"0.5576385\",\n \"0.55624014\",\n \"0.55591416\",\n \"0.5553269\",\n \"0.5538311\",\n \"0.5530503\",\n \"0.55295527\",\n \"0.552804\",\n \"0.552804\",\n \"0.552804\",\n \"0.55234724\",\n \"0.551216\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.5505954\",\n \"0.547451\",\n \"0.54655224\",\n \"0.54655224\",\n \"0.54655224\",\n \"0.54455817\",\n \"0.5428948\",\n \"0.5419821\",\n \"0.5406856\",\n \"0.539788\",\n \"0.53917\",\n \"0.53683686\",\n \"0.53683686\",\n \"0.53683686\",\n \"0.53683686\",\n \"0.53683686\",\n \"0.53683686\",\n \"0.53683686\",\n \"0.53683686\",\n \"0.5348318\",\n \"0.53248614\",\n \"0.53034204\",\n \"0.528949\",\n \"0.5282309\",\n \"0.5277172\",\n \"0.52767485\",\n \"0.52749455\",\n \"0.5269021\",\n \"0.5258745\",\n \"0.52557075\",\n \"0.52524424\",\n \"0.52522665\",\n \"0.52522665\",\n \"0.52522665\",\n \"0.52522665\",\n \"0.52522665\",\n \"0.52440155\",\n \"0.52440155\",\n \"0.52427435\",\n \"0.5233813\",\n \"0.5229799\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73358494"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94295,"cells":{"query":{"kind":"string","value":"Get the name of the API resource."},"document":{"kind":"string","value":"def resource_name() -> str:\n return \"contactTags\""},"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 name(self):\n return self.raw_resource[\"name\"]","def name(self):\n\n return self.resource[\"metadata\"][\"name\"]","def get_resource_name(self):\n return self._resource_name","def resource_name(self) -> Optional[str]:\n return pulumi.get(self, \"resource_name\")","def resource_name(self) -> Optional[str]:\n return pulumi.get(self, \"resource_name\")","def API_NAME(): # noqa\n raise NotImplementedError(\"API_NAME must be implemented\")","def resource_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"resource_name\")","def resource_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"resource_name\")","def resource_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"resource_name\")","def resource_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"resource_name\")","def resource_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"resource_name\")","def _get_api_resource_type_name(self):\n return \"AWS::Serverless::HttpApi\"","def get_name(self) -> Text:\n return self._get_value(KubernetesResource.Keys.NAME)","def subresource_name(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"subresource_name\")","def get_objectName(self):\n return self.resource.get_name()","def get_name_from_resource_id(resource_id):\n return resource_id.rstrip(\"/\").split(\"/\")[-1]","def get_name() -> str:\n pass","def subresource_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"subresource_name\")","def subresource_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"subresource_name\")","def get_name(self) -> str:\n pass","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")","def name(self) -> str:\n return pulumi.get(self, \"name\")"],"string":"[\n \"def name(self):\\n return self.raw_resource[\\\"name\\\"]\",\n \"def name(self):\\n\\n return self.resource[\\\"metadata\\\"][\\\"name\\\"]\",\n \"def get_resource_name(self):\\n return self._resource_name\",\n \"def resource_name(self) -> Optional[str]:\\n return pulumi.get(self, \\\"resource_name\\\")\",\n \"def resource_name(self) -> Optional[str]:\\n return pulumi.get(self, \\\"resource_name\\\")\",\n \"def API_NAME(): # noqa\\n raise NotImplementedError(\\\"API_NAME must be implemented\\\")\",\n \"def resource_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"resource_name\\\")\",\n \"def resource_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"resource_name\\\")\",\n \"def resource_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"resource_name\\\")\",\n \"def resource_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"resource_name\\\")\",\n \"def resource_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"resource_name\\\")\",\n \"def _get_api_resource_type_name(self):\\n return \\\"AWS::Serverless::HttpApi\\\"\",\n \"def get_name(self) -> Text:\\n return self._get_value(KubernetesResource.Keys.NAME)\",\n \"def subresource_name(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"subresource_name\\\")\",\n \"def get_objectName(self):\\n return self.resource.get_name()\",\n \"def get_name_from_resource_id(resource_id):\\n return resource_id.rstrip(\\\"/\\\").split(\\\"/\\\")[-1]\",\n \"def get_name() -> str:\\n pass\",\n \"def subresource_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"subresource_name\\\")\",\n \"def subresource_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"subresource_name\\\")\",\n \"def get_name(self) -> str:\\n pass\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\",\n \"def name(self) -> str:\\n return pulumi.get(self, \\\"name\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7821574","0.7735648","0.7670678","0.7447657","0.7447657","0.74427205","0.7221747","0.7221747","0.7221747","0.7221747","0.7221747","0.7201344","0.7172618","0.69053936","0.68893594","0.68083745","0.68061125","0.6781027","0.6781027","0.6777424","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043","0.67408043"],"string":"[\n \"0.7821574\",\n \"0.7735648\",\n \"0.7670678\",\n \"0.7447657\",\n \"0.7447657\",\n \"0.74427205\",\n \"0.7221747\",\n \"0.7221747\",\n \"0.7221747\",\n \"0.7221747\",\n \"0.7221747\",\n \"0.7201344\",\n \"0.7172618\",\n \"0.69053936\",\n \"0.68893594\",\n \"0.68083745\",\n \"0.68061125\",\n \"0.6781027\",\n \"0.6781027\",\n \"0.6777424\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\",\n \"0.67408043\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94296,"cells":{"query":{"kind":"string","value":"Map field names to attributes."},"document":{"kind":"string","value":"def map_field_name_to_attribute() -> typing.Dict:\n return {\n \"tag\": \"tag\",\n \"contact\": \"contact\",\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 _attrs_map(self) -> \"dict[int, str]\":\n return {i: attr.name for i, attr in enumerate(self._attrs())}","def map_to_db_fields(field_attrs):\n attr_keys = field_attrs.keys()\n field_name = field_attrs[attr_keys.pop(attr_keys.index('name'))]\n field_type_raw = field_attrs[attr_keys.pop(attr_keys.index('type'))]\n\n # field_type - constructor for a django.db.models.fields objects\n try:\n field_type = getattr(fields, field_type_raw)\n except:\n raise Exception(\n \"Can not create field with type {0}\".format(field_type_raw))\n\n field_attributes = {}\n\n for key in attr_keys:\n if key in TO_INT_ATTRS:\n value = int(field_attrs[key])\n elif key in TO_BOOL_ATTRS:\n value = True if field_attrs[key] == 'true' else False\n else:\n value = field_attrs[key]\n\n field_attributes[key] = value\n\n return {field_name: field_type(**field_attributes)}","def field_mapping(self):\n fields = self.fields\n if self.target_field is not None:\n del fields[self.target_field.get('name')]\n field_labels = list(self.fields.keys())\n\n field_mapping = {\n name: (\n field_labels.index(name),\n lambda value, e=e: self.parse_type(value, e)\n )\n for name, e in fields.items()\n if e.tag == f'{{{self.namespace}}}DataField'\n }\n\n field_mapping.update({\n name: (\n field_labels.index(self.find(e, 'FieldRef').get('field')),\n lambda value, e=e: self.parse_type(value, e)\n )\n for name, e in fields.items()\n if e.tag == f'{{{self.namespace}}}DerivedField'\n })\n\n return field_mapping","def read_field_attributes(self, fieldname):\n return self.read_field(fieldname).attributes","def _make_field_map(fields):\n field_map = {}\n for field in fields:\n if field.name in field_map:\n raise SchemaParseException(\n 'Duplicate record field name %r.' % field.name)\n field_map[field.name] = field\n return field_map","def _map_field_names(self, members):\n result = []\n for member in members:\n mapped_info = {}\n for entry_key, entry_value in member.iteritems():\n if not entry_key in self.DATA_MAPPING: # skip the entry if there is no mapping\n continue\n mapped_info[self.DATA_MAPPING[entry_key]] = entry_value\n result.append(mapped_info)\n return result","def add_fields(self, fields):\n for label, data in fields.items():\n self[label] = data","def get_fields(cls):\n return map(lambda x: getattr(cls, x), cls.get_field_names())","def _getAttributeNames(self):\n return sorted(self._field_map.keys())","def convert_fields(fields, _fields):\n mapper = {\n \"id\": \"local_id\",\n \"local_id\": \"id\"\n }\n fields = deepcopy(fields)\n for field in fields:\n if field['name'] in _fields:\n field['name'] = mapper[field['name']]\n return fields","def model_fields(self):\n converter = connections[self.db].introspection.identifier_converter\n model_fields = {}\n for field in self.model._meta.fields:\n name, column = field.get_attname_column()\n model_fields[converter(column)] = field\n return model_fields","def map_cols_to_attr(self):\n ## this is from the base class:\n ## for attr, label in zip(self.attr_names, self.labels):\n ## col_ind = self.col_inds[label]\n ## if len(self.data) > 0:\n ## setattr(self, attr, self.data[:,col_ind])\n #\n # hard coding based on what I know about saleae files:\n self.t = self.data[:,0]#.astype(float)\n nr, nc = self.data.shape\n self.num_cols = nc-1\n \n for i in range(0,self.num_cols):\n attr = 'ch_%i' % i\n j = i+1\n setattr(self, attr, self.data[:,j])#.astype(float))","def get_fields(self):\n fields = {}\n allowed_types = (\n SerializerMethodField,\n Field,\n Serializer,\n )\n for attr in dir(self):\n if attr == 'data':\n continue\n\n if isinstance(getattr(self, attr), allowed_types):\n fields[attr] = getattr(self, attr)\n\n return fields","def get_attributes(self, shape):\n attributes = {}\n identifier_names = [i.name for i in self.identifiers]\n\n for name, member in shape.members.items():\n snake_cased = xform_name(name)\n if snake_cased in identifier_names:\n # Skip identifiers, these are set through other means\n continue\n snake_cased = self._get_name(\n 'attribute', snake_cased, snake_case=False\n )\n attributes[snake_cased] = (name, member)\n\n return attributes","def _set_attr_name_map(self):\n self.attr_name_map = {}\n for object_query in self.query:\n object_name = object_query[\"object_name\"]\n object_class = self.object_map[object_name]\n aliases = AttributeInfo.gather_aliases(object_class)\n self.attr_name_map[object_class] = {}\n for key, value in aliases.items():\n filter_by = None\n if isinstance(value, dict):\n filter_name = value.get(\"filter_by\", None)\n if filter_name is not None:\n filter_by = getattr(object_class, filter_name, None)\n value = value[\"display_name\"]\n if value:\n self.attr_name_map[object_class][value.lower()] = (key.lower(),\n filter_by)\n custom_attrs = AttributeInfo.get_custom_attr_definitions(\n object_class)\n for key, definition in custom_attrs.items():\n if not key.startswith(\"__custom__:\") or \\\n \"display_name\" not in definition:\n continue\n try:\n # Global custom attribute definition can only have a single id on\n # their name, so it is safe for that. Currently the filters do not\n # work with object level custom attributes.\n attr_id = definition[\"definition_ids\"][0]\n except KeyError:\n continue\n filter_by = CustomAttributeValue.mk_filter_by_custom(object_class,\n attr_id)\n name = definition[\"display_name\"].lower()\n self.attr_name_map[object_class][name] = (name, filter_by)","def _attrs(self):\n for field in self.model._meta.get_fields():\n if isinstance(field, (models.OneToOneField, models.ManyToOneRel)):\n # Skip non-field attributes\n continue\n if field is self._geom_field:\n # Skip the geometry field, which is not an attribute\n continue\n yield field","def fields(cls):\n if not hasattr(cls, '_fields'):\n cls.parse_attributes()\n return cls._fields","def get_attributes(self) -> Dict[str, str]:\n pass","def add_lowercase_fields(attributes, data):\n for attrib in attributes:\n if attrib['similarity'] == 'EqualIgnoreCase':\n value = data.get(attrib['name'])\n if value is not None:\n data[attrib['name']] = value.lower()\n return data","def _update_all_fields(self, name, value):\n for field in self._field_map.values():\n setattr(field, name, value)","def fields(self):\n return {k:getattr(self, k, None) for k in self.schema.fields}","def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a","def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs","def attributes(self):\n return { k: getattr(self, k) for k in self.__class__.columns().keys() }","def get_field_attr(name):\n # de variant met een repeating group (entiteit, dataitem) levert hier nog een probleem op.\n # is dat omdat er twee entiteiten in 1 scherm staan?\n fields = []\n opts = my.rectypes[name]._meta\n for x in opts.get_fields(): # fields:\n fldname = x.name\n fldtype = x.get_internal_type()\n if fldname == 'id' or fldtype in ('ForeignKey', 'ManyToManyField'):\n # if fldname == 'id' or any((x.many2one, x.many2many, x.one2many))\n continue\n try:\n length = x.max_length\n except AttributeError:\n length = -1\n fields.append((fldname, fldtype[:-5], length))\n return fields","def rename_fields(r, rename_map):\n new_record = {}\n for f in r.keys():\n if f in rename_map.keys():\n new_record[rename_map[f]] = r[f]\n else:\n new_key = f.lower().replace(' ', '_')\n new_record[new_key] = r[f]\n return new_record","def field_names(self):\n ...","def modelfields(entity) -> Dict[str, Field]:\n return entity.__modelfields__","def _to_user_model_attrs(self, data, attrs_map):\n user_attrs = {}\n for k, v in attrs_map.iteritems():\n attr = (v, data.get(k)) if isinstance(v, str) else v(data.get(k))\n user_attrs.setdefault(*attr)\n\n user_attrs.setdefault('server', 'All')\n user_attrs.setdefault('faction', 0)\n user_attrs.setdefault('admin', True)\n user_attrs.setdefault('uploader', True)\n user_attrs.setdefault('upload_server', None)\n\n return user_attrs","def fields(self) -> Mapping[str, str]:\n return pulumi.get(self, \"fields\")","def _init_fields(self):\n if self._fields is None:\n M.mset('U', \"^\") # DBS Calls Require this\n f = self._fields = {}\n attrs = self.fieldnames = {}\n fieldid = \"0\"\n while 1:\n # Subscript 0 is field description, .1 is the title, 3 is help\n fieldid, info, title, fieldhelp = M.ddwalk(self._fileid, fieldid)\n #fieldid, info, title, fieldhelp = M.mexec(\n # \"\"\"set s0=$order(^DD(s2,s0)) Q:s0'=+s0 s s1=$G(^DD(s2,s0,0)),s3=$G(^DD(s2,s0,.1)),s4=$G(^DD(s2,s0,3))\"\"\",\n # M.INOUT(str(fieldid)), M.INOUT(\"\"), str(self._fileid), M.INOUT(\"\"), M.INOUT(\"\"))\n if fieldid == \"\" or fieldid[0] not in \"0123456789.\":\n break\n\n info = info.split(\"^\", 4) \n label = self._clean_label(info[0])\n try:\n ftype = info[1]\n except:\n ftype = None\n if ftype:\n finst = None\n for klass in FIELD_TYPES:\n if klass.isa(ftype):\n finst = f[fieldid] = klass(fieldid, label, info)\n finst.fileid = self.fileid\n finst.ownerdd = self\n attrs[label] = fieldid\n break\n if finst is None:\n print finst, \"FIELD [%s], spec [%s] was not identified\" % (label, ftype)\n continue\n finst.title = title\n finst.fieldhelp = fieldhelp\n else:\n assert finst, \"FIELD [%s] %s has no fieldspec\" % (label, info)\n\n return self._fields","def __init__(cls, name, bases, attrs):\r\n if sys.version_info[1] < 6: # Backport of __set_name__ from 3.6 :)\r\n for k, v in attrs.items():\r\n if isinstance(v, (Field, Store, Section)):\r\n v.__set_name__(cls, k)\r\n\r\n fields = attrs['__fields__']\r\n stores = attrs['__store_attrs__']\r\n\r\n for attr_name in dir(cls):\r\n attr = getattr(cls, attr_name)\r\n if isinstance(attr, Field):\r\n fields.add(attr)\r\n stores.add(attr.store_attr)\r\n\r\n super().__init__(name, bases, attrs)","def fields(self):\n _fields = {\n i: attrgetter(i) for i in ('pf_type', 'label',)\n }\n _fields['host'] = self.get_safely_instance_partial(Host, 'host')\n return _fields","def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]:\n fields: Dict[str, Callable[[Any], None]] = {\n \"assignedDateTime\": lambda n : setattr(self, 'assigned_date_time', n.get_datetime_value()),\n \"capabilityStatus\": lambda n : setattr(self, 'capability_status', n.get_str_value()),\n \"@odata.type\": lambda n : setattr(self, 'odata_type', n.get_str_value()),\n \"service\": lambda n : setattr(self, 'service', n.get_str_value()),\n \"servicePlanId\": lambda n : setattr(self, 'service_plan_id', n.get_uuid_value()),\n }\n return fields","def record_dict(self):\n return {p.key: getattr(self, p.key) for p in self.__mapper__.attrs}","def parse_attributes(cls):\n cls._fields = []\n cls._tables = []\n for attr_k in dir(cls):\n try:\n attr = object.__getattribute__(cls, attr_k)\n except AttributeError:\n continue\n if issubclass(attr.__class__, ReferenceManyField):\n cls._tables.append(attr_k)\n elif issubclass(attr.__class__, Field):\n cls._fields.append(attr_k)","def get_dataclass_attributes(cls) -> Dict[str, Tuple[Any, str]]:\n fields = cls.__dataclass_fields__.values()\n attrs = {}\n for field in fields:\n if field.type != InitVar:\n attrs[field.name] = field.type, \"\"\n return attrs","def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs","def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_","def update_attributes_map(klass):\n\n return {\n 'name': '',\n 'default_locale': ''\n }","def _getAttrMap(self):\r\n if not getattr(self, 'attrMap'):\r\n self.attrMap = {}\r\n for (key, value) in self.attrs:\r\n self.attrMap[key] = value\r\n return self.attrMap","def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic","def fields(cls):\n return cls._nameToValue","def attributes(self):\n _attrs = []\n if self.name:\n _attrs.append(\"name\")\n if self.label:\n _attrs.append(\"label\")\n if self.confidence:\n _attrs.append(\"confidence\")\n if self.index:\n _attrs.append(\"index\")\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs + [\"points\"]","def map_csv_fields(self):\n etod_csv_fields = {\n 'ctry_id': None,\n 'obst_identifier': None,\n 'obst_name': None,\n 'lon_src': None,\n 'lat_src': None,\n 'agl': None,\n 'amsl': None,\n 'vert_uom': None,\n 'hor_acc': None,\n 'hor_acc_uom': None,\n 'vert_acc': None,\n 'vert_acc_uom': None,\n 'obst_type': None,\n 'lighting': None,\n 'marking': None,\n 'is_group': None,\n }\n\n for field in etod_csv_fields:\n try:\n etod_csv_fields[field] = etod_map[self.ctry_short_name]['fields'][field]\n except KeyError:\n etod_csv_fields[field] = None\n\n self.field_map = etod_csv_fields","def meta(cls):\n if getattr(cls, '__from_class__', None) is not None:\n cls = cls.__from_class__\n attribute_info = {}\n for name, value in cls.__table__.columns.items():\n attribute_info[name] = str(value.type).lower()\n\n return {cls.__name__: attribute_info}","def get_switched_form_field_attrs(self, prefix, input_type, name):\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\n attributes['data-' + prefix + 'field-' + input_type] = name\n return attributes","def make_record_properties(fieldnames,\n default='float',\n overrides={},\n aliases={}):\n return [(aliases.get(f, f), overrides.get(f, default))\n for f in fieldnames]","def get_field_names(self):\n return {rv[0] for rv in self.iter_fields()}","def get_attributes(cls):\r\n return [Attribute('allowed_files', '[]', transform=cls.parse_files),\r\n Attribute('label', ''),\r\n Attribute('required_files', '[]', transform=cls.parse_files), ]","def _fields(self):\n fields = [(\"serial\", self.serial), (\"active\", str(self.active)),\n (\"name\", self.name), (\"version\", self.version),\n (\"auto_update\", str(self.auto_update)),\n (\"new_version_available\", str(self.new_version_available)),\n (\"product_type\", self.product_type),\n (\"network_device\", str(self.network_device))]\n return fields","def get_attributes(self):\n \n retdict = {}\n retdict['s'] = str(self.s)\n if self.t != None:\n retdict['t'] = str(self.t)\n retdict['a'] = str(self.a)\n retdict['b'] = str(self.b)\n retdict['c'] = str(self.c)\n retdict['d'] = str(self.d)\n return retdict","def _fields_names(cls) -> List:\n return list(field.name for field in dataclasses.fields(cls))","def as_dict(self):\n return {c.key: getattr(self, c.key)\n for c in inspect(self).mapper.column_attrs}","def _field_names(self):\n return [self._sanitize_field_name(field_name)\n for field_name in self._all_fields]","def fields(self) -> Dict[str, Field]:\n return self._fields","def add_attributes(self, x):\n for k, v in x.items():\n setattr(self, k, v)","def get_fields(self):\n\n return {\n attr: field['serializer']\n for attr, field in self._fields.items()\n }","def _replace_fields(self):\n for name, value in self._cleaned_data.items():\n setattr(self, name, value)","def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict","def get_attributes(cls):\r\n return [Attribute('size', '20'),\r\n Attribute('label', ''), ]","def fields() -> Dict[str, models.Field]:\n return dict(\n (field.name, field)\n for field in AccountTier._meta.get_fields()\n if field.name not in [\"id\"]\n )","def items(self):\n for name in self.fields:\n yield name, getattr(self, name)","def get_attrs_field_names(env, arch, model, editable):\n VIEW_TYPES = {item[0] for item in type(env['ir.ui.view']).type.selection}\n symbols = _get_attrs_symbols() | {None}\n result = []\n\n def get_name(node):\n \"\"\" return the name from an AST node, or None \"\"\"\n if isinstance(node, ast.Name):\n return node.id\n\n def get_subname(get, node):\n \"\"\" return the subfield name from an AST node, or None \"\"\"\n if isinstance(node, ast.Attribute) and get(node.value) == 'parent':\n return node.attr\n\n def process_expr(expr, get, key, val):\n \"\"\" parse `expr` and collect triples \"\"\"\n for node in ast.walk(ast.parse(expr.strip(), mode='eval')):\n name = get(node)\n if name not in symbols:\n result.append((name, key, val))\n\n def process_attrs(expr, get, key, val):\n \"\"\" parse `expr` and collect field names in lhs of conditions. \"\"\"\n for domain in safe_eval(expr).values():\n if not isinstance(domain, list):\n continue\n for arg in domain:\n if isinstance(arg, (tuple, list)):\n process_expr(str(arg[0]), get, key, expr)\n\n def process(node, model, editable, get=get_name):\n \"\"\" traverse `node` and collect triples \"\"\"\n if node.tag in VIEW_TYPES:\n # determine whether this view is editable\n editable = editable and _view_is_editable(node)\n elif node.tag in ('field', 'groupby'):\n # determine whether the field is editable\n field = model._fields.get(node.get('name'))\n if field:\n editable = editable and field_is_editable(field, node)\n\n for key, val in node.items():\n if not val:\n continue\n if key in ATTRS_WITH_FIELD_NAMES:\n process_expr(val, get, key, val)\n elif key == 'attrs':\n process_attrs(val, get, key, val)\n\n if node.tag in ('field', 'groupby') and field and field.relational:\n if editable and not node.get('domain'):\n domain = field._description_domain(env)\n # process the field's domain as if it was in the view\n if isinstance(domain, str):\n process_expr(domain, get, 'domain', domain)\n # retrieve subfields of 'parent'\n model = env[field.comodel_name]\n get = partial(get_subname, get)\n\n for child in node:\n if node.tag == 'search' and child.tag == 'searchpanel':\n # searchpanel part has to be validated independently\n continue\n process(child, model, editable, get)\n\n process(arch, model, editable)\n return result","def extra_from_record(self, record):\n return {\n attr_name: record.__dict__[attr_name]\n for attr_name in record.__dict__\n if attr_name not in BUILTIN_ATTRS\n }","def field_names(cls) -> tuple:\n return tuple((field.name for field in fields(cls)))","def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass","def fields(self):\r\n return self._by_name.iteritems()","def attributes(self, *args):\n kwargs = {}\n if args:\n kwargs[\"attributenames\"] = args\n\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\n\n # parse contennt looking for all attributes\n attributes = []\n for line in r.text.splitlines():\n r = re.match(\"(userdetails\\.attribute\\.name)=(.*)\", line)\n if r:\n name = r.groups()[1]\n attributes.append([name, None])\n continue # next line\n\n r = re.match(\"(userdetails\\.attribute\\.value)=(.*)\", line)\n if r:\n value = r.groups()[1]\n # last name parsed is where it has to\n # be stacked\n if attributes[-1][1] == None:\n attributes[-1][1] = value\n if isinstance(attributes[-1][1], list):\n attributes[-1][1].append(value)\n else:\n # cast to list\n attributes[-1].append([attributes[-1][1], value])\n\n return dict([(item[0], item[1]) for item in attributes])","def normalize_field_names(cls, torrent_info: dict):\n for old_name, new_name in cls.torrent_fields_map.items():\n if old_name in torrent_info:\n torrent_info[new_name] = torrent_info[old_name]","def _iter_attrs_for_field_type(cls, field_type):\n return six.iterkeys(cls._get_defaults_for_field_type(field_type))","def _iter_attrs_for_field_type(cls, field_type):\n return six.iterkeys(cls._get_defaults_for_field_type(field_type))","def _get_field_details(self, data, fields):\n fields_metadata = dict()\n for field in fields:\n dtype = data[field].dtype\n field_template = self._FIELD_TEMPLATES.get(dtype.kind)\n if not field_template:\n raise ValueError('Unsupported dtype {} in column {}'.format(dtype, field))\n\n field_details = copy.deepcopy(field_template)\n fields_metadata[field] = field_details\n\n return fields_metadata","def fields(self):","def __new__(metacls, name, bases, attributes, **kwargs):\n # Use both a namespaced mapping and a standard dict\n # as class-based records of our field attributes:\n field_index = Flat()\n field_names = {}\n \n # Stow both the Python name and the namespaced name\n # for each field attribute defined on the schema,\n # additionally manually calling __set_name__(…) if\n # we’re on a pre-3.6 version of Python:\n for attribute, value in attributes.items():\n if isinstance(value, FieldBase):\n if NEED_NAME:\n value.__set_name__(None, attribute)\n attributes[attribute] = value\n field_names[attribute] = value\n field_index.set(attribute, value,\n namespace=value.namespace)\n \n # This is the same as the above, but for the base\n # ancestor class – this enables field inheritance:\n for base in bases:\n parent = base.__mro__[0]\n for attribute, value in vars(parent).items():\n if isinstance(value, FieldBase) and attribute not in attributes:\n if NEED_NAME:\n value.__set_name__(None, attribute)\n attributes[attribute] = value\n field_names[attribute] = value\n field_index.set(attribute, value,\n namespace=value.namespace)\n \n for namespace in field_index.namespaces():\n nsfield = Namespace(field_index, namespace=namespace)\n if NEED_NAME:\n nsfield.__set_name__(None, namespace)\n attributes[namespace] = nsfield\n field_names[namespace] = nsfield\n \n # Add both the field-index and the field-names mappings\n # to the class dictionary for the new type:\n attributes['__field_index__'] = field_index\n attributes['__field_names__'] = field_names\n \n # Create and return the schema type:\n return super(MetaSchema, metacls).__new__(metacls, name,\n bases,\n attributes,\n **kwargs)","def field_names(self):\n return self.base_field_names() + list(self.data.keys())","def field_names(self):\n if not self._field_names:\n self._field_names.update(self.properties.keys())\n\n self._field_names = [attr for attr in self._field_names if not attr.startswith(\"_\")]\n\n return self._field_names","def map_conf_field_names(self, data, **kwargs):\n # TODO: it's dangerous to depend on an alphabetical order, we'd better move related logic out of Schema.\n conf = data[\"conf\"] if \"conf\" in data else None\n if conf is not None:\n for field_key, dict_key in CONF_KEY_MAP.items():\n value = conf.get(dict_key, None)\n if dict_key in conf and value is not None:\n del conf[dict_key]\n conf[field_key] = value\n data[\"conf\"] = conf\n return data","def _build_attributes(self):\n\n # We might rebuild the program because of snippets but we must\n # keep already bound attributes\n\n dtype = []\n for (name,gtype) in self.all_attributes:\n if name not in self._attributes.keys():\n attribute = Attribute(self, name, gtype)\n else:\n attribute = self._attributes[name]\n\n self._attributes[name] = attribute\n dtype.append(attribute.dtype)","def attribute_to_params_map(self):\n return self._param_names_map","def get_fields(self):\n fields = super(GeoModelSerializer, self).get_fields()\n # Set the geometry field name when it's undeclared.\n if not self.Meta.geom_field:\n for name, field in fields.items():\n if isinstance(field, GeometryField):\n self.Meta.geom_field = name\n break\n return fields","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def map(self, attr1, attr2):\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))","def get_fields(self) -> Iterable[fields.Field]:\n for attr_name in dir(self):\n attr = getattr(self, attr_name)\n if isinstance(attr, fields.Field):\n yield attr","def get_ask_mapping(cls):\n mapping = {}\n for field in cls._meta.fields:\n if isinstance(field, AskForField):\n mapping[field.allows_field] = field.name\n return mapping","def get_attrs(self):\n attrs = []\n for attribute in self.__dict__.keys():\n attrs.append(attribute)","def set_up_fields(self, fields):\n self.fields = {\n 'name': self.name,\n 'email': self.email\n }\n for key in fields.keys():\n # special keys first, not to be used in the template\n if key.upper() == 'CC':\n self.is_cc = fields[key]\n elif key.upper() == 'BCC':\n self.is_bcc = fields[key]\n else:\n self.fields[key] = fields[key]","def fill_by_name(self, fields, prefix=\"\"):\n self.fill({'[name=\"%s%s\"]' % (prefix, k): v for k, v in fields.items()})","def retype(self, dictionary):\r\n\r\n for name, retype in dictionary.items():\r\n field = self._field_dict[name]\r\n for key, value in retype.items():\r\n if key in _valid_retype_attributes:\r\n field.__setattr__(key, value)\r\n else:\r\n raise Exception(\"Should not use retype to change field attribute '%s'\", key)","def generate_attributes(self):\n for group in self.dict:\n for param in self.dict[group]:\n if group in self.group_douplicate and param in self.name_douplicate:\n setattr(self, group+'_'+param, self(group, param))\n else:\n setattr(self, param, self(group, param))","def map_attributes(order: dict) -> dict:\n map_dict = {\n \"has_batteries\": FactoryMapping.cast_str_to_bool,\n \"has_glow\": FactoryMapping.cast_str_to_bool,\n \"has_lactose\": FactoryMapping.cast_str_to_bool,\n \"has_nuts\": FactoryMapping.cast_str_to_bool,\n \"min_age\": int,\n \"num_rooms\": int,\n \"num_sound\": int,\n \"pack_size\": int,\n \"dimensions\": lambda x: float(x.replace(\",\", '.')),\n \"spider_type\": SpiderType.map_str_to_enum,\n \"colour\": Colours.map_str_to_enum,\n \"variety\": ToffeeVariety.map_str_to_enum,\n \"stuffing\": Stuffing.map_str_to_enum,\n \"size\": Size.map_str_to_enum,\n \"fabric\": Fabric.map_str_to_enum\n }\n for key, value in map_dict.items():\n if key in order:\n order[key] = value(order[key])\n return order","def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs","def get_format_attrs(self, name, field, alt_field_info={}):\n # important_props = ('initial', 'autofocus', 'widget')\n if name in alt_field_info:\n field = deepcopy(field)\n for prop, value in alt_field_info[name].items():\n setattr(field, prop, value)\n initial = field.initial\n initial = initial() if callable(initial) else initial\n attrs, result = {}, []\n if initial and not isinstance(field.widget, Textarea):\n attrs['value'] = str(initial)\n data_val = self.form.data.get(get_html_name(self.form, name), None)\n if data_val not in ('', None):\n attrs['value'] = data_val\n attrs.update(field.widget_attrs(field.widget))\n result = ''.join(f'{key}=\"{val}\" ' for key, val in attrs.items())\n if getattr(field, 'autofocus', None):\n result += 'autofocus '\n if issubclass(self.form.__class__, FormOverrideMixIn):\n # TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.\n result += '%(attrs)s' # content '%(attrs)s'\n else:\n result = '%(attrs)s' + result # '%(attrs)s' content\n return result","def _process_attrs(attrs):\n new_attrs = OrderedDict()\n for attr in attrs:\n col = attr\n if isinstance(attr, tuple):\n col, attr = attr\n # special cases\n if attr == 'class_name':\n attr = '__class__.__name__'\n if attr == 'repr':\n attr = repr\n new_attrs[col] = attr\n\n return new_attrs","def iterate_over_fields(cls):\n for attr in dir(cls):\n clsattr = getattr(cls, attr)\n if isinstance(clsattr, BaseField):\n yield attr, clsattr","def extract_mapping(self) -> DatasetMapping:\n # store fields\n fields = []\n for col in self.data.columns:\n #get field label\n label = col\n #get field type using PANDAS_TYPE (see apps.utils.utils)\n col_type = self.data[col].dtype\n field_type = PANDAS_TYPE[col_type]\n #set field\n field = FieldMapping(label=label, type=field_type)\n fields.append(field)\n self.mapping.append(label)\n return DatasetMapping(fields=fields)","def create_attributes(klass, attributes, previous_object=None):\n\n if previous_object is not None:\n return {'name': attributes.get('name', previous_object.name)}\n return {\n 'name': attributes.get('name', ''),\n 'defaultLocale': attributes['default_locale']\n }","def createFieldMapping(sgidPoints):\n # Create field mappings\n sgidFMs = arcpy.FieldMappings()\n\n # Perform some field renaming\n mapPairs = [\n ('State', 'State'),\n ('City', 'Inc_Muni'),\n ('CountyID', 'County'),\n ('ZipCode', 'Zip_Code'),\n ('PrefixDir', 'StN_PreDir'),\n ('StreetName', 'StreetName'),\n ('StreetType', 'StN_PosTyp'),\n ('SuffixDir', 'StN_PosDir'),\n ('AddNum', 'Add_Number'),\n ('LandmarkName', 'landmkName'),\n ('Building', 'Building'),\n ('UnitType', 'Unit'),\n ('AddSource', 'AddAuth'),\n ('AddSystem', 'UniqWithin'),\n ('LoadDate', 'LastUpdate')]\n\n for p in mapPairs:\n print p\n sgidFMs.addFieldMap(getRenameFieldMap(sgidPoints, p[0], p[1]))\n\n return sgidFMs","def insertable_dict(self):\n # .strip('_') is for type_\n return {\n 'f_' +\n p.key.strip('_'): getattr(\n self,\n p.key) for p in self.__mapper__.attrs}","def audit_fields(elem, fields):\r\n errs = []\r\n parsed = {}\r\n for field, field_type, dict_field in fields:\r\n if field not in elem.attrib:\r\n errs.append(('missing value', field))\r\n else:\r\n value = ensure_type(elem.get(field), field_type)\r\n if not value:\r\n errs.append(('wrong type', field))\r\n else:\r\n parsed[dict_field] = value\r\n \r\n if errs:\r\n parsed = None\r\n return parsed, errs"],"string":"[\n \"def _attrs_map(self) -> \\\"dict[int, str]\\\":\\n return {i: attr.name for i, attr in enumerate(self._attrs())}\",\n \"def map_to_db_fields(field_attrs):\\n attr_keys = field_attrs.keys()\\n field_name = field_attrs[attr_keys.pop(attr_keys.index('name'))]\\n field_type_raw = field_attrs[attr_keys.pop(attr_keys.index('type'))]\\n\\n # field_type - constructor for a django.db.models.fields objects\\n try:\\n field_type = getattr(fields, field_type_raw)\\n except:\\n raise Exception(\\n \\\"Can not create field with type {0}\\\".format(field_type_raw))\\n\\n field_attributes = {}\\n\\n for key in attr_keys:\\n if key in TO_INT_ATTRS:\\n value = int(field_attrs[key])\\n elif key in TO_BOOL_ATTRS:\\n value = True if field_attrs[key] == 'true' else False\\n else:\\n value = field_attrs[key]\\n\\n field_attributes[key] = value\\n\\n return {field_name: field_type(**field_attributes)}\",\n \"def field_mapping(self):\\n fields = self.fields\\n if self.target_field is not None:\\n del fields[self.target_field.get('name')]\\n field_labels = list(self.fields.keys())\\n\\n field_mapping = {\\n name: (\\n field_labels.index(name),\\n lambda value, e=e: self.parse_type(value, e)\\n )\\n for name, e in fields.items()\\n if e.tag == f'{{{self.namespace}}}DataField'\\n }\\n\\n field_mapping.update({\\n name: (\\n field_labels.index(self.find(e, 'FieldRef').get('field')),\\n lambda value, e=e: self.parse_type(value, e)\\n )\\n for name, e in fields.items()\\n if e.tag == f'{{{self.namespace}}}DerivedField'\\n })\\n\\n return field_mapping\",\n \"def read_field_attributes(self, fieldname):\\n return self.read_field(fieldname).attributes\",\n \"def _make_field_map(fields):\\n field_map = {}\\n for field in fields:\\n if field.name in field_map:\\n raise SchemaParseException(\\n 'Duplicate record field name %r.' % field.name)\\n field_map[field.name] = field\\n return field_map\",\n \"def _map_field_names(self, members):\\n result = []\\n for member in members:\\n mapped_info = {}\\n for entry_key, entry_value in member.iteritems():\\n if not entry_key in self.DATA_MAPPING: # skip the entry if there is no mapping\\n continue\\n mapped_info[self.DATA_MAPPING[entry_key]] = entry_value\\n result.append(mapped_info)\\n return result\",\n \"def add_fields(self, fields):\\n for label, data in fields.items():\\n self[label] = data\",\n \"def get_fields(cls):\\n return map(lambda x: getattr(cls, x), cls.get_field_names())\",\n \"def _getAttributeNames(self):\\n return sorted(self._field_map.keys())\",\n \"def convert_fields(fields, _fields):\\n mapper = {\\n \\\"id\\\": \\\"local_id\\\",\\n \\\"local_id\\\": \\\"id\\\"\\n }\\n fields = deepcopy(fields)\\n for field in fields:\\n if field['name'] in _fields:\\n field['name'] = mapper[field['name']]\\n return fields\",\n \"def model_fields(self):\\n converter = connections[self.db].introspection.identifier_converter\\n model_fields = {}\\n for field in self.model._meta.fields:\\n name, column = field.get_attname_column()\\n model_fields[converter(column)] = field\\n return model_fields\",\n \"def map_cols_to_attr(self):\\n ## this is from the base class:\\n ## for attr, label in zip(self.attr_names, self.labels):\\n ## col_ind = self.col_inds[label]\\n ## if len(self.data) > 0:\\n ## setattr(self, attr, self.data[:,col_ind])\\n #\\n # hard coding based on what I know about saleae files:\\n self.t = self.data[:,0]#.astype(float)\\n nr, nc = self.data.shape\\n self.num_cols = nc-1\\n \\n for i in range(0,self.num_cols):\\n attr = 'ch_%i' % i\\n j = i+1\\n setattr(self, attr, self.data[:,j])#.astype(float))\",\n \"def get_fields(self):\\n fields = {}\\n allowed_types = (\\n SerializerMethodField,\\n Field,\\n Serializer,\\n )\\n for attr in dir(self):\\n if attr == 'data':\\n continue\\n\\n if isinstance(getattr(self, attr), allowed_types):\\n fields[attr] = getattr(self, attr)\\n\\n return fields\",\n \"def get_attributes(self, shape):\\n attributes = {}\\n identifier_names = [i.name for i in self.identifiers]\\n\\n for name, member in shape.members.items():\\n snake_cased = xform_name(name)\\n if snake_cased in identifier_names:\\n # Skip identifiers, these are set through other means\\n continue\\n snake_cased = self._get_name(\\n 'attribute', snake_cased, snake_case=False\\n )\\n attributes[snake_cased] = (name, member)\\n\\n return attributes\",\n \"def _set_attr_name_map(self):\\n self.attr_name_map = {}\\n for object_query in self.query:\\n object_name = object_query[\\\"object_name\\\"]\\n object_class = self.object_map[object_name]\\n aliases = AttributeInfo.gather_aliases(object_class)\\n self.attr_name_map[object_class] = {}\\n for key, value in aliases.items():\\n filter_by = None\\n if isinstance(value, dict):\\n filter_name = value.get(\\\"filter_by\\\", None)\\n if filter_name is not None:\\n filter_by = getattr(object_class, filter_name, None)\\n value = value[\\\"display_name\\\"]\\n if value:\\n self.attr_name_map[object_class][value.lower()] = (key.lower(),\\n filter_by)\\n custom_attrs = AttributeInfo.get_custom_attr_definitions(\\n object_class)\\n for key, definition in custom_attrs.items():\\n if not key.startswith(\\\"__custom__:\\\") or \\\\\\n \\\"display_name\\\" not in definition:\\n continue\\n try:\\n # Global custom attribute definition can only have a single id on\\n # their name, so it is safe for that. Currently the filters do not\\n # work with object level custom attributes.\\n attr_id = definition[\\\"definition_ids\\\"][0]\\n except KeyError:\\n continue\\n filter_by = CustomAttributeValue.mk_filter_by_custom(object_class,\\n attr_id)\\n name = definition[\\\"display_name\\\"].lower()\\n self.attr_name_map[object_class][name] = (name, filter_by)\",\n \"def _attrs(self):\\n for field in self.model._meta.get_fields():\\n if isinstance(field, (models.OneToOneField, models.ManyToOneRel)):\\n # Skip non-field attributes\\n continue\\n if field is self._geom_field:\\n # Skip the geometry field, which is not an attribute\\n continue\\n yield field\",\n \"def fields(cls):\\n if not hasattr(cls, '_fields'):\\n cls.parse_attributes()\\n return cls._fields\",\n \"def get_attributes(self) -> Dict[str, str]:\\n pass\",\n \"def add_lowercase_fields(attributes, data):\\n for attrib in attributes:\\n if attrib['similarity'] == 'EqualIgnoreCase':\\n value = data.get(attrib['name'])\\n if value is not None:\\n data[attrib['name']] = value.lower()\\n return data\",\n \"def _update_all_fields(self, name, value):\\n for field in self._field_map.values():\\n setattr(field, name, value)\",\n \"def fields(self):\\n return {k:getattr(self, k, None) for k in self.schema.fields}\",\n \"def _attribs(self, name=None, description=None):\\n a = {}\\n if name:\\n a['name'] = name\\n if description:\\n a['description'] = description\\n return a\",\n \"def attributes(self):\\n _attrs = [\\\"label\\\"]\\n if self.attrs:\\n _attrs.append(\\\"attrs\\\")\\n return _attrs\",\n \"def attributes(self):\\n return { k: getattr(self, k) for k in self.__class__.columns().keys() }\",\n \"def get_field_attr(name):\\n # de variant met een repeating group (entiteit, dataitem) levert hier nog een probleem op.\\n # is dat omdat er twee entiteiten in 1 scherm staan?\\n fields = []\\n opts = my.rectypes[name]._meta\\n for x in opts.get_fields(): # fields:\\n fldname = x.name\\n fldtype = x.get_internal_type()\\n if fldname == 'id' or fldtype in ('ForeignKey', 'ManyToManyField'):\\n # if fldname == 'id' or any((x.many2one, x.many2many, x.one2many))\\n continue\\n try:\\n length = x.max_length\\n except AttributeError:\\n length = -1\\n fields.append((fldname, fldtype[:-5], length))\\n return fields\",\n \"def rename_fields(r, rename_map):\\n new_record = {}\\n for f in r.keys():\\n if f in rename_map.keys():\\n new_record[rename_map[f]] = r[f]\\n else:\\n new_key = f.lower().replace(' ', '_')\\n new_record[new_key] = r[f]\\n return new_record\",\n \"def field_names(self):\\n ...\",\n \"def modelfields(entity) -> Dict[str, Field]:\\n return entity.__modelfields__\",\n \"def _to_user_model_attrs(self, data, attrs_map):\\n user_attrs = {}\\n for k, v in attrs_map.iteritems():\\n attr = (v, data.get(k)) if isinstance(v, str) else v(data.get(k))\\n user_attrs.setdefault(*attr)\\n\\n user_attrs.setdefault('server', 'All')\\n user_attrs.setdefault('faction', 0)\\n user_attrs.setdefault('admin', True)\\n user_attrs.setdefault('uploader', True)\\n user_attrs.setdefault('upload_server', None)\\n\\n return user_attrs\",\n \"def fields(self) -> Mapping[str, str]:\\n return pulumi.get(self, \\\"fields\\\")\",\n \"def _init_fields(self):\\n if self._fields is None:\\n M.mset('U', \\\"^\\\") # DBS Calls Require this\\n f = self._fields = {}\\n attrs = self.fieldnames = {}\\n fieldid = \\\"0\\\"\\n while 1:\\n # Subscript 0 is field description, .1 is the title, 3 is help\\n fieldid, info, title, fieldhelp = M.ddwalk(self._fileid, fieldid)\\n #fieldid, info, title, fieldhelp = M.mexec(\\n # \\\"\\\"\\\"set s0=$order(^DD(s2,s0)) Q:s0'=+s0 s s1=$G(^DD(s2,s0,0)),s3=$G(^DD(s2,s0,.1)),s4=$G(^DD(s2,s0,3))\\\"\\\"\\\",\\n # M.INOUT(str(fieldid)), M.INOUT(\\\"\\\"), str(self._fileid), M.INOUT(\\\"\\\"), M.INOUT(\\\"\\\"))\\n if fieldid == \\\"\\\" or fieldid[0] not in \\\"0123456789.\\\":\\n break\\n\\n info = info.split(\\\"^\\\", 4) \\n label = self._clean_label(info[0])\\n try:\\n ftype = info[1]\\n except:\\n ftype = None\\n if ftype:\\n finst = None\\n for klass in FIELD_TYPES:\\n if klass.isa(ftype):\\n finst = f[fieldid] = klass(fieldid, label, info)\\n finst.fileid = self.fileid\\n finst.ownerdd = self\\n attrs[label] = fieldid\\n break\\n if finst is None:\\n print finst, \\\"FIELD [%s], spec [%s] was not identified\\\" % (label, ftype)\\n continue\\n finst.title = title\\n finst.fieldhelp = fieldhelp\\n else:\\n assert finst, \\\"FIELD [%s] %s has no fieldspec\\\" % (label, info)\\n\\n return self._fields\",\n \"def __init__(cls, name, bases, attrs):\\r\\n if sys.version_info[1] < 6: # Backport of __set_name__ from 3.6 :)\\r\\n for k, v in attrs.items():\\r\\n if isinstance(v, (Field, Store, Section)):\\r\\n v.__set_name__(cls, k)\\r\\n\\r\\n fields = attrs['__fields__']\\r\\n stores = attrs['__store_attrs__']\\r\\n\\r\\n for attr_name in dir(cls):\\r\\n attr = getattr(cls, attr_name)\\r\\n if isinstance(attr, Field):\\r\\n fields.add(attr)\\r\\n stores.add(attr.store_attr)\\r\\n\\r\\n super().__init__(name, bases, attrs)\",\n \"def fields(self):\\n _fields = {\\n i: attrgetter(i) for i in ('pf_type', 'label',)\\n }\\n _fields['host'] = self.get_safely_instance_partial(Host, 'host')\\n return _fields\",\n \"def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]:\\n fields: Dict[str, Callable[[Any], None]] = {\\n \\\"assignedDateTime\\\": lambda n : setattr(self, 'assigned_date_time', n.get_datetime_value()),\\n \\\"capabilityStatus\\\": lambda n : setattr(self, 'capability_status', n.get_str_value()),\\n \\\"@odata.type\\\": lambda n : setattr(self, 'odata_type', n.get_str_value()),\\n \\\"service\\\": lambda n : setattr(self, 'service', n.get_str_value()),\\n \\\"servicePlanId\\\": lambda n : setattr(self, 'service_plan_id', n.get_uuid_value()),\\n }\\n return fields\",\n \"def record_dict(self):\\n return {p.key: getattr(self, p.key) for p in self.__mapper__.attrs}\",\n \"def parse_attributes(cls):\\n cls._fields = []\\n cls._tables = []\\n for attr_k in dir(cls):\\n try:\\n attr = object.__getattribute__(cls, attr_k)\\n except AttributeError:\\n continue\\n if issubclass(attr.__class__, ReferenceManyField):\\n cls._tables.append(attr_k)\\n elif issubclass(attr.__class__, Field):\\n cls._fields.append(attr_k)\",\n \"def get_dataclass_attributes(cls) -> Dict[str, Tuple[Any, str]]:\\n fields = cls.__dataclass_fields__.values()\\n attrs = {}\\n for field in fields:\\n if field.type != InitVar:\\n attrs[field.name] = field.type, \\\"\\\"\\n return attrs\",\n \"def attributes(self):\\n _attrs = [\\\"type\\\", \\\"name\\\", \\\"value\\\"]\\n if self.confidence is not None:\\n _attrs.append(\\\"confidence\\\")\\n if self.constant:\\n _attrs.append(\\\"constant\\\")\\n if self.tags:\\n _attrs.append(\\\"tags\\\")\\n\\n return _attrs\",\n \"def attributes(self):\\n attrs_ = [\\\"name\\\", \\\"type\\\"]\\n if self.exclusive:\\n attrs_.append(\\\"exclusive\\\")\\n if self.default is not None:\\n attrs_.append(\\\"default\\\")\\n\\n return attrs_\",\n \"def update_attributes_map(klass):\\n\\n return {\\n 'name': '',\\n 'default_locale': ''\\n }\",\n \"def _getAttrMap(self):\\r\\n if not getattr(self, 'attrMap'):\\r\\n self.attrMap = {}\\r\\n for (key, value) in self.attrs:\\r\\n self.attrMap[key] = value\\r\\n return self.attrMap\",\n \"def _get_attribute_dic(self, attrs):\\n attr_dic = {}\\n for attr_pair in attrs:\\n attr_dic[attr_pair[0]] = attr_pair[1]\\n return attr_dic\",\n \"def fields(cls):\\n return cls._nameToValue\",\n \"def attributes(self):\\n _attrs = []\\n if self.name:\\n _attrs.append(\\\"name\\\")\\n if self.label:\\n _attrs.append(\\\"label\\\")\\n if self.confidence:\\n _attrs.append(\\\"confidence\\\")\\n if self.index:\\n _attrs.append(\\\"index\\\")\\n if self.attrs:\\n _attrs.append(\\\"attrs\\\")\\n return _attrs + [\\\"points\\\"]\",\n \"def map_csv_fields(self):\\n etod_csv_fields = {\\n 'ctry_id': None,\\n 'obst_identifier': None,\\n 'obst_name': None,\\n 'lon_src': None,\\n 'lat_src': None,\\n 'agl': None,\\n 'amsl': None,\\n 'vert_uom': None,\\n 'hor_acc': None,\\n 'hor_acc_uom': None,\\n 'vert_acc': None,\\n 'vert_acc_uom': None,\\n 'obst_type': None,\\n 'lighting': None,\\n 'marking': None,\\n 'is_group': None,\\n }\\n\\n for field in etod_csv_fields:\\n try:\\n etod_csv_fields[field] = etod_map[self.ctry_short_name]['fields'][field]\\n except KeyError:\\n etod_csv_fields[field] = None\\n\\n self.field_map = etod_csv_fields\",\n \"def meta(cls):\\n if getattr(cls, '__from_class__', None) is not None:\\n cls = cls.__from_class__\\n attribute_info = {}\\n for name, value in cls.__table__.columns.items():\\n attribute_info[name] = str(value.type).lower()\\n\\n return {cls.__name__: attribute_info}\",\n \"def get_switched_form_field_attrs(self, prefix, input_type, name):\\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\\n attributes['data-' + prefix + 'field-' + input_type] = name\\n return attributes\",\n \"def make_record_properties(fieldnames,\\n default='float',\\n overrides={},\\n aliases={}):\\n return [(aliases.get(f, f), overrides.get(f, default))\\n for f in fieldnames]\",\n \"def get_field_names(self):\\n return {rv[0] for rv in self.iter_fields()}\",\n \"def get_attributes(cls):\\r\\n return [Attribute('allowed_files', '[]', transform=cls.parse_files),\\r\\n Attribute('label', ''),\\r\\n Attribute('required_files', '[]', transform=cls.parse_files), ]\",\n \"def _fields(self):\\n fields = [(\\\"serial\\\", self.serial), (\\\"active\\\", str(self.active)),\\n (\\\"name\\\", self.name), (\\\"version\\\", self.version),\\n (\\\"auto_update\\\", str(self.auto_update)),\\n (\\\"new_version_available\\\", str(self.new_version_available)),\\n (\\\"product_type\\\", self.product_type),\\n (\\\"network_device\\\", str(self.network_device))]\\n return fields\",\n \"def get_attributes(self):\\n \\n retdict = {}\\n retdict['s'] = str(self.s)\\n if self.t != None:\\n retdict['t'] = str(self.t)\\n retdict['a'] = str(self.a)\\n retdict['b'] = str(self.b)\\n retdict['c'] = str(self.c)\\n retdict['d'] = str(self.d)\\n return retdict\",\n \"def _fields_names(cls) -> List:\\n return list(field.name for field in dataclasses.fields(cls))\",\n \"def as_dict(self):\\n return {c.key: getattr(self, c.key)\\n for c in inspect(self).mapper.column_attrs}\",\n \"def _field_names(self):\\n return [self._sanitize_field_name(field_name)\\n for field_name in self._all_fields]\",\n \"def fields(self) -> Dict[str, Field]:\\n return self._fields\",\n \"def add_attributes(self, x):\\n for k, v in x.items():\\n setattr(self, k, v)\",\n \"def get_fields(self):\\n\\n return {\\n attr: field['serializer']\\n for attr, field in self._fields.items()\\n }\",\n \"def _replace_fields(self):\\n for name, value in self._cleaned_data.items():\\n setattr(self, name, value)\",\n \"def process_attrs(attrs):\\n if attrs.getLength() == 0:\\n return {}\\n tmp_dict = {}\\n for name in attrs.getNames():\\n tmp_dict[name] = attrs.getValue(name)\\n return tmp_dict\",\n \"def get_attributes(cls):\\r\\n return [Attribute('size', '20'),\\r\\n Attribute('label', ''), ]\",\n \"def fields() -> Dict[str, models.Field]:\\n return dict(\\n (field.name, field)\\n for field in AccountTier._meta.get_fields()\\n if field.name not in [\\\"id\\\"]\\n )\",\n \"def items(self):\\n for name in self.fields:\\n yield name, getattr(self, name)\",\n \"def get_attrs_field_names(env, arch, model, editable):\\n VIEW_TYPES = {item[0] for item in type(env['ir.ui.view']).type.selection}\\n symbols = _get_attrs_symbols() | {None}\\n result = []\\n\\n def get_name(node):\\n \\\"\\\"\\\" return the name from an AST node, or None \\\"\\\"\\\"\\n if isinstance(node, ast.Name):\\n return node.id\\n\\n def get_subname(get, node):\\n \\\"\\\"\\\" return the subfield name from an AST node, or None \\\"\\\"\\\"\\n if isinstance(node, ast.Attribute) and get(node.value) == 'parent':\\n return node.attr\\n\\n def process_expr(expr, get, key, val):\\n \\\"\\\"\\\" parse `expr` and collect triples \\\"\\\"\\\"\\n for node in ast.walk(ast.parse(expr.strip(), mode='eval')):\\n name = get(node)\\n if name not in symbols:\\n result.append((name, key, val))\\n\\n def process_attrs(expr, get, key, val):\\n \\\"\\\"\\\" parse `expr` and collect field names in lhs of conditions. \\\"\\\"\\\"\\n for domain in safe_eval(expr).values():\\n if not isinstance(domain, list):\\n continue\\n for arg in domain:\\n if isinstance(arg, (tuple, list)):\\n process_expr(str(arg[0]), get, key, expr)\\n\\n def process(node, model, editable, get=get_name):\\n \\\"\\\"\\\" traverse `node` and collect triples \\\"\\\"\\\"\\n if node.tag in VIEW_TYPES:\\n # determine whether this view is editable\\n editable = editable and _view_is_editable(node)\\n elif node.tag in ('field', 'groupby'):\\n # determine whether the field is editable\\n field = model._fields.get(node.get('name'))\\n if field:\\n editable = editable and field_is_editable(field, node)\\n\\n for key, val in node.items():\\n if not val:\\n continue\\n if key in ATTRS_WITH_FIELD_NAMES:\\n process_expr(val, get, key, val)\\n elif key == 'attrs':\\n process_attrs(val, get, key, val)\\n\\n if node.tag in ('field', 'groupby') and field and field.relational:\\n if editable and not node.get('domain'):\\n domain = field._description_domain(env)\\n # process the field's domain as if it was in the view\\n if isinstance(domain, str):\\n process_expr(domain, get, 'domain', domain)\\n # retrieve subfields of 'parent'\\n model = env[field.comodel_name]\\n get = partial(get_subname, get)\\n\\n for child in node:\\n if node.tag == 'search' and child.tag == 'searchpanel':\\n # searchpanel part has to be validated independently\\n continue\\n process(child, model, editable, get)\\n\\n process(arch, model, editable)\\n return result\",\n \"def extra_from_record(self, record):\\n return {\\n attr_name: record.__dict__[attr_name]\\n for attr_name in record.__dict__\\n if attr_name not in BUILTIN_ATTRS\\n }\",\n \"def field_names(cls) -> tuple:\\n return tuple((field.name for field in fields(cls)))\",\n \"def proc_attr(inp):\\n dic = {}\\n for att in inp.attrs.keys():\\n if getattr(inp.attrs[att], \\\"dtype\\\", None) is None:\\n dic[att] = inp.attrs[att]\\n elif inp.attrs[att].dtype.char == 'S':\\n dic[att] = [\\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\\n ]\\n else:\\n dic[att] = (\\n inp.attrs[att][0]\\n if isinstance(inp.attrs[att],np.ndarray) and\\n inp.attrs[att].size==1\\n else inp.attrs[att]\\n )\\n return dic\\n pass\",\n \"def fields(self):\\r\\n return self._by_name.iteritems()\",\n \"def attributes(self, *args):\\n kwargs = {}\\n if args:\\n kwargs[\\\"attributenames\\\"] = args\\n\\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\\n\\n # parse contennt looking for all attributes\\n attributes = []\\n for line in r.text.splitlines():\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.name)=(.*)\\\", line)\\n if r:\\n name = r.groups()[1]\\n attributes.append([name, None])\\n continue # next line\\n\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.value)=(.*)\\\", line)\\n if r:\\n value = r.groups()[1]\\n # last name parsed is where it has to\\n # be stacked\\n if attributes[-1][1] == None:\\n attributes[-1][1] = value\\n if isinstance(attributes[-1][1], list):\\n attributes[-1][1].append(value)\\n else:\\n # cast to list\\n attributes[-1].append([attributes[-1][1], value])\\n\\n return dict([(item[0], item[1]) for item in attributes])\",\n \"def normalize_field_names(cls, torrent_info: dict):\\n for old_name, new_name in cls.torrent_fields_map.items():\\n if old_name in torrent_info:\\n torrent_info[new_name] = torrent_info[old_name]\",\n \"def _iter_attrs_for_field_type(cls, field_type):\\n return six.iterkeys(cls._get_defaults_for_field_type(field_type))\",\n \"def _iter_attrs_for_field_type(cls, field_type):\\n return six.iterkeys(cls._get_defaults_for_field_type(field_type))\",\n \"def _get_field_details(self, data, fields):\\n fields_metadata = dict()\\n for field in fields:\\n dtype = data[field].dtype\\n field_template = self._FIELD_TEMPLATES.get(dtype.kind)\\n if not field_template:\\n raise ValueError('Unsupported dtype {} in column {}'.format(dtype, field))\\n\\n field_details = copy.deepcopy(field_template)\\n fields_metadata[field] = field_details\\n\\n return fields_metadata\",\n \"def fields(self):\",\n \"def __new__(metacls, name, bases, attributes, **kwargs):\\n # Use both a namespaced mapping and a standard dict\\n # as class-based records of our field attributes:\\n field_index = Flat()\\n field_names = {}\\n \\n # Stow both the Python name and the namespaced name\\n # for each field attribute defined on the schema,\\n # additionally manually calling __set_name__(…) if\\n # we’re on a pre-3.6 version of Python:\\n for attribute, value in attributes.items():\\n if isinstance(value, FieldBase):\\n if NEED_NAME:\\n value.__set_name__(None, attribute)\\n attributes[attribute] = value\\n field_names[attribute] = value\\n field_index.set(attribute, value,\\n namespace=value.namespace)\\n \\n # This is the same as the above, but for the base\\n # ancestor class – this enables field inheritance:\\n for base in bases:\\n parent = base.__mro__[0]\\n for attribute, value in vars(parent).items():\\n if isinstance(value, FieldBase) and attribute not in attributes:\\n if NEED_NAME:\\n value.__set_name__(None, attribute)\\n attributes[attribute] = value\\n field_names[attribute] = value\\n field_index.set(attribute, value,\\n namespace=value.namespace)\\n \\n for namespace in field_index.namespaces():\\n nsfield = Namespace(field_index, namespace=namespace)\\n if NEED_NAME:\\n nsfield.__set_name__(None, namespace)\\n attributes[namespace] = nsfield\\n field_names[namespace] = nsfield\\n \\n # Add both the field-index and the field-names mappings\\n # to the class dictionary for the new type:\\n attributes['__field_index__'] = field_index\\n attributes['__field_names__'] = field_names\\n \\n # Create and return the schema type:\\n return super(MetaSchema, metacls).__new__(metacls, name,\\n bases,\\n attributes,\\n **kwargs)\",\n \"def field_names(self):\\n return self.base_field_names() + list(self.data.keys())\",\n \"def field_names(self):\\n if not self._field_names:\\n self._field_names.update(self.properties.keys())\\n\\n self._field_names = [attr for attr in self._field_names if not attr.startswith(\\\"_\\\")]\\n\\n return self._field_names\",\n \"def map_conf_field_names(self, data, **kwargs):\\n # TODO: it's dangerous to depend on an alphabetical order, we'd better move related logic out of Schema.\\n conf = data[\\\"conf\\\"] if \\\"conf\\\" in data else None\\n if conf is not None:\\n for field_key, dict_key in CONF_KEY_MAP.items():\\n value = conf.get(dict_key, None)\\n if dict_key in conf and value is not None:\\n del conf[dict_key]\\n conf[field_key] = value\\n data[\\\"conf\\\"] = conf\\n return data\",\n \"def _build_attributes(self):\\n\\n # We might rebuild the program because of snippets but we must\\n # keep already bound attributes\\n\\n dtype = []\\n for (name,gtype) in self.all_attributes:\\n if name not in self._attributes.keys():\\n attribute = Attribute(self, name, gtype)\\n else:\\n attribute = self._attributes[name]\\n\\n self._attributes[name] = attribute\\n dtype.append(attribute.dtype)\",\n \"def attribute_to_params_map(self):\\n return self._param_names_map\",\n \"def get_fields(self):\\n fields = super(GeoModelSerializer, self).get_fields()\\n # Set the geometry field name when it's undeclared.\\n if not self.Meta.geom_field:\\n for name, field in fields.items():\\n if isinstance(field, GeometryField):\\n self.Meta.geom_field = name\\n break\\n return fields\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def map(self, attr1, attr2):\\n return dict(zip(getattr(self, attr1), getattr(self, attr2)))\",\n \"def get_fields(self) -> Iterable[fields.Field]:\\n for attr_name in dir(self):\\n attr = getattr(self, attr_name)\\n if isinstance(attr, fields.Field):\\n yield attr\",\n \"def get_ask_mapping(cls):\\n mapping = {}\\n for field in cls._meta.fields:\\n if isinstance(field, AskForField):\\n mapping[field.allows_field] = field.name\\n return mapping\",\n \"def get_attrs(self):\\n attrs = []\\n for attribute in self.__dict__.keys():\\n attrs.append(attribute)\",\n \"def set_up_fields(self, fields):\\n self.fields = {\\n 'name': self.name,\\n 'email': self.email\\n }\\n for key in fields.keys():\\n # special keys first, not to be used in the template\\n if key.upper() == 'CC':\\n self.is_cc = fields[key]\\n elif key.upper() == 'BCC':\\n self.is_bcc = fields[key]\\n else:\\n self.fields[key] = fields[key]\",\n \"def fill_by_name(self, fields, prefix=\\\"\\\"):\\n self.fill({'[name=\\\"%s%s\\\"]' % (prefix, k): v for k, v in fields.items()})\",\n \"def retype(self, dictionary):\\r\\n\\r\\n for name, retype in dictionary.items():\\r\\n field = self._field_dict[name]\\r\\n for key, value in retype.items():\\r\\n if key in _valid_retype_attributes:\\r\\n field.__setattr__(key, value)\\r\\n else:\\r\\n raise Exception(\\\"Should not use retype to change field attribute '%s'\\\", key)\",\n \"def generate_attributes(self):\\n for group in self.dict:\\n for param in self.dict[group]:\\n if group in self.group_douplicate and param in self.name_douplicate:\\n setattr(self, group+'_'+param, self(group, param))\\n else:\\n setattr(self, param, self(group, param))\",\n \"def map_attributes(order: dict) -> dict:\\n map_dict = {\\n \\\"has_batteries\\\": FactoryMapping.cast_str_to_bool,\\n \\\"has_glow\\\": FactoryMapping.cast_str_to_bool,\\n \\\"has_lactose\\\": FactoryMapping.cast_str_to_bool,\\n \\\"has_nuts\\\": FactoryMapping.cast_str_to_bool,\\n \\\"min_age\\\": int,\\n \\\"num_rooms\\\": int,\\n \\\"num_sound\\\": int,\\n \\\"pack_size\\\": int,\\n \\\"dimensions\\\": lambda x: float(x.replace(\\\",\\\", '.')),\\n \\\"spider_type\\\": SpiderType.map_str_to_enum,\\n \\\"colour\\\": Colours.map_str_to_enum,\\n \\\"variety\\\": ToffeeVariety.map_str_to_enum,\\n \\\"stuffing\\\": Stuffing.map_str_to_enum,\\n \\\"size\\\": Size.map_str_to_enum,\\n \\\"fabric\\\": Fabric.map_str_to_enum\\n }\\n for key, value in map_dict.items():\\n if key in order:\\n order[key] = value(order[key])\\n return order\",\n \"def _parse_attr(self, attr_proto):\\n attrs = {}\\n for a in attr_proto:\\n for f in ['f', 'i', 's']:\\n if a.HasField(f):\\n attrs[a.name] = getattr(a, f)\\n for f in ['floats', 'ints', 'strings']:\\n if list(getattr(a, f)):\\n assert a.name not in attrs, \\\"Only one type of attr is allowed\\\"\\n attrs[a.name] = tuple(getattr(a, f))\\n for f in ['t', 'g']:\\n if a.HasField(f):\\n attrs[a.name] = getattr(a, f)\\n for f in ['tensors', 'graphs']:\\n if list(getattr(a, f)):\\n raise NotImplementedError(\\\"Filed {} is not supported in mxnet.\\\".format(f))\\n if a.name not in attrs:\\n raise ValueError(\\\"Cannot parse attribute: \\\\n{}\\\\n.\\\".format(a))\\n return attrs\",\n \"def get_format_attrs(self, name, field, alt_field_info={}):\\n # important_props = ('initial', 'autofocus', 'widget')\\n if name in alt_field_info:\\n field = deepcopy(field)\\n for prop, value in alt_field_info[name].items():\\n setattr(field, prop, value)\\n initial = field.initial\\n initial = initial() if callable(initial) else initial\\n attrs, result = {}, []\\n if initial and not isinstance(field.widget, Textarea):\\n attrs['value'] = str(initial)\\n data_val = self.form.data.get(get_html_name(self.form, name), None)\\n if data_val not in ('', None):\\n attrs['value'] = data_val\\n attrs.update(field.widget_attrs(field.widget))\\n result = ''.join(f'{key}=\\\"{val}\\\" ' for key, val in attrs.items())\\n if getattr(field, 'autofocus', None):\\n result += 'autofocus '\\n if issubclass(self.form.__class__, FormOverrideMixIn):\\n # TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.\\n result += '%(attrs)s' # content '%(attrs)s'\\n else:\\n result = '%(attrs)s' + result # '%(attrs)s' content\\n return result\",\n \"def _process_attrs(attrs):\\n new_attrs = OrderedDict()\\n for attr in attrs:\\n col = attr\\n if isinstance(attr, tuple):\\n col, attr = attr\\n # special cases\\n if attr == 'class_name':\\n attr = '__class__.__name__'\\n if attr == 'repr':\\n attr = repr\\n new_attrs[col] = attr\\n\\n return new_attrs\",\n \"def iterate_over_fields(cls):\\n for attr in dir(cls):\\n clsattr = getattr(cls, attr)\\n if isinstance(clsattr, BaseField):\\n yield attr, clsattr\",\n \"def extract_mapping(self) -> DatasetMapping:\\n # store fields\\n fields = []\\n for col in self.data.columns:\\n #get field label\\n label = col\\n #get field type using PANDAS_TYPE (see apps.utils.utils)\\n col_type = self.data[col].dtype\\n field_type = PANDAS_TYPE[col_type]\\n #set field\\n field = FieldMapping(label=label, type=field_type)\\n fields.append(field)\\n self.mapping.append(label)\\n return DatasetMapping(fields=fields)\",\n \"def create_attributes(klass, attributes, previous_object=None):\\n\\n if previous_object is not None:\\n return {'name': attributes.get('name', previous_object.name)}\\n return {\\n 'name': attributes.get('name', ''),\\n 'defaultLocale': attributes['default_locale']\\n }\",\n \"def createFieldMapping(sgidPoints):\\n # Create field mappings\\n sgidFMs = arcpy.FieldMappings()\\n\\n # Perform some field renaming\\n mapPairs = [\\n ('State', 'State'),\\n ('City', 'Inc_Muni'),\\n ('CountyID', 'County'),\\n ('ZipCode', 'Zip_Code'),\\n ('PrefixDir', 'StN_PreDir'),\\n ('StreetName', 'StreetName'),\\n ('StreetType', 'StN_PosTyp'),\\n ('SuffixDir', 'StN_PosDir'),\\n ('AddNum', 'Add_Number'),\\n ('LandmarkName', 'landmkName'),\\n ('Building', 'Building'),\\n ('UnitType', 'Unit'),\\n ('AddSource', 'AddAuth'),\\n ('AddSystem', 'UniqWithin'),\\n ('LoadDate', 'LastUpdate')]\\n\\n for p in mapPairs:\\n print p\\n sgidFMs.addFieldMap(getRenameFieldMap(sgidPoints, p[0], p[1]))\\n\\n return sgidFMs\",\n \"def insertable_dict(self):\\n # .strip('_') is for type_\\n return {\\n 'f_' +\\n p.key.strip('_'): getattr(\\n self,\\n p.key) for p in self.__mapper__.attrs}\",\n \"def audit_fields(elem, fields):\\r\\n errs = []\\r\\n parsed = {}\\r\\n for field, field_type, dict_field in fields:\\r\\n if field not in elem.attrib:\\r\\n errs.append(('missing value', field))\\r\\n else:\\r\\n value = ensure_type(elem.get(field), field_type)\\r\\n if not value:\\r\\n errs.append(('wrong type', field))\\r\\n else:\\r\\n parsed[dict_field] = value\\r\\n \\r\\n if errs:\\r\\n parsed = None\\r\\n return parsed, errs\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6646376","0.65862083","0.65552986","0.65168107","0.6496606","0.63440627","0.6253964","0.6224082","0.61496115","0.61344844","0.60731304","0.60435295","0.60270566","0.5998152","0.5984378","0.59624","0.59521395","0.59237885","0.5913278","0.59089035","0.58935136","0.5889567","0.5886418","0.58837163","0.5882489","0.586821","0.5844601","0.57894444","0.5788735","0.5788207","0.57765007","0.577326","0.5768034","0.5741848","0.5704149","0.5698268","0.5685755","0.56689656","0.56487036","0.5645976","0.5637582","0.55970937","0.5587819","0.55820286","0.557871","0.55745214","0.5556045","0.55559254","0.55429053","0.5531964","0.5528027","0.55157113","0.55125535","0.5504066","0.5496073","0.54950047","0.54942036","0.54852515","0.54837424","0.54782367","0.54775023","0.54748887","0.5462258","0.54608315","0.5456623","0.54565156","0.5454708","0.5447678","0.5447429","0.54429644","0.54421574","0.54421574","0.5424822","0.54154396","0.53954804","0.53939646","0.53908944","0.53895026","0.5380292","0.5378784","0.5372736","0.5368681","0.5368681","0.5368519","0.53621787","0.53604156","0.53586674","0.53520733","0.5344714","0.53401035","0.53355265","0.5334642","0.5329467","0.5323729","0.53182125","0.5316282","0.53137594","0.53022665","0.52959454","0.5294544"],"string":"[\n \"0.6646376\",\n \"0.65862083\",\n \"0.65552986\",\n \"0.65168107\",\n \"0.6496606\",\n \"0.63440627\",\n \"0.6253964\",\n \"0.6224082\",\n \"0.61496115\",\n \"0.61344844\",\n \"0.60731304\",\n \"0.60435295\",\n \"0.60270566\",\n \"0.5998152\",\n \"0.5984378\",\n \"0.59624\",\n \"0.59521395\",\n \"0.59237885\",\n \"0.5913278\",\n \"0.59089035\",\n \"0.58935136\",\n \"0.5889567\",\n \"0.5886418\",\n \"0.58837163\",\n \"0.5882489\",\n \"0.586821\",\n \"0.5844601\",\n \"0.57894444\",\n \"0.5788735\",\n \"0.5788207\",\n \"0.57765007\",\n \"0.577326\",\n \"0.5768034\",\n \"0.5741848\",\n \"0.5704149\",\n \"0.5698268\",\n \"0.5685755\",\n \"0.56689656\",\n \"0.56487036\",\n \"0.5645976\",\n \"0.5637582\",\n \"0.55970937\",\n \"0.5587819\",\n \"0.55820286\",\n \"0.557871\",\n \"0.55745214\",\n \"0.5556045\",\n \"0.55559254\",\n \"0.55429053\",\n \"0.5531964\",\n \"0.5528027\",\n \"0.55157113\",\n \"0.55125535\",\n \"0.5504066\",\n \"0.5496073\",\n \"0.54950047\",\n \"0.54942036\",\n \"0.54852515\",\n \"0.54837424\",\n \"0.54782367\",\n \"0.54775023\",\n \"0.54748887\",\n \"0.5462258\",\n \"0.54608315\",\n \"0.5456623\",\n \"0.54565156\",\n \"0.5454708\",\n \"0.5447678\",\n \"0.5447429\",\n \"0.54429644\",\n \"0.54421574\",\n \"0.54421574\",\n \"0.5424822\",\n \"0.54154396\",\n \"0.53954804\",\n \"0.53939646\",\n \"0.53908944\",\n \"0.53895026\",\n \"0.5380292\",\n \"0.5378784\",\n \"0.5372736\",\n \"0.5368681\",\n \"0.5368681\",\n \"0.5368519\",\n \"0.53621787\",\n \"0.53604156\",\n \"0.53586674\",\n \"0.53520733\",\n \"0.5344714\",\n \"0.53401035\",\n \"0.53355265\",\n \"0.5334642\",\n \"0.5329467\",\n \"0.5323729\",\n \"0.53182125\",\n \"0.5316282\",\n \"0.53137594\",\n \"0.53022665\",\n \"0.52959454\",\n \"0.5294544\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81743294"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94297,"cells":{"query":{"kind":"string","value":"Get all ContactTags associated to contact with that id"},"document":{"kind":"string","value":"def all_in_contact(cls, contact_id: int):\n for contact_tag in cls.get_all_in(\"contacts\", contact_id):\n yield contact_tag"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_photo_tags(self, photo_id):\n\n query_string = '''\n select photo_tag.tag_name from photo\n join photo_tag on(photo_tag.photo_id=photo.photo_id)\n where photo.photo_id={}\n '''.format(photo_id)\n\n # so an array of tags would be ok\n tag_data = self.db.get_query_as_list(query_string)\n for tag in tag_data:\n # print(self.decode_tag(tag['tag_name']))\n\n tag['human_readable_tag'] = self.decode_tag(tag['tag_name'])\n\n # print(tag_data)\n\n return tag_data","def get_tag_to_post(id_post):\n try:\n tags = Posts.objects.get(id=id_post)\n list_tags = [t.tag for t in tags.tags.all()]\n except:\n list_tags = []\n return list_tags","def subject_tag_get_all(context, subject_id, session=None):\n _check_subject_id(subject_id)\n session = session or get_session()\n tags = session.query(models.SubjectTag.value).filter_by(\n subject_id=subject_id).filter_by(deleted=False).all()\n return [tag[0] for tag in tags]","def get_all_id_and_tags(self):\n return self.database.select(self.tname,\n [self.primary_key, 'tags'])","def get_taggable_contacts(state, user):\n\n def get_state_users(state):\n if state is None:\n criteria = {'location__slug': 'nigeria'}\n else:\n criteria = {'location__type__slug': 'state', 'location__slug': state}\n\n users = Contact.objects.filter(**criteria).select_related()\n for u in users:\n if user.id != u.user.id:\n yield {\n 'user_id': u.id,\n 'username': u.user.username,\n 'first_name': u.first_name,\n 'last_name': u.last_name,\n 'state': state or 'national'\n }\n\n taggables = list(get_state_users(None))\n if state:\n taggables.extend(get_state_users(state))\n\n by_state = map_reduce(taggables, lambda u: [(u['state'], u)], lambda v, k: sorted(v, key=lambda u: (u['last_name'], u['first_name'])))\n by_state = [{'state': k, 'users': v} for k, v in by_state.iteritems()]\n by_state.sort(key=lambda e: 'zzzzz' if e['state'] == 'national' else e['state'])\n return by_state","def get(self, currency, address):\n check_inputs(address=address, currency=currency) # abort if fails\n address_tags = commonDAO.list_address_tags(currency, address)\n return address_tags # can be empty list","def getcontacts():\n contacts = {}\n\n try:\n #get list of contact ids\n contactids = r.smembers(\"contacts\")\n\n #for each contact id get data\n for contactid in contactids:\n contacts.update(_getcontact(str(contactid)))\n return contacts\n except:\n print \"Unexpected error:\", sys.exc_info()[0]\n raise","def get_tags(self, obj):\n tags = obj.tags.all()\n serializer = TagSerializer(tags, many=True)\n return serializer.data","def get(self, currency, entity):\n check_inputs(currency=currency, entity=entity)\n tags = entitiesDAO.list_entity_tags(currency, entity)\n return tags","def list_contacts(self):\n return self.contacts","def get_contact_interactions(request, pk):\n try:\n contact = Contact.objects.get(pk=pk)\n except Contact.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n ans = []\n interactions = contact.interaction_set.all()\n for interaction in interactions:\n ans.append(InteractionSerializer(interaction).data)\n return Response(ans)","async def get_contacts_for_contact_group(dbcon: DBConnection, contact_group_id: int) -> Iterable[object_models.Contact]:\n q = \"\"\"select\n contacts.id, contacts.name, contacts.email, contacts.phone, contacts.active\n from contact_group_contacts, contacts\n where contact_group_contacts.contact_group_id = %s\n and contact_group_contacts.contact_id = contacts.id\"\"\"\n return [object_models.Contact(*row) for row in await dbcon.fetch_all(q, (contact_group_id,))]","def getTagsUsingId(self,resourceId):\n response = requests.get('https://api.imagga.com/v1/tagging?content=%s' % resourceId,\n auth=(self.apikey, self.secret))\n #print ('printing response')\n #print (response.json())","def get_queryset(self):\n contact_data = Contact.objects.filter(contact_groups__in=Member.objects.filter(\n user=self.request.user).values('group_id').distinct())\n\n return contact_data","def get_contacts(self):\n contacts = Membership.objects.filter(entity = self, key_contact = True).order_by('importance_to_entity')\n return contacts","def get_tags_list(*args, **kwargs):\n return Tag.objects.active()","def get_tags_list(*args, **kwargs):\n return Tag.objects.active()","def get_contacts_by_company(self, company_id):\n\n contacts = self._request('getContactsByCompany', {'company_id': company_id})\n for contact in contacts:\n yield contact","def tags(self, uuid):\n return self._backend.tags(uuid)","def get_all_contacts(self):\n self.init_db(self._testing)\n\n query = \"SELECT {} FROM {} ORDER BY id;\".format(\", \".join(Contact.columns_with_uid), Contact.table_name)\n\n data = self.db.conn.execute(query)\n\n return [Contact(*item) for item in data]","def get_all_tags():\n try:\n tags = g.projects.distinct('tags')\n return jsonify(sorted(tags, key=str.lower))\n except Exception as err:\n raise ApiException(str(err), 500)","def get_tags(self):\n resp = self.get(_u.build_uri(\"tags\", domain=self.domain))\n return utils.handle_response(resp)","def get_tag_ids(self, cr, uid, model, code=None, name=None, context=None):\n assert bool(code) or bool(name), \"code or name must not be None! (code=%s;name=%s)\" % (code, name)\n tag_domain = [('model_id.model', '=', model)]\n if code is not None:\n tag_domain.append(('code', '=', code))\n if name is not None:\n tag_domain.append(('name', '=', name))\n return self.search(cr, uid, tag_domain, context=context)","def get_all_tagged(self,tag_name):\n return self.tag2elements[tag_name]","def resource_name() -> str:\n return \"contactTags\"","def ListAllContacts(self):\n feed = self.gd_client.GetContacts()\n self.contacts = self.CleanPhoneNumbers(self.GetContactsInfo(feed))\n return self.contacts","def list(self):\n return self._post(\n request='list',\n uri=ApiUri.TAGS.value,\n ).get('tags')","def get_contacts(self):\n\n\t\treturn self.__contacts","def contact_list(self):\n return self._contact_list","def get_all_tags_list(cls):\n all_tags_list = []\n # obj_list = cls.objects.filter(status=0).order_by('-update_time')\n obj_list = Article.objects.all()\n for obj in obj_list:\n all_tags_list = all_tags_list + obj.tags_list()\n # for tag in obj.tags.split(','):\n # all_tags_list.append(tag)\n return all_tags_list","def get_tags(self, tag_name: str):\n return self.soup.find_all(tag_name)","def read(self, request, tag=None):\n tags = Tag.objects\n if tag:\n t = tags.get(slug=tag)\n return t.entry_set.all()\n else:\n return tags.all()","def get_tag_interactions(request, pk):\n try:\n tag = InteractionTag.objects.get(pk=pk)\n except InteractionTag.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n ans = []\n interactions = tag.interaction_set.all()\n for interaction in interactions:\n if request.user == interaction.owner:\n ans.append(InteractionSerializer(interaction).data)\n return Response(ans)","def getTags(self,):\n\t\treturn self.tags;","def contacts(self):\r\n return contacts.Contacts(self)","def tag_ids(self, convthread_id=None):\n if None == convthread_id:\n return [tag[0] for tag in self.dfs[\"tags\"][[\"tag_id\"]].values]\n else :\n df = self.dfs[\"convthreads_with_tags\"]\n tag_records = df[df.convthread_id == convthread_id]\n return tag_records[\"tag_id\"].values","def get_tags(self):\n return self.get_url_data(self.api_url + 'refs/tags')","def contacts(self):\n return ContactCollection(self.request)","def address_tags(self):\n return self._address_tags","def get_tags_for_instance(self, instance_id):\n try:\n response = self.ec2.describe_instances(InstanceIds=[instance_id])\n except Exception as e:\n logger.info(e)\n return []\n for reservation in response['Reservations']:\n for instance in reservation['Instances']:\n if instance['InstanceId'] == instance_id:\n return instance['Tags']\n return []","def get_tags(self) -> Set[Text]:\r\n return {tag for tag in self.tags}","def get_tags(self):\n return self.tags","def get_mailing_tagnames(self, mailing_obj):\n tag_refs = mailing_obj.get('mailing', mailing_obj).get('tags', [])\n tags = []\n for t in tag_refs:\n tdata = self.client.get('%s%s' % (self.base_url, t))\n tags.append(tdata.json().get('name'))\n return tags","def get_tags(request):\n as_list = request.params.get('as_list')\n if as_list:\n return [\n tag.name\n for tag in Tag.query.all()\n ]\n else:\n return [\n {\n 'name': tag.name,\n 'id': tag.id\n }\n for tag in Tag.query.all()\n ]","def prepare_tags(self, obj):\n return [tag.name for tag in obj.tags.all()]","def find_all(self, params={}, **options):\n return self.client.get_collection(\"/tags\", params, **options)","def get_by_tag(cls, tag):\n out = []\n \n tags = Tag.expand_implied_by([tag])\n \n for t in tags:\n results = cls.objects.filter(owner=tag.owner, tags=t)\n \n for b in results:\n if b not in out:\n out.append(b)\n \n return out","def getTags(number=None):","def get_queryset(self):\n return self.request.user.contacts.all()","def get_document_tags(self, docid):\n return [(key, json.loads(value))\n for key, value\n in self.sql_session.query(Feature)\n .filter(Feature.document == docid)\n .values(Feature.key, Feature.value)]","def tags(self):\n return self.get(\"tags\")","def list_all_tags(self,obs):","def list(self):\n\n\t\treturn self._list(\"/tag\", \"tag\")","def tags(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'tags')\r\n\r\n return http.Request('GET', url), parsers.parse_json","def fetch_contacts(owner_account_id):\n resp = oauth.tapkey.get(f\"Owners/{owner_account_id}/Contacts?$select=id,identifier\")\n contacts = resp.json()\n return contacts","async def test_list_address_tags_by_entity(self):\n await test_service.list_address_tags_by_entity(self)","def get_tags(self):\n\n return self.tags","def list_tags(self, entry_name):\n return self.__datacatalog.list_tags(parent=entry_name)","def first_level_tags(self) -> Any:\n return self.client.get_instances_id_content_tags_path(self.id_, '')","def tags(self) -> \"IterableList[TagReference]\":\n return TagReference.list_items(self)","def get_tags(self) -> List:\n LOGGER.info('Get all the tags')\n\n with self.client.create_session() as session:\n tag_count = (func.count(RDSTableTag.table_rk)\n + func.count(RDSDashboardTag.dashboard_rk)).label('tag_count')\n\n records = session.query(\n RDSTag.rk.label('tag_name'),\n tag_count\n )\\\n .outerjoin(RDSTableTag)\\\n .outerjoin(RDSDashboardTag)\\\n .filter(RDSTag.tag_type == 'default')\\\n .group_by(RDSTag.rk)\\\n .having(tag_count > 0)\\\n .all()\n\n results = []\n for record in records:\n results.append(TagDetail(tag_name=record.tag_name,\n tag_count=record.tag_count))\n\n return results","def tags(request):\n return Tag.objects.filter(user=request.user)","def tags_by_id(self, repository_id, access_token=None):\n return self._complete_request_by_id(repository_id, \"tags\", access_token)","def create_a_tag(self, tag_id, contact_id):\n data = {\"contactTag\":{\"contact\":str(contact_id),\"tag\":str(tag_id)}}\n\n return self.client._post(\"/contactTags\", json=data)","def dataset_tags(connection):\n assert connection\n query = \"\"\"select * from tags()\"\"\"\n result = sqlio.read_sql_query(query, connection)\n return [item.strip() for item in result['name']], [tag_id.strip() for tag_id in result['tag_id']]","def get_tags(self):\n\n base_url = self.get_parent().url\n tags = self.tags.all()\n\n for tag in tags:\n tag.url = f\"{base_url}tags/{tag.slug}/\"\n\n return tags","def tags(self) -> Dict:\n return dict(self.client.get_instances_id_tags(self.id_))","def contacts(request):\n User = get_user_model()\n ids = set(request.user.chatmessage_set.all().values_list(\"recipients\", flat=True))\n context = {\n 'contacts': User.objects.filter(pk__in=ids)\n }\n return render(request, \"chat/contacts.html\", context)","def get_tags(self, tags):\n tag_list = []\n for tag in tags:\n tag_list.append(tag[\"name\"])\n return tag_list","def getTags(owner_id=None, photo_id=None, access_key=None):\n params = {\n 'owner_id': owner_id,\n 'photo_id': photo_id,\n 'access_key': access_key\n }\n result = call('photos.getTags', **params)\n return parse_response(result)","def get_tags(self, *args, **kwargs):\n \n tags_data = api.get_tags(\n *args,\n api_key=self.__creds.api_key_v2,\n **kwargs)\n return [en.Tag(tag_data) for tag_data in tags_data]","def queryset(self, request, queryset):\n for tag in get_resource_tags():\n if self.value() == tag[0]:\n return queryset.filter(tags__slug__iexact=tag[0])","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 findTaggedServiceIds(self, name):\n pass;","def tags(self):\r\n url = '{0}/tags/'.format(self.get_url())\r\n request = http.Request('GET', url)\r\n\r\n return request, parsers.parse_json","def get_tags(self) -> Dict:\n return self.orthanc.get_instance_tags(self.identifier)","def get_post_tags(postid, posttags, tags):\n _tags = []\n _nametags = []\n for item in posttags:\n if item['post_id'] == postid:\n _tags.append(item['tag_id'])\n for tag in _tags:\n nametag = get_tagname(tags, tag)\n _nametags.append(nametag)\n return _nametags","def get_contacts_list(self):\n return [(id + 1, contact) for id, contact in enumerate(self.contact_list)]","def obj_categories(self):\r\n return self._tags","def get_asset_tags(user_id):\n result = db.session.query(Tag).filter(\n NotificationAssetTag.user_id == user_id,\n NotificationAssetTag.tag_id == Tag.id\n ).all()\n return result if result else []","def tags(self):\r\n return resources.Tags(self)","def tags(self) -> list[str]:\n _args: list[Arg] = []\n _ctx = self._select(\"tags\", _args)\n return _ctx.execute_sync(list[str])","def collect_tags(self):\n tags = []\n for document in self.documents:\n for tag_token in document.tags:\n tags.append(tag_token)\n return tags","def find_asset_set(self, uid):\n doc_tags = self._collection_asset_tags.find_one({'uid': uid})\n return doc_tags","def get_translated_ids(id):","def entity_tags(self):\n return self._entity_tags","def api_get_tags(request):\n\n # TODO Get favorite tags for the given user ID\n\n tags = Tag.objects.get_not_empty_tags()\n tag_names = []\n for tag in tags:\n tag_names.append(tag.name)\n\n return HttpResponse(content=json.dumps(tag_names))","def test_get_device_tags_by_id(self):\n pass","def list_tags(self, session):\n result = self._tag(session.get, session=session)\n return result['tags']","def tags(self):\n return self._tags","def tags(self):\n return self._tags","def tags(self):\n return self._tags","def tags(self):\n return self._tags","def tags(self):\n return self._tags","def tags(self):\n return self._tags","def tags(self):\n return self._tags","def tags(self):\n return self._tags","def get_contacts():\n return jsonify(g.driver.get_contacts())","def tagPosts(db, tags):\n c=db.cursor()\n print >>sys.stderr, \"Finding tagged posts from\", tags\n idents = []\n for tag in tags:\n c.execute(\"\"\"SELECT post_id FROM tags WHERE tag='%s'\"\"\" % tag)\n idents += [int(ident[0]) for ident in c.fetchall()]\n c.close()\n return list(set(idents))","def tags(self):\n return self._item.get(\"tags\")"],"string":"[\n \"def get_photo_tags(self, photo_id):\\n\\n query_string = '''\\n select photo_tag.tag_name from photo\\n join photo_tag on(photo_tag.photo_id=photo.photo_id)\\n where photo.photo_id={}\\n '''.format(photo_id)\\n\\n # so an array of tags would be ok\\n tag_data = self.db.get_query_as_list(query_string)\\n for tag in tag_data:\\n # print(self.decode_tag(tag['tag_name']))\\n\\n tag['human_readable_tag'] = self.decode_tag(tag['tag_name'])\\n\\n # print(tag_data)\\n\\n return tag_data\",\n \"def get_tag_to_post(id_post):\\n try:\\n tags = Posts.objects.get(id=id_post)\\n list_tags = [t.tag for t in tags.tags.all()]\\n except:\\n list_tags = []\\n return list_tags\",\n \"def subject_tag_get_all(context, subject_id, session=None):\\n _check_subject_id(subject_id)\\n session = session or get_session()\\n tags = session.query(models.SubjectTag.value).filter_by(\\n subject_id=subject_id).filter_by(deleted=False).all()\\n return [tag[0] for tag in tags]\",\n \"def get_all_id_and_tags(self):\\n return self.database.select(self.tname,\\n [self.primary_key, 'tags'])\",\n \"def get_taggable_contacts(state, user):\\n\\n def get_state_users(state):\\n if state is None:\\n criteria = {'location__slug': 'nigeria'}\\n else:\\n criteria = {'location__type__slug': 'state', 'location__slug': state}\\n\\n users = Contact.objects.filter(**criteria).select_related()\\n for u in users:\\n if user.id != u.user.id:\\n yield {\\n 'user_id': u.id,\\n 'username': u.user.username,\\n 'first_name': u.first_name,\\n 'last_name': u.last_name,\\n 'state': state or 'national'\\n }\\n\\n taggables = list(get_state_users(None))\\n if state:\\n taggables.extend(get_state_users(state))\\n\\n by_state = map_reduce(taggables, lambda u: [(u['state'], u)], lambda v, k: sorted(v, key=lambda u: (u['last_name'], u['first_name'])))\\n by_state = [{'state': k, 'users': v} for k, v in by_state.iteritems()]\\n by_state.sort(key=lambda e: 'zzzzz' if e['state'] == 'national' else e['state'])\\n return by_state\",\n \"def get(self, currency, address):\\n check_inputs(address=address, currency=currency) # abort if fails\\n address_tags = commonDAO.list_address_tags(currency, address)\\n return address_tags # can be empty list\",\n \"def getcontacts():\\n contacts = {}\\n\\n try:\\n #get list of contact ids\\n contactids = r.smembers(\\\"contacts\\\")\\n\\n #for each contact id get data\\n for contactid in contactids:\\n contacts.update(_getcontact(str(contactid)))\\n return contacts\\n except:\\n print \\\"Unexpected error:\\\", sys.exc_info()[0]\\n raise\",\n \"def get_tags(self, obj):\\n tags = obj.tags.all()\\n serializer = TagSerializer(tags, many=True)\\n return serializer.data\",\n \"def get(self, currency, entity):\\n check_inputs(currency=currency, entity=entity)\\n tags = entitiesDAO.list_entity_tags(currency, entity)\\n return tags\",\n \"def list_contacts(self):\\n return self.contacts\",\n \"def get_contact_interactions(request, pk):\\n try:\\n contact = Contact.objects.get(pk=pk)\\n except Contact.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n ans = []\\n interactions = contact.interaction_set.all()\\n for interaction in interactions:\\n ans.append(InteractionSerializer(interaction).data)\\n return Response(ans)\",\n \"async def get_contacts_for_contact_group(dbcon: DBConnection, contact_group_id: int) -> Iterable[object_models.Contact]:\\n q = \\\"\\\"\\\"select\\n contacts.id, contacts.name, contacts.email, contacts.phone, contacts.active\\n from contact_group_contacts, contacts\\n where contact_group_contacts.contact_group_id = %s\\n and contact_group_contacts.contact_id = contacts.id\\\"\\\"\\\"\\n return [object_models.Contact(*row) for row in await dbcon.fetch_all(q, (contact_group_id,))]\",\n \"def getTagsUsingId(self,resourceId):\\n response = requests.get('https://api.imagga.com/v1/tagging?content=%s' % resourceId,\\n auth=(self.apikey, self.secret))\\n #print ('printing response')\\n #print (response.json())\",\n \"def get_queryset(self):\\n contact_data = Contact.objects.filter(contact_groups__in=Member.objects.filter(\\n user=self.request.user).values('group_id').distinct())\\n\\n return contact_data\",\n \"def get_contacts(self):\\n contacts = Membership.objects.filter(entity = self, key_contact = True).order_by('importance_to_entity')\\n return contacts\",\n \"def get_tags_list(*args, **kwargs):\\n return Tag.objects.active()\",\n \"def get_tags_list(*args, **kwargs):\\n return Tag.objects.active()\",\n \"def get_contacts_by_company(self, company_id):\\n\\n contacts = self._request('getContactsByCompany', {'company_id': company_id})\\n for contact in contacts:\\n yield contact\",\n \"def tags(self, uuid):\\n return self._backend.tags(uuid)\",\n \"def get_all_contacts(self):\\n self.init_db(self._testing)\\n\\n query = \\\"SELECT {} FROM {} ORDER BY id;\\\".format(\\\", \\\".join(Contact.columns_with_uid), Contact.table_name)\\n\\n data = self.db.conn.execute(query)\\n\\n return [Contact(*item) for item in data]\",\n \"def get_all_tags():\\n try:\\n tags = g.projects.distinct('tags')\\n return jsonify(sorted(tags, key=str.lower))\\n except Exception as err:\\n raise ApiException(str(err), 500)\",\n \"def get_tags(self):\\n resp = self.get(_u.build_uri(\\\"tags\\\", domain=self.domain))\\n return utils.handle_response(resp)\",\n \"def get_tag_ids(self, cr, uid, model, code=None, name=None, context=None):\\n assert bool(code) or bool(name), \\\"code or name must not be None! (code=%s;name=%s)\\\" % (code, name)\\n tag_domain = [('model_id.model', '=', model)]\\n if code is not None:\\n tag_domain.append(('code', '=', code))\\n if name is not None:\\n tag_domain.append(('name', '=', name))\\n return self.search(cr, uid, tag_domain, context=context)\",\n \"def get_all_tagged(self,tag_name):\\n return self.tag2elements[tag_name]\",\n \"def resource_name() -> str:\\n return \\\"contactTags\\\"\",\n \"def ListAllContacts(self):\\n feed = self.gd_client.GetContacts()\\n self.contacts = self.CleanPhoneNumbers(self.GetContactsInfo(feed))\\n return self.contacts\",\n \"def list(self):\\n return self._post(\\n request='list',\\n uri=ApiUri.TAGS.value,\\n ).get('tags')\",\n \"def get_contacts(self):\\n\\n\\t\\treturn self.__contacts\",\n \"def contact_list(self):\\n return self._contact_list\",\n \"def get_all_tags_list(cls):\\n all_tags_list = []\\n # obj_list = cls.objects.filter(status=0).order_by('-update_time')\\n obj_list = Article.objects.all()\\n for obj in obj_list:\\n all_tags_list = all_tags_list + obj.tags_list()\\n # for tag in obj.tags.split(','):\\n # all_tags_list.append(tag)\\n return all_tags_list\",\n \"def get_tags(self, tag_name: str):\\n return self.soup.find_all(tag_name)\",\n \"def read(self, request, tag=None):\\n tags = Tag.objects\\n if tag:\\n t = tags.get(slug=tag)\\n return t.entry_set.all()\\n else:\\n return tags.all()\",\n \"def get_tag_interactions(request, pk):\\n try:\\n tag = InteractionTag.objects.get(pk=pk)\\n except InteractionTag.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n ans = []\\n interactions = tag.interaction_set.all()\\n for interaction in interactions:\\n if request.user == interaction.owner:\\n ans.append(InteractionSerializer(interaction).data)\\n return Response(ans)\",\n \"def getTags(self,):\\n\\t\\treturn self.tags;\",\n \"def contacts(self):\\r\\n return contacts.Contacts(self)\",\n \"def tag_ids(self, convthread_id=None):\\n if None == convthread_id:\\n return [tag[0] for tag in self.dfs[\\\"tags\\\"][[\\\"tag_id\\\"]].values]\\n else :\\n df = self.dfs[\\\"convthreads_with_tags\\\"]\\n tag_records = df[df.convthread_id == convthread_id]\\n return tag_records[\\\"tag_id\\\"].values\",\n \"def get_tags(self):\\n return self.get_url_data(self.api_url + 'refs/tags')\",\n \"def contacts(self):\\n return ContactCollection(self.request)\",\n \"def address_tags(self):\\n return self._address_tags\",\n \"def get_tags_for_instance(self, instance_id):\\n try:\\n response = self.ec2.describe_instances(InstanceIds=[instance_id])\\n except Exception as e:\\n logger.info(e)\\n return []\\n for reservation in response['Reservations']:\\n for instance in reservation['Instances']:\\n if instance['InstanceId'] == instance_id:\\n return instance['Tags']\\n return []\",\n \"def get_tags(self) -> Set[Text]:\\r\\n return {tag for tag in self.tags}\",\n \"def get_tags(self):\\n return self.tags\",\n \"def get_mailing_tagnames(self, mailing_obj):\\n tag_refs = mailing_obj.get('mailing', mailing_obj).get('tags', [])\\n tags = []\\n for t in tag_refs:\\n tdata = self.client.get('%s%s' % (self.base_url, t))\\n tags.append(tdata.json().get('name'))\\n return tags\",\n \"def get_tags(request):\\n as_list = request.params.get('as_list')\\n if as_list:\\n return [\\n tag.name\\n for tag in Tag.query.all()\\n ]\\n else:\\n return [\\n {\\n 'name': tag.name,\\n 'id': tag.id\\n }\\n for tag in Tag.query.all()\\n ]\",\n \"def prepare_tags(self, obj):\\n return [tag.name for tag in obj.tags.all()]\",\n \"def find_all(self, params={}, **options):\\n return self.client.get_collection(\\\"/tags\\\", params, **options)\",\n \"def get_by_tag(cls, tag):\\n out = []\\n \\n tags = Tag.expand_implied_by([tag])\\n \\n for t in tags:\\n results = cls.objects.filter(owner=tag.owner, tags=t)\\n \\n for b in results:\\n if b not in out:\\n out.append(b)\\n \\n return out\",\n \"def getTags(number=None):\",\n \"def get_queryset(self):\\n return self.request.user.contacts.all()\",\n \"def get_document_tags(self, docid):\\n return [(key, json.loads(value))\\n for key, value\\n in self.sql_session.query(Feature)\\n .filter(Feature.document == docid)\\n .values(Feature.key, Feature.value)]\",\n \"def tags(self):\\n return self.get(\\\"tags\\\")\",\n \"def list_all_tags(self,obs):\",\n \"def list(self):\\n\\n\\t\\treturn self._list(\\\"/tag\\\", \\\"tag\\\")\",\n \"def tags(self):\\r\\n url = '{0}/{1}'.format(self.get_url(), 'tags')\\r\\n\\r\\n return http.Request('GET', url), parsers.parse_json\",\n \"def fetch_contacts(owner_account_id):\\n resp = oauth.tapkey.get(f\\\"Owners/{owner_account_id}/Contacts?$select=id,identifier\\\")\\n contacts = resp.json()\\n return contacts\",\n \"async def test_list_address_tags_by_entity(self):\\n await test_service.list_address_tags_by_entity(self)\",\n \"def get_tags(self):\\n\\n return self.tags\",\n \"def list_tags(self, entry_name):\\n return self.__datacatalog.list_tags(parent=entry_name)\",\n \"def first_level_tags(self) -> Any:\\n return self.client.get_instances_id_content_tags_path(self.id_, '')\",\n \"def tags(self) -> \\\"IterableList[TagReference]\\\":\\n return TagReference.list_items(self)\",\n \"def get_tags(self) -> List:\\n LOGGER.info('Get all the tags')\\n\\n with self.client.create_session() as session:\\n tag_count = (func.count(RDSTableTag.table_rk)\\n + func.count(RDSDashboardTag.dashboard_rk)).label('tag_count')\\n\\n records = session.query(\\n RDSTag.rk.label('tag_name'),\\n tag_count\\n )\\\\\\n .outerjoin(RDSTableTag)\\\\\\n .outerjoin(RDSDashboardTag)\\\\\\n .filter(RDSTag.tag_type == 'default')\\\\\\n .group_by(RDSTag.rk)\\\\\\n .having(tag_count > 0)\\\\\\n .all()\\n\\n results = []\\n for record in records:\\n results.append(TagDetail(tag_name=record.tag_name,\\n tag_count=record.tag_count))\\n\\n return results\",\n \"def tags(request):\\n return Tag.objects.filter(user=request.user)\",\n \"def tags_by_id(self, repository_id, access_token=None):\\n return self._complete_request_by_id(repository_id, \\\"tags\\\", access_token)\",\n \"def create_a_tag(self, tag_id, contact_id):\\n data = {\\\"contactTag\\\":{\\\"contact\\\":str(contact_id),\\\"tag\\\":str(tag_id)}}\\n\\n return self.client._post(\\\"/contactTags\\\", json=data)\",\n \"def dataset_tags(connection):\\n assert connection\\n query = \\\"\\\"\\\"select * from tags()\\\"\\\"\\\"\\n result = sqlio.read_sql_query(query, connection)\\n return [item.strip() for item in result['name']], [tag_id.strip() for tag_id in result['tag_id']]\",\n \"def get_tags(self):\\n\\n base_url = self.get_parent().url\\n tags = self.tags.all()\\n\\n for tag in tags:\\n tag.url = f\\\"{base_url}tags/{tag.slug}/\\\"\\n\\n return tags\",\n \"def tags(self) -> Dict:\\n return dict(self.client.get_instances_id_tags(self.id_))\",\n \"def contacts(request):\\n User = get_user_model()\\n ids = set(request.user.chatmessage_set.all().values_list(\\\"recipients\\\", flat=True))\\n context = {\\n 'contacts': User.objects.filter(pk__in=ids)\\n }\\n return render(request, \\\"chat/contacts.html\\\", context)\",\n \"def get_tags(self, tags):\\n tag_list = []\\n for tag in tags:\\n tag_list.append(tag[\\\"name\\\"])\\n return tag_list\",\n \"def getTags(owner_id=None, photo_id=None, access_key=None):\\n params = {\\n 'owner_id': owner_id,\\n 'photo_id': photo_id,\\n 'access_key': access_key\\n }\\n result = call('photos.getTags', **params)\\n return parse_response(result)\",\n \"def get_tags(self, *args, **kwargs):\\n \\n tags_data = api.get_tags(\\n *args,\\n api_key=self.__creds.api_key_v2,\\n **kwargs)\\n return [en.Tag(tag_data) for tag_data in tags_data]\",\n \"def queryset(self, request, queryset):\\n for tag in get_resource_tags():\\n if self.value() == tag[0]:\\n return queryset.filter(tags__slug__iexact=tag[0])\",\n \"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})\",\n \"def findTaggedServiceIds(self, name):\\n pass;\",\n \"def tags(self):\\r\\n url = '{0}/tags/'.format(self.get_url())\\r\\n request = http.Request('GET', url)\\r\\n\\r\\n return request, parsers.parse_json\",\n \"def get_tags(self) -> Dict:\\n return self.orthanc.get_instance_tags(self.identifier)\",\n \"def get_post_tags(postid, posttags, tags):\\n _tags = []\\n _nametags = []\\n for item in posttags:\\n if item['post_id'] == postid:\\n _tags.append(item['tag_id'])\\n for tag in _tags:\\n nametag = get_tagname(tags, tag)\\n _nametags.append(nametag)\\n return _nametags\",\n \"def get_contacts_list(self):\\n return [(id + 1, contact) for id, contact in enumerate(self.contact_list)]\",\n \"def obj_categories(self):\\r\\n return self._tags\",\n \"def get_asset_tags(user_id):\\n result = db.session.query(Tag).filter(\\n NotificationAssetTag.user_id == user_id,\\n NotificationAssetTag.tag_id == Tag.id\\n ).all()\\n return result if result else []\",\n \"def tags(self):\\r\\n return resources.Tags(self)\",\n \"def tags(self) -> list[str]:\\n _args: list[Arg] = []\\n _ctx = self._select(\\\"tags\\\", _args)\\n return _ctx.execute_sync(list[str])\",\n \"def collect_tags(self):\\n tags = []\\n for document in self.documents:\\n for tag_token in document.tags:\\n tags.append(tag_token)\\n return tags\",\n \"def find_asset_set(self, uid):\\n doc_tags = self._collection_asset_tags.find_one({'uid': uid})\\n return doc_tags\",\n \"def get_translated_ids(id):\",\n \"def entity_tags(self):\\n return self._entity_tags\",\n \"def api_get_tags(request):\\n\\n # TODO Get favorite tags for the given user ID\\n\\n tags = Tag.objects.get_not_empty_tags()\\n tag_names = []\\n for tag in tags:\\n tag_names.append(tag.name)\\n\\n return HttpResponse(content=json.dumps(tag_names))\",\n \"def test_get_device_tags_by_id(self):\\n pass\",\n \"def list_tags(self, session):\\n result = self._tag(session.get, session=session)\\n return result['tags']\",\n \"def tags(self):\\n return self._tags\",\n \"def tags(self):\\n return self._tags\",\n \"def tags(self):\\n return self._tags\",\n \"def tags(self):\\n return self._tags\",\n \"def tags(self):\\n return self._tags\",\n \"def tags(self):\\n return self._tags\",\n \"def tags(self):\\n return self._tags\",\n \"def tags(self):\\n return self._tags\",\n \"def get_contacts():\\n return jsonify(g.driver.get_contacts())\",\n \"def tagPosts(db, tags):\\n c=db.cursor()\\n print >>sys.stderr, \\\"Finding tagged posts from\\\", tags\\n idents = []\\n for tag in tags:\\n c.execute(\\\"\\\"\\\"SELECT post_id FROM tags WHERE tag='%s'\\\"\\\"\\\" % tag)\\n idents += [int(ident[0]) for ident in c.fetchall()]\\n c.close()\\n return list(set(idents))\",\n \"def tags(self):\\n return self._item.get(\\\"tags\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59750104","0.59688324","0.5902836","0.58065534","0.5737934","0.56792","0.5666696","0.56300694","0.56000763","0.5579044","0.55602413","0.5539786","0.5474715","0.54744804","0.54674107","0.546423","0.546423","0.5387576","0.5375769","0.5366009","0.53620964","0.53493714","0.5338336","0.53381556","0.53158957","0.5290614","0.52836025","0.5279322","0.5257186","0.5247879","0.5241851","0.5231902","0.52288723","0.5218876","0.5215778","0.52127415","0.51939964","0.51857746","0.51835656","0.5172548","0.5170723","0.51678497","0.5164406","0.51544976","0.5149598","0.513339","0.51224047","0.5120788","0.51200116","0.5118745","0.5111579","0.5111258","0.50984275","0.50906295","0.5079039","0.5073982","0.50712925","0.5068463","0.50548905","0.50343686","0.50287896","0.502789","0.50270516","0.5026636","0.5024029","0.5022212","0.5019983","0.5019373","0.5015886","0.5014633","0.50083417","0.50023526","0.49917528","0.49874666","0.49835265","0.4981862","0.49788502","0.49785203","0.49720296","0.4969989","0.49623483","0.496217","0.49522674","0.4947717","0.49467754","0.49448442","0.49413246","0.49375886","0.4928411","0.4926625","0.4926625","0.4926625","0.4926625","0.4926625","0.4926625","0.4926625","0.4926625","0.49233073","0.4922935","0.49193725"],"string":"[\n \"0.59750104\",\n \"0.59688324\",\n \"0.5902836\",\n \"0.58065534\",\n \"0.5737934\",\n \"0.56792\",\n \"0.5666696\",\n \"0.56300694\",\n \"0.56000763\",\n \"0.5579044\",\n \"0.55602413\",\n \"0.5539786\",\n \"0.5474715\",\n \"0.54744804\",\n \"0.54674107\",\n \"0.546423\",\n \"0.546423\",\n \"0.5387576\",\n \"0.5375769\",\n \"0.5366009\",\n \"0.53620964\",\n \"0.53493714\",\n \"0.5338336\",\n \"0.53381556\",\n \"0.53158957\",\n \"0.5290614\",\n \"0.52836025\",\n \"0.5279322\",\n \"0.5257186\",\n \"0.5247879\",\n \"0.5241851\",\n \"0.5231902\",\n \"0.52288723\",\n \"0.5218876\",\n \"0.5215778\",\n \"0.52127415\",\n \"0.51939964\",\n \"0.51857746\",\n \"0.51835656\",\n \"0.5172548\",\n \"0.5170723\",\n \"0.51678497\",\n \"0.5164406\",\n \"0.51544976\",\n \"0.5149598\",\n \"0.513339\",\n \"0.51224047\",\n \"0.5120788\",\n \"0.51200116\",\n \"0.5118745\",\n \"0.5111579\",\n \"0.5111258\",\n \"0.50984275\",\n \"0.50906295\",\n \"0.5079039\",\n \"0.5073982\",\n \"0.50712925\",\n \"0.5068463\",\n \"0.50548905\",\n \"0.50343686\",\n \"0.50287896\",\n \"0.502789\",\n \"0.50270516\",\n \"0.5026636\",\n \"0.5024029\",\n \"0.5022212\",\n \"0.5019983\",\n \"0.5019373\",\n \"0.5015886\",\n \"0.5014633\",\n \"0.50083417\",\n \"0.50023526\",\n \"0.49917528\",\n \"0.49874666\",\n \"0.49835265\",\n \"0.4981862\",\n \"0.49788502\",\n \"0.49785203\",\n \"0.49720296\",\n \"0.4969989\",\n \"0.49623483\",\n \"0.496217\",\n \"0.49522674\",\n \"0.4947717\",\n \"0.49467754\",\n \"0.49448442\",\n \"0.49413246\",\n \"0.49375886\",\n \"0.4928411\",\n \"0.4926625\",\n \"0.4926625\",\n \"0.4926625\",\n \"0.4926625\",\n \"0.4926625\",\n \"0.4926625\",\n \"0.4926625\",\n \"0.4926625\",\n \"0.49233073\",\n \"0.4922935\",\n \"0.49193725\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7933677"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94298,"cells":{"query":{"kind":"string","value":"Is true when ``argument`` is an iterable collection with integerequivalent items."},"document":{"kind":"string","value":"def all_are_integer_equivalent_numbers(argument):\n from abjad import mathtools\n try:\n return all(mathtools.is_integer_equivalent_number(_) for _ in argument)\n except TypeError:\n return False"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def iterable(arg):\n return isinstance(arg, collections.Iterable) and not isinstance(arg, six.string_types)","def is_sequence_of_int(items):\n return all(isinstance(item, int) for item in items)","def is_iterable(arg):\n return (\n isinstance(arg, collections.Iterable)\n and not isinstance(arg, str)\n )","def is_iterable(element):\n return isinstance(element, (set, list, tuple))","def _is_iterable(items):\n return isinstance(items, (list, tuple, set, np.ndarray))","def is_int(*args): \n try:\n for i in args:\n int(i)\n return True\n except Exception:\n return False","def is_numlike(x):\r\n if iterable(x):\r\n for thisx in x:\r\n return is_numlike(thisx)\r\n else:\r\n return is_numlike(x)","def is_iterable(var, iterable_types=ITERABLE_TYPES):\n return isinstance(var, iterable_types)","def is_sequence_of_iterable(items):\n return all(is_item_iterable(item) for item in items)","def _is_iterable(value):\n return isinstance(value, list) or isinstance(value, tuple)","def iterable(x):\n try:\n iter(x)\n return True\n except TypeError:\n return False","def is_iterable(self):\n return all(set.is_iterable for set in self.sets)","def isIterable(value):\n try:\n iter(value)\n return True\n except:\n return False","def is_iterable(var):\n return any(isinstance(var, cls) for cls in [list, tuple, types.GeneratorType])","def is_item_iterable(item):\n try:\n _ = [_ for _ in item]\n except TypeError:\n return False\n return True","def is_iterable(x: Any) -> bool:\r\n return isinstance(x, collections.abc.Iterable) and not isinstance(x, (str, bytes))","def has_args(iterable, args):\n\n try:\n return all(x in iterable for x in args)\n\n except TypeError:\n return False","def is_sequence(arg):\n\n # np.float{16,32,64} and np.int types have __getitem__ defined\n # this is a long-standing bug in NumPy and unlikely to be fixed\n # todo: backport to qmmlpack, write tests\n if isinstance(arg, (str, bytes, np.number, dict, set)):\n return False\n\n return hasattr(arg, \"__getitem__\") or hasattr(arg, \"__iter__\")","def isiterable(x):\n try:\n iter(x)\n except TypeError:\n return False\n return True","def isiterable(x):\n try:\n iter(x)\n return True\n except TypeError:\n return False","def _is_positive_int_tuple(item):\n if not isinstance(item, tuple):\n return False\n for i in item:\n if not _is_positive_int(i):\n return False\n return True","def is_sequence_of_uint(items):\n return all(isinstance(item, int) and item >= 0 for item in items)","def is_integer(value: Union[float, np.ndarray]) -> bool:\n if type(value) == np.ndarray:\n for entry in value:\n result = Comparator.is_integer(entry)\n if not result:\n return False\n return True\n else:\n value = abs(value)\n value -= int(value)\n if value > 0.5:\n return Comparator.is_close_to_zero(1 - value)\n return Comparator.is_close_to_zero(value)","def is_intscalar(x: Any) -> bool:\r\n return isinstance(x, (\r\n int,\r\n np.int8,\r\n np.int16,\r\n np.int32,\r\n np.int64,\r\n np.uint8,\r\n np.uint16,\r\n np.uint32,\r\n np.uint64,\r\n ))","def is_iterable_container(value):\n # strings are iterable too so we have to treat them as a special case\n return not isinstance(value, str) and isinstance(value, collections.Iterable)","def is_iterable(value):\n # noinspection PyUnresolvedReferences\n return hasattr(value, '__iter__') and hasattr(value, '__getitem__')","def is_nonstring_iterable(x):\n if isinstance(x, primitive_iterable):\n return False\n return isinstance(x, collections.Iterable)","def _is_integer(x):\n return (not isinstance(x, (bool, np.bool))) and \\\n isinstance(x, (numbers.Integral, int, np.int, np.long, long)) # no long type in python 3","def is_iterable(x):\n if isinstance(x, six.string_types):\n return False\n return hasattr(x, '__iter__')","def is_iterable(thing):\n\n try:\n iter(thing)\n except TypeError:\n return False\n return True","def _is_iterable_non_string(arg):\n return (hasattr(arg, \"__iter__\") or hasattr(arg, \"__getattr__\")) and not isinstance(arg, str)","def test_defined_in_iter():\n\n @type_checked\n def _run_test(thing:[(int, str, str)]):\n for group in thing:\n assert isinstance(group[0], int)\n assert isinstance(group[1], str)\n assert isinstance(group[2], str)\n assert len(thing) == 4\n\n _run_test(thing=[\n (12.3, None, False),\n (\"12.1\", True, 1),\n (False, 10, 12.1),\n (True, 14.9, None),\n ])","def isInteger(self):","def isInteger(self):","def are_sequential_integers(values: List[Union[str, int, float]]):\n int_list = []\n for value in values:\n if not is_integer(value):\n return False\n int_list.append(int(float(value)))\n return (max(int_list) - min(int_list) + 1) == len(int_list)","def acceptsArgument(self):\n range = self.validateRange(self.range)\n return not(not(range[1]))","def test_in_operator_on_non_iterable(self):\n\n class User(Document):\n name = StringField()\n\n class BlogPost(Document):\n content = StringField()\n authors = ListField(ReferenceField(User))\n\n User.drop_collection()\n BlogPost.drop_collection()\n\n author = User.objects.create(name=\"Test User\")\n post = BlogPost.objects.create(\n content=\"Had a good coffee today...\", authors=[author]\n )\n\n # Make sure using `__in` with a list works\n blog_posts = BlogPost.objects(authors__in=[author])\n assert list(blog_posts) == [post]\n\n # Using `__in` with a non-iterable should raise a TypeError\n with pytest.raises(TypeError):\n BlogPost.objects(authors__in=author.pk).count()\n\n # Using `__in` with a `Document` (which is seemingly iterable but not\n # in a way we'd expect) should raise a TypeError, too\n with pytest.raises(TypeError):\n BlogPost.objects(authors__in=author).count()","def any_user(iterable):\n for element in iterable:\n if element:\n return True\n return False","def is_sequence(arg):\n return (not hasattr(arg, \"strip\") and\n hasattr(arg, \"__getitem__\") or\n hasattr(arg, \"__iter__\"))","def isIterable(obj):\n return isinstance(obj, ListType)","def isInteger(data):\n\tif type(data) == list or type(data) == np.ndarray:\n\t\tcol = pd.Series(data)\n\telse:\n\t\tcol = data\n\treturn col.dtype == np.int32 or col.dtype == np.int64","def _all_equal(arg):\n return arg.count(arg[0]) == len(arg)","def isInteger(self):\n return isinstance(self.value, int)","def is_iterable(obj):\n return isinstance(obj, (list, tuple, types.GeneratorType)) or \\\n (not isinstance(obj, (int, str, dict)) and\n bool(getattr(obj, \"next\", False)))","def is_convertible_to_int(v: Any) -> bool:\n\n try:\n test = int(v)\n return True\n except:\n return False","def isInteger(self):\n pass","def is_iterable(obj):\n if isinstance(obj, (str, bytes, bytearray)):\n return False\n return isinstance(obj, Iterable)","def __contains__(self, item: OidValue) -> bool:\n item = to_int_tuple(item)\n return self.value == item[0 : len(self.value)]","def is_int3(items):\n return len(items) == 3 and all(isinstance(item, int) for item in items)","def same(seq: typing.Iterable[typing.Any]) -> bool:\n seq = iter(seq)\n first = type(next(seq))\n return all(isinstance(i, first) for i in seq)","def is_valid_integer_list(any_list):\n list_object = json.loads(any_list)\n return not any(not is_valid_integer(str(listing_id)) for listing_id in\n list_object)","def isiterable(obj, strings=False, isinstance=isinstance, Iterable=Iterable):\n return (isinstance(obj, Iterable) and\n not (isinstance(obj, str) and not strings))","def _is_list(arg):\n return isinstance(arg, collections.Sequence) and not _is_string(arg)","def _is_integer_like(input):\n if _is_boolean_like(input):\n return True\n if type(input) is int:\n return True\n if isinstance(input, _ScalarConstant):\n if input.dtype in _int_like_types:\n return True\n return False","def is_int(x):\n return int(x) == x","def isIterable(obj):\n # type: (Any) -> bool\n if isinstance(obj, basestring):\n return False\n elif isinstance(obj, ProxyUnicode):\n return False\n try:\n iter(obj)\n except TypeError:\n return False\n else:\n return True","def __eq__(self, *args):\n return _ida_hexrays.user_numforms_iterator_t___eq__(self, *args)","def contains(self, *args):\n return _libsbml.IdList_contains(self, *args)","def allIn(listA: Union[int, List[int]], listB: Union[int, List[int]]) -> bool:\n if isinstance(listA, int):\n listA = [listA]\n if isinstance(listB, int):\n return listB in listA\n else:\n for item in listB:\n if item not in listA:\n return False\n return True","def is_int(x):\n # boolean are subclasses of integers in Python, so explicitly exclude them\n return isinstance(x, (int, np.integer)) and not isinstance(x, bool)","def is_int(q):\n if isinstance(q, (Integer, int)):\n return True\n if isinstance(q, Rational):\n if q.denominator() == 1:\n return True\n if isinstance(q, tuple):\n return False\n try:\n if floor(q) == ceil(q):\n return True\n except TypeError:\n pass\n return False","def __contains__(self, a):\n try:\n self.convert(a)\n except CoercionFailed:\n return False\n\n return True","def _is_good_iterable(obj):\n return _is_iterable(obj) and _has_str_elems(obj)","def is_collection(var):\n return isinstance(var, Iterable) and not isinstance(var, str)","def any(self) -> int:","def any(self) -> int:","def hasNextInt(self) -> bool:\n raise NotImplementedError","def any(iterable):\n for item in iterable:\n if item:\n return True\n return False","def is_int(x):\n # From sktime: BSD 3-Clause\n # boolean are subclasses of integers in Python, so explicitly exclude them\n return isinstance(x, (int, np.integer)) and not isinstance(x, bool)","def is_int(self):\n return self.value_type in (int, arrow.JuArrow)","def _is_positive_int(item):\n if not isinstance(item, int):\n return False\n return item > 0","def is_integer(i):\n import numpy as np\n if isinstance(i, (int, long)):\n return True\n if isinstance(i, float):\n return (i).is_integer()\n if issubclass(type(i), np.integer):\n return i\n else:\n return False","def test_args_count_equal(args: list, target: int) -> bool:\n\n\treturn (args_count(args) == target)","def operator_in(item: Result, container: Result) -> Result:\n result: Result = celpy.celtypes.BoolType(False)\n for c in cast(Iterable[Result], container):\n try:\n if c == item:\n return celpy.celtypes.BoolType(True)\n except TypeError as ex:\n logger.debug(f\"operator_in({item}, {container}) --> {ex}\")\n result = CELEvalError(\"no such overload\", ex.__class__, ex.args)\n logger.debug(f\"operator_in({item!r}, {container!r}) = {result!r}\")\n return result","def is_int(value):\n return isinstance(value, int)","def _assert_valid_value_and_cast(self, value):\n if not hasattr(value, '__iter__'):\n raise AssertionError(f\"{value} is not a valid iterable type\")\n return value","def is_int(self, size=None):\n return False","def isInteger(data):\n\ttry:\n\t\tfrom types import LongType, IntType\n\t\tif type(data) == LongType or type(data) == IntType:\n\t\t\treturn True\n\texcept ImportError:\n\t\tif type(data) == type(int(0)):\n\t\t\treturn True\n\treturn False","def _is_all_int(df_list: List[Union[dd.DataFrame, pd.DataFrame]], col: str) -> bool:\n for df in df_list:\n if col in df.columns:\n srs = df[col]\n if isinstance(srs, (dd.DataFrame, pd.DataFrame)):\n for dtype in srs.dtypes:\n if not is_integer_dtype(dtype):\n return False\n elif isinstance(srs, (dd.Series, pd.Series)):\n if not is_integer_dtype(srs.dtype):\n return False\n else:\n raise ValueError(f\"unprocessed type of data:{type(srs)}\")\n return True","def is_integral(self):\n return all(x in ZZ for x in self._representation_vector)","def in_list(value, arg):\r\n return value in arg","def isInteger(self):\n return _libsbml.ASTNode_isInteger(self)","def check_if_input_is_int(self):\n try:\n int(self.input)\n except ValueError:\n return False\n else:\n return True","def equal(self, *args):\n return _libsbml.SwigPyIterator_equal(self, *args)","def isiterable(obj, classinfo=None, of_type=None):\n if classinfo is not None:\n if not isinstance(obj, classinfo):\n return False\n elif not hasattr(obj, '__iter__') and not hasattr(obj, '__getitem__'):\n return False\n if of_type is not None:\n return all(isinstance(ele, of_type) for ele in obj)\n return True","def check_iterable(value):\n try:\n iter(value)\n if not isinstance(value, six.string_types):\n return True\n else:\n return False\n except Exception as e:\n pass\n\n return False","def is_iterable_object(maybe_iterable: Any) -> TypeGuard[Iterable[Any]]:\n\n return isinstance(maybe_iterable, Iterable)","def all_user(iterable):\n for element in iterable:\n if not element:\n return False\n return True","def _is_single_range(r):\n return (isinstance(r, numbers.Integral) or\n (isinstance(r, collections.Sequence) and (len(r) == 2) and\n _is_range_boundary(r[0]) and _is_range_boundary(r[1])))","def check_all_iterable_values_equal(iterable):\n return all(second_value_onwards == iterable[0] for second_value_onwards in iterable[1:])","def any(self) -> int:\n ...","def is_sequence(value):\n return (hasattr(value, \"__iter__\") and not\n isinstance(value, (six.string_types, six.binary_type)))","def _contains(self, element):\n if not isinstance(element, Tuple) or len(element) != 2:\n return S.false\n\n if not element[1].is_Integer:\n return S.false\n\n if element[1] >= len(self.sets) or element[1] < 0:\n return S.false\n\n return self.sets[element[1]]._contains(element[0])","def is_in(elt, seq):\n\treturn any(x is elt for x in seq)","def isInteger(self):\n return self._is_int","def indexists(list, *args): # Technically doesn't have to do with the screen, but it is very useful. \n return all([int(arg) < len(list) for arg in args])","def _is_sequence_like(self, data):\n return hasattr(data, \"__iter__\") and hasattr(data, \"__getitem__\")","def is_iterable(refobject):\n is_iter = False\n try:\n for e in refobject: \n break\n is_iter = True\n except:\n pass\n\n return is_iter","def is_int(self):\n return self.v & 1 != 0","def hasCorrectNumberArguments(self, *args):\n return _libsbml.ASTBasePlugin_hasCorrectNumberArguments(self, *args)"],"string":"[\n \"def iterable(arg):\\n return isinstance(arg, collections.Iterable) and not isinstance(arg, six.string_types)\",\n \"def is_sequence_of_int(items):\\n return all(isinstance(item, int) for item in items)\",\n \"def is_iterable(arg):\\n return (\\n isinstance(arg, collections.Iterable)\\n and not isinstance(arg, str)\\n )\",\n \"def is_iterable(element):\\n return isinstance(element, (set, list, tuple))\",\n \"def _is_iterable(items):\\n return isinstance(items, (list, tuple, set, np.ndarray))\",\n \"def is_int(*args): \\n try:\\n for i in args:\\n int(i)\\n return True\\n except Exception:\\n return False\",\n \"def is_numlike(x):\\r\\n if iterable(x):\\r\\n for thisx in x:\\r\\n return is_numlike(thisx)\\r\\n else:\\r\\n return is_numlike(x)\",\n \"def is_iterable(var, iterable_types=ITERABLE_TYPES):\\n return isinstance(var, iterable_types)\",\n \"def is_sequence_of_iterable(items):\\n return all(is_item_iterable(item) for item in items)\",\n \"def _is_iterable(value):\\n return isinstance(value, list) or isinstance(value, tuple)\",\n \"def iterable(x):\\n try:\\n iter(x)\\n return True\\n except TypeError:\\n return False\",\n \"def is_iterable(self):\\n return all(set.is_iterable for set in self.sets)\",\n \"def isIterable(value):\\n try:\\n iter(value)\\n return True\\n except:\\n return False\",\n \"def is_iterable(var):\\n return any(isinstance(var, cls) for cls in [list, tuple, types.GeneratorType])\",\n \"def is_item_iterable(item):\\n try:\\n _ = [_ for _ in item]\\n except TypeError:\\n return False\\n return True\",\n \"def is_iterable(x: Any) -> bool:\\r\\n return isinstance(x, collections.abc.Iterable) and not isinstance(x, (str, bytes))\",\n \"def has_args(iterable, args):\\n\\n try:\\n return all(x in iterable for x in args)\\n\\n except TypeError:\\n return False\",\n \"def is_sequence(arg):\\n\\n # np.float{16,32,64} and np.int types have __getitem__ defined\\n # this is a long-standing bug in NumPy and unlikely to be fixed\\n # todo: backport to qmmlpack, write tests\\n if isinstance(arg, (str, bytes, np.number, dict, set)):\\n return False\\n\\n return hasattr(arg, \\\"__getitem__\\\") or hasattr(arg, \\\"__iter__\\\")\",\n \"def isiterable(x):\\n try:\\n iter(x)\\n except TypeError:\\n return False\\n return True\",\n \"def isiterable(x):\\n try:\\n iter(x)\\n return True\\n except TypeError:\\n return False\",\n \"def _is_positive_int_tuple(item):\\n if not isinstance(item, tuple):\\n return False\\n for i in item:\\n if not _is_positive_int(i):\\n return False\\n return True\",\n \"def is_sequence_of_uint(items):\\n return all(isinstance(item, int) and item >= 0 for item in items)\",\n \"def is_integer(value: Union[float, np.ndarray]) -> bool:\\n if type(value) == np.ndarray:\\n for entry in value:\\n result = Comparator.is_integer(entry)\\n if not result:\\n return False\\n return True\\n else:\\n value = abs(value)\\n value -= int(value)\\n if value > 0.5:\\n return Comparator.is_close_to_zero(1 - value)\\n return Comparator.is_close_to_zero(value)\",\n \"def is_intscalar(x: Any) -> bool:\\r\\n return isinstance(x, (\\r\\n int,\\r\\n np.int8,\\r\\n np.int16,\\r\\n np.int32,\\r\\n np.int64,\\r\\n np.uint8,\\r\\n np.uint16,\\r\\n np.uint32,\\r\\n np.uint64,\\r\\n ))\",\n \"def is_iterable_container(value):\\n # strings are iterable too so we have to treat them as a special case\\n return not isinstance(value, str) and isinstance(value, collections.Iterable)\",\n \"def is_iterable(value):\\n # noinspection PyUnresolvedReferences\\n return hasattr(value, '__iter__') and hasattr(value, '__getitem__')\",\n \"def is_nonstring_iterable(x):\\n if isinstance(x, primitive_iterable):\\n return False\\n return isinstance(x, collections.Iterable)\",\n \"def _is_integer(x):\\n return (not isinstance(x, (bool, np.bool))) and \\\\\\n isinstance(x, (numbers.Integral, int, np.int, np.long, long)) # no long type in python 3\",\n \"def is_iterable(x):\\n if isinstance(x, six.string_types):\\n return False\\n return hasattr(x, '__iter__')\",\n \"def is_iterable(thing):\\n\\n try:\\n iter(thing)\\n except TypeError:\\n return False\\n return True\",\n \"def _is_iterable_non_string(arg):\\n return (hasattr(arg, \\\"__iter__\\\") or hasattr(arg, \\\"__getattr__\\\")) and not isinstance(arg, str)\",\n \"def test_defined_in_iter():\\n\\n @type_checked\\n def _run_test(thing:[(int, str, str)]):\\n for group in thing:\\n assert isinstance(group[0], int)\\n assert isinstance(group[1], str)\\n assert isinstance(group[2], str)\\n assert len(thing) == 4\\n\\n _run_test(thing=[\\n (12.3, None, False),\\n (\\\"12.1\\\", True, 1),\\n (False, 10, 12.1),\\n (True, 14.9, None),\\n ])\",\n \"def isInteger(self):\",\n \"def isInteger(self):\",\n \"def are_sequential_integers(values: List[Union[str, int, float]]):\\n int_list = []\\n for value in values:\\n if not is_integer(value):\\n return False\\n int_list.append(int(float(value)))\\n return (max(int_list) - min(int_list) + 1) == len(int_list)\",\n \"def acceptsArgument(self):\\n range = self.validateRange(self.range)\\n return not(not(range[1]))\",\n \"def test_in_operator_on_non_iterable(self):\\n\\n class User(Document):\\n name = StringField()\\n\\n class BlogPost(Document):\\n content = StringField()\\n authors = ListField(ReferenceField(User))\\n\\n User.drop_collection()\\n BlogPost.drop_collection()\\n\\n author = User.objects.create(name=\\\"Test User\\\")\\n post = BlogPost.objects.create(\\n content=\\\"Had a good coffee today...\\\", authors=[author]\\n )\\n\\n # Make sure using `__in` with a list works\\n blog_posts = BlogPost.objects(authors__in=[author])\\n assert list(blog_posts) == [post]\\n\\n # Using `__in` with a non-iterable should raise a TypeError\\n with pytest.raises(TypeError):\\n BlogPost.objects(authors__in=author.pk).count()\\n\\n # Using `__in` with a `Document` (which is seemingly iterable but not\\n # in a way we'd expect) should raise a TypeError, too\\n with pytest.raises(TypeError):\\n BlogPost.objects(authors__in=author).count()\",\n \"def any_user(iterable):\\n for element in iterable:\\n if element:\\n return True\\n return False\",\n \"def is_sequence(arg):\\n return (not hasattr(arg, \\\"strip\\\") and\\n hasattr(arg, \\\"__getitem__\\\") or\\n hasattr(arg, \\\"__iter__\\\"))\",\n \"def isIterable(obj):\\n return isinstance(obj, ListType)\",\n \"def isInteger(data):\\n\\tif type(data) == list or type(data) == np.ndarray:\\n\\t\\tcol = pd.Series(data)\\n\\telse:\\n\\t\\tcol = data\\n\\treturn col.dtype == np.int32 or col.dtype == np.int64\",\n \"def _all_equal(arg):\\n return arg.count(arg[0]) == len(arg)\",\n \"def isInteger(self):\\n return isinstance(self.value, int)\",\n \"def is_iterable(obj):\\n return isinstance(obj, (list, tuple, types.GeneratorType)) or \\\\\\n (not isinstance(obj, (int, str, dict)) and\\n bool(getattr(obj, \\\"next\\\", False)))\",\n \"def is_convertible_to_int(v: Any) -> bool:\\n\\n try:\\n test = int(v)\\n return True\\n except:\\n return False\",\n \"def isInteger(self):\\n pass\",\n \"def is_iterable(obj):\\n if isinstance(obj, (str, bytes, bytearray)):\\n return False\\n return isinstance(obj, Iterable)\",\n \"def __contains__(self, item: OidValue) -> bool:\\n item = to_int_tuple(item)\\n return self.value == item[0 : len(self.value)]\",\n \"def is_int3(items):\\n return len(items) == 3 and all(isinstance(item, int) for item in items)\",\n \"def same(seq: typing.Iterable[typing.Any]) -> bool:\\n seq = iter(seq)\\n first = type(next(seq))\\n return all(isinstance(i, first) for i in seq)\",\n \"def is_valid_integer_list(any_list):\\n list_object = json.loads(any_list)\\n return not any(not is_valid_integer(str(listing_id)) for listing_id in\\n list_object)\",\n \"def isiterable(obj, strings=False, isinstance=isinstance, Iterable=Iterable):\\n return (isinstance(obj, Iterable) and\\n not (isinstance(obj, str) and not strings))\",\n \"def _is_list(arg):\\n return isinstance(arg, collections.Sequence) and not _is_string(arg)\",\n \"def _is_integer_like(input):\\n if _is_boolean_like(input):\\n return True\\n if type(input) is int:\\n return True\\n if isinstance(input, _ScalarConstant):\\n if input.dtype in _int_like_types:\\n return True\\n return False\",\n \"def is_int(x):\\n return int(x) == x\",\n \"def isIterable(obj):\\n # type: (Any) -> bool\\n if isinstance(obj, basestring):\\n return False\\n elif isinstance(obj, ProxyUnicode):\\n return False\\n try:\\n iter(obj)\\n except TypeError:\\n return False\\n else:\\n return True\",\n \"def __eq__(self, *args):\\n return _ida_hexrays.user_numforms_iterator_t___eq__(self, *args)\",\n \"def contains(self, *args):\\n return _libsbml.IdList_contains(self, *args)\",\n \"def allIn(listA: Union[int, List[int]], listB: Union[int, List[int]]) -> bool:\\n if isinstance(listA, int):\\n listA = [listA]\\n if isinstance(listB, int):\\n return listB in listA\\n else:\\n for item in listB:\\n if item not in listA:\\n return False\\n return True\",\n \"def is_int(x):\\n # boolean are subclasses of integers in Python, so explicitly exclude them\\n return isinstance(x, (int, np.integer)) and not isinstance(x, bool)\",\n \"def is_int(q):\\n if isinstance(q, (Integer, int)):\\n return True\\n if isinstance(q, Rational):\\n if q.denominator() == 1:\\n return True\\n if isinstance(q, tuple):\\n return False\\n try:\\n if floor(q) == ceil(q):\\n return True\\n except TypeError:\\n pass\\n return False\",\n \"def __contains__(self, a):\\n try:\\n self.convert(a)\\n except CoercionFailed:\\n return False\\n\\n return True\",\n \"def _is_good_iterable(obj):\\n return _is_iterable(obj) and _has_str_elems(obj)\",\n \"def is_collection(var):\\n return isinstance(var, Iterable) and not isinstance(var, str)\",\n \"def any(self) -> int:\",\n \"def any(self) -> int:\",\n \"def hasNextInt(self) -> bool:\\n raise NotImplementedError\",\n \"def any(iterable):\\n for item in iterable:\\n if item:\\n return True\\n return False\",\n \"def is_int(x):\\n # From sktime: BSD 3-Clause\\n # boolean are subclasses of integers in Python, so explicitly exclude them\\n return isinstance(x, (int, np.integer)) and not isinstance(x, bool)\",\n \"def is_int(self):\\n return self.value_type in (int, arrow.JuArrow)\",\n \"def _is_positive_int(item):\\n if not isinstance(item, int):\\n return False\\n return item > 0\",\n \"def is_integer(i):\\n import numpy as np\\n if isinstance(i, (int, long)):\\n return True\\n if isinstance(i, float):\\n return (i).is_integer()\\n if issubclass(type(i), np.integer):\\n return i\\n else:\\n return False\",\n \"def test_args_count_equal(args: list, target: int) -> bool:\\n\\n\\treturn (args_count(args) == target)\",\n \"def operator_in(item: Result, container: Result) -> Result:\\n result: Result = celpy.celtypes.BoolType(False)\\n for c in cast(Iterable[Result], container):\\n try:\\n if c == item:\\n return celpy.celtypes.BoolType(True)\\n except TypeError as ex:\\n logger.debug(f\\\"operator_in({item}, {container}) --> {ex}\\\")\\n result = CELEvalError(\\\"no such overload\\\", ex.__class__, ex.args)\\n logger.debug(f\\\"operator_in({item!r}, {container!r}) = {result!r}\\\")\\n return result\",\n \"def is_int(value):\\n return isinstance(value, int)\",\n \"def _assert_valid_value_and_cast(self, value):\\n if not hasattr(value, '__iter__'):\\n raise AssertionError(f\\\"{value} is not a valid iterable type\\\")\\n return value\",\n \"def is_int(self, size=None):\\n return False\",\n \"def isInteger(data):\\n\\ttry:\\n\\t\\tfrom types import LongType, IntType\\n\\t\\tif type(data) == LongType or type(data) == IntType:\\n\\t\\t\\treturn True\\n\\texcept ImportError:\\n\\t\\tif type(data) == type(int(0)):\\n\\t\\t\\treturn True\\n\\treturn False\",\n \"def _is_all_int(df_list: List[Union[dd.DataFrame, pd.DataFrame]], col: str) -> bool:\\n for df in df_list:\\n if col in df.columns:\\n srs = df[col]\\n if isinstance(srs, (dd.DataFrame, pd.DataFrame)):\\n for dtype in srs.dtypes:\\n if not is_integer_dtype(dtype):\\n return False\\n elif isinstance(srs, (dd.Series, pd.Series)):\\n if not is_integer_dtype(srs.dtype):\\n return False\\n else:\\n raise ValueError(f\\\"unprocessed type of data:{type(srs)}\\\")\\n return True\",\n \"def is_integral(self):\\n return all(x in ZZ for x in self._representation_vector)\",\n \"def in_list(value, arg):\\r\\n return value in arg\",\n \"def isInteger(self):\\n return _libsbml.ASTNode_isInteger(self)\",\n \"def check_if_input_is_int(self):\\n try:\\n int(self.input)\\n except ValueError:\\n return False\\n else:\\n return True\",\n \"def equal(self, *args):\\n return _libsbml.SwigPyIterator_equal(self, *args)\",\n \"def isiterable(obj, classinfo=None, of_type=None):\\n if classinfo is not None:\\n if not isinstance(obj, classinfo):\\n return False\\n elif not hasattr(obj, '__iter__') and not hasattr(obj, '__getitem__'):\\n return False\\n if of_type is not None:\\n return all(isinstance(ele, of_type) for ele in obj)\\n return True\",\n \"def check_iterable(value):\\n try:\\n iter(value)\\n if not isinstance(value, six.string_types):\\n return True\\n else:\\n return False\\n except Exception as e:\\n pass\\n\\n return False\",\n \"def is_iterable_object(maybe_iterable: Any) -> TypeGuard[Iterable[Any]]:\\n\\n return isinstance(maybe_iterable, Iterable)\",\n \"def all_user(iterable):\\n for element in iterable:\\n if not element:\\n return False\\n return True\",\n \"def _is_single_range(r):\\n return (isinstance(r, numbers.Integral) or\\n (isinstance(r, collections.Sequence) and (len(r) == 2) and\\n _is_range_boundary(r[0]) and _is_range_boundary(r[1])))\",\n \"def check_all_iterable_values_equal(iterable):\\n return all(second_value_onwards == iterable[0] for second_value_onwards in iterable[1:])\",\n \"def any(self) -> int:\\n ...\",\n \"def is_sequence(value):\\n return (hasattr(value, \\\"__iter__\\\") and not\\n isinstance(value, (six.string_types, six.binary_type)))\",\n \"def _contains(self, element):\\n if not isinstance(element, Tuple) or len(element) != 2:\\n return S.false\\n\\n if not element[1].is_Integer:\\n return S.false\\n\\n if element[1] >= len(self.sets) or element[1] < 0:\\n return S.false\\n\\n return self.sets[element[1]]._contains(element[0])\",\n \"def is_in(elt, seq):\\n\\treturn any(x is elt for x in seq)\",\n \"def isInteger(self):\\n return self._is_int\",\n \"def indexists(list, *args): # Technically doesn't have to do with the screen, but it is very useful. \\n return all([int(arg) < len(list) for arg in args])\",\n \"def _is_sequence_like(self, data):\\n return hasattr(data, \\\"__iter__\\\") and hasattr(data, \\\"__getitem__\\\")\",\n \"def is_iterable(refobject):\\n is_iter = False\\n try:\\n for e in refobject: \\n break\\n is_iter = True\\n except:\\n pass\\n\\n return is_iter\",\n \"def is_int(self):\\n return self.v & 1 != 0\",\n \"def hasCorrectNumberArguments(self, *args):\\n return _libsbml.ASTBasePlugin_hasCorrectNumberArguments(self, *args)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6820437","0.68176305","0.6641058","0.6636341","0.6526343","0.6496134","0.6355871","0.6260515","0.62311673","0.62234855","0.6213004","0.61957854","0.6160951","0.6089377","0.6064915","0.6020444","0.60009134","0.5981801","0.5974256","0.596914","0.5965121","0.59427434","0.5904345","0.5840324","0.58266085","0.5820261","0.5808173","0.5774553","0.5761449","0.57570106","0.5746608","0.5746167","0.57446164","0.57446164","0.57210964","0.57145286","0.57141286","0.57012105","0.5699501","0.56880933","0.56764215","0.56741446","0.5641429","0.56090033","0.5605464","0.5601156","0.5582899","0.55643064","0.55611444","0.5559913","0.55354965","0.5510966","0.5501193","0.5492886","0.545869","0.54577905","0.5446587","0.5446272","0.5444816","0.54329205","0.54222965","0.5420525","0.5420262","0.5419984","0.5419324","0.5419324","0.5417846","0.54144216","0.54007024","0.5389604","0.5388609","0.5385773","0.5380712","0.53793514","0.5368442","0.5367622","0.53583646","0.5351963","0.53512424","0.53398633","0.53365177","0.5330039","0.532099","0.53095216","0.5305583","0.5303254","0.52941775","0.5290233","0.52789056","0.52772385","0.5274677","0.52528936","0.52525574","0.5250229","0.5248068","0.5245593","0.52437884","0.5238501","0.5222876","0.5210599"],"string":"[\n \"0.6820437\",\n \"0.68176305\",\n \"0.6641058\",\n \"0.6636341\",\n \"0.6526343\",\n \"0.6496134\",\n \"0.6355871\",\n \"0.6260515\",\n \"0.62311673\",\n \"0.62234855\",\n \"0.6213004\",\n \"0.61957854\",\n \"0.6160951\",\n \"0.6089377\",\n \"0.6064915\",\n \"0.6020444\",\n \"0.60009134\",\n \"0.5981801\",\n \"0.5974256\",\n \"0.596914\",\n \"0.5965121\",\n \"0.59427434\",\n \"0.5904345\",\n \"0.5840324\",\n \"0.58266085\",\n \"0.5820261\",\n \"0.5808173\",\n \"0.5774553\",\n \"0.5761449\",\n \"0.57570106\",\n \"0.5746608\",\n \"0.5746167\",\n \"0.57446164\",\n \"0.57446164\",\n \"0.57210964\",\n \"0.57145286\",\n \"0.57141286\",\n \"0.57012105\",\n \"0.5699501\",\n \"0.56880933\",\n \"0.56764215\",\n \"0.56741446\",\n \"0.5641429\",\n \"0.56090033\",\n \"0.5605464\",\n \"0.5601156\",\n \"0.5582899\",\n \"0.55643064\",\n \"0.55611444\",\n \"0.5559913\",\n \"0.55354965\",\n \"0.5510966\",\n \"0.5501193\",\n \"0.5492886\",\n \"0.545869\",\n \"0.54577905\",\n \"0.5446587\",\n \"0.5446272\",\n \"0.5444816\",\n \"0.54329205\",\n \"0.54222965\",\n \"0.5420525\",\n \"0.5420262\",\n \"0.5419984\",\n \"0.5419324\",\n \"0.5419324\",\n \"0.5417846\",\n \"0.54144216\",\n \"0.54007024\",\n \"0.5389604\",\n \"0.5388609\",\n \"0.5385773\",\n \"0.5380712\",\n \"0.53793514\",\n \"0.5368442\",\n \"0.5367622\",\n \"0.53583646\",\n \"0.5351963\",\n \"0.53512424\",\n \"0.53398633\",\n \"0.53365177\",\n \"0.5330039\",\n \"0.532099\",\n \"0.53095216\",\n \"0.5305583\",\n \"0.5303254\",\n \"0.52941775\",\n \"0.5290233\",\n \"0.52789056\",\n \"0.52772385\",\n \"0.5274677\",\n \"0.52528936\",\n \"0.52525574\",\n \"0.5250229\",\n \"0.5248068\",\n \"0.5245593\",\n \"0.52437884\",\n \"0.5238501\",\n \"0.5222876\",\n \"0.5210599\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75479543"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94299,"cells":{"query":{"kind":"string","value":"Initialize this dataset class."},"document":{"kind":"string","value":"def __init__(self, opt):\n BaseDataset.__init__(self, opt)\n self.A_paths = sorted(make_dataset(opt.dataroot, opt.max_dataset_size))\n input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc\n self.transform = get_transform(opt, grayscale=(input_nc == 1))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(self):\n self.__dataset = None","def __init__(self, dataset):\n self._dataset = dataset","def __init__(self, dataset: Dataset):\n self.dataset = dataset","def __init__(self, config):\n logger.info(f\"{self.__class__.__name__}: Dataset initializing ...\")\n super().__init__(config)","def __init__(self, **kwargs):\n DataLoader.__init__(self, **kwargs)\n \n self._results_ = None","def __init__(self):\n self.args = self._prepare_args(locals())\n self.requires_full_dataset_in_memory = False","def __init__(self, **kwargs):\n DataLoader.__init__(self, **kwargs)","def __init__(self):\n self.model = None\n self.joined_datasets = None\n self.id_col = None\n self.val_col = None\n self.pop_col = None\n self.total_population_per_unit = None\n self.centroids_of_areal_data = None\n self.prepared_data = None\n self.unknown_area_id = None\n\n # Parameters\n self.lags = None\n self.step = None\n self.min_no_of_observations = None\n self.max_search_radius = None","def __init__(self):\n self.data_file = ''\n self.data = pd.DataFrame()\n self.labels = pd.DataFrame()\n self.labels_onehot = pd.DataFrame()\n self.df = pd.DataFrame()\n self.df_perm = pd.DataFrame() # for debug purpose\n self.n_samples = 0\n self.n_features = 0\n self.label_dict = {}\n self.inv_label_dict = {}\n self.n_classes = 0\n self.batch_size = 0\n self.n_batch = 0\n self.current_batch_idx = 0\n self.true_distribution = []","def __init__(self, num_locations):\n self.dataset = {}\n self.num_locations = num_locations\n self.add_locations()","def _init_al_dataset(self):\n\n self._init_dataset()\n\n train_dataset = self.datasets['train']\n\n dataset_size = len(train_dataset)\n self.budget = math.ceil(self.budget_frac*dataset_size)\n Sampler.__init__(self, config, self.budget) # TODO: Weird place to initialise this\n\n all_indices = set(np.arange(dataset_size))\n k_initial = math.ceil(len(all_indices)*self.initial_budget_frac)\n initial_indices = random.sample(list(all_indices), k=k_initial)\n\n sampler_init = data.sampler.SubsetRandomSampler(initial_indices) # need to sample from training dataset\n\n self.labelled_dataloader = data.DataLoader(train_dataset, sampler=sampler_init, batch_size=self.batch_size, drop_last=True)\n self.val_dataloader = data.DataLoader(self.datasets['valid'], batch_size=self.batch_size, drop_last=False)\n self.test_dataloader = data.DataLoader(self.datasets['test'], batch_size=self.batch_size, drop_last=False)\n\n return all_indices, initial_indices","def __init__(self, data_set):\r\n self.name = data_set\r\n\r\n # The training and test labels\r\n self.labels = {'train': None, 'test': None}\r\n\r\n # The training and test examples\r\n self.examples = {'train': None, 'test': None}\r\n\r\n # Load all the data for this data set\r\n for data in ['train', 'test']:\r\n self.load_file(data)\r\n\r\n # The shape of the training and test data matrices\r\n self.num_train = self.examples['train'].shape[0]\r\n self.num_test = self.examples['test'].shape[0]\r\n self.dim = self.examples['train'].shape[1]","def __init__(self):\n print ('Initializing Data reader object...')\n data_Train_Images, data_Train_Labels, data_Test_Image, data_Test_Labels = self.readDataFromFile()\n test_10k_x, test_10k_y, training_55k_x, training_55k_y, validation_5k_x, validation_5k_y = self.dataTransform(\n data_Test_Image, data_Test_Labels, data_Train_Images, data_Train_Labels)\n self.train = zip(training_55k_x, training_55k_y)\n self.valid = zip(validation_5k_x, validation_5k_y)\n self.test = zip(test_10k_x, test_10k_y)\n\n self.train_position = 0\n print ('Initialized!')","def __init__(self):\n\n self.check_nans = False\n self.debug_force_memmap = False\n\n # Implementations must initialise the dtype so that feature arrays can be created with correct type:\n self.dtype = None","def __init__(self, *, dataset=None, aliases=None):\n self._datasets = [] if dataset is None else [dataset]\n self._aliases = {} if aliases is None else {a: 0 for a in aliases}\n self._default_index = 0","def __init__(self):\n\t\tsuper().__init__()\n\t\t\n\t\t# Typically a list of data here\n\t\t# Typically a dict of header keys and values here","def __init__(self):\n self._distance_data = []\n self._location_data = []\n self._package_data = []","def __init__(self, data):\n self.data = data\n self.columns = Columns(data)\n self.rows = Rows(data)","def init(*args):\n global dataset\n dataset = args[0]","def _init_from_DataArrays(self, data, validate=True):\n self._data_vars = self._DataArrays_as_mapping(data)\n\n if (len(self) > 1) and validate:\n first = self[0]\n for i in range(1, len(self)):\n da = self[i]\n first._is_compatible(da, raise_error=True)\n\n self._check_all_different_ids(self._data_vars.values())\n\n self.__itemattr = []\n for key, value in self._data_vars.items():\n self._set_name_attr(key, value)\n\n self.plot = _DatasetPlotter(self)\n\n if len(self) > 0:\n self._set_spectral_attributes(self.geometry)\n\n # since Dataset is MutableMapping it has values and keys by default\n # but we delete those to avoid confusion\n # self.values = None\n self.keys = None","def __init__(self, path: str = './') -> None:\n super(DataHandler, self).__init__()\n self.path = path\n self.dataset = None # type: str\n self._file_format = None # type: str\n self._max_file_count = 0","def setUp(self):\n self.dataset = self.dataset_cls()","def __init__(self, data_dict, mode):\n self.data_dict = data_dict\n self.mode = mode\n\n #Get the data\n self.input_data = data_dict[\"input\"]\n self.output_data = data_dict[\"output\"]\n self.num_samples = self.input_data.shape[0]","def __init__(self, dataset):\n\n if isinstance(dataset, DataConfig):\n self.__data_config = dataset\n self.dataset = dataset.dataset\n elif isinstance(dataset, str):\n logger.debug(\"Dataset argument {} is string, looking up known dataset.\".format(dataset))\n self.__data_config = DataConfig.known_dataset(dataset)\n self.dataset = dataset\n else:\n raise ValueError(\"Argument 'dataset' must be of type DataConfig or str.\")","def __init__(\n self,\n path,\n tier,\n embeddings=None,\n preprocessor=None,\n transform=True):\n super().__init__()\n assert os.path.isdir(path)\n assert os.path.exists(os.path.join(path, f'{tier}.csv'))\n assert tier in self.TIERS\n\n self.path = path\n self.tier = tier\n self.data = None\n self.embeddings = embeddings\n self.preprocessor = preprocessor\n self.is_transform = transform\n self._init_dataset()","def _init_data(self, data):\n assert type(data) is dict, \"dict expected: %r\" % type(data)\n assert len(data) is 1, \"size of dict should be 1: %r\" % len(data)\n self._name = data.keys()[0]\n self._data = np.asarray(data[self._name])\n self._set = True","def __init__(self):\n self.relation = ''\n self.attributes = []\n self.attribute_types = dict()\n self.attribute_data = dict()\n self.comment = []\n self.data = []\n pass","def initialize(self):\n raise NotImplementedError","def initialize(self):\n raise NotImplementedError","def initialize(self):\n raise NotImplementedError","def __init__(self):\n\n data_extract=DataExtracter()\n self.data = tuple()","def initialize(self):\n self.data = None\n self.errors = []","def __init__(self):\n self.data_set = []\n self.finalized_data = LogData()","def init(self):\n raise NotImplementedError","def init(self):\n raise NotImplementedError","def __init__(self, opt):\n BaseDataset.__init__(self, opt)\n\n self.data_folder = os.path.join(opt.dataroot, opt.phase)\n self.image_file_names = sorted(os.listdir(self.data_folder))\n self.batch_size = opt.batch_size\n self.z_dim = opt.z_dim\n self.imsize = opt.crop_size\n\n self.transform = self.get_transform(True, True, True, opt.center_crop)","def __init__(self, dat):\n self.data = dat","def __init__(self, datasets=[], summaries=[], ordinal_columns=[]):\r\n if not datasets:\r\n raise ValueError(\"Parameter datasets is empty. A list of Datasets is required.\")\r\n self.datasets = datasets\r\n if not summaries:\r\n raise ValueError(\"Parameter summaries[] is empty. A list of Summary objects is required.\")\r\n self.summaries = summaries\r\n # future- add checking here that each dataset has the column names\r\n # required by each summary,\r\n # and same for ordinal_columns when they are implemented. \r\n # Or do checking in Dataset().\r","def __init__(self, opt):\n BaseDataset.__init__(self, opt)\n\n self.img_paths = glob.glob(os.path.join(opt.dataroot, '{}_image'.format(opt.phase), '*.png'))\n self.segment_dir = os.path.join(opt.dataroot, '{}_segment'.format(opt.phase))\n self.edge_dir = os.path.join(opt.dataroot, '{}_edge'.format(opt.phase))\n self.centerline_dir = os.path.join(opt.dataroot, '{}_centerline'.format(opt.phase))\n\n self.img_transforms = transforms.Compose([transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5),\n (0.5, 0.5, 0.5))])\n self.lab_transform = MaskToTensor()","def __init__(self, opt):\n BaseDataset.__init__(self, opt)\n self.SR_factor = opt.SR_factor\n\n assert util_dataset.check_whether_last_dir(opt.dataroot), 'when SingleDataset, opt.dataroot:{} should be dir and contains only image files'.format(opt.dataroot)\n self.dir_A = opt.dataroot\n self.A_paths = sorted(make_images_dataset(self.dir_A, opt.max_dataset_size)) # get image paths\n\n self.input_nc = self.opt.input_nc\n self.output_nc = self.opt.output_nc","def __init__(self,dataset=scripts,group=\"\"):\n self.dataset = dataset\n self.group=group","def __init__(self, dataset_path):\n super(TorchData, self).__init__()\n self.dataset = h5py.File(dataset_path, 'r')\n self.bg = self.dataset['bg']\n self.vocal = self.dataset['vocal']\n self.mix = self.dataset['mix']\n self.len = self.bg.shape[0]","def initialize(self) -> None:\n pass","def __init__(self):\n #---+----|----+----|----+----|----+----|----+----|----+----|----+----|\n NexusReaderBase.__init__(self, -1)\n self.taxa = None\n self._data_matrices = None","def __init__(self, dir_path, window_size,\n user_map_path, computer_map_path, auth_type_map_path, logon_type_map_path):\n logging.info(f\"Initiating Dataset instance for directory {dir_path}\")\n self.directory = dir_path\n self.filenames = [filename for filename in os.listdir(dir_path) if os.path.isfile(os.path.join(dir_path, filename))]\n assert len(self.filenames) > 0\n random.shuffle(self.filenames)\n self.window_size = window_size\n self.len = self.count_len()\n self.user_map, self.user_count = util.load_mapping(user_map_path)\n self.computer_map, self.computer_count = util.load_mapping(computer_map_path)\n self.auth_type_map, self.auth_type_count = util.load_mapping(auth_type_map_path)\n self.logon_type_map, self.logon_type_count = util.load_mapping(logon_type_map_path)","def __init__(self):\n self.data_set_loc = conf.config_section_mapper(\"filePath\").get(\"data_set_loc\")\n self.data_extractor = DataExtractor(self.data_set_loc)","def __init__(self, datafiles, plotter):\n self.datafiles = datafiles\n self.datasets = dict()\n self.plotter = plotter","def __init__(self, dataset: ds.Dataset, settings):\r\n self.dataset = dataset\r\n self.settings = settings\r\n\r\n self.visualizer = visualizer.Visualizer()","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def _init_data(self) -> None:\n self.dtype = dict()\n self.shape = dict()\n self.size = dict()\n self.attrs = dict()\n self.data_ptr = dict()\n\n if self.mode == 'r':\n for k in self.fp.keys():\n self.dtype[k] = self.fp[k].dtype\n self.shape[k] = self.fp[k].shape\n self.size[k] = self.fp[k].shape[0]\n self.data_ptr[k] = 0","def __init__(self, df):\n self.data = df","def __init__(self, name_dataset, reduce=False):\n dataset = TUDataset(root='data/TUDataset', name=name_dataset)\n if reduce:\n new_dataset = []\n for i in tqdm(range(len(dataset))):\n aux_graph = copy.deepcopy(dataset[i])\n aux_graph.edge_index = TUDData.reduce_edges(aux_graph.edge_index)\n new_dataset.append(copy.deepcopy(aux_graph))\n dataset = WrapperSynthetic(new_dataset, dataset.num_node_features,\n dataset.num_classes, None)\n super(TUDData, self).__init__(dataset)","def _initialize_data(self):\n self.unique_id = 123\n\n self.gas_valve_open = False\n self.buffer_valve_open = False\n self.pump_valve_open = False\n\n self.operatingmode = 0\n\n self.sample_pressure_high_limit = 100\n self.sample_pressure_low_limit = 10\n self.sample_pressure = 0\n\n self.error = 0\n\n self.buffer_pressure_high = True","def __init__(self, dataset_name, split, num_shards, data_dir,\n filetype_suffix=None):\n self.dataset_name = dataset_name\n self.split = split\n self.num_shards = num_shards\n self.data_dir = data_dir\n self.filetype_suffix = filetype_suffix","def __init__(\n self,\n embedder_path: Optional[str] = None,\n dataset: Optional[np.ndarray] = None,\n metadata: Optional[List[AnyStr]] = None,\n ) -> None:\n self._embedder_path = embedder_path\n\n # Cache dataset list which can be concatenated to the single dataset. This\n # is used since users may load the data several times, if each time the data\n # are directly concatenated together, memory copy will be costed each time.\n self._cache_dataset_list = []\n\n if dataset is None:\n # Sets dataset and metadata as empty. Will load them from raw input data\n # later.\n self._dataset = np.array([])\n self._metadata = []\n else:\n # Directly sets dataset and metadata.\n self._dataset = dataset\n self._metadata = metadata","def __init__(self) -> None:\n\n self.train_env = None # Training environment\n self.agent = None # The algorithm used to solve an RL problem is represented by a TF-Agent\n self.replay_buffer = None # The replay buffer keeps track of data collected from the environment\n self.dataset = None # The agent needs access to the replay buffer via an iterable tf.data.Dataset\n self.iterator = None # The iterator of self.dataset","def __init__(self, subset):\n if subset not in ('background', 'evaluation'):\n raise(ValueError, 'subset must be one of (background, evaluation)')\n self.subset = subset\n\n self.df = pd.DataFrame(self.index_subset(self.subset))\n\n # Index of dataframe has direct correspondence to item in dataset\n self.df = self.df.assign(id=self.df.index.values)\n\n # Convert arbitrary class names of dataset to ordered 0-(num_speakers - 1) integers\n self.unique_characters = sorted(self.df['class_name'].unique())\n self.class_name_to_id = {self.unique_characters[i]: i for i in range(self.num_classes())}\n self.df = self.df.assign(class_id=self.df['class_name'].apply(lambda c: self.class_name_to_id[c]))\n\n # Create dicts\n self.datasetid_to_filepath = self.df.to_dict()['data']\n self.datasetid_to_class_id = self.df.to_dict()['class_id']","def __init__(self, subset):\n if subset not in ('background', 'evaluation'):\n raise(ValueError, 'subset must be one of (background, evaluation)')\n self.subset = subset\n\n self.df = pd.DataFrame(self.index_subset(self.subset))\n\n # Index of dataframe has direct correspondence to item in dataset\n self.df = self.df.assign(id=self.df.index.values)\n\n # Convert arbitrary class names of dataset to ordered 0-(num_speakers - 1) integers\n self.unique_characters = sorted(self.df['class_name'].unique())\n self.class_name_to_id = {self.unique_characters[i]: i for i in range(self.num_classes())}\n self.df = self.df.assign(class_id=self.df['class_name'].apply(lambda c: self.class_name_to_id[c]))\n\n # Create dicts\n self.datasetid_to_filepath = self.df.to_dict()['data']\n self.datasetid_to_class_id = self.df.to_dict()['class_id']","def __init__(self, subset):\n if subset not in ('background', 'evaluation'):\n raise(ValueError, 'subset must be one of (background, evaluation)')\n self.subset = subset\n\n self.df = pd.DataFrame(self.index_subset(self.subset))\n\n # Index of dataframe has direct correspondence to item in dataset\n self.df = self.df.assign(id=self.df.index.values)\n\n # Convert arbitrary class names of dataset to ordered 0-(num_speakers - 1) integers\n self.unique_characters = sorted(self.df['class_name'].unique())\n self.class_name_to_id = {self.unique_characters[i]: i for i in range(self.num_classes())}\n self.df = self.df.assign(class_id=self.df['class_name'].apply(lambda c: self.class_name_to_id[c]))\n\n # Create dicts\n self.datasetid_to_filepath = self.df.to_dict()['data']\n self.datasetid_to_class_id = self.df.to_dict()['class_id']","def __init__(self, subset):\n if subset not in ('background', 'evaluation'):\n raise(ValueError, 'subset must be one of (background, evaluation)')\n self.subset = subset\n\n self.df = pd.DataFrame(self.index_subset(self.subset))\n\n # Index of dataframe has direct correspondence to item in dataset\n self.df = self.df.assign(id=self.df.index.values)\n\n # Convert arbitrary class names of dataset to ordered 0-(num_speakers - 1) integers\n self.unique_characters = sorted(self.df['class_name'].unique())\n self.class_name_to_id = {self.unique_characters[i]: i for i in range(self.num_classes())}\n self.df = self.df.assign(class_id=self.df['class_name'].apply(lambda c: self.class_name_to_id[c]))\n\n # Create dicts\n self.datasetid_to_filepath = self.df.to_dict()['filepath']\n self.datasetid_to_class_id = self.df.to_dict()['class_id']","def initialize(self):\r\n pass","def initialize(self):\r\n pass","def __init__(self, opt):\n BaseDataset.__init__(self, opt)\n self.dir_images = os.path.join(opt.dataroot, opt.phase) # get the image directory\n self.image_paths = sorted(make_dataset(self.dir_images, opt.max_dataset_size)) # get image paths\n assert(self.opt.load_size >= self.opt.crop_size) # crop_size should be smaller than the size of loaded image\n self.input_nc = self.opt.output_nc\n self.output_nc = self.opt.input_nc","def initialize(self):\n\t\tpass","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","def init(self):\n pass","def __init__(self, parameters: jnp.ndarray):\n\n # Note that this method is implicitly overriden by the dataclass decorator and\n # should _not_ be marked abstract.\n raise NotImplementedError()","def initialise_dataset_loader(\n self, data_param=None, task_param=None, data_partitioner=None):\n raise NotImplementedError","def _create_init(self):\n\n assert self._topology is not None, \\\n \"Topology must be given for a creation constructor\"\n\n # initialize the runs group\n runs_grp = self._h5.create_group(RUNS)\n\n # initialize the settings group\n settings_grp = self._h5.create_group(SETTINGS)\n\n # create the topology dataset\n self._h5.create_dataset(TOPOLOGY, data=self._topology)\n\n # sparse fields\n if self._sparse_fields is not None:\n\n # make a dataset for the sparse fields allowed. this requires\n # a 'special' datatype for variable length strings. This is\n # supported by HDF5 but not numpy.\n vlen_str_dt = h5py.special_dtype(vlen=str)\n\n # create the dataset with empty values for the length of the\n # sparse fields given\n sparse_fields_ds = settings_grp.create_dataset(SPARSE_FIELDS,\n (len(self._sparse_fields),),\n dtype=vlen_str_dt,\n maxshape=(None,))\n\n # set the flags\n for i, sparse_field in enumerate(self._sparse_fields):\n sparse_fields_ds[i] = sparse_field\n\n\n # field feature shapes and dtypes\n\n # initialize to the defaults, this gives values to\n # self._n_coords, and self.field_feature_dtypes, and\n # self.field_feature_shapes\n self._set_default_init_field_attributes(n_dims=self._n_dims)\n\n # save the number of dimensions and number of atoms in settings\n settings_grp.create_dataset(N_DIMS_STR, data=np.array(self._n_dims))\n settings_grp.create_dataset(N_ATOMS, data=np.array(self._n_coords))\n\n # the main rep atom idxs\n settings_grp.create_dataset(MAIN_REP_IDXS, data=self._main_rep_idxs, dtype=int)\n\n # alt_reps settings\n alt_reps_idxs_grp = settings_grp.create_group(ALT_REPS_IDXS)\n for alt_rep_name, idxs in self._alt_reps.items():\n alt_reps_idxs_grp.create_dataset(alt_rep_name, data=idxs, dtype=int)\n\n # if both feature shapes and dtypes were specified overwrite\n # (or initialize if not set by defaults) the defaults\n if (self._field_feature_shapes_kwarg is not None) and\\\n (self._field_feature_dtypes_kwarg is not None):\n\n self._field_feature_shapes.update(self._field_feature_shapes_kwarg)\n self._field_feature_dtypes.update(self._field_feature_dtypes_kwarg)\n\n # any sparse field with unspecified shape and dtype must be\n # set to None so that it will be set at runtime\n for sparse_field in self.sparse_fields:\n if (not sparse_field in self._field_feature_shapes) or \\\n (not sparse_field in self._field_feature_dtypes):\n self._field_feature_shapes[sparse_field] = None\n self._field_feature_dtypes[sparse_field] = None\n\n\n # save the field feature shapes and dtypes in the settings group\n shapes_grp = settings_grp.create_group(FIELD_FEATURE_SHAPES_STR)\n for field_path, field_shape in self._field_feature_shapes.items():\n if field_shape is None:\n # set it as a dimensionless array of NaN\n field_shape = np.array(np.nan)\n\n shapes_grp.create_dataset(field_path, data=field_shape)\n\n dtypes_grp = settings_grp.create_group(FIELD_FEATURE_DTYPES_STR)\n for field_path, field_dtype in self._field_feature_dtypes.items():\n if field_dtype is None:\n dt_str = NONE_STR\n else:\n # make a json string of the datatype that can be read\n # in again, we call np.dtype again because there is no\n # np.float.descr attribute\n dt_str = json.dumps(np.dtype(field_dtype).descr)\n\n dtypes_grp.create_dataset(field_path, data=dt_str)\n\n # initialize the units group\n unit_grp = self._h5.create_group(UNITS)\n\n # if units were not given set them all to None\n if self._units is None:\n self._units = {}\n for field_path in self._field_feature_shapes.keys():\n self._units[field_path] = None\n\n # set the units\n for field_path, unit_value in self._units.items():\n\n # ignore the field if not given\n if unit_value is None:\n continue\n\n unit_path = '{}/{}'.format(UNITS, field_path)\n\n unit_grp.create_dataset(unit_path, data=unit_value)\n\n\n # create the group for the run data records\n records_grp = settings_grp.create_group(RECORD_FIELDS)\n\n # create a dataset for the continuation run tuples\n # (continuation_run, base_run), where the first element\n # of the new run that is continuing the run in the second\n # position\n self._init_continuations()","def __init__(self, **kwargs):\n is_training = kwargs.get('is_training', True)\n rootfolder = kwargs['rootfolder']\n dtype = kwargs.get('dtype', np.float64)\n self._load_mnist(rootfolder, is_training, dtype)\n # normalize data.\n self._data /= 255.\n ndarraydata.NdarrayDataLayer.__init__(\n self, sources=[self._data, self._label], **kwargs)","def __init__(self, opt):\n BaseDataset.__init__(self, opt)\n self.dir_A = opt.dataroot\n self.classes_A, self.class_to_idx_A = self._find_classes(self.dir_A) # find classes in '/path/to/data/trainA'\n samples_A = make_dataset(self.dir_A, self.class_to_idx_A, extensions=self.img_extension, is_valid_file=None) # samples (list): List of (sample path, class_index) tuples\n self.A_paths = [s[0] for s in samples_A]\n self.A_targets = [s[1] for s in samples_A]\n #self.A_paths = sorted(make_dataset(opt.dataroot, opt.max_dataset_size))\n input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc\n self.transform = get_transform(opt, grayscale=(input_nc == 1))","def __init__(self, directory):\n self._path = os.path.join(\"../../datasets\", directory)\n self.airlines = pd.read_csv(os.path.join(self._path, 'airlines.csv'))\n self.airports = pd.read_csv(os.path.join(self._path, 'airports.csv'))\n self.planes = pd.read_csv(os.path.join(self._path, 'planes.csv'))\n self.countries = pd.read_csv(os.path.join(self._path, 'countries.csv'))\n self.routes = pd.read_csv(os.path.join(self._path, 'routes.csv'))\n self._CreateGraph()","def __init__(self, annotation_file=None):\n # load dataset\n self.dataset,self.anns,self.cats,self.imgs = dict(),dict(),dict(),dict()\n self.imgToAnns, self.catToImgs = defaultdict(list), defaultdict(list)\n if not annotation_file == None:\n print('loading annotations into memory...')\n tic = time.time()\n dataset = json.load(open(annotation_file, 'r'))\n assert type(dataset)==dict, 'annotation file format {} not supported'.format(type(dataset))\n print('Done (t={:0.2f}s)'.format(time.time()- tic))\n self.dataset = dataset\n self.createIndex()","def initialize(self):\n LOG.info(\"Initializing Model.\")\n self.model = self.convert(df=self.training_df)\n if self.bootstraps is not None:\n LOG.info(\"Bootstrapping Data.\")\n self.bootstrap_data()","def __init__(self, subset):\n if subset not in ('background', 'evaluation'):\n raise(ValueError, 'subset must be one of (background, evaluation)')\n self.subset = subset\n\n self.df = pd.DataFrame(self.index_subset(self.subset))\n\n # Index of dataframe has direct correspondence to item in dataset\n self.df = self.df.assign(id=self.df.index.values)\n\n # Convert arbitrary class names of dataset to ordered 0-(num_speakers - 1) integers\n self.unique_characters = sorted(self.df['class_name'].unique())\n self.class_name_to_id = {self.unique_characters[i]: i for i in range(self.num_classes())}\n self.df = self.df.assign(class_id=self.df['class_name'].apply(lambda c: self.class_name_to_id[c]))\n\n # Create dicts\n self.datasetid_to_filepath = self.df.to_dict()['filepath']\n self.datasetid_to_class_id = self.df.to_dict()['class_id']\n\n # Setup transforms\n self.transform = transforms.Compose([\n transforms.CenterCrop(224),\n transforms.Resize(84),\n transforms.ToTensor(),\n transforms.Normalize(mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225])\n ])","def __init__(self, *args, **kwargs):\n # Training/prediction data volume\n self.train_volume: np.ndarray = None\n # Training label volume\n self.train_label_volume: Optional[np.ndarray] = None\n # Per-voxel training error weighting volume\n self.train_weight_volume: Optional[np.ndarray] = None\n # Validation data volume\n self.eval_volume: Optional[np.ndarray] = None\n # Validation label volume\n self.eval_label_volume: Optional[np.ndarray] = None\n\n # Number of label classes\n self.n_classes: int = None\n\n # RandomState used to control random number generation\n self.random_state = np.random.RandomState()\n\n # Image augmentation instance_settings for use during training\n self.augmentation_settings: Dict[str, Any] = None\n\n # Load data if arguments are supplied\n if len(args) > 0 or len(kwargs) > 0:\n self.load(*args, **kwargs)\n\n pass","def __init__(self, num_detectors):\n self.dataset = []\n self.num_detectors = num_detectors\n self.add_detectors()","def __init__(self):\n self.X = None\n self.Y = None\n self.features = None\n self.max = self.min = None\n self._look_up = None\n self.attr_weight = None","def initialize(self):\n self.initialize_edges()\n self.initialize_prob()\n self.initialize_total_input_dict()\n\n self.initialize_fpmusigv_dict()","def __init__(self, *args, **kwargs):\n ignore_version = kwargs.pop('ignore_version', False)\n\n super(Hdf5, self).__init__(*args, **kwargs)\n\n # If True, always translate __getitem__ requests according to the\n # schema, even if __getitem__ requests a dataset that exists\n self.always_translate = False\n\n self._version = self.attrs.get('version')\n if isinstance(self._version, bytes):\n self._version = self._version.decode()\n self._timesteps = {}\n\n # Connect the schema map to this object\n if self._version in SCHEMA:\n self.schema = SCHEMA[self._version]\n elif self._version is None:\n self.schema = {}\n elif not ignore_version:\n raise KeyError(\"Unknown schema version %s\" % self._version)\n\n # Connect the schema dataset providers to this object\n if self._version in SCHEMA_DATASET_PROVIDERS:\n self.dataset_providers = SCHEMA_DATASET_PROVIDERS[self._version]\n else:\n self.dataset_providers = {}","def __init__(self, path='data'):\r\n self.nb_data = 3\r\n self.path = path\r\n self.data_train_name = 'Xtr'\r\n self.data_test_name = 'Xte'\r\n self.features_name = '_mat100'\r\n self.label_train_name = 'Ytr'\r\n self.label_test_name = 'Ytr'\r\n # load raw data\r\n self.raw_data = {'train': self.load_data(self.data_train_name),\r\n 'test': self.load_data(self.data_test_name)}\r\n # load data features\r\n self.data_features = {'train': self.load_data(self.data_train_name, self.features_name, type_='features'),\r\n 'test': self.load_data(self.data_test_name, self.features_name, type_='features')}\r\n # load labels\r\n self.labels = {'train': self.load_data(self.label_train_name),\r\n 'test': self.load_data(self.label_test_name)}\r\n\r\n # toy data\r\n self.toy_data_functions = {\r\n 'blobs': blobs,\r\n 'two_moons': two_moons\r\n }\r\n self.toy_data = dict()","def __init__(self,data):\n\t\tself.data = tuple([tuple(x) if isiterable(x) else (x,) for x in data])\n\t\tself.rows = len(self.data)\n\t\tself.cols = len(self.data[0]) if len(self.data)>0 else 0","def _init(self):\n raise NotImplementedError","def __init__(self, data=None, filename=None, schema=None):\n self.data = None\n self.schema = None\n self.filename = None\n if schema:\n self.load_schema(schema)\n if filename:\n self.load_file(filename)\n if data:\n self.load_data(data)","def __initialize(self):\n\t\tself.matrix = [None] * self.size\n\t\tself.__get_log_values()\n\t\tfor row in range(self.size):\n\t\t\tself.matrix[row] = [None] * self.size\n\t\tmax_len = self.__get_max_length()\n\t\tdata = self.__get_data(self.text,max_len)\n\t\tmpoly = self.__get_mpoly(data)\n\t\tgpoly = self.__get_gploy()\n\t\tself.final_data = self.__get_final_data(mpoly,gpoly)\n\t\tself.__set_FIP(FP_num = 1)\n\t\tself.__set_FIP(FP_num = 2)\n\t\tself.__set_FIP(FP_num = 3)\n\t\tself.__set_AP()\n\t\tself.__fill_format_info_area()\n\t\tself.__set_TP()","def __init__(self, opt):\n BaseDataset.__init__(self, opt)\n self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A') # create a path '/path/to/data/trainA'\n self.dir_B = os.path.join(opt.dataroot, opt.phase + 'B') # create a path '/path/to/data/trainB'\n\n self.A_paths = sorted(make_dataset(self.dir_A, opt.max_dataset_size)) # load images from '/path/to/data/trainA'\n self.B_paths = sorted(make_dataset(self.dir_B, opt.max_dataset_size)) # load images from '/path/to/data/trainB'\n self.A_size = len(self.A_paths) # get the size of dataset A\n self.B_size = len(self.B_paths) # get the size of dataset B\n btoA = self.opt.direction == 'BtoA'\n input_nc = self.opt.output_nc if btoA else self.opt.input_nc # get the number of channels of input image\n output_nc = self.opt.input_nc if btoA else self.opt.output_nc # get the number of channels of output image\n self.transform_A = get_transform(self.opt, grayscale=(input_nc == 1))\n self.transform_B = get_transform(self.opt, grayscale=(output_nc == 1))","def __init__(self):\n # Calls super constructor:\n super().__init__()\n\n # This list holds all the information for computing each 'group' of features:\n self.features_group_list = []","def __init__(self, file, sdef, name, path, attrs, parent, value, dtype, compress, link_info=None):\n super(Dataset, self).__init__(file, sdef, name, path, attrs, parent, link_info)\n # print \"Creating Dataset, sdef=\"\n # pp.pprint(sdef)\n if 'attributes' in self.sdef['df']:\n self.attributes = copy.deepcopy(self.sdef['df']['attributes'])\n # del self.sdef['df']['attributes'] # if do this, no need to check for attributes in mk_dsinfo\n # print \"found attributes:\"\n # else:\n # print \"did not find attributes:\"\n # pp.pprint(self.attributes)\n # if self.sdef['df']:\n self.dsinfo = self.mk_dsinfo(value)\n self.merge_attribute_defs(self.attributes, self.dsinfo['atags'])\n # else:\n # definition empty, must be custom dataset\n # self.dsinfo = {}\n self.merge_attrs()\n if self.link_info:\n # this dataset set to link to another. Already done in Node. Nothing to do here\n pass\n else:\n # creating new dataset (normally done)\n self.link_node = None\n # compress = \"gzip\" if compress else None\n # self.h5node = self.h5parent.create_dataset(self.name, data=value,\n # dtype=dtype, compression=compress)\n #- self.file.file_pointer.create_dataset(self.full_path, data=value,\n #- dtype=dtype, compression=compress)\n self.file.create_dataset(self.full_path, data=value, dtype=dtype,\n compress=compress)\n # self.file.h5commands.append(\"create_dataset(%s, %s)\" % (self.full_path, value))\n # if dtype:\n # self.h5node = self.h5parent.create_dataset(self.name, data=value, dtype=dtype)\n # else: # should find out what default value for dtype used in h5py and use that, combine these\n # self.h5node = self.h5parent.create_dataset(self.name, data=value)\n self.set_attr_values()","def _initialize_data(self):\n self.reset_count = 0\n self._idn_no_firmware = \"KEPCO,BOP 50-20,E1234,\"\n self._firmware = 2.6\n self._init_data()","def init(self, **kwargs):\n self._d = {}\n self._th = None\n self._run = True\n self.load()"],"string":"[\n \"def __init__(self):\\n self.__dataset = None\",\n \"def __init__(self, dataset):\\n self._dataset = dataset\",\n \"def __init__(self, dataset: Dataset):\\n self.dataset = dataset\",\n \"def __init__(self, config):\\n logger.info(f\\\"{self.__class__.__name__}: Dataset initializing ...\\\")\\n super().__init__(config)\",\n \"def __init__(self, **kwargs):\\n DataLoader.__init__(self, **kwargs)\\n \\n self._results_ = None\",\n \"def __init__(self):\\n self.args = self._prepare_args(locals())\\n self.requires_full_dataset_in_memory = False\",\n \"def __init__(self, **kwargs):\\n DataLoader.__init__(self, **kwargs)\",\n \"def __init__(self):\\n self.model = None\\n self.joined_datasets = None\\n self.id_col = None\\n self.val_col = None\\n self.pop_col = None\\n self.total_population_per_unit = None\\n self.centroids_of_areal_data = None\\n self.prepared_data = None\\n self.unknown_area_id = None\\n\\n # Parameters\\n self.lags = None\\n self.step = None\\n self.min_no_of_observations = None\\n self.max_search_radius = None\",\n \"def __init__(self):\\n self.data_file = ''\\n self.data = pd.DataFrame()\\n self.labels = pd.DataFrame()\\n self.labels_onehot = pd.DataFrame()\\n self.df = pd.DataFrame()\\n self.df_perm = pd.DataFrame() # for debug purpose\\n self.n_samples = 0\\n self.n_features = 0\\n self.label_dict = {}\\n self.inv_label_dict = {}\\n self.n_classes = 0\\n self.batch_size = 0\\n self.n_batch = 0\\n self.current_batch_idx = 0\\n self.true_distribution = []\",\n \"def __init__(self, num_locations):\\n self.dataset = {}\\n self.num_locations = num_locations\\n self.add_locations()\",\n \"def _init_al_dataset(self):\\n\\n self._init_dataset()\\n\\n train_dataset = self.datasets['train']\\n\\n dataset_size = len(train_dataset)\\n self.budget = math.ceil(self.budget_frac*dataset_size)\\n Sampler.__init__(self, config, self.budget) # TODO: Weird place to initialise this\\n\\n all_indices = set(np.arange(dataset_size))\\n k_initial = math.ceil(len(all_indices)*self.initial_budget_frac)\\n initial_indices = random.sample(list(all_indices), k=k_initial)\\n\\n sampler_init = data.sampler.SubsetRandomSampler(initial_indices) # need to sample from training dataset\\n\\n self.labelled_dataloader = data.DataLoader(train_dataset, sampler=sampler_init, batch_size=self.batch_size, drop_last=True)\\n self.val_dataloader = data.DataLoader(self.datasets['valid'], batch_size=self.batch_size, drop_last=False)\\n self.test_dataloader = data.DataLoader(self.datasets['test'], batch_size=self.batch_size, drop_last=False)\\n\\n return all_indices, initial_indices\",\n \"def __init__(self, data_set):\\r\\n self.name = data_set\\r\\n\\r\\n # The training and test labels\\r\\n self.labels = {'train': None, 'test': None}\\r\\n\\r\\n # The training and test examples\\r\\n self.examples = {'train': None, 'test': None}\\r\\n\\r\\n # Load all the data for this data set\\r\\n for data in ['train', 'test']:\\r\\n self.load_file(data)\\r\\n\\r\\n # The shape of the training and test data matrices\\r\\n self.num_train = self.examples['train'].shape[0]\\r\\n self.num_test = self.examples['test'].shape[0]\\r\\n self.dim = self.examples['train'].shape[1]\",\n \"def __init__(self):\\n print ('Initializing Data reader object...')\\n data_Train_Images, data_Train_Labels, data_Test_Image, data_Test_Labels = self.readDataFromFile()\\n test_10k_x, test_10k_y, training_55k_x, training_55k_y, validation_5k_x, validation_5k_y = self.dataTransform(\\n data_Test_Image, data_Test_Labels, data_Train_Images, data_Train_Labels)\\n self.train = zip(training_55k_x, training_55k_y)\\n self.valid = zip(validation_5k_x, validation_5k_y)\\n self.test = zip(test_10k_x, test_10k_y)\\n\\n self.train_position = 0\\n print ('Initialized!')\",\n \"def __init__(self):\\n\\n self.check_nans = False\\n self.debug_force_memmap = False\\n\\n # Implementations must initialise the dtype so that feature arrays can be created with correct type:\\n self.dtype = None\",\n \"def __init__(self, *, dataset=None, aliases=None):\\n self._datasets = [] if dataset is None else [dataset]\\n self._aliases = {} if aliases is None else {a: 0 for a in aliases}\\n self._default_index = 0\",\n \"def __init__(self):\\n\\t\\tsuper().__init__()\\n\\t\\t\\n\\t\\t# Typically a list of data here\\n\\t\\t# Typically a dict of header keys and values here\",\n \"def __init__(self):\\n self._distance_data = []\\n self._location_data = []\\n self._package_data = []\",\n \"def __init__(self, data):\\n self.data = data\\n self.columns = Columns(data)\\n self.rows = Rows(data)\",\n \"def init(*args):\\n global dataset\\n dataset = args[0]\",\n \"def _init_from_DataArrays(self, data, validate=True):\\n self._data_vars = self._DataArrays_as_mapping(data)\\n\\n if (len(self) > 1) and validate:\\n first = self[0]\\n for i in range(1, len(self)):\\n da = self[i]\\n first._is_compatible(da, raise_error=True)\\n\\n self._check_all_different_ids(self._data_vars.values())\\n\\n self.__itemattr = []\\n for key, value in self._data_vars.items():\\n self._set_name_attr(key, value)\\n\\n self.plot = _DatasetPlotter(self)\\n\\n if len(self) > 0:\\n self._set_spectral_attributes(self.geometry)\\n\\n # since Dataset is MutableMapping it has values and keys by default\\n # but we delete those to avoid confusion\\n # self.values = None\\n self.keys = None\",\n \"def __init__(self, path: str = './') -> None:\\n super(DataHandler, self).__init__()\\n self.path = path\\n self.dataset = None # type: str\\n self._file_format = None # type: str\\n self._max_file_count = 0\",\n \"def setUp(self):\\n self.dataset = self.dataset_cls()\",\n \"def __init__(self, data_dict, mode):\\n self.data_dict = data_dict\\n self.mode = mode\\n\\n #Get the data\\n self.input_data = data_dict[\\\"input\\\"]\\n self.output_data = data_dict[\\\"output\\\"]\\n self.num_samples = self.input_data.shape[0]\",\n \"def __init__(self, dataset):\\n\\n if isinstance(dataset, DataConfig):\\n self.__data_config = dataset\\n self.dataset = dataset.dataset\\n elif isinstance(dataset, str):\\n logger.debug(\\\"Dataset argument {} is string, looking up known dataset.\\\".format(dataset))\\n self.__data_config = DataConfig.known_dataset(dataset)\\n self.dataset = dataset\\n else:\\n raise ValueError(\\\"Argument 'dataset' must be of type DataConfig or str.\\\")\",\n \"def __init__(\\n self,\\n path,\\n tier,\\n embeddings=None,\\n preprocessor=None,\\n transform=True):\\n super().__init__()\\n assert os.path.isdir(path)\\n assert os.path.exists(os.path.join(path, f'{tier}.csv'))\\n assert tier in self.TIERS\\n\\n self.path = path\\n self.tier = tier\\n self.data = None\\n self.embeddings = embeddings\\n self.preprocessor = preprocessor\\n self.is_transform = transform\\n self._init_dataset()\",\n \"def _init_data(self, data):\\n assert type(data) is dict, \\\"dict expected: %r\\\" % type(data)\\n assert len(data) is 1, \\\"size of dict should be 1: %r\\\" % len(data)\\n self._name = data.keys()[0]\\n self._data = np.asarray(data[self._name])\\n self._set = True\",\n \"def __init__(self):\\n self.relation = ''\\n self.attributes = []\\n self.attribute_types = dict()\\n self.attribute_data = dict()\\n self.comment = []\\n self.data = []\\n pass\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n\\n data_extract=DataExtracter()\\n self.data = tuple()\",\n \"def initialize(self):\\n self.data = None\\n self.errors = []\",\n \"def __init__(self):\\n self.data_set = []\\n self.finalized_data = LogData()\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def __init__(self, opt):\\n BaseDataset.__init__(self, opt)\\n\\n self.data_folder = os.path.join(opt.dataroot, opt.phase)\\n self.image_file_names = sorted(os.listdir(self.data_folder))\\n self.batch_size = opt.batch_size\\n self.z_dim = opt.z_dim\\n self.imsize = opt.crop_size\\n\\n self.transform = self.get_transform(True, True, True, opt.center_crop)\",\n \"def __init__(self, dat):\\n self.data = dat\",\n \"def __init__(self, datasets=[], summaries=[], ordinal_columns=[]):\\r\\n if not datasets:\\r\\n raise ValueError(\\\"Parameter datasets is empty. A list of Datasets is required.\\\")\\r\\n self.datasets = datasets\\r\\n if not summaries:\\r\\n raise ValueError(\\\"Parameter summaries[] is empty. A list of Summary objects is required.\\\")\\r\\n self.summaries = summaries\\r\\n # future- add checking here that each dataset has the column names\\r\\n # required by each summary,\\r\\n # and same for ordinal_columns when they are implemented. \\r\\n # Or do checking in Dataset().\\r\",\n \"def __init__(self, opt):\\n BaseDataset.__init__(self, opt)\\n\\n self.img_paths = glob.glob(os.path.join(opt.dataroot, '{}_image'.format(opt.phase), '*.png'))\\n self.segment_dir = os.path.join(opt.dataroot, '{}_segment'.format(opt.phase))\\n self.edge_dir = os.path.join(opt.dataroot, '{}_edge'.format(opt.phase))\\n self.centerline_dir = os.path.join(opt.dataroot, '{}_centerline'.format(opt.phase))\\n\\n self.img_transforms = transforms.Compose([transforms.ToTensor(),\\n transforms.Normalize((0.5, 0.5, 0.5),\\n (0.5, 0.5, 0.5))])\\n self.lab_transform = MaskToTensor()\",\n \"def __init__(self, opt):\\n BaseDataset.__init__(self, opt)\\n self.SR_factor = opt.SR_factor\\n\\n assert util_dataset.check_whether_last_dir(opt.dataroot), 'when SingleDataset, opt.dataroot:{} should be dir and contains only image files'.format(opt.dataroot)\\n self.dir_A = opt.dataroot\\n self.A_paths = sorted(make_images_dataset(self.dir_A, opt.max_dataset_size)) # get image paths\\n\\n self.input_nc = self.opt.input_nc\\n self.output_nc = self.opt.output_nc\",\n \"def __init__(self,dataset=scripts,group=\\\"\\\"):\\n self.dataset = dataset\\n self.group=group\",\n \"def __init__(self, dataset_path):\\n super(TorchData, self).__init__()\\n self.dataset = h5py.File(dataset_path, 'r')\\n self.bg = self.dataset['bg']\\n self.vocal = self.dataset['vocal']\\n self.mix = self.dataset['mix']\\n self.len = self.bg.shape[0]\",\n \"def initialize(self) -> None:\\n pass\",\n \"def __init__(self):\\n #---+----|----+----|----+----|----+----|----+----|----+----|----+----|\\n NexusReaderBase.__init__(self, -1)\\n self.taxa = None\\n self._data_matrices = None\",\n \"def __init__(self, dir_path, window_size,\\n user_map_path, computer_map_path, auth_type_map_path, logon_type_map_path):\\n logging.info(f\\\"Initiating Dataset instance for directory {dir_path}\\\")\\n self.directory = dir_path\\n self.filenames = [filename for filename in os.listdir(dir_path) if os.path.isfile(os.path.join(dir_path, filename))]\\n assert len(self.filenames) > 0\\n random.shuffle(self.filenames)\\n self.window_size = window_size\\n self.len = self.count_len()\\n self.user_map, self.user_count = util.load_mapping(user_map_path)\\n self.computer_map, self.computer_count = util.load_mapping(computer_map_path)\\n self.auth_type_map, self.auth_type_count = util.load_mapping(auth_type_map_path)\\n self.logon_type_map, self.logon_type_count = util.load_mapping(logon_type_map_path)\",\n \"def __init__(self):\\n self.data_set_loc = conf.config_section_mapper(\\\"filePath\\\").get(\\\"data_set_loc\\\")\\n self.data_extractor = DataExtractor(self.data_set_loc)\",\n \"def __init__(self, datafiles, plotter):\\n self.datafiles = datafiles\\n self.datasets = dict()\\n self.plotter = plotter\",\n \"def __init__(self, dataset: ds.Dataset, settings):\\r\\n self.dataset = dataset\\r\\n self.settings = settings\\r\\n\\r\\n self.visualizer = visualizer.Visualizer()\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def _init_data(self) -> None:\\n self.dtype = dict()\\n self.shape = dict()\\n self.size = dict()\\n self.attrs = dict()\\n self.data_ptr = dict()\\n\\n if self.mode == 'r':\\n for k in self.fp.keys():\\n self.dtype[k] = self.fp[k].dtype\\n self.shape[k] = self.fp[k].shape\\n self.size[k] = self.fp[k].shape[0]\\n self.data_ptr[k] = 0\",\n \"def __init__(self, df):\\n self.data = df\",\n \"def __init__(self, name_dataset, reduce=False):\\n dataset = TUDataset(root='data/TUDataset', name=name_dataset)\\n if reduce:\\n new_dataset = []\\n for i in tqdm(range(len(dataset))):\\n aux_graph = copy.deepcopy(dataset[i])\\n aux_graph.edge_index = TUDData.reduce_edges(aux_graph.edge_index)\\n new_dataset.append(copy.deepcopy(aux_graph))\\n dataset = WrapperSynthetic(new_dataset, dataset.num_node_features,\\n dataset.num_classes, None)\\n super(TUDData, self).__init__(dataset)\",\n \"def _initialize_data(self):\\n self.unique_id = 123\\n\\n self.gas_valve_open = False\\n self.buffer_valve_open = False\\n self.pump_valve_open = False\\n\\n self.operatingmode = 0\\n\\n self.sample_pressure_high_limit = 100\\n self.sample_pressure_low_limit = 10\\n self.sample_pressure = 0\\n\\n self.error = 0\\n\\n self.buffer_pressure_high = True\",\n \"def __init__(self, dataset_name, split, num_shards, data_dir,\\n filetype_suffix=None):\\n self.dataset_name = dataset_name\\n self.split = split\\n self.num_shards = num_shards\\n self.data_dir = data_dir\\n self.filetype_suffix = filetype_suffix\",\n \"def __init__(\\n self,\\n embedder_path: Optional[str] = None,\\n dataset: Optional[np.ndarray] = None,\\n metadata: Optional[List[AnyStr]] = None,\\n ) -> None:\\n self._embedder_path = embedder_path\\n\\n # Cache dataset list which can be concatenated to the single dataset. This\\n # is used since users may load the data several times, if each time the data\\n # are directly concatenated together, memory copy will be costed each time.\\n self._cache_dataset_list = []\\n\\n if dataset is None:\\n # Sets dataset and metadata as empty. Will load them from raw input data\\n # later.\\n self._dataset = np.array([])\\n self._metadata = []\\n else:\\n # Directly sets dataset and metadata.\\n self._dataset = dataset\\n self._metadata = metadata\",\n \"def __init__(self) -> None:\\n\\n self.train_env = None # Training environment\\n self.agent = None # The algorithm used to solve an RL problem is represented by a TF-Agent\\n self.replay_buffer = None # The replay buffer keeps track of data collected from the environment\\n self.dataset = None # The agent needs access to the replay buffer via an iterable tf.data.Dataset\\n self.iterator = None # The iterator of self.dataset\",\n \"def __init__(self, subset):\\n if subset not in ('background', 'evaluation'):\\n raise(ValueError, 'subset must be one of (background, evaluation)')\\n self.subset = subset\\n\\n self.df = pd.DataFrame(self.index_subset(self.subset))\\n\\n # Index of dataframe has direct correspondence to item in dataset\\n self.df = self.df.assign(id=self.df.index.values)\\n\\n # Convert arbitrary class names of dataset to ordered 0-(num_speakers - 1) integers\\n self.unique_characters = sorted(self.df['class_name'].unique())\\n self.class_name_to_id = {self.unique_characters[i]: i for i in range(self.num_classes())}\\n self.df = self.df.assign(class_id=self.df['class_name'].apply(lambda c: self.class_name_to_id[c]))\\n\\n # Create dicts\\n self.datasetid_to_filepath = self.df.to_dict()['data']\\n self.datasetid_to_class_id = self.df.to_dict()['class_id']\",\n \"def __init__(self, subset):\\n if subset not in ('background', 'evaluation'):\\n raise(ValueError, 'subset must be one of (background, evaluation)')\\n self.subset = subset\\n\\n self.df = pd.DataFrame(self.index_subset(self.subset))\\n\\n # Index of dataframe has direct correspondence to item in dataset\\n self.df = self.df.assign(id=self.df.index.values)\\n\\n # Convert arbitrary class names of dataset to ordered 0-(num_speakers - 1) integers\\n self.unique_characters = sorted(self.df['class_name'].unique())\\n self.class_name_to_id = {self.unique_characters[i]: i for i in range(self.num_classes())}\\n self.df = self.df.assign(class_id=self.df['class_name'].apply(lambda c: self.class_name_to_id[c]))\\n\\n # Create dicts\\n self.datasetid_to_filepath = self.df.to_dict()['data']\\n self.datasetid_to_class_id = self.df.to_dict()['class_id']\",\n \"def __init__(self, subset):\\n if subset not in ('background', 'evaluation'):\\n raise(ValueError, 'subset must be one of (background, evaluation)')\\n self.subset = subset\\n\\n self.df = pd.DataFrame(self.index_subset(self.subset))\\n\\n # Index of dataframe has direct correspondence to item in dataset\\n self.df = self.df.assign(id=self.df.index.values)\\n\\n # Convert arbitrary class names of dataset to ordered 0-(num_speakers - 1) integers\\n self.unique_characters = sorted(self.df['class_name'].unique())\\n self.class_name_to_id = {self.unique_characters[i]: i for i in range(self.num_classes())}\\n self.df = self.df.assign(class_id=self.df['class_name'].apply(lambda c: self.class_name_to_id[c]))\\n\\n # Create dicts\\n self.datasetid_to_filepath = self.df.to_dict()['data']\\n self.datasetid_to_class_id = self.df.to_dict()['class_id']\",\n \"def __init__(self, subset):\\n if subset not in ('background', 'evaluation'):\\n raise(ValueError, 'subset must be one of (background, evaluation)')\\n self.subset = subset\\n\\n self.df = pd.DataFrame(self.index_subset(self.subset))\\n\\n # Index of dataframe has direct correspondence to item in dataset\\n self.df = self.df.assign(id=self.df.index.values)\\n\\n # Convert arbitrary class names of dataset to ordered 0-(num_speakers - 1) integers\\n self.unique_characters = sorted(self.df['class_name'].unique())\\n self.class_name_to_id = {self.unique_characters[i]: i for i in range(self.num_classes())}\\n self.df = self.df.assign(class_id=self.df['class_name'].apply(lambda c: self.class_name_to_id[c]))\\n\\n # Create dicts\\n self.datasetid_to_filepath = self.df.to_dict()['filepath']\\n self.datasetid_to_class_id = self.df.to_dict()['class_id']\",\n \"def initialize(self):\\r\\n pass\",\n \"def initialize(self):\\r\\n pass\",\n \"def __init__(self, opt):\\n BaseDataset.__init__(self, opt)\\n self.dir_images = os.path.join(opt.dataroot, opt.phase) # get the image directory\\n self.image_paths = sorted(make_dataset(self.dir_images, opt.max_dataset_size)) # get image paths\\n assert(self.opt.load_size >= self.opt.crop_size) # crop_size should be smaller than the size of loaded image\\n self.input_nc = self.opt.output_nc\\n self.output_nc = self.opt.input_nc\",\n \"def initialize(self):\\n\\t\\tpass\",\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 \"def init(self):\\n pass\",\n \"def __init__(self, parameters: jnp.ndarray):\\n\\n # Note that this method is implicitly overriden by the dataclass decorator and\\n # should _not_ be marked abstract.\\n raise NotImplementedError()\",\n \"def initialise_dataset_loader(\\n self, data_param=None, task_param=None, data_partitioner=None):\\n raise NotImplementedError\",\n \"def _create_init(self):\\n\\n assert self._topology is not None, \\\\\\n \\\"Topology must be given for a creation constructor\\\"\\n\\n # initialize the runs group\\n runs_grp = self._h5.create_group(RUNS)\\n\\n # initialize the settings group\\n settings_grp = self._h5.create_group(SETTINGS)\\n\\n # create the topology dataset\\n self._h5.create_dataset(TOPOLOGY, data=self._topology)\\n\\n # sparse fields\\n if self._sparse_fields is not None:\\n\\n # make a dataset for the sparse fields allowed. this requires\\n # a 'special' datatype for variable length strings. This is\\n # supported by HDF5 but not numpy.\\n vlen_str_dt = h5py.special_dtype(vlen=str)\\n\\n # create the dataset with empty values for the length of the\\n # sparse fields given\\n sparse_fields_ds = settings_grp.create_dataset(SPARSE_FIELDS,\\n (len(self._sparse_fields),),\\n dtype=vlen_str_dt,\\n maxshape=(None,))\\n\\n # set the flags\\n for i, sparse_field in enumerate(self._sparse_fields):\\n sparse_fields_ds[i] = sparse_field\\n\\n\\n # field feature shapes and dtypes\\n\\n # initialize to the defaults, this gives values to\\n # self._n_coords, and self.field_feature_dtypes, and\\n # self.field_feature_shapes\\n self._set_default_init_field_attributes(n_dims=self._n_dims)\\n\\n # save the number of dimensions and number of atoms in settings\\n settings_grp.create_dataset(N_DIMS_STR, data=np.array(self._n_dims))\\n settings_grp.create_dataset(N_ATOMS, data=np.array(self._n_coords))\\n\\n # the main rep atom idxs\\n settings_grp.create_dataset(MAIN_REP_IDXS, data=self._main_rep_idxs, dtype=int)\\n\\n # alt_reps settings\\n alt_reps_idxs_grp = settings_grp.create_group(ALT_REPS_IDXS)\\n for alt_rep_name, idxs in self._alt_reps.items():\\n alt_reps_idxs_grp.create_dataset(alt_rep_name, data=idxs, dtype=int)\\n\\n # if both feature shapes and dtypes were specified overwrite\\n # (or initialize if not set by defaults) the defaults\\n if (self._field_feature_shapes_kwarg is not None) and\\\\\\n (self._field_feature_dtypes_kwarg is not None):\\n\\n self._field_feature_shapes.update(self._field_feature_shapes_kwarg)\\n self._field_feature_dtypes.update(self._field_feature_dtypes_kwarg)\\n\\n # any sparse field with unspecified shape and dtype must be\\n # set to None so that it will be set at runtime\\n for sparse_field in self.sparse_fields:\\n if (not sparse_field in self._field_feature_shapes) or \\\\\\n (not sparse_field in self._field_feature_dtypes):\\n self._field_feature_shapes[sparse_field] = None\\n self._field_feature_dtypes[sparse_field] = None\\n\\n\\n # save the field feature shapes and dtypes in the settings group\\n shapes_grp = settings_grp.create_group(FIELD_FEATURE_SHAPES_STR)\\n for field_path, field_shape in self._field_feature_shapes.items():\\n if field_shape is None:\\n # set it as a dimensionless array of NaN\\n field_shape = np.array(np.nan)\\n\\n shapes_grp.create_dataset(field_path, data=field_shape)\\n\\n dtypes_grp = settings_grp.create_group(FIELD_FEATURE_DTYPES_STR)\\n for field_path, field_dtype in self._field_feature_dtypes.items():\\n if field_dtype is None:\\n dt_str = NONE_STR\\n else:\\n # make a json string of the datatype that can be read\\n # in again, we call np.dtype again because there is no\\n # np.float.descr attribute\\n dt_str = json.dumps(np.dtype(field_dtype).descr)\\n\\n dtypes_grp.create_dataset(field_path, data=dt_str)\\n\\n # initialize the units group\\n unit_grp = self._h5.create_group(UNITS)\\n\\n # if units were not given set them all to None\\n if self._units is None:\\n self._units = {}\\n for field_path in self._field_feature_shapes.keys():\\n self._units[field_path] = None\\n\\n # set the units\\n for field_path, unit_value in self._units.items():\\n\\n # ignore the field if not given\\n if unit_value is None:\\n continue\\n\\n unit_path = '{}/{}'.format(UNITS, field_path)\\n\\n unit_grp.create_dataset(unit_path, data=unit_value)\\n\\n\\n # create the group for the run data records\\n records_grp = settings_grp.create_group(RECORD_FIELDS)\\n\\n # create a dataset for the continuation run tuples\\n # (continuation_run, base_run), where the first element\\n # of the new run that is continuing the run in the second\\n # position\\n self._init_continuations()\",\n \"def __init__(self, **kwargs):\\n is_training = kwargs.get('is_training', True)\\n rootfolder = kwargs['rootfolder']\\n dtype = kwargs.get('dtype', np.float64)\\n self._load_mnist(rootfolder, is_training, dtype)\\n # normalize data.\\n self._data /= 255.\\n ndarraydata.NdarrayDataLayer.__init__(\\n self, sources=[self._data, self._label], **kwargs)\",\n \"def __init__(self, opt):\\n BaseDataset.__init__(self, opt)\\n self.dir_A = opt.dataroot\\n self.classes_A, self.class_to_idx_A = self._find_classes(self.dir_A) # find classes in '/path/to/data/trainA'\\n samples_A = make_dataset(self.dir_A, self.class_to_idx_A, extensions=self.img_extension, is_valid_file=None) # samples (list): List of (sample path, class_index) tuples\\n self.A_paths = [s[0] for s in samples_A]\\n self.A_targets = [s[1] for s in samples_A]\\n #self.A_paths = sorted(make_dataset(opt.dataroot, opt.max_dataset_size))\\n input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc\\n self.transform = get_transform(opt, grayscale=(input_nc == 1))\",\n \"def __init__(self, directory):\\n self._path = os.path.join(\\\"../../datasets\\\", directory)\\n self.airlines = pd.read_csv(os.path.join(self._path, 'airlines.csv'))\\n self.airports = pd.read_csv(os.path.join(self._path, 'airports.csv'))\\n self.planes = pd.read_csv(os.path.join(self._path, 'planes.csv'))\\n self.countries = pd.read_csv(os.path.join(self._path, 'countries.csv'))\\n self.routes = pd.read_csv(os.path.join(self._path, 'routes.csv'))\\n self._CreateGraph()\",\n \"def __init__(self, annotation_file=None):\\n # load dataset\\n self.dataset,self.anns,self.cats,self.imgs = dict(),dict(),dict(),dict()\\n self.imgToAnns, self.catToImgs = defaultdict(list), defaultdict(list)\\n if not annotation_file == None:\\n print('loading annotations into memory...')\\n tic = time.time()\\n dataset = json.load(open(annotation_file, 'r'))\\n assert type(dataset)==dict, 'annotation file format {} not supported'.format(type(dataset))\\n print('Done (t={:0.2f}s)'.format(time.time()- tic))\\n self.dataset = dataset\\n self.createIndex()\",\n \"def initialize(self):\\n LOG.info(\\\"Initializing Model.\\\")\\n self.model = self.convert(df=self.training_df)\\n if self.bootstraps is not None:\\n LOG.info(\\\"Bootstrapping Data.\\\")\\n self.bootstrap_data()\",\n \"def __init__(self, subset):\\n if subset not in ('background', 'evaluation'):\\n raise(ValueError, 'subset must be one of (background, evaluation)')\\n self.subset = subset\\n\\n self.df = pd.DataFrame(self.index_subset(self.subset))\\n\\n # Index of dataframe has direct correspondence to item in dataset\\n self.df = self.df.assign(id=self.df.index.values)\\n\\n # Convert arbitrary class names of dataset to ordered 0-(num_speakers - 1) integers\\n self.unique_characters = sorted(self.df['class_name'].unique())\\n self.class_name_to_id = {self.unique_characters[i]: i for i in range(self.num_classes())}\\n self.df = self.df.assign(class_id=self.df['class_name'].apply(lambda c: self.class_name_to_id[c]))\\n\\n # Create dicts\\n self.datasetid_to_filepath = self.df.to_dict()['filepath']\\n self.datasetid_to_class_id = self.df.to_dict()['class_id']\\n\\n # Setup transforms\\n self.transform = transforms.Compose([\\n transforms.CenterCrop(224),\\n transforms.Resize(84),\\n transforms.ToTensor(),\\n transforms.Normalize(mean=[0.485, 0.456, 0.406],\\n std=[0.229, 0.224, 0.225])\\n ])\",\n \"def __init__(self, *args, **kwargs):\\n # Training/prediction data volume\\n self.train_volume: np.ndarray = None\\n # Training label volume\\n self.train_label_volume: Optional[np.ndarray] = None\\n # Per-voxel training error weighting volume\\n self.train_weight_volume: Optional[np.ndarray] = None\\n # Validation data volume\\n self.eval_volume: Optional[np.ndarray] = None\\n # Validation label volume\\n self.eval_label_volume: Optional[np.ndarray] = None\\n\\n # Number of label classes\\n self.n_classes: int = None\\n\\n # RandomState used to control random number generation\\n self.random_state = np.random.RandomState()\\n\\n # Image augmentation instance_settings for use during training\\n self.augmentation_settings: Dict[str, Any] = None\\n\\n # Load data if arguments are supplied\\n if len(args) > 0 or len(kwargs) > 0:\\n self.load(*args, **kwargs)\\n\\n pass\",\n \"def __init__(self, num_detectors):\\n self.dataset = []\\n self.num_detectors = num_detectors\\n self.add_detectors()\",\n \"def __init__(self):\\n self.X = None\\n self.Y = None\\n self.features = None\\n self.max = self.min = None\\n self._look_up = None\\n self.attr_weight = None\",\n \"def initialize(self):\\n self.initialize_edges()\\n self.initialize_prob()\\n self.initialize_total_input_dict()\\n\\n self.initialize_fpmusigv_dict()\",\n \"def __init__(self, *args, **kwargs):\\n ignore_version = kwargs.pop('ignore_version', False)\\n\\n super(Hdf5, self).__init__(*args, **kwargs)\\n\\n # If True, always translate __getitem__ requests according to the\\n # schema, even if __getitem__ requests a dataset that exists\\n self.always_translate = False\\n\\n self._version = self.attrs.get('version')\\n if isinstance(self._version, bytes):\\n self._version = self._version.decode()\\n self._timesteps = {}\\n\\n # Connect the schema map to this object\\n if self._version in SCHEMA:\\n self.schema = SCHEMA[self._version]\\n elif self._version is None:\\n self.schema = {}\\n elif not ignore_version:\\n raise KeyError(\\\"Unknown schema version %s\\\" % self._version)\\n\\n # Connect the schema dataset providers to this object\\n if self._version in SCHEMA_DATASET_PROVIDERS:\\n self.dataset_providers = SCHEMA_DATASET_PROVIDERS[self._version]\\n else:\\n self.dataset_providers = {}\",\n \"def __init__(self, path='data'):\\r\\n self.nb_data = 3\\r\\n self.path = path\\r\\n self.data_train_name = 'Xtr'\\r\\n self.data_test_name = 'Xte'\\r\\n self.features_name = '_mat100'\\r\\n self.label_train_name = 'Ytr'\\r\\n self.label_test_name = 'Ytr'\\r\\n # load raw data\\r\\n self.raw_data = {'train': self.load_data(self.data_train_name),\\r\\n 'test': self.load_data(self.data_test_name)}\\r\\n # load data features\\r\\n self.data_features = {'train': self.load_data(self.data_train_name, self.features_name, type_='features'),\\r\\n 'test': self.load_data(self.data_test_name, self.features_name, type_='features')}\\r\\n # load labels\\r\\n self.labels = {'train': self.load_data(self.label_train_name),\\r\\n 'test': self.load_data(self.label_test_name)}\\r\\n\\r\\n # toy data\\r\\n self.toy_data_functions = {\\r\\n 'blobs': blobs,\\r\\n 'two_moons': two_moons\\r\\n }\\r\\n self.toy_data = dict()\",\n \"def __init__(self,data):\\n\\t\\tself.data = tuple([tuple(x) if isiterable(x) else (x,) for x in data])\\n\\t\\tself.rows = len(self.data)\\n\\t\\tself.cols = len(self.data[0]) if len(self.data)>0 else 0\",\n \"def _init(self):\\n raise NotImplementedError\",\n \"def __init__(self, data=None, filename=None, schema=None):\\n self.data = None\\n self.schema = None\\n self.filename = None\\n if schema:\\n self.load_schema(schema)\\n if filename:\\n self.load_file(filename)\\n if data:\\n self.load_data(data)\",\n \"def __initialize(self):\\n\\t\\tself.matrix = [None] * self.size\\n\\t\\tself.__get_log_values()\\n\\t\\tfor row in range(self.size):\\n\\t\\t\\tself.matrix[row] = [None] * self.size\\n\\t\\tmax_len = self.__get_max_length()\\n\\t\\tdata = self.__get_data(self.text,max_len)\\n\\t\\tmpoly = self.__get_mpoly(data)\\n\\t\\tgpoly = self.__get_gploy()\\n\\t\\tself.final_data = self.__get_final_data(mpoly,gpoly)\\n\\t\\tself.__set_FIP(FP_num = 1)\\n\\t\\tself.__set_FIP(FP_num = 2)\\n\\t\\tself.__set_FIP(FP_num = 3)\\n\\t\\tself.__set_AP()\\n\\t\\tself.__fill_format_info_area()\\n\\t\\tself.__set_TP()\",\n \"def __init__(self, opt):\\n BaseDataset.__init__(self, opt)\\n self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A') # create a path '/path/to/data/trainA'\\n self.dir_B = os.path.join(opt.dataroot, opt.phase + 'B') # create a path '/path/to/data/trainB'\\n\\n self.A_paths = sorted(make_dataset(self.dir_A, opt.max_dataset_size)) # load images from '/path/to/data/trainA'\\n self.B_paths = sorted(make_dataset(self.dir_B, opt.max_dataset_size)) # load images from '/path/to/data/trainB'\\n self.A_size = len(self.A_paths) # get the size of dataset A\\n self.B_size = len(self.B_paths) # get the size of dataset B\\n btoA = self.opt.direction == 'BtoA'\\n input_nc = self.opt.output_nc if btoA else self.opt.input_nc # get the number of channels of input image\\n output_nc = self.opt.input_nc if btoA else self.opt.output_nc # get the number of channels of output image\\n self.transform_A = get_transform(self.opt, grayscale=(input_nc == 1))\\n self.transform_B = get_transform(self.opt, grayscale=(output_nc == 1))\",\n \"def __init__(self):\\n # Calls super constructor:\\n super().__init__()\\n\\n # This list holds all the information for computing each 'group' of features:\\n self.features_group_list = []\",\n \"def __init__(self, file, sdef, name, path, attrs, parent, value, dtype, compress, link_info=None):\\n super(Dataset, self).__init__(file, sdef, name, path, attrs, parent, link_info)\\n # print \\\"Creating Dataset, sdef=\\\"\\n # pp.pprint(sdef)\\n if 'attributes' in self.sdef['df']:\\n self.attributes = copy.deepcopy(self.sdef['df']['attributes'])\\n # del self.sdef['df']['attributes'] # if do this, no need to check for attributes in mk_dsinfo\\n # print \\\"found attributes:\\\"\\n # else:\\n # print \\\"did not find attributes:\\\"\\n # pp.pprint(self.attributes)\\n # if self.sdef['df']:\\n self.dsinfo = self.mk_dsinfo(value)\\n self.merge_attribute_defs(self.attributes, self.dsinfo['atags'])\\n # else:\\n # definition empty, must be custom dataset\\n # self.dsinfo = {}\\n self.merge_attrs()\\n if self.link_info:\\n # this dataset set to link to another. Already done in Node. Nothing to do here\\n pass\\n else:\\n # creating new dataset (normally done)\\n self.link_node = None\\n # compress = \\\"gzip\\\" if compress else None\\n # self.h5node = self.h5parent.create_dataset(self.name, data=value,\\n # dtype=dtype, compression=compress)\\n #- self.file.file_pointer.create_dataset(self.full_path, data=value,\\n #- dtype=dtype, compression=compress)\\n self.file.create_dataset(self.full_path, data=value, dtype=dtype,\\n compress=compress)\\n # self.file.h5commands.append(\\\"create_dataset(%s, %s)\\\" % (self.full_path, value))\\n # if dtype:\\n # self.h5node = self.h5parent.create_dataset(self.name, data=value, dtype=dtype)\\n # else: # should find out what default value for dtype used in h5py and use that, combine these\\n # self.h5node = self.h5parent.create_dataset(self.name, data=value)\\n self.set_attr_values()\",\n \"def _initialize_data(self):\\n self.reset_count = 0\\n self._idn_no_firmware = \\\"KEPCO,BOP 50-20,E1234,\\\"\\n self._firmware = 2.6\\n self._init_data()\",\n \"def init(self, **kwargs):\\n self._d = {}\\n self._th = None\\n self._run = True\\n self.load()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.816631","0.81641185","0.8013762","0.76137954","0.7422038","0.7393049","0.7352237","0.73437655","0.7111143","0.71019876","0.7099074","0.7096382","0.70223516","0.696418","0.6961817","0.6889772","0.6879775","0.68740934","0.68599087","0.68520594","0.6842619","0.6836507","0.6828825","0.6809566","0.68037564","0.6800808","0.67909133","0.6782312","0.6782312","0.6782312","0.67627436","0.6756033","0.6751991","0.67498195","0.67498195","0.6730716","0.6715901","0.6707858","0.67010975","0.66988236","0.668923","0.66852677","0.66807044","0.66806763","0.6678971","0.66789216","0.665757","0.6655296","0.66539544","0.66539544","0.66539544","0.66539544","0.66539544","0.6644616","0.6638509","0.6629376","0.66151416","0.66142374","0.66007245","0.65974915","0.6596506","0.6596506","0.6596506","0.65858185","0.6573607","0.6573607","0.65658706","0.6564532","0.65609944","0.65609944","0.65609944","0.65609944","0.65609944","0.65609944","0.65609944","0.65609944","0.654954","0.6544916","0.6543092","0.65408367","0.6540651","0.6540625","0.65384096","0.6535255","0.65305084","0.65303224","0.65216005","0.6519088","0.6515111","0.651333","0.65091664","0.6499544","0.6497439","0.64938307","0.64920795","0.6488813","0.6484341","0.6480846","0.64773333","0.6466663"],"string":"[\n \"0.816631\",\n \"0.81641185\",\n \"0.8013762\",\n \"0.76137954\",\n \"0.7422038\",\n \"0.7393049\",\n \"0.7352237\",\n \"0.73437655\",\n \"0.7111143\",\n \"0.71019876\",\n \"0.7099074\",\n \"0.7096382\",\n \"0.70223516\",\n \"0.696418\",\n \"0.6961817\",\n \"0.6889772\",\n \"0.6879775\",\n \"0.68740934\",\n \"0.68599087\",\n \"0.68520594\",\n \"0.6842619\",\n \"0.6836507\",\n \"0.6828825\",\n \"0.6809566\",\n \"0.68037564\",\n \"0.6800808\",\n \"0.67909133\",\n \"0.6782312\",\n \"0.6782312\",\n \"0.6782312\",\n \"0.67627436\",\n \"0.6756033\",\n \"0.6751991\",\n \"0.67498195\",\n \"0.67498195\",\n \"0.6730716\",\n \"0.6715901\",\n \"0.6707858\",\n \"0.67010975\",\n \"0.66988236\",\n \"0.668923\",\n \"0.66852677\",\n \"0.66807044\",\n \"0.66806763\",\n \"0.6678971\",\n \"0.66789216\",\n \"0.665757\",\n \"0.6655296\",\n \"0.66539544\",\n \"0.66539544\",\n \"0.66539544\",\n \"0.66539544\",\n \"0.66539544\",\n \"0.6644616\",\n \"0.6638509\",\n \"0.6629376\",\n \"0.66151416\",\n \"0.66142374\",\n \"0.66007245\",\n \"0.65974915\",\n \"0.6596506\",\n \"0.6596506\",\n \"0.6596506\",\n \"0.65858185\",\n \"0.6573607\",\n \"0.6573607\",\n \"0.65658706\",\n \"0.6564532\",\n \"0.65609944\",\n \"0.65609944\",\n \"0.65609944\",\n \"0.65609944\",\n \"0.65609944\",\n \"0.65609944\",\n \"0.65609944\",\n \"0.65609944\",\n \"0.654954\",\n \"0.6544916\",\n \"0.6543092\",\n \"0.65408367\",\n \"0.6540651\",\n \"0.6540625\",\n \"0.65384096\",\n \"0.6535255\",\n \"0.65305084\",\n \"0.65303224\",\n \"0.65216005\",\n \"0.6519088\",\n \"0.6515111\",\n \"0.651333\",\n \"0.65091664\",\n \"0.6499544\",\n \"0.6497439\",\n \"0.64938307\",\n \"0.64920795\",\n \"0.6488813\",\n \"0.6484341\",\n \"0.6480846\",\n \"0.64773333\",\n \"0.6466663\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6548279"},"document_rank":{"kind":"string","value":"77"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":942,"numItemsPerPage":100,"numTotalItems":95772,"offset":94200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTUwOTkwMCwianRpIjoiNGZjOGJhZTYtMWY5OS00ZTQ1LWEwYmQtZDdmOGM3ZjlkNTgyIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU1MTM1MDAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.yxZHMNxYga2OUFd50zFAE-aHnUY7i4gZRN3o10iIFVYBhWwsvIw09bHqtnuVcn6Hy2x9lpGTRAT8gR4ItgW1CA","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 |
|---|---|---|---|---|---|---|
Build the model with args.inn_depth many layers If args.inn_glow is true, then each layer includes 1x1 convolutions. | def build_fc_inn(
args: ClusterArgs, input_shape: Tuple[int, ...], level_depth: Optional[int] = None
) -> layers.Bijector:
input_dim = input_shape[0]
level_depth = level_depth or args.inn_level_depth
chain: List[layers.Bijector] = [layers.Flatten()]
for i in range(level_depth):
if args.inn_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_layers(self) -> None:\n self.convs_all_levels = nn.ModuleList()\n for i in range(self.start_level, self.end_level + 1):\n convs_per_level = nn.Sequential()\n convs_per_level.add_module(\n f'conv{i}',\n ConvModule(\n self... | [
"0.6300217",
"0.6081184",
"0.6023422",
"0.60000265",
"0.5995302",
"0.59686184",
"0.59679914",
"0.5925756",
"0.59211046",
"0.5914937",
"0.59135234",
"0.5860571",
"0.5852755",
"0.5852108",
"0.581896",
"0.5807225",
"0.5793126",
"0.57791585",
"0.577166",
"0.5771581",
"0.57675666"... | 0.66995215 | 0 |
Construct one block of the conv INN | def _block(args: ClusterArgs, input_dim: int) -> layers.Bijector:
_chain: List[layers.Bijector] = []
if args.inn_idf:
_chain += [
layers.IntegerDiscreteFlow(input_dim, hidden_channels=args.inn_coupling_channels)
]
_chain += [layers.RandomPermutation(input_dim)]
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_unet(input_layer = Input((128,128,3)), start_depth=64, activation='relu', initializer='he_normal'):\n\n # 128 -> 64\n conv1 = Conv2D_BN(input_layer, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\n conv1 = Conv2D_BN(conv1, start_depth * 1, (3, 3), activation=acti... | [
"0.594262",
"0.5939619",
"0.59235996",
"0.59181947",
"0.5897077",
"0.5897077",
"0.587706",
"0.587706",
"0.58607095",
"0.5825037",
"0.58241177",
"0.58117056",
"0.57984984",
"0.57984984",
"0.57732284",
"0.5751117",
"0.570624",
"0.568427",
"0.5672911",
"0.5664635",
"0.5664635",
... | 0.5344787 | 57 |
This gets called when the source file was moved. | def updateFontPath(self, newFontPath):
self.fontPath = newFontPath | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_moved(self, event):\n print(\"Moved\")\n time.sleep(5)\n self.moveFile(event.dest_path)",
"def move_file(self, ctx):\n pass",
"def on_moved(self, event):\n super(myEventHandler,self).on_moved(event)\n #moveto events from external folders have no src_path\n ... | [
"0.7210631",
"0.6951233",
"0.68050367",
"0.67851174",
"0.6536601",
"0.646156",
"0.6355364",
"0.63365686",
"0.6311357",
"0.6226218",
"0.6219465",
"0.61488163",
"0.6109679",
"0.6086167",
"0.60812443",
"0.60367584",
"0.60130316",
"0.60042614",
"0.597683",
"0.5955222",
"0.5948722... | 0.0 | -1 |
Subclasses may override this to return a list of external files, that clients can observe for changes. | def getExternalFiles(self):
return [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_files(self):\r\n return self._filelist",
"def getFiles(self):\n\t\treturn os.listdir(self.getPath())",
"def listFiles(self):\n pass",
"def get_files(self):\n return self.ebook_file.get_files()",
"def files(self):\r\n return self._files",
"def files(self):\n try:\n ... | [
"0.76476604",
"0.74927044",
"0.7429381",
"0.73926634",
"0.7326719",
"0.7309371",
"0.7282806",
"0.7274433",
"0.722302",
"0.7204074",
"0.71247035",
"0.7104432",
"0.7064401",
"0.7045729",
"0.70131254",
"0.7007956",
"0.69954735",
"0.6967799",
"0.6939747",
"0.69316167",
"0.6928061... | 0.9027203 | 0 |
`externalFilePath` is None or an external file. If it is None, the main source file was changed on disk, else the externalFilePath was changed. This method should return True if it can update itself, in which case font.load() will be called. If it returns False, the font will be discarded and rebuilt from scratch. | def canReloadWithChange(self, externalFilePath):
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fix_font(src_root, dst_root, file_path, is_hinted, save_unmodified):\n\n src_file = os.path.join(src_root, file_path)\n\n print('Font file: %s' % src_file)\n font = ttLib.TTFont(src_file)\n modified = False\n\n modified |= fix_revision(font)\n modified |= fix_fstype(font)\n modified |= fix... | [
"0.5081905",
"0.50366616",
"0.50216615",
"0.49829918",
"0.49263966",
"0.49156058",
"0.4806569",
"0.47662523",
"0.47610694",
"0.47367972",
"0.47354025",
"0.47352326",
"0.47022414",
"0.47002628",
"0.46964857",
"0.46519396",
"0.46338332",
"0.46322864",
"0.46244994",
"0.4612329",
... | 0.64111775 | 0 |
The signal handler for the 'triggered' signal. | def onTriggered(self, action):
if action.isCheckable() and action.isChecked():
if self.isExclusive():
last = self._last_checked
if last is not None and last is not action:
last.setChecked(False)
self._last_checked = action | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_triggered(self, slot):\n self.triggered.connect(slot)",
"def _action_triggered(self, action, checked=False):\n self._emit_signal_for_action(self.action_triggered, action, checked)",
"def on_action_11_triggered(self):\n # TODO: not implemented yet\n exit(0)",
"def on_action_... | [
"0.79236376",
"0.6559447",
"0.64768285",
"0.62798786",
"0.61472255",
"0.611165",
"0.60122555",
"0.59837323",
"0.59460413",
"0.5918585",
"0.5875592",
"0.576396",
"0.5753168",
"0.5750694",
"0.5705757",
"0.5685465",
"0.56775683",
"0.5605326",
"0.55946964",
"0.5547762",
"0.553689... | 0.0 | -1 |
Set the exclusive state of the action group. | def setExclusive(self, exclusive):
super(QCustomActionGroup, self).setExclusive(exclusive)
if exclusive:
last = self._last_checked
if last is not None:
last.setChecked(True)
for action in self.actions():
if action is not last:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def action_lock(self):\n self.state = 'locked'",
"def set_exclusive(self, exclusive):\n self.widget.setExclusive(exclusive)",
"def set_exclusive_active(self, name):\n self.set_all_inactive()\n self.set_active(name)",
"def disable(self):\n if self.active != DISABLED:\n ... | [
"0.63360256",
"0.6294087",
"0.6230919",
"0.5686868",
"0.56087244",
"0.5578127",
"0.5569583",
"0.5548554",
"0.54780567",
"0.5418087",
"0.5412914",
"0.54105514",
"0.53850436",
"0.535912",
"0.535912",
"0.5358296",
"0.52563006",
"0.52535677",
"0.5228041",
"0.5220662",
"0.52197784... | 0.77546895 | 0 |
Create the underlying action group widget. | def create_widget(self):
self.widget = QCustomActionGroup(self.parent_widget()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_action(self, *args, **kwargs):\n action_group = kwargs.pop('action_group', None)\n act = QAction(*args, **kwargs)\n if action_group:\n act.setActionGroup(action_group)\n\n return act",
"def init_layout(self):\n super(QtActionGroup, self).init_layout()\n ... | [
"0.75482804",
"0.6695908",
"0.66494614",
"0.62164736",
"0.60830635",
"0.6036351",
"0.6004404",
"0.58673584",
"0.5848936",
"0.5833886",
"0.5833164",
"0.5814237",
"0.5802912",
"0.5681113",
"0.5641236",
"0.55654967",
"0.5556217",
"0.55348945",
"0.5505949",
"0.5497972",
"0.544596... | 0.84242666 | 0 |
Initialize the layout for the control. | def init_layout(self):
super(QtActionGroup, self).init_layout()
widget = self.widget
for action in self.actions():
widget.addAction(action) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_layout(self):\n pass",
"def init_layout(self):\n\t\tself.pack_start(self.edit, expand=True)\n\t\tself.pack_start(self.button, expand=False)\n\t\tself.show_all()",
"def __createLayout(self):\r\n self.__createCanvas()\r\n self.__createButton()\r\n self.__createInputFunction()... | [
"0.84849787",
"0.8151154",
"0.75447416",
"0.7424792",
"0.7365498",
"0.72760487",
"0.7237962",
"0.71668446",
"0.7161154",
"0.71545607",
"0.7138541",
"0.71254814",
"0.70788753",
"0.70205253",
"0.69035393",
"0.69017667",
"0.6865221",
"0.6782825",
"0.6781948",
"0.67713374",
"0.67... | 0.6108049 | 81 |
Locate the QAction object which logically follows the child. If the given child is last in the list of children, then the parent object will be invoked to find the QAction which follows this action group. | def find_next_action(self, child):
found = False
for dchild in self.children():
if found and isinstance(dchild, QtAction):
return dchild.widget
else:
found = child is dchild
parent = self.parent()
if parent is not None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def child_added(self, child):\n super(QtActionGroup, self).child_added(child)\n if isinstance(child, QtAction):\n self.widget.addAction(child.widget)\n parent = self.parent()\n if parent is not None:\n before = self.find_next_action(child)\n ... | [
"0.65133506",
"0.5764956",
"0.56135213",
"0.5588276",
"0.556616",
"0.5460327",
"0.54077643",
"0.53608245",
"0.53120625",
"0.52631944",
"0.52541935",
"0.5245333",
"0.5144854",
"0.513944",
"0.51289624",
"0.50804204",
"0.5078679",
"0.5062347",
"0.5059294",
"0.50372154",
"0.50300... | 0.7250408 | 0 |
Handle the child added event for a QtActionGroup. This handler will also add the widget to the parent widget, since a QActionGroup only serves as a management container. | def child_added(self, child):
super(QtActionGroup, self).child_added(child)
if isinstance(child, QtAction):
self.widget.addAction(child.widget)
parent = self.parent()
if parent is not None:
before = self.find_next_action(child)
parent.w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_widget(self):\n self.widget = QCustomActionGroup(self.parent_widget())",
"def child_added(self, child):\n super(QtToolButton, self).child_added(child)\n if isinstance(child, QtMenu):\n self.widget.setMenu(child.widget)",
"def child_removed(self, child):\n super... | [
"0.67494166",
"0.6715713",
"0.6624586",
"0.612766",
"0.58904576",
"0.5739347",
"0.56276655",
"0.5609154",
"0.5497478",
"0.5419861",
"0.53794026",
"0.5364947",
"0.5319612",
"0.5314476",
"0.53119785",
"0.5293082",
"0.52860713",
"0.5270443",
"0.5258827",
"0.5233708",
"0.52084774... | 0.8052653 | 0 |
Handle the child removed event for a QtActionGroup. This handler will also remove the widget to the parent widget, since a QActionGroup only serves as a management container. | def child_removed(self, child):
super(QtActionGroup, self).child_removed(child)
if isinstance(child, QtAction) and child.widget is not None:
self.widget.removeAction(child.widget)
parent = self.parent()
if parent is not None:
parent.widget.removeAction... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def child_removed(self, child):\n super(QtToolButton, self).child_removed(child)\n if isinstance(child, QtMenu):\n if child.widget is self.widget.menu():\n self.widget.setMenu(None)",
"def child_removed(self, child):\n super(AbstractItemView, self).child_removed(chi... | [
"0.66755563",
"0.6194727",
"0.6103499",
"0.59941256",
"0.5964826",
"0.59547776",
"0.56917274",
"0.5554345",
"0.53270316",
"0.5319716",
"0.5318732",
"0.53073436",
"0.5299997",
"0.52597994",
"0.5187974",
"0.51409185",
"0.51390886",
"0.5129079",
"0.51237017",
"0.5121978",
"0.508... | 0.8089256 | 0 |
Get the QAction children for this action group. Returns | def actions(self):
isinst = isinstance
return [c.widget for c in self.children() if isinst(c, QtAction)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getChildren(self):\n \n return self._children",
"def children(self):\n \n return self._children",
"def children(self):\n return self._children",
"def children(self):\n return self._children",
"def get_children(self):\n return self._children",
"def get_... | [
"0.68728095",
"0.67529786",
"0.66481596",
"0.66481596",
"0.65832484",
"0.65597486",
"0.65548855",
"0.65548855",
"0.65548855",
"0.6481813",
"0.64334065",
"0.6417876",
"0.6396768",
"0.63655233",
"0.63655233",
"0.63300586",
"0.63013625",
"0.62966573",
"0.62869656",
"0.6238286",
... | 0.72453445 | 0 |
Set the exclusive state of the underlying control. | def set_exclusive(self, exclusive):
self.widget.setExclusive(exclusive) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setExclusive(self, exclusive):\n super(QCustomActionGroup, self).setExclusive(exclusive)\n if exclusive:\n last = self._last_checked\n if last is not None:\n last.setChecked(True)\n for action in self.actions():\n if action is... | [
"0.6620294",
"0.6611052",
"0.65280485",
"0.6495654",
"0.6394166",
"0.6288686",
"0.62424856",
"0.6240522",
"0.61622685",
"0.61020094",
"0.6073353",
"0.60687214",
"0.604627",
"0.5999525",
"0.5999525",
"0.59711045",
"0.5961201",
"0.5957905",
"0.5943796",
"0.59436667",
"0.5928598... | 0.7793201 | 0 |
Set the enabled state of the underlying control. | def set_enabled(self, enabled):
self.widget.setEnabled(enabled) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setEnabled( self, cCtrlName, bEnabled=True ):\n self.setControlModelProperty( cCtrlName, \"Enabled\", bEnabled )",
"def setEnabled(self, enable: bool) -> None:\n self.enabled = ...",
"def set_enabled(self, enabled=True):\n self._enabled = enabled",
"def enable(self):\r\n self.... | [
"0.7554714",
"0.7493753",
"0.739995",
"0.7382345",
"0.731879",
"0.731879",
"0.72874004",
"0.7201384",
"0.7166079",
"0.71536714",
"0.71536714",
"0.7085178",
"0.7085178",
"0.7061498",
"0.70269674",
"0.68897516",
"0.6885137",
"0.6868981",
"0.6791306",
"0.67691064",
"0.67643887",... | 0.81380314 | 1 |
Set the visible state of the underlying control. | def set_visible(self, visible):
self.widget.setVisible(visible) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_visible(self, visible):\n widget = self.widget\n if visible:\n widget.setVisible(True)\n widget.raise_()\n widget.activateWindow()\n else:\n widget.setVisible(False)",
"def set_visible(self, visible):\n # Make sure the 'visible' attr... | [
"0.8229523",
"0.8191319",
"0.79702616",
"0.7886644",
"0.77734816",
"0.7673497",
"0.7571436",
"0.7353849",
"0.73125196",
"0.71429527",
"0.7117967",
"0.711646",
"0.70657074",
"0.70528007",
"0.68809277",
"0.6869344",
"0.6869344",
"0.6869344",
"0.6869344",
"0.6869344",
"0.6869344... | 0.8712535 | 1 |
train the node2vec model | def load_node2vec_for_doc_collection(cls, preprocess_document_collection: PreprocessMultiFieldDocumentCollection,
pretrain_node2vec_path=None,
embedding_size=DEFAULT_EMBEDDING_SIZE,
):
no... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trainNet():",
"def main() -> None:\n\n # Load pickled (adj, feat) tuple\n with open(os.path.join(NETWORK_DIR, PICKLE_FILE), \"rb\") as file:\n adj, features = pickle.load(file)\n\n g = nx.Graph(adj) # Recreate graph using node indices (0 to num_nodes-1)\n\n # Draw the network\n # nx.dr... | [
"0.7426452",
"0.66420937",
"0.663728",
"0.65732425",
"0.6568101",
"0.6489874",
"0.64146864",
"0.63706493",
"0.6360775",
"0.6325146",
"0.63113385",
"0.63113385",
"0.63113385",
"0.63113385",
"0.63113385",
"0.63027394",
"0.628448",
"0.6281508",
"0.6272129",
"0.62691456",
"0.6269... | 0.6219104 | 25 |
All the harvesters and utilities use a common parser. | def setup_common_parser(id, description=None, epilog=None):
parser = argparse.ArgumentParser(
description=description,
epilog=epilog,
formatter_class=argparse.ArgumentDefaultsHelpFormatter
)
help = f"Verbosity level of log file {id}.log"
choices = ['DEBUG', 'INFO', 'WARNING', '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_parser(self, parser):",
"def select_parser():\n\n try:\n select_texttools_parser()\n except ImportError:\n select_python_parser()",
"def test_simple_parse(self):\n pass",
"def test_basic_parsers():",
"def __init__(self, parser):\n if parser == \"csv\":\n self._par... | [
"0.67136407",
"0.64401156",
"0.63453275",
"0.62447006",
"0.6202729",
"0.61242324",
"0.61228955",
"0.6109933",
"0.60615706",
"0.60477245",
"0.60369617",
"0.6022127",
"0.5999023",
"0.59757316",
"0.594359",
"0.5933972",
"0.5901211",
"0.5888715",
"0.5855673",
"0.584835",
"0.58434... | 0.56508 | 45 |
These are options that only make sense for actual harvesters, such as ARM. They do not make sense for utilities that do not perform harvesting, such as the sitemap checker. | def add_harvesting_options(parser, id):
help = (
"Ignore the last harvest time. Use this switch to attempt to "
"harvest records that may have failed for some reason on a recent "
"harvest attempt. The regex option may also be useful here."
)
parser.add_argument('--ignore-harvest-... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def options(self) -> list[str]:\n return [BYPASS, ARMED]",
"def options(self): # pragma: no cover\r\n return ''",
"def getServerOptions(self):\n pass",
"def _options(self):\n return",
"def __options(self):\n\t\ta = 1 if self.random else 0\n\t\tb = 2 if self.topoftheday else 0\n... | [
"0.63878936",
"0.62212753",
"0.61612546",
"0.61248803",
"0.5934255",
"0.5776161",
"0.5709554",
"0.5666998",
"0.56532615",
"0.564446",
"0.55798537",
"0.5551045",
"0.55506915",
"0.5514824",
"0.5505621",
"0.5467913",
"0.54607224",
"0.5432014",
"0.54278624",
"0.54107505",
"0.5408... | 0.490981 | 89 |
Validate an XML document. | def validate():
description = f"Validate XML metadata."
parser = argparse.ArgumentParser(
description=description,
formatter_class=argparse.ArgumentDefaultsHelpFormatter
)
help = "XML file or URL"
parser.add_argument('infile', help=help)
help = (
"Format ID for metadata... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validateDocument(self, doc):\n if doc is None: doc__o = None\n else: doc__o = doc._o\n ret = libxml2mod.xmlValidateDocument(self._o, doc__o)\n return ret",
"def validate(self) :\n\t\tif self.doc is not None :\n\t\t\tparser = etree.XMLParser(recover=True, strip_cdata=True)\n\t\t\tt... | [
"0.77251816",
"0.73353755",
"0.7165082",
"0.71011734",
"0.70915216",
"0.7084776",
"0.6905823",
"0.6782283",
"0.67535055",
"0.6746288",
"0.6682557",
"0.65831435",
"0.65698",
"0.6530995",
"0.651539",
"0.64867383",
"0.64745414",
"0.6468379",
"0.64606",
"0.6451013",
"0.6378289",
... | 0.64024895 | 20 |
Get fields for a schema or instance context element. | def get_fields(self, element_node: ElementNode,
namespaces: Optional[NamespacesType] = None,
decoders: Optional[Tuple[XsdAttribute, ...]] = None) -> IdentityCounterType:
fields: List[IdentityFieldItemType] = []
def append_fields() -> None:
if isinstance... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_fields(self):\n return self._fields",
"def get_fields(self):\n return self.fields",
"def get_fields(self):\n return self.fields",
"def get_fields(self):\n\n\t\treturn self.__fields",
"def get_fields(self):\r\n return self.fields",
"def fields(self):\n return {k... | [
"0.69482595",
"0.6679385",
"0.6679385",
"0.6660547",
"0.66575557",
"0.6621774",
"0.65962017",
"0.65450466",
"0.65231115",
"0.64742976",
"0.64686394",
"0.6364058",
"0.63173836",
"0.6307222",
"0.62955815",
"0.6285253",
"0.62815905",
"0.62411195",
"0.6234588",
"0.6227274",
"0.62... | 0.5588493 | 79 |
What are the most popular three articles of all time? | def print_top_articles():
create_view_top_articles = (
"CREATE VIEW top_articles AS " +
"SELECT COUNT(path) AS num, path " +
"FROM log GROUP BY path ORDER BY num DESC;")
get_popular_articles_names = (
"SELECT title, num " +
"FROM top_articles, articles " +
"WHERE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def most_popular_articles():\n\n results = query_database(QUERIES[0])\n print('\\nWhat are the most popular three articles of all time?\\n')\n for title, views in results:\n print(' * \"{}\" -- {} views'.format(title, views))",
"def most_popular_articles():\n print '1. The most popular article... | [
"0.79686993",
"0.7780535",
"0.7766619",
"0.77628744",
"0.77026826",
"0.763548",
"0.75076354",
"0.7505313",
"0.7494586",
"0.74271536",
"0.7414069",
"0.71258545",
"0.7118688",
"0.71109426",
"0.70809424",
"0.70300716",
"0.7005257",
"0.6999698",
"0.69860226",
"0.69293576",
"0.692... | 0.0 | -1 |
Who are the most popular article authors of all time? | def print_top_authors():
create_view_top_articles = (
"CREATE VIEW top_articles AS " +
"SELECT COUNT(path) AS num, path " +
"FROM log GROUP BY path ORDER BY num DESC;")
create_view_top_authors = (
"CREATE VIEW top_authors as " +
"SELECT sum(num) as views, author " +
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_mostPopularAuthors():\n\n query = \"\"\"\n SELECT authors.name,COUNT(*) as views\n FROM articles join authors\n ON articles.author=authors.id\n JOIN log ON log.path LIKE ('/article/' || articles.slug)\n GROUP BY authors.name\n ORDER BY views DE... | [
"0.84637415",
"0.8395699",
"0.8325273",
"0.8321845",
"0.8157658",
"0.80273575",
"0.7990549",
"0.7792252",
"0.77818847",
"0.7686615",
"0.7682264",
"0.76261973",
"0.75585544",
"0.7522089",
"0.7496455",
"0.73912114",
"0.7381132",
"0.735024",
"0.73232555",
"0.7270634",
"0.7169818... | 0.61229473 | 46 |
On which days did more than 1% of requests lead to errors? | def print_errors():
create_view_total_requests = (
"CREATE VIEW total_requests AS " +
"SELECT date(time), count(status) as count " +
"FROM log GROUP BY date;")
create_view_error_requests = (
"CREATE VIEW error_requests AS " +
"SELECT date(time), count(status) as count " ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def days_with_request():\n\n # To print information\n information_string = '3. Days with more than ' \\\n '1% of request that lead to an error:\\n'\n\n # Query string\n query = \"\"\"select * from (select date(time),\n round(100.0*sum(case log.status\n whe... | [
"0.74424076",
"0.7376572",
"0.70266056",
"0.7013269",
"0.69252485",
"0.685988",
"0.6858518",
"0.68238664",
"0.6589236",
"0.6509093",
"0.6447439",
"0.64048654",
"0.6340471",
"0.63340926",
"0.6213541",
"0.6193134",
"0.61706835",
"0.60453206",
"0.596626",
"0.5903541",
"0.5840484... | 0.0 | -1 |
Generates a series of reflections for an intial point p and first impact q | def reflect_gen(p,q):
while True:
yield q
# n is a unit vector normal to the ellipse at point q
n = unit([ci*qi for (ci,qi) in zip((-4,-1),q)])
# d is a unit vector from p to q, e.g. the laser beams path
d = unit([pi - qi for (pi,qi) in zip(p,q)])
# r is a unit vector in the direction of the reflected lase... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mutation(i,N_p,t,T,P,N_vars,F_min,F_const):\n\n #Adaptive scaling factor\n if N_vars >= 3:\n F=F_min*2**np.exp(1-(T/(T+1-t)))\n else:\n F = F_const\n #candidates are assigned without the i-th element\n candidates= np.delete(np.arange(N_p), np.where(np.arange(N_p)==i))\n #3 targe... | [
"0.55361575",
"0.5507782",
"0.5372579",
"0.5360624",
"0.53593516",
"0.53491974",
"0.53188616",
"0.53064805",
"0.52135396",
"0.519285",
"0.51851183",
"0.51435244",
"0.51339656",
"0.5130794",
"0.51189184",
"0.5111052",
"0.5100512",
"0.50761175",
"0.5057054",
"0.50560147",
"0.50... | 0.6714796 | 0 |
The intersection of vector v and cell 4 x^2 + y^2 = 100 starting from p | def intersect(v, p):
# Solve for t: 100 = 4 * (px + t * vx)^2 + (py + t * vy)^2
# Note: 4 * px^2 + py^2 - 100 = 0
t = sum([c*vi*pi for (c,vi,pi) in zip((-8.0, -2.0),v,p)])
t /= sum([c * vi**2 for (c,vi) in zip((4.0,1.0),v)])
return [pi + vi * t for (pi, vi) in zip(p, v)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersection(x, y, f, p):",
"def getIntersectPoint(p1, p2, p3, p4):\n points = p1, p2, p3, p4\n gradients = (\n CollisionUtility.calculate_gradient(p1, p2), CollisionUtility.calculate_gradient(p3, p4)\n )\n\n # See if the the lines are parallel\n if gradients[0] ... | [
"0.724931",
"0.65389293",
"0.64866877",
"0.64301056",
"0.6412559",
"0.6410918",
"0.64012647",
"0.6370324",
"0.6325234",
"0.6305374",
"0.62554836",
"0.6230082",
"0.620606",
"0.6137867",
"0.61155015",
"0.6092252",
"0.6087884",
"0.60685384",
"0.6036107",
"0.60347986",
"0.6028091... | 0.8056194 | 0 |
vector d reflection about unit vector normal n r = D (2dot(D,N) / abs(N)^2) n | def reflect(d,n):
# coefficent c, because easier
c = 2 * dot(d,n)
return [di - c * ni for (di, ni) in zip(d,n)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _normal_vector(o, p0_3d, p1_3d):\n # The vector between middle point of v1-v2 and object center location\n # is the normal vector I'm looking for\n vn = p0_3d.lerp(p1_3d, 0.5) - o.matrix_world.translation\n # normalize so I can to length computation on it\n vn.normalize()\n return vn",
"def... | [
"0.6807638",
"0.6755607",
"0.6614936",
"0.6611211",
"0.6596045",
"0.65917015",
"0.657798",
"0.6512491",
"0.64908576",
"0.6453393",
"0.6406519",
"0.6351979",
"0.6341675",
"0.63390315",
"0.6328692",
"0.6297034",
"0.6287553",
"0.62832576",
"0.62556225",
"0.62344724",
"0.6223208"... | 0.6571784 | 7 |
Dot product of vectors x and y | def dot(x,y):
return sum([xi*yi for (xi,yi) in zip(x,y)]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vec_dot(x, y):\r\n return sum(a * b for a, b in zip(x, y))",
"def vector_dot(x, y):\n\n if(len(x) != len(y)):\n raise ValueError(\"vector lengths differ\")\n else:\n # return x1*y1+x2*y2+...xn*yn\n return sum([x[i] * y[i] for i in range(len(x))])",
"def dot(x, y):\n res = x[0... | [
"0.8719347",
"0.85587317",
"0.81081426",
"0.79403627",
"0.7918046",
"0.78332645",
"0.7820983",
"0.78134316",
"0.7771925",
"0.77611864",
"0.7745346",
"0.7739358",
"0.76962656",
"0.7687426",
"0.7682485",
"0.7668282",
"0.7629572",
"0.76284784",
"0.7628374",
"0.7611728",
"0.75885... | 0.83901334 | 2 |
Returns a unit vector in the same direction as x | def unit(x):
l = sum([i**2 for i in x])**0.5
return [xi/l for xi in x] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unit(self):\r\n return Vector(self.x/self.length(), self.y/self.length())",
"def unit():\n return Vec2d(0, 1)",
"def getUnitVector(self):\n return Vector.createFromPolar(1, self.angle)",
"def unit_vector(self,vector):\n return vector / np.linalg.norm(vector)",
"def to_unit(s... | [
"0.78788394",
"0.7592913",
"0.7465866",
"0.7433125",
"0.7410085",
"0.7399616",
"0.73799765",
"0.73799765",
"0.73799765",
"0.73718464",
"0.7347905",
"0.7326668",
"0.7326668",
"0.7326668",
"0.7326668",
"0.7326668",
"0.7326668",
"0.7326668",
"0.7326668",
"0.7326668",
"0.7326668"... | 0.6536953 | 51 |
Generate Brauer states on 4 qubits. | def test_brauer_2_dim_2_pval():
expected_res = np.array(
[
[1, 1, 1],
[0, 0, 0],
[0, 0, 0],
[1, 0, 0],
[0, 0, 0],
[0, 1, 0],
[0, 0, 1],
[0, 0, 0],
[0, 0, 0],
[0, 0, 1],
[0, 1, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generate_qubits(self):\n return cq.LineQubit.range(4)",
"def make_QN(Jmin, Jmax, I1, I2):\n QN = [UncoupledBasisState(J,mJ,I1,m1,I2,m2)\n for J in np.arange(Jmin, Jmax+1)\n for mJ in np.arange(-J,J+1)\n for m1 in np.arange(-I1,I1+1)\n for m2 in np.arange(-I2,I2+1)\n ]\n ... | [
"0.6086551",
"0.60675687",
"0.60443336",
"0.5823746",
"0.57302165",
"0.5619075",
"0.55097914",
"0.54892236",
"0.54565513",
"0.5449651",
"0.54224604",
"0.54169273",
"0.5399316",
"0.5391886",
"0.5355335",
"0.53444993",
"0.5337477",
"0.5316138",
"0.5313683",
"0.5300682",
"0.5290... | 0.0 | -1 |
Set the power of all motors in the system | def set_motors(self,power):
for i in range(len(self.motors)):
self.motors[i].power = power
#print "Motor %i: %d" % (i, self.motors[i].power) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_power(self, power):\n print('Setting santec power to %.4f mW' % power)\n self.santec1.write(\"LP %.2f\" % power)\n self.santec2.write(\"LP %.2f\" % power)\n self.santec3.write(\"LP %.2f\" % power)\n self.santec4.write(\"LP %.2f\" % power)",
"def set_powers(self, power_1... | [
"0.7091687",
"0.70202076",
"0.6936355",
"0.68218803",
"0.6769513",
"0.6765122",
"0.6765122",
"0.67307574",
"0.67279464",
"0.6608434",
"0.6575763",
"0.65288085",
"0.65074164",
"0.6494266",
"0.64406693",
"0.64244634",
"0.6414524",
"0.6405676",
"0.6385484",
"0.63689655",
"0.6355... | 0.7770252 | 0 |
Updates the thrust, climb rate and height of the QuadCopter model. | def update_all(self,delta_t):
self.update_thrust()
self.update_climb_rate()
self.update_height(delta_t) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_vehicle_state(self):\n #vel = self.v + self.commands['throttle']/self.m/self.simulation_rate\n\n vel = self.commands['speed']\n steer = self.commands['steering_angle']\n\n if steer > 0.5:\n steer_cmd = 25\n elif steer < -0.5:\n steer_cmd = 185\n ... | [
"0.5559533",
"0.5498132",
"0.54623824",
"0.54417586",
"0.5429667",
"0.54125965",
"0.5399066",
"0.5371565",
"0.53581613",
"0.5342093",
"0.5301803",
"0.5297535",
"0.52953154",
"0.5255505",
"0.52489734",
"0.52468264",
"0.5231706",
"0.5230685",
"0.51868993",
"0.517444",
"0.517129... | 0.6069336 | 0 |
Print Hall Account statements for specified hall_ID | def print_statement(Hall):
pdf = FPDF('P', 'mm', 'A4')
pdf.add_page('P')
pdf.set_font('Times', 'B', 14)
pdf.multi_cell(0, 5, ('Hall Account Statement for Hall: %s' % Hall.name))
pdf.ln()
pdf.multi_cell(0, 5, ('Mess Account: %s' % Hall.mess_account))
pdf.ln()
pdf.multi_cell(0, 5, ('Sala... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_out_account_balances(list_of_all_accounts_known):\n for account in list_of_all_accounts_known:\n print('{0} {1}'.format(account.account_id, account.balance))",
"def printout_all(self, indent_level):\n indent = \" \"*indent_level*INDENTATION_MULTIPLIER\n\n print(indent, \"Challen... | [
"0.5709103",
"0.5544263",
"0.5517013",
"0.5512406",
"0.539924",
"0.53783804",
"0.534881",
"0.53042066",
"0.5273528",
"0.5243377",
"0.5196611",
"0.5160384",
"0.51566947",
"0.5139505",
"0.5105222",
"0.5089654",
"0.50697607",
"0.50514734",
"0.50506085",
"0.5023857",
"0.5022506",... | 0.7365047 | 0 |
Print salary and payment cheques with worker_ID Print hall payment cheques with hall_ID | def issue_cheque(name, amount):
pdf = FPDF('P', 'mm', 'A4')
pdf.add_page('P')
pdf.set_font('Times', 'B', 14)
pdf.multi_cell(0, 5, 'Cheque Payment System')
pdf.ln()
pdf.multi_cell(0, 5, ('Pay: %s' % name))
pdf.ln()
pdf.multi_cell(0, 5, ('The amount of: Rs. %s' % str(amount)))
pdf.ln... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_salary_list(Hall):\n\n pdf = FPDF('P', 'mm', 'A4')\n pdf.add_page('P')\n pdf.set_font('Times', 'B', 14)\n\n pdf.multi_cell(0, 5, ('Hall Salary List: Hall %s' % Hall.hall_ID))\n pdf.ln()\n\n worker_list = dbr.rebuild(\"worker\")\n title = \"Role\"\n wage = 0\n for key in work... | [
"0.66752523",
"0.6188767",
"0.5423987",
"0.5204655",
"0.5056237",
"0.49969152",
"0.49781322",
"0.49219614",
"0.49140453",
"0.49073628",
"0.48915973",
"0.48814258",
"0.48631328",
"0.48400798",
"0.48394734",
"0.48239037",
"0.4811467",
"0.48080567",
"0.48048052",
"0.4777241",
"0... | 0.4374707 | 93 |
Print list of all employees and respective salary details for specified hall Take dict of Worker objects as parameter | def generate_salary_list(Hall):
pdf = FPDF('P', 'mm', 'A4')
pdf.add_page('P')
pdf.set_font('Times', 'B', 14)
pdf.multi_cell(0, 5, ('Hall Salary List: Hall %s' % Hall.hall_ID))
pdf.ln()
worker_list = dbr.rebuild("worker")
title = "Role"
wage = 0
for key in worker_list:
if w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_employee(self):\n print \"[Name: %s] [Salary: %d]\" % (self.name, self.salary)",
"def process_employees_salary(self, employees_info: List[List[str]]) -> None:\n pass",
"def get_employee():\n\n employee_id = get_employee_input_int('Enter employee ID to get the data ')\n employee ... | [
"0.6291626",
"0.60116225",
"0.5826728",
"0.574985",
"0.5696388",
"0.5555719",
"0.551769",
"0.546262",
"0.54150295",
"0.5407232",
"0.5379048",
"0.5360772",
"0.5356221",
"0.53249127",
"0.52363753",
"0.52281964",
"0.5221268",
"0.5192776",
"0.5192633",
"0.51646",
"0.5135642",
"... | 0.7293566 | 0 |
Print receipts related to specified Student Contain all three amounts paid mess fees, room rent, amenities charge | def print_receipt(Student):
pdf = FPDF('P', 'mm', 'A4')
pdf.add_page('P')
pdf.set_font('Times', 'B', 14)
pdf.multi_cell(0, 5, 'Student Dues Payment Receipt')
pdf.ln()
pdf.multi_cell(0, 5, ('Student ID: %s' % Student.student_ID))
pdf.ln()
pdf.multi_cell(0, 5, ('Name: %s' % Student.name)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_student_report(self):\n \n period_type = self.parameter_dict.get(\"period_type\", \"monthly\")\n insert_gender_markers = self.parameter_dict.get(\n \"insert_gender_markers\", False)\n period = [(self.start_date,self.end_date)]\n for student in self.student... | [
"0.58656114",
"0.5852727",
"0.5595382",
"0.55868745",
"0.5516554",
"0.5511955",
"0.5490234",
"0.54839575",
"0.5436576",
"0.541411",
"0.5412061",
"0.53985006",
"0.53951246",
"0.5368056",
"0.53509426",
"0.5329534",
"0.5324563",
"0.5310762",
"0.5279635",
"0.527889",
"0.5268582",... | 0.75747764 | 0 |
Print letter for Student at time of admission Contains details as provided by the Student | def issue_student_admission_letter(Student, body):
pdf = FPDF('P', 'mm', 'A4')
pdf.add_page('P')
pdf.set_font('Times', 'B', 14)
pdf.multi_cell(0, 5, 'Student Admission Letter')
pdf.ln()
pdf.multi_cell(0, 5, ('Name: %s' % Student.name))
pdf.ln()
pdf.multi_cell(0, 5, ('Address: %s' % Stu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_student(s_info):\n print('')\n print('Your information:')\n print(f'{s_info.student_id} - {s_info.first_name} {s_info.last_name}')",
"def __str__(self):\n return \"student:\"+str(self.name)+\":\"+str(self.age)+\":\"+str(self.major)",
"def __str__(self):\n return str(self.__st... | [
"0.6675286",
"0.6378189",
"0.6343893",
"0.6320618",
"0.6295893",
"0.6235386",
"0.61603206",
"0.6133385",
"0.6130784",
"0.6011712",
"0.6004627",
"0.5992418",
"0.5982091",
"0.59453845",
"0.5931745",
"0.59027773",
"0.5890217",
"0.58893615",
"0.585697",
"0.5848341",
"0.5838587",
... | 0.6613428 | 1 |
Initialize an object with loading the credentials using a credentials file and yaml key | def __init__(self, cred_file, yaml_key):
self.premium_search_args = load_credentials(cred_file,
yaml_key=yaml_key,
env_overwrite=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, passwd=None, yamlname=None): # Passwd is in the clear so be careful\n if yamlname is None:\n utilities.log.error('No json configuration was provided for iRODS: Abort')\n sys.exit(1)\n if passwd is None:\n utilities.log.error('No passwd was provided ... | [
"0.7274843",
"0.6939988",
"0.69185185",
"0.68165654",
"0.6759032",
"0.67555183",
"0.6753559",
"0.67516315",
"0.6747947",
"0.6732597",
"0.6726737",
"0.6692598",
"0.6635135",
"0.65862745",
"0.6492167",
"0.6491658",
"0.64460856",
"0.6417166",
"0.64065987",
"0.63984865",
"0.63525... | 0.728429 | 0 |
Get only the necessary fields of a tweet returns a Tweet with the needed attributes as a dict | def get_tweet_attributes(self, tw):
tw_dict = {}
tw_dict['created_at'] = tw['created_at']
tw_dict['lang'] = tw['lang']
tw_dict['text'] = tw['text']
tw_dict['entities'] = tw['entities']
tw_dict['favorite_count'] = tw['favorite_count']
tw_dict['ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tweets_features(tweet):\n tweet = remove_stop_words(tweet)\n return {'TWEET': tweet}",
"def extract_user_dict_from_tweet( tweet: Tweet ):\n if tweet.other_data and len( tweet.other_data ) > 0:\n # extract the json into a dict\n j = json.loads( tweet.other_data )\n # extract the ... | [
"0.6789574",
"0.67805123",
"0.6629773",
"0.6599947",
"0.6406722",
"0.6375403",
"0.6339529",
"0.62415105",
"0.62412876",
"0.6117636",
"0.6082488",
"0.605193",
"0.60203075",
"0.5877773",
"0.58547664",
"0.5826857",
"0.57997686",
"0.57727486",
"0.5763892",
"0.57532144",
"0.573178... | 0.7178673 | 0 |
Sets the Search Query and maximum Tweets to be retrieved to save Quota | def premium_set_search_params(self, search_query, from_date, to_date,
no_retweets=True, results_per_call=500):
# Set a static Language Filter for English Tweets
lang_filter = ' lang:en'
if no_retweets:
rt_filter = ' -is:retweet'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search(self, query, maxhits=100):",
"def search_tweets(q, count=100, result_type=\"recent\"):\n\n return t.search.tweets(q=q, result_type=result_type, count=count)",
"def searchTweets():\n if 'api' not in globals():\n startTwitterApi(getApiKeys(fileName='apiConf2.txt'))\n #SEARC... | [
"0.6628925",
"0.6010755",
"0.58798695",
"0.5672977",
"0.56503266",
"0.56472254",
"0.55878645",
"0.557733",
"0.5573124",
"0.55702484",
"0.54949117",
"0.5455376",
"0.5433694",
"0.5421352",
"0.5407392",
"0.5406379",
"0.53991216",
"0.53986245",
"0.536909",
"0.53584504",
"0.535530... | 0.5829757 | 3 |
Downloads all Tweets since from_date for a Query and saves them into txt File (in append mode) | def premium_download_save_tweets(self, file_name, max_results=100):
tweets = collect_results(self.rule,
max_results=max_results,
result_stream_args=self.premium_search_args)
# save all tweets into specified file_name
with open(file_name, '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_tweets(self):\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\n auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)\n api = tweepy.API(auth)\n search = api.search(self.term, lang='en', count=100)\n\n print(f\"Getting tweets that mention '{self.term}', \"\n ... | [
"0.62766623",
"0.62647164",
"0.6243787",
"0.62299496",
"0.6025572",
"0.5915222",
"0.5898549",
"0.5892832",
"0.5863716",
"0.5862079",
"0.5858822",
"0.5833427",
"0.58319485",
"0.582733",
"0.5794519",
"0.57683766",
"0.57517594",
"0.5748663",
"0.5743377",
"0.57433707",
"0.5739671... | 0.5302306 | 43 |
Add all graphs for displaying sensor data. | def CreateGraphs(self, sensorid):
for i in range(len(sensorid)):
# Add a graph plot to list
self.plotter[sensorid[i]] = plot.PlotCanvas(self.panel)
self.plotter[sensorid[i]].SetEnableLegend(True)
#self.plotter[sensorid[i]].SetEnableGrid(True)
#self.plo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_graphs(self):\n self.frequency_plot_graph.show()\n self.resistance_graph.show()\n self.temperature_plot_graph.show()\n self.pressure_plot_graph.show()\n self.humidity_plot_graph.show()\n self.overview_graph.show()\n self.overview_graph.setXRange(-1000, 5000... | [
"0.6879036",
"0.6579829",
"0.65368325",
"0.6452261",
"0.6339766",
"0.6261383",
"0.62553847",
"0.6229404",
"0.62257975",
"0.62213117",
"0.6219536",
"0.61914164",
"0.6187895",
"0.6159931",
"0.6148075",
"0.61305416",
"0.6126133",
"0.6087059",
"0.60675865",
"0.6028357",
"0.600044... | 0.6922832 | 0 |
Set window size of current display | def SetWindowSize(self, size):
self.WINDOW_SIZE = size | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setwinsize(self, rows, cols):",
"def setWindowSize(width,height):\n dislin.winsiz(width,height)",
"def set_screen(self, size):\r\n self.screen = size",
"def _set_size(self):\n if self.width_key is not None:\n width = config.get(self.width_key)\n height = config.get(self... | [
"0.79207087",
"0.78689796",
"0.7652138",
"0.7652046",
"0.75910395",
"0.75640345",
"0.756109",
"0.7339863",
"0.7235763",
"0.7189826",
"0.71311337",
"0.7078242",
"0.7067841",
"0.69597495",
"0.6903613",
"0.68661195",
"0.68347853",
"0.6817149",
"0.68012214",
"0.67621917",
"0.6740... | 0.76013273 | 4 |
Set sample rate of sensor data | def SetSampleRate(self, rate):
self.SAMPLE_RATE = rate | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_sample_rate(self, rate):\n self.check_validity()\n\n rate = int(rate)\n\n self.ipcon.send_request(self, BrickletIndustrialDualAnalogInV2.FUNCTION_SET_SAMPLE_RATE, (rate,), 'B', 0, '')",
"def set_sample_rate(self, sample_rate):\n self.sample_rate = int(sample_rate)",
"def inp... | [
"0.78305626",
"0.7814654",
"0.7746749",
"0.75562114",
"0.7241588",
"0.72325975",
"0.72177637",
"0.7163793",
"0.71605283",
"0.69814014",
"0.69683295",
"0.68970877",
"0.6854266",
"0.6808533",
"0.6751939",
"0.6750906",
"0.66985595",
"0.6612969",
"0.6603941",
"0.658892",
"0.65612... | 0.77738357 | 2 |
Set the frequency of clock used for timestamps | def SetTimeClockSource(self, source):
self.TIME_CLOCK_SOURCE = source | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_freq_hz(self, freq=None):\n if freq is None:\n freq = 1000000 * self.def_freq\n self.instr.write('F1 ' + str(freq) + ' H')\n time.sleep(self.sleep_time)",
"def frequency(self, freq):\n self.set_frequency(f'{freq}' if self._is_min_max(freq) else f'{freq}HZ')",
"def... | [
"0.7045347",
"0.6800048",
"0.66994375",
"0.66994375",
"0.6680092",
"0.6667348",
"0.6635364",
"0.6589021",
"0.6579017",
"0.6578679",
"0.657218",
"0.6483262",
"0.6451029",
"0.6443337",
"0.6431313",
"0.6403015",
"0.634181",
"0.63294667",
"0.6321863",
"0.6309367",
"0.62990135",
... | 0.607602 | 41 |
Set the range of Yaxis for display | def SetYAxisRange(self, lower, upper):
self.Y_AXIS_RANGE = (lower, upper) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __draw_yaxis(self):\n self.ax.set_ylim(self.ylims)\n # set y ticks\n yticks = [*range(0, self.ymax, 5)]\n fs = self.settings.rcParams[\"axes.labelsize\"] if self.settings.otherParams[\n \"ylabel.fontsize\"] is None else self.settings.otherParams[\"ylabel.fontsize\"]\n ... | [
"0.7353007",
"0.72912204",
"0.7056452",
"0.7000773",
"0.69802177",
"0.69701964",
"0.69701964",
"0.6961962",
"0.6933012",
"0.6850009",
"0.6794499",
"0.67578864",
"0.67419934",
"0.67419934",
"0.67362744",
"0.67272717",
"0.67264444",
"0.666699",
"0.66562355",
"0.6655635",
"0.662... | 0.8293696 | 0 |
Plot the graph for corresponding sensor data | def _PlotGraph(self, event):
self._rcvLock.acquire()
for j in event.data[0].keys():
data = event.data[0][j]
#print data
line = []
for k in data.keys():
if k in COLORS.keys():
c = COLORS[k]
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_data(self):",
"async def plot_device_data(self, axes, name) -> []:\n pass",
"def plot_graph(self) -> None:",
"def visualize_signal(self):\n plt.figure()\n plt.title('Accelerometer Signal')\n plt.plot(range(len(self.data)), self.data[1])",
"def plot(self):\n pass"... | [
"0.75636965",
"0.70755386",
"0.70508736",
"0.7003091",
"0.6793981",
"0.670657",
"0.6649556",
"0.6627259",
"0.6556057",
"0.65330535",
"0.64661133",
"0.64386946",
"0.6424212",
"0.6413959",
"0.6405251",
"0.6394528",
"0.6362279",
"0.63578933",
"0.63299096",
"0.6308484",
"0.630025... | 0.6922587 | 4 |
raises astropy.units.UnitsError if not a distance unit | def _convert_to_and_validate_distance_unit(unit):
if unit is not None:
unit = u.Unit(unit)
if not unit.is_equivalent(u.kpc):
raise u.UnitsError(six.u('Unit "{0}" is not a distance').format(unit))
return unit | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getDistanceUnits(self) -> Unit:\n ...",
"def test_get_distance() -> None:\n meters = location_util.distance(\n COORDINATES_PARIS[0],\n COORDINATES_PARIS[1],\n COORDINATES_NEW_YORK[0],\n COORDINATES_NEW_YORK[1],\n )\n\n assert meters / 1000 - DISTANCE_KM < 0.01",
... | [
"0.68959516",
"0.6531648",
"0.61516035",
"0.6054251",
"0.6039936",
"0.6039793",
"0.60213655",
"0.6009243",
"0.59936506",
"0.5992886",
"0.5975478",
"0.5958747",
"0.5953431",
"0.5900235",
"0.589641",
"0.5890246",
"0.5827913",
"0.58258593",
"0.5817387",
"0.5809252",
"0.58037347"... | 0.7658923 | 0 |
The redshift for this distance assuming its physical distance is a luminosity distance. | def compute_z(self, cosmology=None):
from ..cosmology import luminosity_distance
from scipy import optimize
# FIXME: array: need to make this calculation more vector-friendly
f = lambda z, d, cos: (luminosity_distance(z, cos).value - d) ** 2
return optimize.brent(f, (self.Mpc, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def luminosity_distance(self, z):\n return self.proper_distance(z) * (1 + z)",
"def luminosity_distance(self, z):\n da = self.angular_diameter_distance(z)\n dl = da*(1.+z)**2.\n return(dl)",
"def get_luminosity(self):\n\n if self.no_dist is False and self.no_flux is False:\n\... | [
"0.5890186",
"0.58678305",
"0.5807113",
"0.5798565",
"0.56901914",
"0.5677453",
"0.5615042",
"0.5581174",
"0.5569656",
"0.5483461",
"0.5445089",
"0.52822375",
"0.5251608",
"0.5222585",
"0.5203338",
"0.5182899",
"0.5171239",
"0.5140096",
"0.5124801",
"0.51096433",
"0.510625",
... | 0.0 | -1 |
The distance modulus of this distance as a Quantity | def distmod(self):
val = 5. * np.log10(self.to(u.pc).value) - 5.
return u.Quantity(val, u.mag) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distmod(self):\n val = 5.0 * np.log10(self.to_value(u.pc)) - 5.0\n return u.Quantity(val, u.mag, copy=False)",
"def modulus(self):\n return math.sqrt(self._reNum ** 2 + self._imNum ** 2)",
"def modulus(self):\n return self._n",
"def distance_modulus(d):\n dmag = 5 * log(d) ... | [
"0.7152383",
"0.66799486",
"0.65983427",
"0.6582863",
"0.6300369",
"0.6256586",
"0.6187268",
"0.61243665",
"0.6103785",
"0.606291",
"0.5966888",
"0.58380646",
"0.58076847",
"0.57429963",
"0.5727226",
"0.56864965",
"0.5662907",
"0.565712",
"0.56445813",
"0.56345314",
"0.561879... | 0.69861215 | 1 |
Converts to the spherical representation of this point. Returns | def to_spherical(self):
return cartesian_to_spherical(self.x, self.y, self.z) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cartesian_to_spherical(self, v):\n x = Vector.x(v)\n y = Vector.y(v)\n z = Vector.z(v)\n r = Vector.length(v)\n phi = atan2(y, x)\n theta = acos(z / r)\n \n return [r, phi, theta]",
"def spherical(self, x, y):\n\t\twhile x >= self.planet.width or x < 0 o... | [
"0.7045606",
"0.66927147",
"0.6692273",
"0.668019",
"0.65737593",
"0.65737593",
"0.6492899",
"0.6417639",
"0.6404603",
"0.6351715",
"0.6329752",
"0.6121212",
"0.61188513",
"0.6074496",
"0.6060194",
"0.6014923",
"0.60014564",
"0.5973966",
"0.5957356",
"0.5955025",
"0.594932",
... | 0.81549674 | 0 |
Converts 3D rectangular cartesian coordinates to spherical polar coordinates. Note that the resulting angles are latitude/longitude or elevation/azimuthal form. I.e., the origin is along the equator rather than at the north pole. | def cartesian_to_spherical(x, y, z):
import math
xsq = x ** 2
ysq = y ** 2
zsq = z ** 2
r = (xsq + ysq + zsq) ** 0.5
s = (xsq + ysq) ** 0.5
if np.isscalar(x) and np.isscalar(y) and np.isscalar(z):
lon = math.atan2(y, x)
lat = math.atan2(z, s)
else:
lon = np.arc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cart2polar3d(cartesian):\n radius = np.linalg.norm(cartesian)\n theta = np.cos",
"def cartesian2polar(cartesian):\n cartesian = np.array(cartesian).squeeze()\n x, y = cartesian\n r = np.linalg.norm([x, y])\n azimuth = np.arctan2(y, x)\n return np.array([r, azimuth])",
"def cartesianToS... | [
"0.76471215",
"0.7625322",
"0.7124141",
"0.7048745",
"0.7016254",
"0.6994713",
"0.69758683",
"0.69751894",
"0.6937516",
"0.693436",
"0.6899067",
"0.6815604",
"0.6741575",
"0.6709526",
"0.6708642",
"0.66996217",
"0.6681919",
"0.6673441",
"0.66703224",
"0.665601",
"0.6650638",
... | 0.692961 | 10 |
Converts spherical polar coordinates to rectangular cartesian coordinates. Note that the input angles should be in latitude/longitude or elevation/azimuthal form. I.e., the origin is along the equator rather than at the north pole. | def spherical_to_cartesian(r, lat, lon):
import math
if np.isscalar(r) and np.isscalar(lat) and np.isscalar(lon):
x = r * math.cos(lat) * math.cos(lon)
y = r * math.cos(lat) * math.sin(lon)
z = r * math.sin(lat)
else:
x = r * np.cos(lat) * np.cos(lon)
y = r * np.cos(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cartesian2polar(cartesian):\n cartesian = np.array(cartesian).squeeze()\n x, y = cartesian\n r = np.linalg.norm([x, y])\n azimuth = np.arctan2(y, x)\n return np.array([r, azimuth])",
"def polar2cartesian(polar):\n polar = np.array(polar).squeeze()\n r, azimuth = polar\n x = r * np.cos... | [
"0.69084823",
"0.6874946",
"0.68709445",
"0.6757234",
"0.6717186",
"0.66640395",
"0.6525707",
"0.65130717",
"0.6473055",
"0.63773054",
"0.636866",
"0.63315773",
"0.6329993",
"0.6318075",
"0.63170975",
"0.62099665",
"0.61673385",
"0.6121615",
"0.6089441",
"0.6082668",
"0.60540... | 0.6114368 | 18 |
Compute career pathways (i.e. userperformed and recommended) for each user. | def compute_pathways(users, job_graph, debug, min_likelihood_thr=0.2):
start_time = time.time()
__print_msg('Computing career pathways...', debug)
user_pathways = {}
tot_users = len(users)
i = 0
for user, user_jobs in users.items():
user_pathway = compute_user_pathway(user_jobs, j... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_user_pathway(user_jobs, job_graph, debug=False):\r\n pathway = []\r\n for i, job in enumerate(user_jobs):\r\n if i == 0:\r\n continue\r\n cluster, _ = job_graph.assign_job_to_jobgraph_state(job)\r\n pathway.append(cluster)\r\n return pathway",
"def metric_path... | [
"0.5953887",
"0.59538865",
"0.56319934",
"0.56293374",
"0.55796844",
"0.55332",
"0.55092543",
"0.5428622",
"0.5426576",
"0.54115033",
"0.5401471",
"0.53886443",
"0.5361762",
"0.53074896",
"0.521614",
"0.5194592",
"0.51802075",
"0.51579696",
"0.51287794",
"0.5086181",
"0.50838... | 0.73937947 | 0 |
Compute the user pathway, given the sequence of job titles. The first job will be excluded, because it is only used to build the user's initial profile. | def compute_user_pathway(user_jobs, job_graph, debug=False):
pathway = []
for i, job in enumerate(user_jobs):
if i == 0:
continue
cluster, _ = job_graph.assign_job_to_jobgraph_state(job)
pathway.append(cluster)
return pathway | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_pathways(users, job_graph, debug, min_likelihood_thr=0.2):\r\n start_time = time.time()\r\n __print_msg('Computing career pathways...', debug)\r\n user_pathways = {}\r\n tot_users = len(users)\r\n i = 0\r\n for user, user_jobs in users.items():\r\n user_pathway = compute_user_p... | [
"0.66621715",
"0.64165413",
"0.5436636",
"0.5328678",
"0.5032977",
"0.49962577",
"0.49273804",
"0.488265",
"0.46935585",
"0.46905273",
"0.46765473",
"0.4644199",
"0.46357313",
"0.45190293",
"0.45152992",
"0.4504067",
"0.44798177",
"0.44772255",
"0.4473935",
"0.44730064",
"0.4... | 0.71870023 | 0 |
Recommend a pathway, given the sequence of job titles. | def recommend_pathway(user_jobs, job_graph, goal_state, min_likelihood_thr):
user_jobs_for_mdp = [user_jobs[0]]
mdp = MDP(job_graph, user_jobs_for_mdp, goal_state, min_likelihood_thr=min_likelihood_thr)
return mdp.solve_mdp() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recommendations(artist, title):\n rec = Recommendation(artist, title)\n if rec.find_track_info():\n rec.load_recommendations()\n return render_template('recommendations.html', title='Your Recommendations', rec=rec)\n flash('Whoops, we did not find the track \"{}\" by {}!'.format(\\\n ... | [
"0.55554616",
"0.49509117",
"0.49274385",
"0.49202466",
"0.47717598",
"0.4758381",
"0.47329575",
"0.4687782",
"0.46796837",
"0.46436214",
"0.4615047",
"0.46136823",
"0.45894393",
"0.45886946",
"0.4578933",
"0.45743513",
"0.456499",
"0.4564924",
"0.45648426",
"0.45518708",
"0.... | 0.6105465 | 0 |
Evaluation of the recommended career pathways. | def evaluate_metrics(pathways, debug):
__print_msg('Evaluating metrics...', debug)
metrics = {}
metrics['CareerGoalReached'], metrics['ShorterRecommendedPath'], metrics['UserPathAvgLength'], metrics['RecPathAvgLength'] = metric_path_length(pathways)
__print_msg('Career goal reached: {}'.format(metri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_make_pathways(self):\n basic_test_runner(self, 'pathways')",
"def its_because_school(connection):\n print(\"Shortest path between two nodes\")\n answer = connection.execute(connection.get_path, 0, 4)\n for a in answer.values():\n print(a)\n print(\"Centrality closeness\")\n ... | [
"0.5988142",
"0.5983045",
"0.5924726",
"0.5891215",
"0.58438075",
"0.5810156",
"0.5804012",
"0.5724945",
"0.56719637",
"0.56543106",
"0.56524086",
"0.5631604",
"0.5616083",
"0.5610215",
"0.5607715",
"0.5578848",
"0.5551957",
"0.5545246",
"0.55360115",
"0.55338514",
"0.5530114... | 0.5730355 | 7 |
Compute the percentage of times the recommended pathway is shorter than the user's one. | def metric_path_length(pathways):
num_users = len(pathways)
num_good_recommendations = 0
sum_u_path_len = 0
sum_r_path_len = 0
career_goal_reached = 0
for user, pathway_tuple in pathways.items():
u_path = pathway_tuple[0]
r_path = pathway_tuple[1]
sum_u_path_len ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def h_score(self):\n if self.estimated_moves_to_goal is None:\n self.estimated_moves_to_goal = \\\n max(nx.single_source_shortest_path_length(self.graph, self.head_node).items(), key=lambda x: x[1])[1]\n return self.estimated_moves_to_goal",
"def percent_passing(self) -> f... | [
"0.62298673",
"0.61328906",
"0.6114768",
"0.6096005",
"0.6058874",
"0.60417265",
"0.5953899",
"0.59453714",
"0.59453714",
"0.59438455",
"0.59438455",
"0.59332836",
"0.5882768",
"0.58660126",
"0.5852752",
"0.5846534",
"0.58149326",
"0.58115447",
"0.57984257",
"0.57840717",
"0.... | 0.76785594 | 0 |
Do not return anything, modify nums inplace instead. | def rotate(self, nums, k):
k = k % len(nums)
num = nums[:]
num1 = num[-k:]
del num[-k:]
nums[:] = num1 + num
print(nums) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fn(i):\n if i == len(nums): ans.append(nums.copy())\n for j in range(i, len(nums)): \n nums[i], nums[j] = nums[j], nums[i]\n fn(i+1)\n nums[i], nums[j] = nums[j], nums[i]",
"def double_nums(num_list):",
"def remove_dups(nums):\r\n nums[:... | [
"0.70469916",
"0.67161703",
"0.66934896",
"0.6586775",
"0.6501143",
"0.6482345",
"0.6442288",
"0.6407945",
"0.6376896",
"0.6372343",
"0.63671577",
"0.6365932",
"0.63512594",
"0.6328759",
"0.6298402",
"0.62855035",
"0.62671727",
"0.62472045",
"0.62221444",
"0.6193869",
"0.6188... | 0.0 | -1 |
Executes 'num_steps' number of generations for each island in the archipelago's list of islands | def step_through_generations(self, num_steps):
for island in self._islands:
for _ in range(num_steps):
island.execute_generational_step()
self.archipelago_age += num_steps | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_generations(init_len):\n num_graphs = 0\n current_gen = [nx.path_graph(init_len)]\n complete_graph_list = current_gen.copy()\n while len(current_gen) and current_gen[0].size() < (3*init_len - 7):\n current_gen = generation_next(current_gen)\n num_graphs += show_graph_list(current_... | [
"0.622001",
"0.6160472",
"0.5919634",
"0.5737377",
"0.56605166",
"0.5636519",
"0.5605472",
"0.5555017",
"0.5548242",
"0.5515285",
"0.5510959",
"0.5510417",
"0.54903746",
"0.54616743",
"0.54526263",
"0.54507804",
"0.54276735",
"0.5407268",
"0.54053366",
"0.5392859",
"0.5392859... | 0.8080125 | 0 |
Shuffles island populations for migration and performs migration by swapping pairs of individuals between islands | def coordinate_migration_between_islands(self):
island_partners = self._shuffle_island_indices()
for i in range(self._num_islands//2):
self._shuffle_island_and_swap_pairs(island_partners, i) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def island_migration(self):\n for y in self.island_map:\n for cell in y:\n cell.migration()\n\n for y in self.island_map:\n for cell in y:\n for animal in cell.population:\n animal.has_moved = False",
"def migrate(pops, fit_pop)... | [
"0.68163073",
"0.6413612",
"0.6349531",
"0.61725616",
"0.6144668",
"0.59786785",
"0.59766847",
"0.5838693",
"0.58274037",
"0.58169585",
"0.58069676",
"0.58006257",
"0.5762604",
"0.57593423",
"0.57574344",
"0.571842",
"0.56880665",
"0.5660161",
"0.5643648",
"0.563159",
"0.5629... | 0.73018396 | 0 |
Tests that the fitness of individuals is less than or equal to the specified error tolerance | def test_for_convergence(self, error_tol):
list_of_best_indvs = []
for island in self._islands:
best_indv = island.best_individual()
list_of_best_indvs.append(best_indv)
list_of_best_indvs.sort(key=lambda x: x.fitness)
best_indv = list_of_best_indvs[0]
co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _test_expected_error_bound(bellman_error_margin, optimal_res, test_res, mdp):\n test_eval = test_res.policy.evaluate_on(mdp)\n test_occ = test_eval.state_occupancy #occupancy from start state\n test_start_steps = sum(test_occ.values())\n value_diff = test_res.initial_value - optimal_res.initial_va... | [
"0.67049265",
"0.6273725",
"0.5888294",
"0.5867151",
"0.5821513",
"0.58181053",
"0.5802155",
"0.57919264",
"0.57553136",
"0.5714477",
"0.56883866",
"0.56820804",
"0.56820804",
"0.56757665",
"0.56673026",
"0.5622294",
"0.56171614",
"0.56007904",
"0.5595701",
"0.55744684",
"0.5... | 0.7107953 | 0 |
Returns the best individual if the islands converged to an acceptable fitness. Returns | def get_best_individual(self):
return self._best_indv | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _best_individual(self):\n return max(self._population, key=attrgetter(\"fitness\"))",
"def best_individual(self):\n return self.population.best_individual()",
"def get_best(self) -> Chromosome:\n if not (self._best_chromosome is None): # if the best chromosome is unchanged since the l... | [
"0.80649817",
"0.75292766",
"0.71652573",
"0.6961003",
"0.6884281",
"0.6873114",
"0.67495084",
"0.66600174",
"0.6649065",
"0.6631332",
"0.6609789",
"0.6591238",
"0.65880316",
"0.6585515",
"0.65848273",
"0.65382606",
"0.65047693",
"0.64753777",
"0.6447623",
"0.6391002",
"0.633... | 0.76329255 | 1 |
ctor must be without arguments, it is created with reflection at run time | def __init__(self):
self.command_orchestrator = None # type: CommandOrchestrator | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs):\n raise NotImplementedError",
"def __init__(self, **kwargs):\n raise NotImplementedError",
"def __init__(self, *args, **kwargs) -> None:\n pass",
"def __init__(self, *args, **kwargs) -> None:\n pass",
"def __init__(self, *args, **kwargs):\n ... | [
"0.79701906",
"0.7918839",
"0.78944093",
"0.78944093",
"0.7850591",
"0.7834187",
"0.7754874",
"0.7754874",
"0.7754874",
"0.77097005",
"0.7696675",
"0.7696675",
"0.7696675",
"0.7696675",
"0.7654578",
"0.7654578",
"0.7654578",
"0.7654578",
"0.76379013",
"0.76379013",
"0.7637901... | 0.0 | -1 |
Powers off the remote vm | def PowerOn(self, context, ports):
return self.command_orchestrator.power_on(context, ports) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def power_off_vm_hard(v_sphere, vmw_vm):\n\n task = vmw_vm.PowerOff()\n task_functions.wait_for_task_complete(v_sphere, task, timeout_seconds=60)",
"def off(cls, client_object):\n vm_mor = client_object.get_api()\n return cls._do_power_action(vm_mor.PowerOffVM_Task())",
"def halt(vm='',env=... | [
"0.691207",
"0.68590164",
"0.68160033",
"0.66162086",
"0.65903586",
"0.65885574",
"0.6554674",
"0.64404196",
"0.6437955",
"0.63067865",
"0.6167935",
"0.61371875",
"0.61085886",
"0.60364866",
"0.5960529",
"0.59569734",
"0.5938743",
"0.59068495",
"0.5905675",
"0.58882743",
"0.5... | 0.0 | -1 |
> Part One Given a CSV file, read the data into a nested list | def clean_file(csv_file):
my_list = []
with open(csv_file, newline='') as csvfile:
file_reader = csv.reader(csvfile, delimiter=',', quotechar=" ")
for row in file_reader:
my_list.append(row)
"""
> Part Two
Input: Nested list csv_table and a string file_name
Action: W... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 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 ... | [
"0.7167241",
"0.7161207",
"0.70977736",
"0.7063041",
"0.7038156",
"0.7010745",
"0.70001847",
"0.6948276",
"0.69236016",
"0.6910194",
"0.68603677",
"0.68457425",
"0.68209416",
"0.6799708",
"0.67926854",
"0.6789507",
"0.67835903",
"0.6757448",
"0.67329955",
"0.67210245",
"0.671... | 0.0 | -1 |
THIS FUNCTION DOESN'T WORK PROPERLY DOESN'T WORK ABOVE A CERTAIN LIST SIZE HAVEN'T DEBUGGED TO FIND OUT WHY SINCE AN ANSWER IS GIVEN | def median_approx(values_list, numbins):
# call median_bins function: really nice technique here
mu, sigma, ignore_vals, bins = median_bins(values_list, numbins)
bin_width = 2 * sigma / numbins
# now get to midpoint of ... Adjust to include ignore_vals
N = ignore_vals + np.sum(bins)
midpoint = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_best_guess(self, lst):\n maxlen = 0\n pass\n #for elem in lst:",
"def main(size, item, answer):\n item = list(map(int, item))\n item.sort()\n for number in item:\n if size - number >= 0:\n size -= number\n answer += 1\n print(answer)",
"def solveProblem... | [
"0.67095226",
"0.59630436",
"0.59258145",
"0.56170946",
"0.5612554",
"0.55911374",
"0.55631673",
"0.5525219",
"0.5525219",
"0.5525219",
"0.55023384",
"0.54870147",
"0.54636025",
"0.5461479",
"0.545865",
"0.54275244",
"0.5421886",
"0.5410912",
"0.54019207",
"0.5401082",
"0.539... | 0.0 | -1 |
Largely used model answer idea of 'enumerate', and (b+0.5) not (b0.5) | def median_approx2(values, B):
# Call median_bins to calculate the mean, std,
# and bins for the input values
mean, std, left_bin, bins = median_bins(values, B)
# Position of the middle element
N = len(values)
mid = (N + 1) / 2
count = left_bin
for b, bincount in enumerate(bins):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def I (self, n):",
"def extractstatesusingintegral(self, bias=1.0):\n numtoadd = int(round(float(bias) * simplesum(comp.weight for comp in self.gmm)))\n print(\"bias is %g, numtoadd is %i\" % (bias, numtoadd))\n items = []\n # A temporary list of peaks which will gradually be decimate... | [
"0.57004464",
"0.5678648",
"0.5644198",
"0.55693084",
"0.5482084",
"0.5432887",
"0.54156345",
"0.5355259",
"0.53485566",
"0.53301316",
"0.5308281",
"0.5281137",
"0.5262242",
"0.5249782",
"0.5240983",
"0.523122",
"0.52278364",
"0.52272636",
"0.5227069",
"0.52154845",
"0.518535... | 0.0 | -1 |
This function renames parts of model to meet the specific requirements of this writer. This behaviour replaces the previous approach of subclassing the parser to produce different results depending on the which writer was intended to be used. | def rename(self):
# Remove any zero-padding from single-digit parameter names
# This reverses any change applied by one of the CUDA writers
for i in range(self.parser.comp-1, len(self.parser.parsedModel.parameterId)):
old_name = self.parser.parsedModel.parameterId[i]
num... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_model_name(self, name):\n self._name = name\n if self._zon is not None:\n self._zon.filename = f\"{name}.{self._zon.filename.split('.')[-1]}\"",
"def rename_value(model: onnx.ModelProto, old_name: str, new_name: str):\n if old_name == new_name:\n return\n logger =... | [
"0.6066185",
"0.57070076",
"0.56384206",
"0.5627522",
"0.5619943",
"0.56025624",
"0.55501103",
"0.5547868",
"0.5511047",
"0.54787534",
"0.5460824",
"0.5460824",
"0.5460381",
"0.5453813",
"0.54244596",
"0.53756005",
"0.53688747",
"0.5359618",
"0.53477144",
"0.5337874",
"0.5324... | 0.6582319 | 0 |
create or update customer | def create_or_update_customer(entity):
try:
organisation = entity.get('organisation').replace("'","")
organisation = "%s(C)"%organisation if is_supplier_or_customer_group(organisation) else organisation
name = frappe.db.get_value('Customer', organisation)
if not name:
customer = frappe.new_doc("Customer")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_customer_update(self):\n # first performe create\n id = self._create_model(\"customer\", self.customer_data, [\"name\", \"email\", \"phone\"])\n if id:\n # then performe update\n data = { \n \"name\": \"Changed the name\",\n \"email\... | [
"0.7436413",
"0.7397227",
"0.7354975",
"0.71516573",
"0.7110927",
"0.710495",
"0.7101501",
"0.70412105",
"0.69803005",
"0.69173807",
"0.686979",
"0.68632066",
"0.68632066",
"0.6809742",
"0.6789764",
"0.6761391",
"0.6745711",
"0.67418706",
"0.67362934",
"0.6710319",
"0.6705627... | 0.7588754 | 0 |
create or update the customer Contact | def create_or_update_contact(customer, entity):
name = frappe.db.get_value('Contact', { 'entity_id': entity.get('entity_id') })
if not name:
contact = frappe.new_doc('Contact')
else:
contact = frappe.get_doc("Contact", name)
if not entity.get('firstname'):
return
contact.first_name = entity.get('firstname... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_or_update_customer(entity):\n\ttry:\n\t\torganisation = entity.get('organisation').replace(\"'\",\"\")\n\t\torganisation = \"%s(C)\"%organisation if is_supplier_or_customer_group(organisation) else organisation\n\t\tname = frappe.db.get_value('Customer', organisation)\n\t\tif not name:\n\t\t\tcustomer =... | [
"0.7233565",
"0.68543464",
"0.66533446",
"0.6599077",
"0.6465166",
"0.64515483",
"0.64510775",
"0.6444469",
"0.6425489",
"0.6370573",
"0.63516873",
"0.6306901",
"0.62915707",
"0.62861454",
"0.62610596",
"0.6254461",
"0.6238027",
"0.62310433",
"0.62062687",
"0.61987454",
"0.61... | 0.81380326 | 0 |
create or update the address | def create_or_update_address(address, customer):
name = frappe.db.get_value('Address', { 'entity_id': address.get('entity_id') })
if not name:
addr = frappe.new_doc('Address')
addr.address_title = "{} {} {}".format(
address.get("firstname"),
address.get("lastname"),
address.get("entity_id")
)
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_address(self, new_address, ):\n self.address.append(new_address)\n self.save()",
"def update_address(cls, address_data):\n address_instance = cls.objects.get(email=address_data['customer']['email'])\n address_data = address_data.get('addresses')\n for field_name, values... | [
"0.7209289",
"0.70491314",
"0.6748431",
"0.660723",
"0.66056013",
"0.6600469",
"0.65181816",
"0.65090024",
"0.64898705",
"0.64765316",
"0.6472879",
"0.6464529",
"0.6418298",
"0.6395395",
"0.63934857",
"0.63818413",
"0.6379002",
"0.6343427",
"0.634245",
"0.6290266",
"0.628957"... | 0.762756 | 0 |
Conectado a botones, carga mensajes del grupo correspondiente Imprime mensajes en QTextBox | def cargar_mensajes_grupo(self, grupo):
texto = ""
for mensaje in Mensaje.grupos[grupo]:
if not self.filtrar_mensajes or mensaje.sospechoso:
if mensaje.sospechoso:
texto += f"<p style=\"color: red\">{mensaje}<p/>"
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __sendMessage(self):\n # TODO: Switch to this when implemented\n \n msg = self.ui.inputWidget.toPlainText()\n self.ui.inputWidget.clear()\n strv = StringView()\n strv.appendText(unicode(msg))\n self._amsn_conversation.sendMessage(strv)\n self.ui.textEdit.... | [
"0.6545797",
"0.645299",
"0.625715",
"0.6236866",
"0.61671734",
"0.61267936",
"0.6124985",
"0.61188024",
"0.6083885",
"0.6070145",
"0.6039385",
"0.59454966",
"0.59306055",
"0.59265524",
"0.5921751",
"0.58650035",
"0.58130616",
"0.5776519",
"0.57635653",
"0.57403535",
"0.57364... | 0.63634753 | 2 |
Conectado a QCheckBox, cambia el estado del filtro y refresca mensajes | def filterToggleEvent(self, event):
self.filtrar_mensajes = event
if self.mostrando_grupo:
self.cargar_mensajes_grupo(self.mostrando_grupo) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_filterCheckBox_clicked(self):\n self.__enableFindButton()",
"def comb_box_click(self):\n\n if self.checkBox.isChecked():\n self.completer.setFilterMode(Qt.MatchStartsWith)\n else:\n self.completer.setFilterMode(Qt.MatchContains)",
"def GetCheckButtonSelect(self... | [
"0.7090673",
"0.6638057",
"0.6402959",
"0.6243776",
"0.6092731",
"0.59084094",
"0.5837751",
"0.5827371",
"0.57131046",
"0.5701995",
"0.568451",
"0.5675553",
"0.5539249",
"0.5522574",
"0.55093926",
"0.55083394",
"0.550656",
"0.55010986",
"0.5493006",
"0.5438975",
"0.5406133",
... | 0.57840115 | 8 |
Loads package name from command line arguments. | def get_package_name():
package = None
try:
package = os.environ.get('LOCAL_PART', '') + os.environ.get('LOCAL_PART_SUFFIX', '')
if not package and len(sys.argv) > 1:
package = sys.argv[-1].lower()
except Exception,e:
log.error(str(e))
finally:
return package | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def command_package_init(*args):\n\n if len(args) == 0:\n print 'No package name specified'\n return 1\n packname = args[0]\n\n # Setup build, install, and data directories\n util.ensure_dir_exists(package_path(packname))\n\n # Touch an empty config.py where the user can adjust setting... | [
"0.56937206",
"0.5565932",
"0.5559221",
"0.555798",
"0.5511743",
"0.5511743",
"0.549686",
"0.54937357",
"0.5469482",
"0.5469482",
"0.54630214",
"0.5454337",
"0.54044306",
"0.5401598",
"0.539499",
"0.539345",
"0.53648907",
"0.5363433",
"0.5363248",
"0.5354271",
"0.53508025",
... | 0.6878033 | 0 |
Returns keyword (from supplied package name, if any). | def get_keyword(package):
try:
substr = re.search(r'(\S+)_(\S+)', package)
if substr:
return substr.groups()
except Exception,e:
log.error(str(e))
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readable_keyword(s):\n if s and not s.startswith(\"*\") and not s.startswith(\"[\"):\n if s.count(\".\"):\n library, name = s.rsplit(\".\", 1)\n return library + \".\" + name[0:].title()\n else:\n return s\n else:\n return s",
"def read_package_vari... | [
"0.63861567",
"0.62863207",
"0.6277217",
"0.62762856",
"0.62735116",
"0.62571263",
"0.6205",
"0.6157799",
"0.59881186",
"0.5964056",
"0.5946726",
"0.591496",
"0.588399",
"0.5882375",
"0.58692354",
"0.58623904",
"0.5844938",
"0.58448356",
"0.58406734",
"0.58017486",
"0.5789892... | 0.84235466 | 0 |
Initialise base schema of the DB for car sharing system. | def initialise_schema(db_name: str, password: str):
conn = psycopg2.connect(host='localhost', dbname=db_name, user='postgres', password=password)
cursor = conn.cursor()
cursor.execute(_query)
conn.commit()
conn.close()
print('Database schema was created successfully!\n') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_schema(self):\n models.Base.metadata.create_all(self.session.bind)",
"def initialise(self):\n\n if self.db_type == 'sqlite':\n try:\n # Attempt to create schema if not present, to cope with fresh DB file\n BaseSQLite.metadata.create_all(self.engine... | [
"0.7675053",
"0.7396573",
"0.73593235",
"0.72910017",
"0.7221896",
"0.71476793",
"0.71151453",
"0.70588493",
"0.70209366",
"0.70209366",
"0.70208734",
"0.7015672",
"0.6986679",
"0.6958186",
"0.6949035",
"0.69346476",
"0.69117707",
"0.6891788",
"0.6884205",
"0.687781",
"0.6866... | 0.0 | -1 |
This is my implementation of modularity using the formula directly from Wikipedia. | def get_modularity_other_c(A, cluster_indices):
# define the number of nodes in the graph and the number of clusters
n = len(cluster_indices)
nclusters = max(cluster_indices) + 1
# define the row sums of the adjacency matrix
row_sums = [sum(row) for row in A]
# define one half of the sum of all ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_modularity(modules, degree_table, edges, num_of_edges):\n modularity = 0.0\n for module in modules:\n modularity += calculate_q(module, degree_table, edges, num_of_edges)\n\n return modularity / (2.0 * num_of_edges)",
"def modularity():\n\n q = 0.0\n for idx in... | [
"0.68370956",
"0.67086875",
"0.616814",
"0.61296153",
"0.6121604",
"0.60440207",
"0.59257174",
"0.58213174",
"0.5771041",
"0.57512736",
"0.568411",
"0.56509286",
"0.56152207",
"0.55530596",
"0.55520487",
"0.55343777",
"0.5500709",
"0.54053086",
"0.53607327",
"0.53461915",
"0.... | 0.0 | -1 |
This is a modification of the original GirvanNewman formulation. | def get_modularity_other_b2(A, cluster_indices):
# define the number of nodes in the graph and the number of clusters
n = len(cluster_indices)
nclusters = max(cluster_indices) + 1
girvan_e = np.zeros((nclusters, nclusters))
volume = 0
for i in range(n):
for j in range(n):
if ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def narration_target(self):",
"def substantiate():",
"def genPrimerPairs_5Ext(primer_length=20, anneal_length=10, GC_low=40, GC_high=60):\n\n print('Primers for 5\\' extension half-asstemers')\n\n forwTemplate5_3 = GenOligoGC(primer_length,GC_low, GC_high)\n \"\"\"re.match checks if the first 2 Nuc ar... | [
"0.56081337",
"0.5455168",
"0.54125476",
"0.538638",
"0.53829026",
"0.5340331",
"0.5284942",
"0.52760315",
"0.5272306",
"0.5256002",
"0.5245553",
"0.5241749",
"0.52402973",
"0.5214805",
"0.5193872",
"0.51484257",
"0.5143233",
"0.51325196",
"0.5114381",
"0.51098406",
"0.509313... | 0.0 | -1 |
This is my implementation of modularity using the original GirvanNewman formulation. | def get_modularity_other_b(A, cluster_indices):
# define the number of nodes in the graph and the number of clusters
n = len(cluster_indices)
nclusters = max(cluster_indices) + 1
girvan_e = np.zeros((nclusters, nclusters))
volume = 0
for i in range(n):
for j in range(n):
if i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n n = 34\n # create the adjacency matrix\n stripped_lines = Util.get_stripped_lines(g_karate_data.splitlines())\n string_rows = [line.split() for line in stripped_lines if line]\n assert len(string_rows) == n\n for row in string_rows:\n assert len(row) == n\n data_rows = [[f... | [
"0.6405175",
"0.58857876",
"0.58554703",
"0.5850018",
"0.58353317",
"0.5766119",
"0.5741885",
"0.54117924",
"0.53281623",
"0.5319941",
"0.5288762",
"0.5186005",
"0.516735",
"0.515262",
"0.5149235",
"0.51382715",
"0.51001173",
"0.50766313",
"0.50506675",
"0.50342005",
"0.50274... | 0.4608002 | 96 |
This was my first implementation of modularity using Eric's definition in his paper. | def get_modularity_other_a(A, cluster_indices):
# define the number of nodes in the graph and the number of clusters
n = len(cluster_indices)
nclusters = max(cluster_indices) + 1
# initialize some intermediate variables
within_cluster = [0] * nclusters
between_cluster = [0] * nclusters
volum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def modules():",
"def test_versioned_symbols(self):\n class MyModule(torch.nn.Module):\n def __init__(self):\n super(MyModule, self).__init__()\n\n def forward(self, a, b, alpha: float):\n no_alpha = torch._test_serialization_subcmul(a, b)\n ... | [
"0.6275559",
"0.5581727",
"0.53932595",
"0.53165233",
"0.52899075",
"0.52877235",
"0.52483445",
"0.5226746",
"0.5212492",
"0.51966196",
"0.5192233",
"0.5163047",
"0.5147938",
"0.5141009",
"0.51342773",
"0.51297754",
"0.51278263",
"0.51182884",
"0.51020133",
"0.51010454",
"0.5... | 0.0 | -1 |
Analyze the Zachary karate club data. | def main():
n = 34
# create the adjacency matrix
stripped_lines = Util.get_stripped_lines(g_karate_data.splitlines())
string_rows = [line.split() for line in stripped_lines if line]
assert len(string_rows) == n
for row in string_rows:
assert len(row) == n
data_rows = [[float(x) for x... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_karate_club_data():\n\n # Edge list of Zachary's karate club.\n edge_list = [\n (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8),\n (0, 10), (0, 11), (0, 12), (0, 13), (0, 17), (0, 19), (0, 21), (0, 31),\n (1, 2), (1, 3), (1, 7), (1, 13), (1, 17), (1, 19), (1, 21), (1, 30),\n... | [
"0.66694874",
"0.57432646",
"0.5723401",
"0.5522852",
"0.55180657",
"0.5504678",
"0.5437675",
"0.54102576",
"0.53872174",
"0.53547543",
"0.53277946",
"0.53205276",
"0.53092575",
"0.5265327",
"0.5183534",
"0.5149629",
"0.5142744",
"0.51422846",
"0.51374143",
"0.51307535",
"0.5... | 0.0 | -1 |
Send an email message. | def send_message(user_id, message):
try:
service = get_service('token.pickle')
message = (service.users().messages().send(userId=user_id, body=message).execute())
print('Message Id: %s' % message['id'])
return message
except errors.HttpError as error:
print('An error occurred:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_email(self, message):\n pass",
"def send_mail(email):\n return email.send()",
"def send_email(msg):\n\tprint(\"sendEmail: \" + msg)",
"def send_email(message):\n mail_server = smtplib.SMTP('localhost')\n mail_server.send_message(message)\n mail_server.quit()",
"def send_email(msg):\n ... | [
"0.8239757",
"0.80890095",
"0.79037267",
"0.78920776",
"0.7768939",
"0.7730623",
"0.7727504",
"0.76961035",
"0.76466435",
"0.7635667",
"0.7613354",
"0.7608988",
"0.7607686",
"0.7554999",
"0.7533295",
"0.7488125",
"0.74320126",
"0.74103194",
"0.7409468",
"0.7407818",
"0.740765... | 0.0 | -1 |
Shows basic usage of the Gmail API. Lists the user's Gmail labels. | def build_service():
creds = None
# The file token.pickle stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
if os.path.exists('token.pickle'):
with open('token.pickle', 'rb') as token:
cr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_labels():\n\n logging.info(\"Getting metadata about labels\")\n\n labels = []\n\n if len(args.labels) == 0:\n logging.warning(\"No labels specified, assuming all labels. If you have a lot of labels in your inbox you could hit API limits quickly.\")\n results = GMAIL_CLIENT.users().la... | [
"0.69438267",
"0.67967373",
"0.67262995",
"0.64360845",
"0.63330704",
"0.62724566",
"0.6237401",
"0.5750789",
"0.5673543",
"0.5591335",
"0.55725247",
"0.5570501",
"0.55700606",
"0.5568798",
"0.5558453",
"0.55524904",
"0.550932",
"0.549548",
"0.5492455",
"0.5464197",
"0.546312... | 0.0 | -1 |
Input of the Network | def __init__(self, shape, input_var=None):
self.output = layers.InputLayer(shape, input_var=input_var) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def input(self):",
"def input(self):\r\n pass",
"def d_input(self):\n pass",
"def inputs(self):\n pass",
"def input(self):\n return self[\"input\"]",
"def input(self):\n return self[\"input\"]",
"def input_nodes(self):\n pass",
"def processInputs(self):",
"... | [
"0.7633749",
"0.7437",
"0.68596274",
"0.684022",
"0.6768303",
"0.6768303",
"0.6635569",
"0.6624624",
"0.6530338",
"0.644091",
"0.6440604",
"0.6437605",
"0.6437605",
"0.6437605",
"0.6437605",
"0.6437605",
"0.6437605",
"0.6437605",
"0.64358646",
"0.6357148",
"0.6357148",
"0.6... | 0.0 | -1 |
Allocate a TransposedConvLayer with shared variable internal parameters. | def __init__(self, input, num_filters, filter_size, stride=(2, 2), padding=(0, 0), activation=rectify):
self.input = input
self.output = layers.TransposedConv2DLayer(self.input, num_filters, filter_size, stride=stride, crop=padding,
W=initialize_parame... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transpose(incoming, conv, nonlinearity, *args, **kwargs):\n return TransposedConv2DLayer(incoming, conv.input_shape[1],\n conv.filter_size, stride=conv.stride,\n crop=conv.pad, W=conv.W,\n flip_filters=not conv.f... | [
"0.63744015",
"0.5864105",
"0.586131",
"0.5837967",
"0.5762193",
"0.5750853",
"0.57461226",
"0.57346827",
"0.57076824",
"0.5697772",
"0.56805575",
"0.5673117",
"0.5603193",
"0.5555773",
"0.5510417",
"0.5501909",
"0.5458268",
"0.5454152",
"0.5436939",
"0.54160196",
"0.5399038"... | 0.61901104 | 1 |
Allocate an Embedding Layer. | def __init__(self, input, input_size, embedding_size):
self.input = input
self.output = layers.EmbeddingLayer(self.input, input_size, embedding_size, W=initialize_parameters()[0]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def embedding_layer(self):\n with tf.name_scope(\"Embedding_Layer\"):\n V_size = len(self.vocab)\n embed_dim = len(self.embed[0]) \n W_embed_ = tf.get_variable(\"W_embed\",shape=[V_size, embed_dim],trainable=False).assign(np.asarray(self.embed))\n W_analogy_embed_... | [
"0.69322747",
"0.64097595",
"0.64067",
"0.63635826",
"0.63276964",
"0.6208275",
"0.6184051",
"0.6084168",
"0.60155404",
"0.6006011",
"0.6005224",
"0.6002711",
"0.60010916",
"0.59911853",
"0.5990504",
"0.5958701",
"0.5928769",
"0.592201",
"0.59150296",
"0.59118164",
"0.591048"... | 0.63652354 | 3 |
Return list of filename corresponding to JobSpider | def get_spiders_files(spiders_directory=None):
if spiders_directory is None:
spiders_directory = dirname(__file__) + '/spiders/'
return [file for file in glob.glob(spiders_directory + "/*.py")
if isfile(file)
and not file.endswith('__init__.py')] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_job_names(self):\n return []",
"def filenames(self):\n pass",
"def get_job_list():\n\tdirlist = os.listdir(\".\")\n\tjoblist = [x for x in dirlist if \"job.sh\" in x and x in job_dict]\n\ttmplist = [x for x in dirlist if \"job.sh\" in x and x not in job_dict]\n\tdef compare_function(s: st... | [
"0.6951387",
"0.6711222",
"0.6683628",
"0.6501705",
"0.64207095",
"0.6337588",
"0.6322085",
"0.6264899",
"0.62041765",
"0.6117254",
"0.61150414",
"0.6107383",
"0.6075868",
"0.60367036",
"0.6032433",
"0.6024823",
"0.6024823",
"0.6017",
"0.6010282",
"0.5977642",
"0.59388155",
... | 0.0 | -1 |
Do the crawn job (see crawl function) from spider class name (eg. pyjobs_crawlers.spiders.myspider.MySpiderClass) | def crawl_from_class_name(spider_class_name, connector, spider_error_callback=None):
module_name = '.'.join(spider_class_name.split('.')[:-1])
class_name = spider_class_name.split('.')[-1]
spider_module = import_module(module_name)
spider_class = getattr(spider_module, class_name)
return crawl([sp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def runSpider(spiderClass):\n\n\tprocess = CrawlerProcess({\n\t\t# 'USER_AGENT': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'\n\t})\n\n\tprocess.crawl(spiderClass)\n\tprocess.start() # the script will block here until the crawling is finished",
"def crawl(spider: str, book_id: int):\n proc = CrawlerPr... | [
"0.73961866",
"0.6965943",
"0.6719651",
"0.6231977",
"0.6110582",
"0.60992587",
"0.6060535",
"0.6008926",
"0.5995375",
"0.5984809",
"0.5936894",
"0.59176165",
"0.59090364",
"0.5877148",
"0.58751583",
"0.5838686",
"0.5806472",
"0.57944125",
"0.57699037",
"0.57601506",
"0.57359... | 0.70772463 | 1 |
Launch crawl job for JobSpider class | def crawl(spiders_classes, connector, debug=False, spider_error_callback=stdout_error_callback):
if debug:
dispatcher.connect(spider_error_callback, signals.spider_error)
process = CrawlerProcess({
'ITEM_PIPELINES': {
'pyjobs_crawlers.pipelines.RecordJobPipeline': 1,
},
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n # get input params\n args = parm_parser.get_args()\n # init log config\n log.init_log('./log/mini_spider')\n if args:\n # read config file spider.conf\n conf_params = parm_parser.set_config_by_file(args.conf)\n # use config set up spider initial params\n spi... | [
"0.68515605",
"0.68069863",
"0.6725972",
"0.65931946",
"0.6564873",
"0.6453477",
"0.6431938",
"0.6309634",
"0.62984973",
"0.62603843",
"0.62601477",
"0.62413216",
"0.61893225",
"0.6176784",
"0.6167868",
"0.6138753",
"0.61035246",
"0.6056674",
"0.60286516",
"0.6023728",
"0.600... | 0.58343834 | 26 |
Return a parsed BIOM table. | def load_biom_table(table_f):
return parse_biom_table(table_f) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_table(text):\n\n text = str(text)\n try:\n text = text.split(\"<pre>\")[1]\n text = text.split(\"</pre>\")[0]\n text = text.split(\"To save this output\")[0]\n lines = text.split(\"\\n\")\n except Exception as exc:\n raise NNDCRequestError(f\"Unable to parse t... | [
"0.5795739",
"0.56989133",
"0.5626127",
"0.5613763",
"0.55284244",
"0.55272263",
"0.55172074",
"0.5440883",
"0.5421252",
"0.53791916",
"0.53787607",
"0.53451467",
"0.53356135",
"0.5328347",
"0.5308771",
"0.5279552",
"0.52757406",
"0.52719027",
"0.5256095",
"0.5256095",
"0.525... | 0.6301872 | 0 |
Return a BIOM table and the original open filehandle as a tuple. Useful when additional computation needs to be performed on the file contents, such as an MD5 sum. | def load_biom_table_with_file_contents(biom_f):
table = parse_biom_table(biom_f)
if hasattr(biom_f, 'seek'):
biom_f.seek(0)
return table, biom_f | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_file(self) -> tuple:\r\n hash_md5 = hashlib.md5()\r\n with open(self.yara_base_file, \"rb\") as f:\r\n file_map = f.read()\r\n get_file_dict = get_matches(self, file_map)\r\n hash_md5.update(file_map)\r\n return hash_md5.hexdigest(), get_file_dict",
"def __enter__(self) ... | [
"0.5903592",
"0.5517948",
"0.5293327",
"0.5092299",
"0.5019564",
"0.5009954",
"0.49709004",
"0.49704278",
"0.49154168",
"0.49107695",
"0.48602694",
"0.4815139",
"0.47660074",
"0.4726421",
"0.4725368",
"0.4721951",
"0.47156245",
"0.47033814",
"0.46824378",
"0.46797317",
"0.466... | 0.6167393 | 0 |
Return a parsed JSON object. | def load_json_document(f):
return json.load(f) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def json(self):\n return self._parsejson(self.raw)",
"def parse_json(data):\n return json.loads(data)",
"def json(self):\n return json.loads(self.text)",
"def openJson(self):\n json_file = open(self.file, 'r')\n json_data = json_file.read()\n result = json.loads(json_dat... | [
"0.73147",
"0.7164479",
"0.7052984",
"0.70459557",
"0.69945663",
"0.69648427",
"0.69155174",
"0.6909238",
"0.6883624",
"0.68454266",
"0.67840165",
"0.6775863",
"0.67642134",
"0.67337215",
"0.6694092",
"0.6694092",
"0.6694092",
"0.6694092",
"0.66517884",
"0.6608782",
"0.659293... | 0.0 | -1 |
Parse a sample/observation metadata file, return a ``MetadataMap``. If ``lines`` is ``None``, this function will return ``None``. | def load_metadata(lines):
if lines is not None:
return MetadataMap.from_file(lines)
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parseMetadataMap(lines):\r\n return MetadataMap(*parse_mapping_file_to_dict(lines))",
"def get_sample_info(lines):\r\n mapping_data, header, comments = parse_mapping_file(lines)\r\n labels = [\"from\", \"to\", \"eweight\", \"consensus_lin\"]\r\n node_labels = [\"node_name\", \"node_disp_name\... | [
"0.8028162",
"0.5969158",
"0.58202237",
"0.57127655",
"0.56976295",
"0.56358564",
"0.5572141",
"0.55685896",
"0.556603",
"0.5544489",
"0.55414313",
"0.5443912",
"0.5436588",
"0.5433023",
"0.5427803",
"0.5423232",
"0.53913337",
"0.5390329",
"0.5361068",
"0.53360075",
"0.528676... | 0.8175402 | 0 |
Initialize the contact tag. | def __init__(
self,
tag: typing.Optional[int],
contact: typing.Optional[int],
**kwargs: typing.Dict,
) -> None:
super().__init__(**kwargs)
self.tag = tag
self.contact = contact | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, contact):\n\n\t\tself._id = UserClassroom.__ID\n\t\tself._contact = contact\n\t\tself.size = 1\n\n\t\tUserClassroom.__ID += 1",
"def __init__(self, uid=\"\", first_name=\"\", last_name=\"\", email=\"\", phone=\"\", description=\"\",\n company_uid=None, testing=False):\n\n ... | [
"0.6380634",
"0.63572264",
"0.62336594",
"0.61620253",
"0.60732037",
"0.6036036",
"0.60072947",
"0.60072947",
"0.60046685",
"0.6001961",
"0.5892605",
"0.58892137",
"0.58892137",
"0.58549345",
"0.58439875",
"0.57779026",
"0.57670283",
"0.5691324",
"0.56651187",
"0.5649181",
"0... | 0.73358494 | 0 |
Get the name of the API resource. | def resource_name() -> str:
return "contactTags" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def name(self):\n return self.raw_resource[\"name\"]",
"def name(self):\n\n return self.resource[\"metadata\"][\"name\"]",
"def get_resource_name(self):\n return self._resource_name",
"def resource_name(self) -> Optional[str]:\n return pulumi.get(self, \"resource_name\")",
"def ... | [
"0.7821574",
"0.7735648",
"0.7670678",
"0.7447657",
"0.7447657",
"0.74427205",
"0.7221747",
"0.7221747",
"0.7221747",
"0.7221747",
"0.7221747",
"0.7201344",
"0.7172618",
"0.69053936",
"0.68893594",
"0.68083745",
"0.68061125",
"0.6781027",
"0.6781027",
"0.6777424",
"0.67408043... | 0.0 | -1 |
Map field names to attributes. | def map_field_name_to_attribute() -> typing.Dict:
return {
"tag": "tag",
"contact": "contact",
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _attrs_map(self) -> \"dict[int, str]\":\n return {i: attr.name for i, attr in enumerate(self._attrs())}",
"def map_to_db_fields(field_attrs):\n attr_keys = field_attrs.keys()\n field_name = field_attrs[attr_keys.pop(attr_keys.index('name'))]\n field_type_raw = field_attrs[attr_keys.pop(attr_k... | [
"0.6646376",
"0.65862083",
"0.65552986",
"0.65168107",
"0.6496606",
"0.63440627",
"0.6253964",
"0.6224082",
"0.61496115",
"0.61344844",
"0.60731304",
"0.60435295",
"0.60270566",
"0.5998152",
"0.5984378",
"0.59624",
"0.59521395",
"0.59237885",
"0.5913278",
"0.59089035",
"0.589... | 0.81743294 | 0 |
Get all ContactTags associated to contact with that id | def all_in_contact(cls, contact_id: int):
for contact_tag in cls.get_all_in("contacts", contact_id):
yield contact_tag | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_photo_tags(self, photo_id):\n\n query_string = '''\n select photo_tag.tag_name from photo\n join photo_tag on(photo_tag.photo_id=photo.photo_id)\n where photo.photo_id={}\n '''.format(photo_id)\n\n # so an array of tags would be ok\n tag_data = s... | [
"0.59750104",
"0.59688324",
"0.5902836",
"0.58065534",
"0.5737934",
"0.56792",
"0.5666696",
"0.56300694",
"0.56000763",
"0.5579044",
"0.55602413",
"0.5539786",
"0.5474715",
"0.54744804",
"0.54674107",
"0.546423",
"0.546423",
"0.5387576",
"0.5375769",
"0.5366009",
"0.53620964"... | 0.7933677 | 0 |
Is true when ``argument`` is an iterable collection with integerequivalent items. | def all_are_integer_equivalent_numbers(argument):
from abjad import mathtools
try:
return all(mathtools.is_integer_equivalent_number(_) for _ in argument)
except TypeError:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iterable(arg):\n return isinstance(arg, collections.Iterable) and not isinstance(arg, six.string_types)",
"def is_sequence_of_int(items):\n return all(isinstance(item, int) for item in items)",
"def is_iterable(arg):\n return (\n isinstance(arg, collections.Iterable)\n and no... | [
"0.6820437",
"0.68176305",
"0.6641058",
"0.6636341",
"0.6526343",
"0.6496134",
"0.6355871",
"0.6260515",
"0.62311673",
"0.62234855",
"0.6213004",
"0.61957854",
"0.6160951",
"0.6089377",
"0.6064915",
"0.6020444",
"0.60009134",
"0.5981801",
"0.5974256",
"0.596914",
"0.5965121",... | 0.75479543 | 0 |
Initialize this dataset class. | def __init__(self, opt):
BaseDataset.__init__(self, opt)
self.A_paths = sorted(make_dataset(opt.dataroot, opt.max_dataset_size))
input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc
self.transform = get_transform(opt, grayscale=(input_nc == 1)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.__dataset = None",
"def __init__(self, dataset):\n self._dataset = dataset",
"def __init__(self, dataset: Dataset):\n self.dataset = dataset",
"def __init__(self, config):\n logger.info(f\"{self.__class__.__name__}: Dataset initializing ...\")\n s... | [
"0.816631",
"0.81641185",
"0.8013762",
"0.76137954",
"0.7422038",
"0.7393049",
"0.7352237",
"0.73437655",
"0.7111143",
"0.71019876",
"0.7099074",
"0.7096382",
"0.70223516",
"0.696418",
"0.6961817",
"0.6889772",
"0.6879775",
"0.68740934",
"0.68599087",
"0.68520594",
"0.6842619... | 0.6548279 | 77 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.